src/share/classes/com/sun/tools/javac/parser/JavacParser.java

Print this page




 735         int topOpPos = Position.NOPOS;
 736         while (prec(S.token()) >= minprec) {
 737             posStack[top] = topOpPos;
 738             opStack[top] = topOp;
 739             top++;
 740             topOp = S.token();
 741             topOpPos = S.pos();
 742             S.nextToken();
 743             odStack[top] = (topOp == INSTANCEOF) ? parseType() : term3();
 744             while (top > 0 && prec(topOp) >= prec(S.token())) {
 745                 odStack[top-1] = makeOp(topOpPos, topOp, odStack[top-1],
 746                                         odStack[top]);
 747                 top--;
 748                 topOp = opStack[top];
 749                 topOpPos = posStack[top];
 750             }
 751         }
 752         Assert.check(top == 0);
 753         t = odStack[0];
 754 
 755         if (t.getTag() == JCTree.PLUS) {
 756             StringBuffer buf = foldStrings(t);
 757             if (buf != null) {
 758                 t = toP(F.at(startPos).Literal(TypeTags.CLASS, buf.toString()));
 759             }
 760         }
 761 
 762         odStackSupply.elems = savedOd; // optimization
 763         opStackSupply.elems = savedOp; // optimization
 764         posStackSupply.elems = savedPos; // optimization
 765         return t;
 766     }
 767 //where
 768         /** Construct a binary or type test node.
 769          */
 770         private JCExpression makeOp(int pos,
 771                                     Token topOp,
 772                                     JCExpression od1,
 773                                     JCExpression od2)
 774         {
 775             if (topOp == INSTANCEOF) {
 776                 return F.at(pos).TypeTest(od1, od2);
 777             } else {
 778                 return F.at(pos).Binary(optag(topOp), od1, od2);
 779             }
 780         }
 781         /** If tree is a concatenation of string literals, replace it
 782          *  by a single literal representing the concatenated string.
 783          */
 784         protected StringBuffer foldStrings(JCTree tree) {
 785             if (!allowStringFolding)
 786                 return null;
 787             List<String> buf = List.nil();
 788             while (true) {
 789                 if (tree.getTag() == JCTree.LITERAL) {
 790                     JCLiteral lit = (JCLiteral) tree;
 791                     if (lit.typetag == TypeTags.CLASS) {
 792                         StringBuffer sbuf =
 793                             new StringBuffer((String)lit.value);
 794                         while (buf.nonEmpty()) {
 795                             sbuf.append(buf.head);
 796                             buf = buf.tail;
 797                         }
 798                         return sbuf;
 799                     }
 800                 } else if (tree.getTag() == JCTree.PLUS) {
 801                     JCBinary op = (JCBinary)tree;
 802                     if (op.rhs.getTag() == JCTree.LITERAL) {
 803                         JCLiteral lit = (JCLiteral) op.rhs;
 804                         if (lit.typetag == TypeTags.CLASS) {
 805                             buf = buf.prepend((String) lit.value);
 806                             tree = op.lhs;
 807                             continue;
 808                         }
 809                     }
 810                 }
 811                 return null;
 812             }
 813         }
 814 
 815         /** optimization: To save allocating a new operand/operator stack
 816          *  for every binary operation, we use supplys.
 817          */
 818         ListBuffer<JCExpression[]> odStackSupply = new ListBuffer<JCExpression[]>();
 819         ListBuffer<Token[]> opStackSupply = new ListBuffer<Token[]>();
 820         ListBuffer<int[]> posStackSupply = new ListBuffer<int[]>();
 821 
 822         private JCExpression[] newOdStack() {


 887                 S.nextToken();
 888                 mode = EXPR;
 889                 if (token == SUB &&
 890                     (S.token() == INTLITERAL || S.token() == LONGLITERAL) &&
 891                     S.radix() == 10) {
 892                     mode = EXPR;
 893                     t = literal(names.hyphen, pos);
 894                 } else {
 895                     t = term3();
 896                     return F.at(pos).Unary(unoptag(token), t);
 897                 }
 898             } else return illegal();
 899             break;
 900         case LPAREN:
 901             if (typeArgs == null && (mode & EXPR) != 0) {
 902                 S.nextToken();
 903                 mode = EXPR | TYPE | NOPARAMS;
 904                 t = term3();
 905                 if ((mode & TYPE) != 0 && S.token() == LT) {
 906                     // Could be a cast to a parameterized type
 907                     int op = JCTree.LT;
 908                     int pos1 = S.pos();
 909                     S.nextToken();
 910                     mode &= (EXPR | TYPE);
 911                     mode |= TYPEARG;
 912                     JCExpression t1 = term3();
 913                     if ((mode & TYPE) != 0 &&
 914                         (S.token() == COMMA || S.token() == GT)) {
 915                         mode = TYPE;
 916                         ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
 917                         args.append(t1);
 918                         while (S.token() == COMMA) {
 919                             S.nextToken();
 920                             args.append(typeArgument());
 921                         }
 922                         accept(GT);
 923                         t = toP(F.at(pos1).TypeApply(t, args.toList()));
 924                         checkGenerics();
 925                         while (S.token() == DOT) {
 926                             S.nextToken();
 927                             mode = TYPE;


1141                 } else if (S.token() == NEW && (mode & EXPR) != 0) {
1142                     if (typeArgs != null) return illegal();
1143                     mode = EXPR;
1144                     int pos2 = S.pos();
1145                     S.nextToken();
1146                     if (S.token() == LT) typeArgs = typeArguments(false);
1147                     t = innerCreator(pos2, typeArgs, t);
1148                     typeArgs = null;
1149                 } else {
1150                     t = toP(F.at(pos1).Select(t, ident()));
1151                     t = argumentsOpt(typeArgs, typeArgumentsOpt(t));
1152                     typeArgs = null;
1153                 }
1154             } else {
1155                 break;
1156             }
1157         }
1158         while ((S.token() == PLUSPLUS || S.token() == SUBSUB) && (mode & EXPR) != 0) {
1159             mode = EXPR;
1160             t = to(F.at(S.pos()).Unary(
1161                   S.token() == PLUSPLUS ? JCTree.POSTINC : JCTree.POSTDEC, t));
1162             S.nextToken();
1163         }
1164         return toP(t);
1165     }
1166 
1167     /** SuperSuffix = Arguments | "." [TypeArguments] Ident [Arguments]
1168      */
1169     JCExpression superSuffix(List<JCExpression> typeArgs, JCExpression t) {
1170         S.nextToken();
1171         if (S.token() == LPAREN || typeArgs != null) {
1172             t = arguments(typeArgs, t);
1173         } else {
1174             int pos = S.pos();
1175             accept(DOT);
1176             typeArgs = (S.token() == LT) ? typeArguments(false) : null;
1177             t = toP(F.at(pos).Select(t, ident()));
1178             t = argumentsOpt(typeArgs, t);
1179         }
1180         return t;
1181     }


1625             case CLASS:
1626                 stats.append(classOrInterfaceOrEnumDeclaration(modifiersOpt(),
1627                                                                S.docComment()));
1628                 break;
1629             case ENUM:
1630             case ASSERT:
1631                 if (allowEnums && S.token() == ENUM) {
1632                     error(S.pos(), "local.enum");
1633                     stats.
1634                         append(classOrInterfaceOrEnumDeclaration(modifiersOpt(),
1635                                                                  S.docComment()));
1636                     break;
1637                 } else if (allowAsserts && S.token() == ASSERT) {
1638                     stats.append(parseStatement());
1639                     break;
1640                 }
1641                 /* fall through to default */
1642             default:
1643                 Name name = S.name();
1644                 JCExpression t = term(EXPR | TYPE);
1645                 if (S.token() == COLON && t.getTag() == JCTree.IDENT) {
1646                     S.nextToken();
1647                     JCStatement stat = parseStatement();
1648                     stats.append(F.at(pos).Labelled(name, stat));
1649                 } else if ((lastmode & TYPE) != 0 &&
1650                            (S.token() == IDENTIFIER ||
1651                             S.token() == ASSERT ||
1652                             S.token() == ENUM)) {
1653                     pos = S.pos();
1654                     JCModifiers mods = F.at(Position.NOPOS).Modifiers(0);
1655                     F.at(pos);
1656                     stats.appendList(variableDeclarators(mods, t,
1657                                                          new ListBuffer<JCStatement>()));
1658                     // A "LocalVariableDeclarationStatement" subsumes the terminating semicolon
1659                     storeEnd(stats.elems.last(), S.endPos());
1660                     accept(SEMI);
1661                 } else {
1662                     // This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
1663                     stats.append(to(F.at(pos).Exec(checkExprStat(t))));
1664                     accept(SEMI);
1665                 }


1703         int pos = S.pos();
1704         switch (S.token()) {
1705         case LBRACE:
1706             return block();
1707         case IF: {
1708             S.nextToken();
1709             JCExpression cond = parExpression();
1710             JCStatement thenpart = parseStatement();
1711             JCStatement elsepart = null;
1712             if (S.token() == ELSE) {
1713                 S.nextToken();
1714                 elsepart = parseStatement();
1715             }
1716             return F.at(pos).If(cond, thenpart, elsepart);
1717         }
1718         case FOR: {
1719             S.nextToken();
1720             accept(LPAREN);
1721             List<JCStatement> inits = S.token() == SEMI ? List.<JCStatement>nil() : forInit();
1722             if (inits.length() == 1 &&
1723                 inits.head.getTag() == JCTree.VARDEF &&
1724                 ((JCVariableDecl) inits.head).init == null &&
1725                 S.token() == COLON) {
1726                 checkForeach();
1727                 JCVariableDecl var = (JCVariableDecl)inits.head;
1728                 accept(COLON);
1729                 JCExpression expr = parseExpression();
1730                 accept(RPAREN);
1731                 JCStatement body = parseStatement();
1732                 return F.at(pos).ForeachLoop(var, expr, body);
1733             } else {
1734                 accept(SEMI);
1735                 JCExpression cond = S.token() == SEMI ? null : parseExpression();
1736                 accept(SEMI);
1737                 List<JCExpressionStatement> steps = S.token() == RPAREN ? List.<JCExpressionStatement>nil() : forUpdate();
1738                 accept(RPAREN);
1739                 JCStatement body = parseStatement();
1740                 return F.at(pos).ForLoop(inits, cond, steps, body);
1741             }
1742         }
1743         case WHILE: {


1836             return toP(F.Exec(syntaxError("catch.without.try")));
1837         case ASSERT: {
1838             if (allowAsserts && S.token() == ASSERT) {
1839                 S.nextToken();
1840                 JCExpression assertion = parseExpression();
1841                 JCExpression message = null;
1842                 if (S.token() == COLON) {
1843                     S.nextToken();
1844                     message = parseExpression();
1845                 }
1846                 JCAssert t = to(F.at(pos).Assert(assertion, message));
1847                 accept(SEMI);
1848                 return t;
1849             }
1850             /* else fall through to default case */
1851         }
1852         case ENUM:
1853         default:
1854             Name name = S.name();
1855             JCExpression expr = parseExpression();
1856             if (S.token() == COLON && expr.getTag() == JCTree.IDENT) {
1857                 S.nextToken();
1858                 JCStatement stat = parseStatement();
1859                 return F.at(pos).Labelled(name, stat);
1860             } else {
1861                 // This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
1862                 JCExpressionStatement stat = to(F.at(pos).Exec(checkExprStat(expr)));
1863                 accept(SEMI);
1864                 return stat;
1865             }
1866         }
1867     }
1868 
1869     /** CatchClause     = CATCH "(" FormalParameter ")" Block
1870      */
1871     protected JCCatch catchClause() {
1872         int pos = S.pos();
1873         accept(CATCH);
1874         accept(LPAREN);
1875         JCModifiers mods = optFinal(Flags.PARAMETER);
1876         List<JCExpression> catchTypes = catchTypes();


2090         accept(LPAREN);
2091         ListBuffer<JCExpression> buf = new ListBuffer<JCExpression>();
2092         if (S.token() != RPAREN) {
2093             buf.append(annotationFieldValue());
2094             while (S.token() == COMMA) {
2095                 S.nextToken();
2096                 buf.append(annotationFieldValue());
2097             }
2098         }
2099         accept(RPAREN);
2100         return buf.toList();
2101     }
2102 
2103     /** AnnotationFieldValue    = AnnotationValue
2104      *                          | Identifier "=" AnnotationValue
2105      */
2106     JCExpression annotationFieldValue() {
2107         if (S.token() == IDENTIFIER) {
2108             mode = EXPR;
2109             JCExpression t1 = term1();
2110             if (t1.getTag() == JCTree.IDENT && S.token() == EQ) {
2111                 int pos = S.pos();
2112                 accept(EQ);
2113                 JCExpression v = annotationValue();
2114                 return toP(F.at(pos).Assign(t1, v));
2115             } else {
2116                 return t1;
2117             }
2118         }
2119         return annotationValue();
2120     }
2121 
2122     /* AnnotationValue          = ConditionalExpression
2123      *                          | Annotation
2124      *                          | "{" [ AnnotationValue { "," AnnotationValue } ] [","] "}"
2125      */
2126     JCExpression annotationValue() {
2127         int pos;
2128         switch (S.token()) {
2129         case MONKEYS_AT:
2130             pos = S.pos();


2615                 return List.<JCTree>of(block(pos, mods.flags));
2616             } else {
2617                 pos = S.pos();
2618                 List<JCTypeParameter> typarams = typeParametersOpt();
2619                 // if there are type parameters but no modifiers, save the start
2620                 // position of the method in the modifiers.
2621                 if (typarams.nonEmpty() && mods.pos == Position.NOPOS) {
2622                     mods.pos = pos;
2623                     storeEnd(mods, pos);
2624                 }
2625                 Name name = S.name();
2626                 pos = S.pos();
2627                 JCExpression type;
2628                 boolean isVoid = S.token() == VOID;
2629                 if (isVoid) {
2630                     type = to(F.at(pos).TypeIdent(TypeTags.VOID));
2631                     S.nextToken();
2632                 } else {
2633                     type = parseType();
2634                 }
2635                 if (S.token() == LPAREN && !isInterface && type.getTag() == JCTree.IDENT) {
2636                     if (isInterface || name != className)
2637                         error(pos, "invalid.meth.decl.ret.type.req");
2638                     return List.of(methodDeclaratorRest(
2639                         pos, mods, null, names.init, typarams,
2640                         isInterface, true, dc));
2641                 } else {
2642                     pos = S.pos();
2643                     name = ident();
2644                     if (S.token() == LPAREN) {
2645                         return List.of(methodDeclaratorRest(
2646                             pos, mods, type, name, typarams,
2647                             isInterface, isVoid, dc));
2648                     } else if (!isVoid && typarams.isEmpty()) {
2649                         List<JCTree> defs =
2650                             variableDeclaratorsRest(pos, mods, type, name, isInterface, dc,
2651                                                     new ListBuffer<JCTree>()).toList();
2652                         storeEnd(defs.last(), S.endPos());
2653                         accept(SEMI);
2654                         return defs;
2655                     } else {


2812     }
2813 
2814 /* ---------- auxiliary methods -------------- */
2815 
2816     void error(int pos, String key, Object ... args) {
2817         log.error(DiagnosticFlag.SYNTAX, pos, key, args);
2818     }
2819 
2820     void error(DiagnosticPosition pos, String key, Object ... args) {
2821         log.error(DiagnosticFlag.SYNTAX, pos, key, args);
2822     }
2823 
2824     void warning(int pos, String key, Object ... args) {
2825         log.warning(pos, key, args);
2826     }
2827 
2828     /** Check that given tree is a legal expression statement.
2829      */
2830     protected JCExpression checkExprStat(JCExpression t) {
2831         switch(t.getTag()) {
2832         case JCTree.PREINC: case JCTree.PREDEC:
2833         case JCTree.POSTINC: case JCTree.POSTDEC:
2834         case JCTree.ASSIGN:
2835         case JCTree.BITOR_ASG: case JCTree.BITXOR_ASG: case JCTree.BITAND_ASG:
2836         case JCTree.SL_ASG: case JCTree.SR_ASG: case JCTree.USR_ASG:
2837         case JCTree.PLUS_ASG: case JCTree.MINUS_ASG:
2838         case JCTree.MUL_ASG: case JCTree.DIV_ASG: case JCTree.MOD_ASG:
2839         case JCTree.APPLY: case JCTree.NEWCLASS:
2840         case JCTree.ERRONEOUS:
2841             return t;
2842         default:
2843             JCExpression ret = F.at(t.pos).Erroneous(List.<JCTree>of(t));
2844             error(ret, "not.stmt");
2845             return ret;
2846         }
2847     }
2848 
2849     /** Return precedence of operator represented by token,
2850      *  -1 if token is not a binary operator. @see TreeInfo.opPrec
2851      */
2852     static int prec(Token token) {
2853         int oc = optag(token);
2854         return (oc >= 0) ? TreeInfo.opPrec(oc) : -1;
2855     }
2856 
2857     /**
2858      * Return the lesser of two positions, making allowance for either one
2859      * being unset.
2860      */
2861     static int earlier(int pos1, int pos2) {
2862         if (pos1 == Position.NOPOS)
2863             return pos2;
2864         if (pos2 == Position.NOPOS)
2865             return pos1;
2866         return (pos1 < pos2 ? pos1 : pos2);
2867     }
2868 
2869     /** Return operation tag of binary operator represented by token,
2870      *  -1 if token is not a binary operator.
2871      */
2872     static int optag(Token token) {
2873         switch (token) {
2874         case BARBAR:
2875             return JCTree.OR;
2876         case AMPAMP:
2877             return JCTree.AND;
2878         case BAR:
2879             return JCTree.BITOR;
2880         case BAREQ:
2881             return JCTree.BITOR_ASG;
2882         case CARET:
2883             return JCTree.BITXOR;
2884         case CARETEQ:
2885             return JCTree.BITXOR_ASG;
2886         case AMP:
2887             return JCTree.BITAND;
2888         case AMPEQ:
2889             return JCTree.BITAND_ASG;
2890         case EQEQ:
2891             return JCTree.EQ;
2892         case BANGEQ:
2893             return JCTree.NE;
2894         case LT:
2895             return JCTree.LT;
2896         case GT:
2897             return JCTree.GT;
2898         case LTEQ:
2899             return JCTree.LE;
2900         case GTEQ:
2901             return JCTree.GE;
2902         case LTLT:
2903             return JCTree.SL;
2904         case LTLTEQ:
2905             return JCTree.SL_ASG;
2906         case GTGT:
2907             return JCTree.SR;
2908         case GTGTEQ:
2909             return JCTree.SR_ASG;
2910         case GTGTGT:
2911             return JCTree.USR;
2912         case GTGTGTEQ:
2913             return JCTree.USR_ASG;
2914         case PLUS:
2915             return JCTree.PLUS;
2916         case PLUSEQ:
2917             return JCTree.PLUS_ASG;
2918         case SUB:
2919             return JCTree.MINUS;
2920         case SUBEQ:
2921             return JCTree.MINUS_ASG;
2922         case STAR:
2923             return JCTree.MUL;
2924         case STAREQ:
2925             return JCTree.MUL_ASG;
2926         case SLASH:
2927             return JCTree.DIV;
2928         case SLASHEQ:
2929             return JCTree.DIV_ASG;
2930         case PERCENT:
2931             return JCTree.MOD;
2932         case PERCENTEQ:
2933             return JCTree.MOD_ASG;
2934         case INSTANCEOF:
2935             return JCTree.TYPETEST;
2936         default:
2937             return -1;
2938         }
2939     }
2940 
2941     /** Return operation tag of unary operator represented by token,
2942      *  -1 if token is not a binary operator.
2943      */
2944     static int unoptag(Token token) {
2945         switch (token) {
2946         case PLUS:
2947             return JCTree.POS;
2948         case SUB:
2949             return JCTree.NEG;
2950         case BANG:
2951             return JCTree.NOT;
2952         case TILDE:
2953             return JCTree.COMPL;
2954         case PLUSPLUS:
2955             return JCTree.PREINC;
2956         case SUBSUB:
2957             return JCTree.PREDEC;
2958         default:
2959             return -1;
2960         }
2961     }
2962 
2963     /** Return type tag of basic type represented by token,
2964      *  -1 if token is not a basic type identifier.
2965      */
2966     static int typetag(Token token) {
2967         switch (token) {
2968         case BYTE:
2969             return TypeTags.BYTE;
2970         case CHAR:
2971             return TypeTags.CHAR;
2972         case SHORT:
2973             return TypeTags.SHORT;
2974         case INT:
2975             return TypeTags.INT;
2976         case LONG:
2977             return TypeTags.LONG;
2978         case FLOAT:
2979             return TypeTags.FLOAT;




 735         int topOpPos = Position.NOPOS;
 736         while (prec(S.token()) >= minprec) {
 737             posStack[top] = topOpPos;
 738             opStack[top] = topOp;
 739             top++;
 740             topOp = S.token();
 741             topOpPos = S.pos();
 742             S.nextToken();
 743             odStack[top] = (topOp == INSTANCEOF) ? parseType() : term3();
 744             while (top > 0 && prec(topOp) >= prec(S.token())) {
 745                 odStack[top-1] = makeOp(topOpPos, topOp, odStack[top-1],
 746                                         odStack[top]);
 747                 top--;
 748                 topOp = opStack[top];
 749                 topOpPos = posStack[top];
 750             }
 751         }
 752         Assert.check(top == 0);
 753         t = odStack[0];
 754 
 755         if (t.getTag() == JCTree.Tag.PLUS) {
 756             StringBuffer buf = foldStrings(t);
 757             if (buf != null) {
 758                 t = toP(F.at(startPos).Literal(TypeTags.CLASS, buf.toString()));
 759             }
 760         }
 761 
 762         odStackSupply.elems = savedOd; // optimization
 763         opStackSupply.elems = savedOp; // optimization
 764         posStackSupply.elems = savedPos; // optimization
 765         return t;
 766     }
 767 //where
 768         /** Construct a binary or type test node.
 769          */
 770         private JCExpression makeOp(int pos,
 771                                     Token topOp,
 772                                     JCExpression od1,
 773                                     JCExpression od2)
 774         {
 775             if (topOp == INSTANCEOF) {
 776                 return F.at(pos).TypeTest(od1, od2);
 777             } else {
 778                 return F.at(pos).Binary(optag(topOp), od1, od2);
 779             }
 780         }
 781         /** If tree is a concatenation of string literals, replace it
 782          *  by a single literal representing the concatenated string.
 783          */
 784         protected StringBuffer foldStrings(JCTree tree) {
 785             if (!allowStringFolding)
 786                 return null;
 787             List<String> buf = List.nil();
 788             while (true) {
 789                 if (tree.getTag() == JCTree.Tag.LITERAL) {
 790                     JCLiteral lit = (JCLiteral) tree;
 791                     if (lit.typetag == TypeTags.CLASS) {
 792                         StringBuffer sbuf =
 793                             new StringBuffer((String)lit.value);
 794                         while (buf.nonEmpty()) {
 795                             sbuf.append(buf.head);
 796                             buf = buf.tail;
 797                         }
 798                         return sbuf;
 799                     }
 800                 } else if (tree.getTag() == JCTree.Tag.PLUS) {
 801                     JCBinary op = (JCBinary)tree;
 802                     if (op.rhs.getTag() == JCTree.Tag.LITERAL) {
 803                         JCLiteral lit = (JCLiteral) op.rhs;
 804                         if (lit.typetag == TypeTags.CLASS) {
 805                             buf = buf.prepend((String) lit.value);
 806                             tree = op.lhs;
 807                             continue;
 808                         }
 809                     }
 810                 }
 811                 return null;
 812             }
 813         }
 814 
 815         /** optimization: To save allocating a new operand/operator stack
 816          *  for every binary operation, we use supplys.
 817          */
 818         ListBuffer<JCExpression[]> odStackSupply = new ListBuffer<JCExpression[]>();
 819         ListBuffer<Token[]> opStackSupply = new ListBuffer<Token[]>();
 820         ListBuffer<int[]> posStackSupply = new ListBuffer<int[]>();
 821 
 822         private JCExpression[] newOdStack() {


 887                 S.nextToken();
 888                 mode = EXPR;
 889                 if (token == SUB &&
 890                     (S.token() == INTLITERAL || S.token() == LONGLITERAL) &&
 891                     S.radix() == 10) {
 892                     mode = EXPR;
 893                     t = literal(names.hyphen, pos);
 894                 } else {
 895                     t = term3();
 896                     return F.at(pos).Unary(unoptag(token), t);
 897                 }
 898             } else return illegal();
 899             break;
 900         case LPAREN:
 901             if (typeArgs == null && (mode & EXPR) != 0) {
 902                 S.nextToken();
 903                 mode = EXPR | TYPE | NOPARAMS;
 904                 t = term3();
 905                 if ((mode & TYPE) != 0 && S.token() == LT) {
 906                     // Could be a cast to a parameterized type
 907                     JCTree.Tag op = JCTree.Tag.LT;
 908                     int pos1 = S.pos();
 909                     S.nextToken();
 910                     mode &= (EXPR | TYPE);
 911                     mode |= TYPEARG;
 912                     JCExpression t1 = term3();
 913                     if ((mode & TYPE) != 0 &&
 914                         (S.token() == COMMA || S.token() == GT)) {
 915                         mode = TYPE;
 916                         ListBuffer<JCExpression> args = new ListBuffer<JCExpression>();
 917                         args.append(t1);
 918                         while (S.token() == COMMA) {
 919                             S.nextToken();
 920                             args.append(typeArgument());
 921                         }
 922                         accept(GT);
 923                         t = toP(F.at(pos1).TypeApply(t, args.toList()));
 924                         checkGenerics();
 925                         while (S.token() == DOT) {
 926                             S.nextToken();
 927                             mode = TYPE;


1141                 } else if (S.token() == NEW && (mode & EXPR) != 0) {
1142                     if (typeArgs != null) return illegal();
1143                     mode = EXPR;
1144                     int pos2 = S.pos();
1145                     S.nextToken();
1146                     if (S.token() == LT) typeArgs = typeArguments(false);
1147                     t = innerCreator(pos2, typeArgs, t);
1148                     typeArgs = null;
1149                 } else {
1150                     t = toP(F.at(pos1).Select(t, ident()));
1151                     t = argumentsOpt(typeArgs, typeArgumentsOpt(t));
1152                     typeArgs = null;
1153                 }
1154             } else {
1155                 break;
1156             }
1157         }
1158         while ((S.token() == PLUSPLUS || S.token() == SUBSUB) && (mode & EXPR) != 0) {
1159             mode = EXPR;
1160             t = to(F.at(S.pos()).Unary(
1161                   S.token() == PLUSPLUS ? JCTree.Tag.POSTINC : JCTree.Tag.POSTDEC, t));
1162             S.nextToken();
1163         }
1164         return toP(t);
1165     }
1166 
1167     /** SuperSuffix = Arguments | "." [TypeArguments] Ident [Arguments]
1168      */
1169     JCExpression superSuffix(List<JCExpression> typeArgs, JCExpression t) {
1170         S.nextToken();
1171         if (S.token() == LPAREN || typeArgs != null) {
1172             t = arguments(typeArgs, t);
1173         } else {
1174             int pos = S.pos();
1175             accept(DOT);
1176             typeArgs = (S.token() == LT) ? typeArguments(false) : null;
1177             t = toP(F.at(pos).Select(t, ident()));
1178             t = argumentsOpt(typeArgs, t);
1179         }
1180         return t;
1181     }


1625             case CLASS:
1626                 stats.append(classOrInterfaceOrEnumDeclaration(modifiersOpt(),
1627                                                                S.docComment()));
1628                 break;
1629             case ENUM:
1630             case ASSERT:
1631                 if (allowEnums && S.token() == ENUM) {
1632                     error(S.pos(), "local.enum");
1633                     stats.
1634                         append(classOrInterfaceOrEnumDeclaration(modifiersOpt(),
1635                                                                  S.docComment()));
1636                     break;
1637                 } else if (allowAsserts && S.token() == ASSERT) {
1638                     stats.append(parseStatement());
1639                     break;
1640                 }
1641                 /* fall through to default */
1642             default:
1643                 Name name = S.name();
1644                 JCExpression t = term(EXPR | TYPE);
1645                 if (S.token() == COLON && t.getTag() == JCTree.Tag.IDENT) {
1646                     S.nextToken();
1647                     JCStatement stat = parseStatement();
1648                     stats.append(F.at(pos).Labelled(name, stat));
1649                 } else if ((lastmode & TYPE) != 0 &&
1650                            (S.token() == IDENTIFIER ||
1651                             S.token() == ASSERT ||
1652                             S.token() == ENUM)) {
1653                     pos = S.pos();
1654                     JCModifiers mods = F.at(Position.NOPOS).Modifiers(0);
1655                     F.at(pos);
1656                     stats.appendList(variableDeclarators(mods, t,
1657                                                          new ListBuffer<JCStatement>()));
1658                     // A "LocalVariableDeclarationStatement" subsumes the terminating semicolon
1659                     storeEnd(stats.elems.last(), S.endPos());
1660                     accept(SEMI);
1661                 } else {
1662                     // This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
1663                     stats.append(to(F.at(pos).Exec(checkExprStat(t))));
1664                     accept(SEMI);
1665                 }


1703         int pos = S.pos();
1704         switch (S.token()) {
1705         case LBRACE:
1706             return block();
1707         case IF: {
1708             S.nextToken();
1709             JCExpression cond = parExpression();
1710             JCStatement thenpart = parseStatement();
1711             JCStatement elsepart = null;
1712             if (S.token() == ELSE) {
1713                 S.nextToken();
1714                 elsepart = parseStatement();
1715             }
1716             return F.at(pos).If(cond, thenpart, elsepart);
1717         }
1718         case FOR: {
1719             S.nextToken();
1720             accept(LPAREN);
1721             List<JCStatement> inits = S.token() == SEMI ? List.<JCStatement>nil() : forInit();
1722             if (inits.length() == 1 &&
1723                 inits.head.getTag() == JCTree.Tag.VARDEF &&
1724                 ((JCVariableDecl) inits.head).init == null &&
1725                 S.token() == COLON) {
1726                 checkForeach();
1727                 JCVariableDecl var = (JCVariableDecl)inits.head;
1728                 accept(COLON);
1729                 JCExpression expr = parseExpression();
1730                 accept(RPAREN);
1731                 JCStatement body = parseStatement();
1732                 return F.at(pos).ForeachLoop(var, expr, body);
1733             } else {
1734                 accept(SEMI);
1735                 JCExpression cond = S.token() == SEMI ? null : parseExpression();
1736                 accept(SEMI);
1737                 List<JCExpressionStatement> steps = S.token() == RPAREN ? List.<JCExpressionStatement>nil() : forUpdate();
1738                 accept(RPAREN);
1739                 JCStatement body = parseStatement();
1740                 return F.at(pos).ForLoop(inits, cond, steps, body);
1741             }
1742         }
1743         case WHILE: {


1836             return toP(F.Exec(syntaxError("catch.without.try")));
1837         case ASSERT: {
1838             if (allowAsserts && S.token() == ASSERT) {
1839                 S.nextToken();
1840                 JCExpression assertion = parseExpression();
1841                 JCExpression message = null;
1842                 if (S.token() == COLON) {
1843                     S.nextToken();
1844                     message = parseExpression();
1845                 }
1846                 JCAssert t = to(F.at(pos).Assert(assertion, message));
1847                 accept(SEMI);
1848                 return t;
1849             }
1850             /* else fall through to default case */
1851         }
1852         case ENUM:
1853         default:
1854             Name name = S.name();
1855             JCExpression expr = parseExpression();
1856             if (S.token() == COLON && expr.getTag() == JCTree.Tag.IDENT) {
1857                 S.nextToken();
1858                 JCStatement stat = parseStatement();
1859                 return F.at(pos).Labelled(name, stat);
1860             } else {
1861                 // This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
1862                 JCExpressionStatement stat = to(F.at(pos).Exec(checkExprStat(expr)));
1863                 accept(SEMI);
1864                 return stat;
1865             }
1866         }
1867     }
1868 
1869     /** CatchClause     = CATCH "(" FormalParameter ")" Block
1870      */
1871     protected JCCatch catchClause() {
1872         int pos = S.pos();
1873         accept(CATCH);
1874         accept(LPAREN);
1875         JCModifiers mods = optFinal(Flags.PARAMETER);
1876         List<JCExpression> catchTypes = catchTypes();


2090         accept(LPAREN);
2091         ListBuffer<JCExpression> buf = new ListBuffer<JCExpression>();
2092         if (S.token() != RPAREN) {
2093             buf.append(annotationFieldValue());
2094             while (S.token() == COMMA) {
2095                 S.nextToken();
2096                 buf.append(annotationFieldValue());
2097             }
2098         }
2099         accept(RPAREN);
2100         return buf.toList();
2101     }
2102 
2103     /** AnnotationFieldValue    = AnnotationValue
2104      *                          | Identifier "=" AnnotationValue
2105      */
2106     JCExpression annotationFieldValue() {
2107         if (S.token() == IDENTIFIER) {
2108             mode = EXPR;
2109             JCExpression t1 = term1();
2110             if (t1.getTag() == JCTree.Tag.IDENT && S.token() == EQ) {
2111                 int pos = S.pos();
2112                 accept(EQ);
2113                 JCExpression v = annotationValue();
2114                 return toP(F.at(pos).Assign(t1, v));
2115             } else {
2116                 return t1;
2117             }
2118         }
2119         return annotationValue();
2120     }
2121 
2122     /* AnnotationValue          = ConditionalExpression
2123      *                          | Annotation
2124      *                          | "{" [ AnnotationValue { "," AnnotationValue } ] [","] "}"
2125      */
2126     JCExpression annotationValue() {
2127         int pos;
2128         switch (S.token()) {
2129         case MONKEYS_AT:
2130             pos = S.pos();


2615                 return List.<JCTree>of(block(pos, mods.flags));
2616             } else {
2617                 pos = S.pos();
2618                 List<JCTypeParameter> typarams = typeParametersOpt();
2619                 // if there are type parameters but no modifiers, save the start
2620                 // position of the method in the modifiers.
2621                 if (typarams.nonEmpty() && mods.pos == Position.NOPOS) {
2622                     mods.pos = pos;
2623                     storeEnd(mods, pos);
2624                 }
2625                 Name name = S.name();
2626                 pos = S.pos();
2627                 JCExpression type;
2628                 boolean isVoid = S.token() == VOID;
2629                 if (isVoid) {
2630                     type = to(F.at(pos).TypeIdent(TypeTags.VOID));
2631                     S.nextToken();
2632                 } else {
2633                     type = parseType();
2634                 }
2635                 if (S.token() == LPAREN && !isInterface && type.getTag() == JCTree.Tag.IDENT) {
2636                     if (isInterface || name != className)
2637                         error(pos, "invalid.meth.decl.ret.type.req");
2638                     return List.of(methodDeclaratorRest(
2639                         pos, mods, null, names.init, typarams,
2640                         isInterface, true, dc));
2641                 } else {
2642                     pos = S.pos();
2643                     name = ident();
2644                     if (S.token() == LPAREN) {
2645                         return List.of(methodDeclaratorRest(
2646                             pos, mods, type, name, typarams,
2647                             isInterface, isVoid, dc));
2648                     } else if (!isVoid && typarams.isEmpty()) {
2649                         List<JCTree> defs =
2650                             variableDeclaratorsRest(pos, mods, type, name, isInterface, dc,
2651                                                     new ListBuffer<JCTree>()).toList();
2652                         storeEnd(defs.last(), S.endPos());
2653                         accept(SEMI);
2654                         return defs;
2655                     } else {


2812     }
2813 
2814 /* ---------- auxiliary methods -------------- */
2815 
2816     void error(int pos, String key, Object ... args) {
2817         log.error(DiagnosticFlag.SYNTAX, pos, key, args);
2818     }
2819 
2820     void error(DiagnosticPosition pos, String key, Object ... args) {
2821         log.error(DiagnosticFlag.SYNTAX, pos, key, args);
2822     }
2823 
2824     void warning(int pos, String key, Object ... args) {
2825         log.warning(pos, key, args);
2826     }
2827 
2828     /** Check that given tree is a legal expression statement.
2829      */
2830     protected JCExpression checkExprStat(JCExpression t) {
2831         switch(t.getTag()) {
2832         case PREINC: case PREDEC:
2833         case POSTINC: case POSTDEC:
2834         case ASSIGN:
2835         case BITOR_ASG: case BITXOR_ASG: case BITAND_ASG:
2836         case SL_ASG: case SR_ASG: case USR_ASG:
2837         case PLUS_ASG: case MINUS_ASG:
2838         case MUL_ASG: case DIV_ASG: case MOD_ASG:
2839         case APPLY: case NEWCLASS:
2840         case ERRONEOUS:
2841             return t;
2842         default:
2843             JCExpression ret = F.at(t.pos).Erroneous(List.<JCTree>of(t));
2844             error(ret, "not.stmt");
2845             return ret;
2846         }
2847     }
2848 
2849     /** Return precedence of operator represented by token,
2850      *  -1 if token is not a binary operator. @see TreeInfo.opPrec
2851      */
2852     static int prec(Token token) {
2853         JCTree.Tag oc = optag(token);
2854         return (oc.ordinal() > 0) ? TreeInfo.opPrec(oc) : -1;
2855     }
2856 
2857     /**
2858      * Return the lesser of two positions, making allowance for either one
2859      * being unset.
2860      */
2861     static int earlier(int pos1, int pos2) {
2862         if (pos1 == Position.NOPOS)
2863             return pos2;
2864         if (pos2 == Position.NOPOS)
2865             return pos1;
2866         return (pos1 < pos2 ? pos1 : pos2);
2867     }
2868 
2869     /** Return operation tag of binary operator represented by token,
2870      *  JCTree.Tag.No_TAG if token is not a binary operator.
2871      */
2872     static JCTree.Tag optag(Token token) {
2873         switch (token) {
2874         case BARBAR:
2875             return JCTree.Tag.OR;
2876         case AMPAMP:
2877             return JCTree.Tag.AND;
2878         case BAR:
2879             return JCTree.Tag.BITOR;
2880         case BAREQ:
2881             return JCTree.Tag.BITOR_ASG;
2882         case CARET:
2883             return JCTree.Tag.BITXOR;
2884         case CARETEQ:
2885             return JCTree.Tag.BITXOR_ASG;
2886         case AMP:
2887             return JCTree.Tag.BITAND;
2888         case AMPEQ:
2889             return JCTree.Tag.BITAND_ASG;
2890         case EQEQ:
2891             return JCTree.Tag.EQ;
2892         case BANGEQ:
2893             return JCTree.Tag.NE;
2894         case LT:
2895             return JCTree.Tag.LT;
2896         case GT:
2897             return JCTree.Tag.GT;
2898         case LTEQ:
2899             return JCTree.Tag.LE;
2900         case GTEQ:
2901             return JCTree.Tag.GE;
2902         case LTLT:
2903             return JCTree.Tag.SL;
2904         case LTLTEQ:
2905             return JCTree.Tag.SL_ASG;
2906         case GTGT:
2907             return JCTree.Tag.SR;
2908         case GTGTEQ:
2909             return JCTree.Tag.SR_ASG;
2910         case GTGTGT:
2911             return JCTree.Tag.USR;
2912         case GTGTGTEQ:
2913             return JCTree.Tag.USR_ASG;
2914         case PLUS:
2915             return JCTree.Tag.PLUS;
2916         case PLUSEQ:
2917             return JCTree.Tag.PLUS_ASG;
2918         case SUB:
2919             return JCTree.Tag.MINUS;
2920         case SUBEQ:
2921             return JCTree.Tag.MINUS_ASG;
2922         case STAR:
2923             return JCTree.Tag.MUL;
2924         case STAREQ:
2925             return JCTree.Tag.MUL_ASG;
2926         case SLASH:
2927             return JCTree.Tag.DIV;
2928         case SLASHEQ:
2929             return JCTree.Tag.DIV_ASG;
2930         case PERCENT:
2931             return JCTree.Tag.MOD;
2932         case PERCENTEQ:
2933             return JCTree.Tag.MOD_ASG;
2934         case INSTANCEOF:
2935             return JCTree.Tag.TYPETEST;
2936         default:
2937             return JCTree.Tag.NO_TAG;
2938         }
2939     }
2940 
2941     /** Return operation tag of unary operator represented by token,
2942      *  JCTree.Tag.No_TAG if token is not a binary operator.
2943      */
2944     static JCTree.Tag unoptag(Token token) {
2945         switch (token) {
2946         case PLUS:
2947             return JCTree.Tag.POS;
2948         case SUB:
2949             return JCTree.Tag.NEG;
2950         case BANG:
2951             return JCTree.Tag.NOT;
2952         case TILDE:
2953             return JCTree.Tag.COMPL;
2954         case PLUSPLUS:
2955             return JCTree.Tag.PREINC;
2956         case SUBSUB:
2957             return JCTree.Tag.PREDEC;
2958         default:
2959             return JCTree.Tag.NO_TAG;
2960         }
2961     }
2962 
2963     /** Return type tag of basic type represented by token,
2964      *  -1 if token is not a basic type identifier.
2965      */
2966     static int typetag(Token token) {
2967         switch (token) {
2968         case BYTE:
2969             return TypeTags.BYTE;
2970         case CHAR:
2971             return TypeTags.CHAR;
2972         case SHORT:
2973             return TypeTags.SHORT;
2974         case INT:
2975             return TypeTags.INT;
2976         case LONG:
2977             return TypeTags.LONG;
2978         case FLOAT:
2979             return TypeTags.FLOAT;