jdk-sandbox: comparison src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavaTokenizer.java

equal deleted inserted replaced

-:6dcbdc9f99fc
+:702043a4cdeb
 */
 package com.sun.tools.javac.parser;
 import com.sun.tools.javac.code.Source;
+import com.sun.tools.javac.code.Source.Feature;
 import com.sun.tools.javac.parser.Tokens.Comment.CommentStyle;
+import com.sun.tools.javac.resources.CompilerProperties.Errors;
 import com.sun.tools.javac.util.*;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;
 import java.nio.CharBuffer;
 import static com.sun.tools.javac.parser.Tokens.*;
 import static com.sun.tools.javac.util.LayoutCharacters.*;
 */
 public class JavaTokenizer {
 private static final boolean scannerDebug = false;
-/** Allow binary literals.
-*/
-private boolean allowBinaryLiterals;
-/** Allow underscores in literals.
-*/
-private boolean allowUnderscoresInLiterals;
 /** The source language setting.
 */
 private Source source;
 /** The log to be used for error reporting.
 this.fac = fac;
 this.log = fac.log;
 this.tokens = fac.tokens;
 this.source = fac.source;
 this.reader = reader;
-this.allowBinaryLiterals = source.allowBinaryLiterals();
+}
-this.allowUnderscoresInLiterals = source.allowUnderscoresInLiterals();
+private void checkSourceLevel(int pos, Feature feature) {
+if (!feature.allowedInSource(source)) {
+lexError(DiagnosticFlag.SOURCE_LEVEL, pos, feature.error(source.name));
+}
 }
 /** Report an error at the given position using the provided arguments.
 */
-protected void lexError(int pos, String key, Object... args) {
+protected void lexError(int pos, JCDiagnostic.Error key) {
-log.error(pos, key, args);
+log.error(pos, key);
+tk = TokenKind.ERROR;
+errPos = pos;
+}
+protected void lexError(DiagnosticFlag flags, int pos, JCDiagnostic.Error key) {
+log.error(flags, pos, key);
 tk = TokenKind.ERROR;
 errPos = pos;
 }
 /** Read next character in character or string literal and copy into sbuf.
 case '\"':
 reader.putChar('\"', true); break;
 case '\\':
 reader.putChar('\\', true); break;
 default:
-lexError(reader.bp, "illegal.esc.char");
+lexError(reader.bp, Errors.IllegalEscChar);
 }
 }
 } else if (reader.bp != reader.buflen) {
 reader.putChar(true);
 }
 int savePos;
 do {
 if (reader.ch != '_') {
 reader.putChar(false);
 } else {
-if (!allowUnderscoresInLiterals) {
+checkSourceLevel(pos, Feature.UNDERSCORES_IN_LITERALS);
-lexError(pos, "unsupported.underscore.lit", source.name);
-allowUnderscoresInLiterals = true;
-}
 }
 saveCh = reader.ch;
 savePos = reader.bp;
 reader.scanChar();
 } while (reader.digit(pos, digitRadix) >= 0 || reader.ch == '_');
 if (saveCh == '_')
-lexError(savePos, "illegal.underscore");
+lexError(savePos, Errors.IllegalUnderscore);
 }
 /** Read fractional part of hexadecimal floating point number.
 */
 private void scanHexExponentAndSuffix(int pos) {
 }
 skipIllegalUnderscores();
 if (reader.digit(pos, 10) >= 0) {
 scanDigits(pos, 10);
 if (!hexFloatsWork)
-lexError(pos, "unsupported.cross.fp.lit");
+lexError(pos, Errors.UnsupportedCrossFpLit);
 } else
-lexError(pos, "malformed.fp.lit");
+lexError(pos, Errors.MalformedFpLit);
 } else {
-lexError(pos, "malformed.fp.lit");
+lexError(pos, Errors.MalformedFpLit);
 }
 if (reader.ch == 'f' || reader.ch == 'F') {
 reader.putChar(true);
 tk = TokenKind.FLOATLITERAL;
 radix = 16;
 skipIllegalUnderscores();
 if (reader.digit(pos, 10) >= 0) {
 scanDigits(pos, 10);
 return;
 }
-lexError(pos, "malformed.fp.lit");
+lexError(pos, Errors.MalformedFpLit);
 reader.sp = sp1;
 }
 }
 /** Read fractional part and 'd' or 'f' suffix of floating point number.
 if (reader.digit(pos, 16) >= 0) {
 seendigit = true;
 scanDigits(pos, 16);
 }
 if (!seendigit)
-lexError(pos, "invalid.hex.number");
+lexError(pos, Errors.InvalidHexNumber);
 else
 scanHexExponentAndSuffix(pos);
 }
 private void skipIllegalUnderscores() {
 if (reader.ch == '_') {
-lexError(reader.bp, "illegal.underscore");
+lexError(reader.bp, Errors.IllegalUnderscore);
 while (reader.ch == '_')
 reader.scanChar();
 }
 }
 scanFractionAndSuffix(pos);
 } else {
 if (!seenValidDigit) {
 switch (radix) {
 case 2:
-lexError(pos, "invalid.binary.number");
+lexError(pos, Errors.InvalidBinaryNumber);
 break;
 case 16:
-lexError(pos, "invalid.hex.number");
+lexError(pos, Errors.InvalidHexNumber);
 break;
 }
 }
 if (reader.ch == 'l' || reader.ch == 'L') {
 reader.scanChar();
 if (reader.ch == 'x' || reader.ch == 'X') {
 reader.scanChar();
 skipIllegalUnderscores();
 scanNumber(pos, 16);
 } else if (reader.ch == 'b' || reader.ch == 'B') {
-if (!allowBinaryLiterals) {
+checkSourceLevel(pos, Feature.BINARY_LITERALS);
-lexError(pos, "unsupported.binary.lit", source.name);
-allowBinaryLiterals = true;
-}
 reader.scanChar();
 skipIllegalUnderscores();
 scanNumber(pos, 2);
 } else {
 reader.putChar('0');
 int savePos = reader.bp;
 do {
 reader.scanChar();
 } while (reader.ch == '_');
 if (reader.digit(pos, 10) < 0) {
-lexError(savePos, "illegal.underscore");
+lexError(savePos, Errors.IllegalUnderscore);
 }
 }
 scanNumber(pos, 8);
 }
 break loop;
 if (reader.ch == '.') {
 reader.scanChar();
 reader.putChar('.');
 tk = TokenKind.ELLIPSIS;
 } else {
-lexError(savePos, "illegal.dot");
+lexError(savePos, Errors.IllegalDot);
 }
 } else {
 tk = TokenKind.DOT;
 }
 break loop;
 if (reader.ch == '/') {
 reader.scanChar();
 comments = addComment(comments, processComment(pos, reader.bp, style));
 break;
 } else {
-lexError(pos, "unclosed.comment");
+lexError(pos, Errors.UnclosedComment);
 break loop;
 }
 } else if (reader.ch == '=') {
 tk = TokenKind.SLASHEQ;
 reader.scanChar();
 }
 break loop;
 case '\'':
 reader.scanChar();
 if (reader.ch == '\'') {
-lexError(pos, "empty.char.lit");
+lexError(pos, Errors.EmptyCharLit);
 reader.scanChar();
 } else {
 if (reader.ch == CR || reader.ch == LF)
-lexError(pos, "illegal.line.end.in.char.lit");
+lexError(pos, Errors.IllegalLineEndInCharLit);
 scanLitChar(pos);
 if (reader.ch == '\'') {
 reader.scanChar();
 tk = TokenKind.CHARLITERAL;
 } else {
-lexError(pos, "unclosed.char.lit");
+lexError(pos, Errors.UnclosedCharLit);
 }
 }
 break loop;
 case '\"':
 reader.scanChar();
 scanLitChar(pos);
 if (reader.ch == '\"') {
 tk = TokenKind.STRINGLITERAL;
 reader.scanChar();
 } else {
-lexError(pos, "unclosed.str.lit");
+lexError(pos, Errors.UnclosedStrLit);
 }
 break loop;
 default:
 if (isSpecial(reader.ch)) {
 scanOperator();
 } else {
 arg = (32 < reader.ch && reader.ch < 127) ?
 String.format("%s", reader.ch) :
 String.format("\\u%04x", (int)reader.ch);
 }
-lexError(pos, "illegal.char", arg);
+lexError(pos, Errors.IllegalChar(arg));
 reader.scanChar();
 }
 }
 break loop;
 }

changeset 48054	702043a4cdeb
parent 47216	71c04702a3d5
child 49580	62b908c9f0e6