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;
|