/** * Report a syntax error at given position using the given * argument unless one was already reported at the same position. */ private void reportSyntaxError(int pos, String key, Object... arg) { if (pos > S.errPos() || pos == Position.NOPOS) { if (S.token() == EOF) log.error(pos, "premature.eof"); else log.error(pos, key, arg); } S.errPos(pos); if (S.pos() == errorPos) S.nextToken(); // guarantee progress errorPos = S.pos(); }
/** TypeDeclaration = ClassOrInterfaceOrEnumDeclaration * | ";" */ JCTree typeDeclaration(JCModifiers mods) { int pos = S.pos(); if (mods == null && S.token() == SEMI) { S.nextToken(); return toP(F.at(pos).Skip()); } else { String dc = S.docComment(); return classOrInterfaceOrEnumDeclaration(modifiersOpt(mods), dc); } }
/** {@inheritDoc} */ @Override protected <T extends JCTree> T to(T t) { storeEnd(t, S.endPos()); return t; }
if (S.token() == SEMI) { S.nextToken(); return List.<JCTree>of(F.at(Position.NOPOS).Block(0, List.<JCStatement>nil())); } else { String dc = S.docComment(); int pos = S.pos(); JCModifiers mods = modifiersOpt(); if (S.token() == CLASS || S.token() == INTERFACE || allowEnums && S.token() == ENUM) { return List.<JCTree>of(classOrInterfaceOrEnumDeclaration(mods, dc)); } else if (S.token() == LBRACE && !isInterface && (mods.flags & Flags.StandardFlags & ~Flags.STATIC) == 0 && mods.annotations.isEmpty()) { return List.<JCTree>of(block(pos, mods.flags)); } else { pos = S.pos(); List<JCTypeParameter> typarams = typeParametersOpt(); Token token = S.token(); Name name = S.name(); pos = S.pos(); JCExpression type; boolean isVoid = S.token() == VOID; if (isVoid) { type = to(F.at(pos).TypeIdent(TypeTags.VOID)); S.nextToken(); } else { type = type();
if (S.token() == IDENTIFIER) { Name name = S.name(); S.nextToken(); return name; } else if (S.token() == ASSERT) { if (allowAsserts) { log.error(S.pos(), "assert.as.identifier"); S.nextToken(); return names.error; } else { log.warning(S.pos(), "assert.as.identifier"); Name name = S.name(); S.nextToken(); return name; } else if (S.token() == ENUM) { if (allowEnums) { log.error(S.pos(), "enum.as.identifier"); S.nextToken(); return names.error; } else { log.warning(S.pos(), "enum.as.identifier"); Name name = S.name(); S.nextToken(); return name;
JCModifiers modifiersOpt(JCModifiers partial) { long flags = (partial == null) ? 0 : partial.flags; if (S.deprecatedFlag()) { flags |= Flags.DEPRECATED; S.resetDeprecatedFlag(); int pos = S.pos(); int lastPos = Position.NOPOS; loop: while (true) { long flag; switch (S.token()) { case PRIVATE : flag = Flags.PRIVATE; break; case PROTECTED : flag = Flags.PROTECTED; break; if ((flags & flag) != 0) log.error(S.pos(), "repeated.modifier"); lastPos = S.pos(); S.nextToken(); if (flag == Flags.ANNOTATION) { checkAnnotations(); if (S.token() != INTERFACE) { JCAnnotation ann = annotation(lastPos); switch (S.token()) { case ENUM: flags |= Flags.ENUM; break; case INTERFACE: flags |= Flags.INTERFACE; break; storeEnd(mods, S.prevEndPos()); return mods;
int pos = S.pos(); JCExpression t = errorTree; switch (S.token()) { case INTLITERAL: try { t = F.at(pos).Literal( TypeTags.INT, Convert.string2int(strval(prefix), S.radix())); } catch (NumberFormatException ex) { log.error(S.pos(), "int.number.too.large", strval(prefix)); t = F.at(pos).Literal( TypeTags.LONG, new Long(Convert.string2long(strval(prefix), S.radix()))); } catch (NumberFormatException ex) { log.error(S.pos(), "int.number.too.large", strval(prefix)); String proper = (S.radix() == 16 ? ("0x"+ S.stringVal()) : S.stringVal()); Float n; try { log.error(S.pos(), "fp.number.too.small"); else if (n.floatValue() == Float.POSITIVE_INFINITY) log.error(S.pos(), "fp.number.too.large"); else t = F.at(pos).Literal(TypeTags.FLOAT, n); String proper = (S.radix() == 16 ? ("0x"+ S.stringVal()) : S.stringVal()); Double n;
String dc = S.docComment(); int flags = Flags.PUBLIC|Flags.STATIC|Flags.FINAL|Flags.ENUM; if (S.deprecatedFlag()) { flags |= Flags.DEPRECATED; S.resetDeprecatedFlag(); int pos = S.pos(); List<JCAnnotation> annotations = annotationsOpt(); JCModifiers mods = F.at(annotations.isEmpty() ? Position.NOPOS : pos).Modifiers(flags, annotations); List<JCExpression> typeArgs = typeArgumentsOpt(); int identPos = S.pos(); Name name = ident(); int createPos = S.pos(); List<JCExpression> args = (S.token() == LPAREN) ? arguments() : List.<JCExpression>nil(); JCClassDecl body = null; if (S.token() == LBRACE) { JCModifiers mods1 = F.at(Position.NOPOS).Modifiers(Flags.ENUM | Flags.STATIC); List<JCTree> defs = classOrInterfaceBody(names.empty, false); JCNewClass create = F.at(createPos).NewClass(null, typeArgs, ident, args, body); if (createPos != Position.NOPOS) storeEnd(create, S.prevEndPos()); ident = F.at(Position.NOPOS).Ident(enumName); JCTree result = toP(F.at(pos).VarDef(mods, name, ident, create));
/** VariableDeclaratorsRest = VariableDeclaratorRest { "," VariableDeclarator } * 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, JCModifiers mods, JCExpression type, Name name, boolean reqInit, String dc, T vdefs) { vdefs.append(variableDeclaratorRest(pos, mods, type, name, reqInit, dc)); while (S.token() == COMMA) { // All but last of multiple declarators subsume a comma storeEnd((JCTree)vdefs.elems.last(), S.endPos()); S.nextToken(); vdefs.append(variableDeclarator(mods, type, reqInit, dc)); } return vdefs; }
@SuppressWarnings("unchecked") protected boolean peekToken(int lookahead, Filter<TokenKind>... kinds) { for (; lookahead < kinds.length ; lookahead++) { if (!kinds[lookahead].accepts(S.token(lookahead + 1).kind)) { return false; } } return true; }
void checkAnnotations() { if (!allowAnnotations) { log.error(S.pos(), "annotations.not.supported.in.source", source.name); allowAnnotations = true; } } }
attach(toplevel, firstToken.comment(CommentStyle.JAVADOC)); if (defs.isEmpty()) storeEnd(toplevel, S.prevToken().endPos); if (keepDocComments) toplevel.docComments = docComments; if (keepLineMap) toplevel.lineMap = S.getLineMap(); this.endPosTable.setParser(null); // remove reference to parser toplevel.endPositions = this.endPosTable;
/** {@inheritDoc} */ @Override protected <T extends JCTree> T toP(T t) { storeEnd(t, S.prevEndPos()); return t; }
/** If next input token matches given token, skip it, otherwise report * an error. */ public void accept(Token token) { if (S.token() == token) { S.nextToken(); } else { setErrorEndPos(S.pos()); reportSyntaxError(S.prevEndPos(), "expected", keywords.token2string(token)); } }
if (S.token() == SEMI) { S.nextToken(); return List.<JCTree>of(F.at(Position.NOPOS).Block(0, List.<JCStatement>nil())); } else { String dc = S.docComment(); int pos = S.pos(); JCModifiers mods = modifiersOpt(); if (S.token() == CLASS || S.token() == INTERFACE || allowEnums && S.token() == ENUM) { return List.<JCTree>of(classOrInterfaceOrEnumDeclaration(mods, dc)); } else if (S.token() == LBRACE && !isInterface && (mods.flags & Flags.StandardFlags & ~Flags.STATIC) == 0 && mods.annotations.isEmpty()) { return List.<JCTree>of(block(pos, mods.flags)); } else { pos = S.pos(); List<JCTypeParameter> typarams = typeParametersOpt(); Token token = S.token(); Name name = S.name(); pos = S.pos(); JCExpression type; boolean isVoid = S.token() == VOID; if (isVoid) { type = to(F.at(pos).TypeIdent(TypeTags.VOID)); S.nextToken(); } else { type = type();