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

equal deleted inserted replaced

-:adf3a039cb7d
+:72e7fdc79b78
 *     mode = EXPR        : an expression
 *     mode = TYPE        : a type
 *     mode = NOPARAMS    : no parameters allowed for type
 *     mode = TYPEARG     : type argument
 */
-static final int EXPR = 0x1;
+protected static final int EXPR = 0x1;
-static final int TYPE = 0x2;
+protected static final int TYPE = 0x2;
-static final int NOPARAMS = 0x4;
+protected static final int NOPARAMS = 0x4;
-static final int TYPEARG = 0x8;
+protected static final int TYPEARG = 0x8;
-static final int DIAMOND = 0x10;
+protected static final int DIAMOND = 0x10;
 /** The current mode.
 */
-private int mode = 0;
+protected int mode = 0;
 /** The mode of the term that was parsed last.
 */
-private int lastmode = 0;
+protected int lastmode = 0;
 /* ---------- token management -------------- */
 protected Token token;
 private JCErroneous errorTree;
 /** Skip forward until a suitable stop token is found.
 */
-private void skip(boolean stopAtImport, boolean stopAtMemberDecl, boolean stopAtIdentifier, boolean stopAtStatement) {
+protected void skip(boolean stopAtImport, boolean stopAtMemberDecl, boolean stopAtIdentifier, boolean stopAtStatement) {
 while (true) {
 switch (token.kind) {
 case SEMI:
 nextToken();
 return;
 }
 nextToken();
 }
 }
-private JCErroneous syntaxError(int pos, String key, TokenKind... args) {
+protected JCErroneous syntaxError(int pos, String key, TokenKind... args) {
 return syntaxError(pos, List.<JCTree>nil(), key, args);
 }
-private JCErroneous syntaxError(int pos, List<JCTree> errs, String key, TokenKind... args) {
+protected JCErroneous syntaxError(int pos, List<JCTree> errs, String key, TokenKind... args) {
 setErrorEndPos(pos);
 JCErroneous err = F.at(pos).Erroneous(errs);
 reportSyntaxError(err, key, (Object[])args);
 if (errs != null) {
 JCTree last = errs.last();
 /**
 * Report a syntax using the given the position parameter and arguments,
 * unless one was already reported at the same position.
 */
-private void reportSyntaxError(int pos, String key, Object... args) {
+protected void reportSyntaxError(int pos, String key, Object... args) {
 JCDiagnostic.DiagnosticPosition diag = new JCDiagnostic.SimpleDiagnosticPosition(pos);
 reportSyntaxError(diag, key, args);
 }
 /**
 * Report a syntax error using the given DiagnosticPosition object and
 * arguments, unless one was already reported at the same position.
 */
-private void reportSyntaxError(JCDiagnostic.DiagnosticPosition diagPos, String key, Object... args) {
+protected void reportSyntaxError(JCDiagnostic.DiagnosticPosition diagPos, String key, Object... args) {
 int pos = diagPos.getPreferredPosition();
 if (pos > S.errPos() || pos == Position.NOPOS) {
 if (token.kind == EOF) {
 error(diagPos, "premature.eof");
 } else {
 /** Generate a syntax error at current position unless one was already
 *  reported at the same position.
 */
-private JCErroneous syntaxError(String key) {
+protected JCErroneous syntaxError(String key) {
 return syntaxError(token.pos, key);
 }
 /** Generate a syntax error at current position unless one was
 *  already reported at the same position.
 */
-private JCErroneous syntaxError(String key, TokenKind arg) {
+protected JCErroneous syntaxError(String key, TokenKind arg) {
 return syntaxError(token.pos, key, arg);
 }
 /** If next input token matches given token, skip it, otherwise report
 *  an error.
 JCExpression illegal() {
 return illegal(token.pos);
 }
 /** Diagnose a modifier flag from the set, if any. */
-void checkNoMods(long mods) {
+protected void checkNoMods(long mods) {
 if (mods != 0) {
 long lowestMod = mods & -mods;
 error(token.pos, "mod.not.allowed.here",
 Flags.asFlagSet(lowestMod));
 }
 /** Make an entry into docComments hashtable,
 *  provided flag keepDocComments is set and given doc comment is non-null.
 *  @param tree   The tree to be used as index in the hashtable
 *  @param dc     The doc comment to associate with the tree, or null.
 */
-void attach(JCTree tree, Comment dc) {
+protected void attach(JCTree tree, Comment dc) {
 if (keepDocComments && dc != null) {
 //          System.out.println("doc comment = ");System.out.println(dc);//DEBUG
 docComments.putComment(tree, dc);
 }
 }
 /* -------- source positions ------- */
-private void setErrorEndPos(int errPos) {
+protected void setErrorEndPos(int errPos) {
 endPosTable.setErrorEndPos(errPos);
 }
-private void storeEnd(JCTree tree, int endpos) {
+protected void storeEnd(JCTree tree, int endpos) {
 endPosTable.storeEnd(tree, endpos);
 }
-private <T extends JCTree> T to(T t) {
+protected <T extends JCTree> T to(T t) {
 return endPosTable.to(t);
 }
-private <T extends JCTree> T toP(T t) {
+protected <T extends JCTree> T toP(T t) {
 return endPosTable.toP(t);
 }
 /** Get the start position for a tree node.  The start position is
 * defined to be the position of the first character of the first
 /* ---------- parsing -------------- */
 /**
 * Ident = IDENTIFIER
 */
-Name ident() {
+protected Name ident() {
 if (token.kind == IDENTIFIER) {
 Name name = token.name();
 nextToken();
 return name;
 } else if (token.kind == ASSERT) {
 public JCExpression unannotatedType() {
 return term(TYPE);
 }
-JCExpression term(int newmode) {
+protected JCExpression term(int newmode) {
 int prevmode = mode;
 mode = newmode;
 JCExpression t = term();
 lastmode = mode;
 mode = prevmode;
 }
 }
 }
 /** Accepts all identifier-like tokens */
-Filter<TokenKind> LAX_IDENTIFIER = new Filter<TokenKind>() {
+protected Filter<TokenKind> LAX_IDENTIFIER = new Filter<TokenKind>() {
 public boolean accepts(TokenKind t) {
 return t == IDENTIFIER || t == UNDERSCORE || t == ASSERT || t == ENUM;
 }
 };
 *     | BREAK [Ident] ";"
 *     | CONTINUE [Ident] ";"
 *     | ASSERT Expression [ ":" Expression ] ";"
 *     | ";"
 */
-JCStatement parseSimpleStatement() {
+public JCStatement parseSimpleStatement() {
 int pos = token.pos;
 switch (token.kind) {
 case LBRACE:
 return block();
 case IF: {
 /** AnnotationsOpt = { '@' Annotation }
 *
 * @param kind Whether to parse an ANNOTATION or TYPE_ANNOTATION
 */
-List<JCAnnotation> annotationsOpt(Tag kind) {
+protected List<JCAnnotation> annotationsOpt(Tag kind) {
 if (token.kind != MONKEYS_AT) return List.nil(); // optimization
 ListBuffer<JCAnnotation> buf = new ListBuffer<>();
 int prevmode = mode;
 while (token.kind == MONKEYS_AT) {
 int pos = token.pos;
 /** ModifiersOpt = { Modifier }
 *  Modifier = PUBLIC | PROTECTED | PRIVATE | STATIC | ABSTRACT | FINAL
 *           | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE | "@"
 *           | "@" Annotation
 */
-JCModifiers modifiersOpt() {
+protected JCModifiers modifiersOpt() {
 return modifiersOpt(null);
 }
 protected JCModifiers modifiersOpt(JCModifiers partial) {
 long flags;
 ListBuffer<JCAnnotation> annotations = new ListBuffer<>();
 *  ConstantDeclaratorsRest = ConstantDeclaratorRest { "," ConstantDeclarator }
 *
 *  @param reqInit  Is an initializer always required?
 *  @param dc       The documentation comment for the variable declarations, or null.
 */
-<T extends ListBuffer<? super JCVariableDecl>> T variableDeclaratorsRest(int pos,
+protected <T extends ListBuffer<? super JCVariableDecl>> T variableDeclaratorsRest(int pos,
 JCModifiers mods,
 JCExpression type,
 Name name,
 boolean reqInit,
 Comment dc,
 return toplevel;
 }
 /** ImportDeclaration = IMPORT [ STATIC ] Ident { "." Ident } [ "." "*" ] ";"
 */
-JCTree importDeclaration() {
+protected JCTree importDeclaration() {
 int pos = token.pos;
 nextToken();
 boolean importStatic = false;
 if (token.kind == STATIC) {
 importStatic = true;
 /** ClassOrInterfaceOrEnumDeclaration = ModifiersOpt
 *           (ClassDeclaration | InterfaceDeclaration | EnumDeclaration)
 *  @param mods     Any modifiers starting the class or interface declaration
 *  @param dc       The documentation comment for the class, or null.
 */
-JCStatement classOrInterfaceOrEnumDeclaration(JCModifiers mods, Comment dc) {
+protected JCStatement classOrInterfaceOrEnumDeclaration(JCModifiers mods, Comment dc) {
 if (token.kind == CLASS) {
 return classDeclaration(mods, dc);
 } else if (token.kind == INTERFACE) {
 return interfaceDeclaration(mods, dc);
 } else if (token.kind == ENUM) {
 /**
 *  {@literal
 *  TypeParametersOpt = ["<" TypeParameter {"," TypeParameter} ">"]
 *  }
 */
-List<JCTypeParameter> typeParametersOpt() {
+protected List<JCTypeParameter> typeParametersOpt() {
 if (token.kind == LT) {
 ListBuffer<JCTypeParameter> typarams = new ListBuffer<>();
 nextToken();
 typarams.append(typeParameter());
 while (token.kind == COMMA) {
 if (!allowTypeAnnotations) {
 log.error(token.pos, "type.annotations.not.supported.in.source", source.name);
 allowTypeAnnotations = true;
 }
 }
-void checkAnnotationsAfterTypeParams(int pos) {
+protected void checkAnnotationsAfterTypeParams(int pos) {
 if (!allowAnnotationsAfterTypeParams) {
 log.error(pos, "annotations.after.type.params.not.supported.in.source", source.name);
 allowAnnotationsAfterTypeParams = true;
 }
 }
 protected JavacParser parser;
 /**
 * Store the last error position.
 */
-protected int errorEndPos = Position.NOPOS;
+public int errorEndPos = Position.NOPOS;
 public AbstractEndPosTable(JavacParser parser) {
 this.parser = parser;
 }
 /**
 * Set the error position during the parsing phases, the value of which
 * will be set only if it is greater than the last stored error position.
 * @param errPos The error position
 */
-protected void setErrorEndPos(int errPos) {
+public void setErrorEndPos(int errPos) {
 if (errPos > errorEndPos) {
 errorEndPos = errPos;
 }
 }
-protected void setParser(JavacParser parser) {
+public void setParser(JavacParser parser) {
 this.parser = parser;
 }
 }
 }

changeset 28147	72e7fdc79b78
parent 27991	8f4b68523da3
child 28454	63c31d7de8f6