equal
deleted
inserted
replaced
558 JCExpression t = errorTree; |
558 JCExpression t = errorTree; |
559 switch (token.kind) { |
559 switch (token.kind) { |
560 case INTLITERAL: |
560 case INTLITERAL: |
561 try { |
561 try { |
562 t = F.at(pos).Literal( |
562 t = F.at(pos).Literal( |
563 TypeTags.INT, |
563 TypeTag.INT, |
564 Convert.string2int(strval(prefix), token.radix())); |
564 Convert.string2int(strval(prefix), token.radix())); |
565 } catch (NumberFormatException ex) { |
565 } catch (NumberFormatException ex) { |
566 error(token.pos, "int.number.too.large", strval(prefix)); |
566 error(token.pos, "int.number.too.large", strval(prefix)); |
567 } |
567 } |
568 break; |
568 break; |
569 case LONGLITERAL: |
569 case LONGLITERAL: |
570 try { |
570 try { |
571 t = F.at(pos).Literal( |
571 t = F.at(pos).Literal( |
572 TypeTags.LONG, |
572 TypeTag.LONG, |
573 new Long(Convert.string2long(strval(prefix), token.radix()))); |
573 new Long(Convert.string2long(strval(prefix), token.radix()))); |
574 } catch (NumberFormatException ex) { |
574 } catch (NumberFormatException ex) { |
575 error(token.pos, "int.number.too.large", strval(prefix)); |
575 error(token.pos, "int.number.too.large", strval(prefix)); |
576 } |
576 } |
577 break; |
577 break; |
589 if (n.floatValue() == 0.0f && !isZero(proper)) |
589 if (n.floatValue() == 0.0f && !isZero(proper)) |
590 error(token.pos, "fp.number.too.small"); |
590 error(token.pos, "fp.number.too.small"); |
591 else if (n.floatValue() == Float.POSITIVE_INFINITY) |
591 else if (n.floatValue() == Float.POSITIVE_INFINITY) |
592 error(token.pos, "fp.number.too.large"); |
592 error(token.pos, "fp.number.too.large"); |
593 else |
593 else |
594 t = F.at(pos).Literal(TypeTags.FLOAT, n); |
594 t = F.at(pos).Literal(TypeTag.FLOAT, n); |
595 break; |
595 break; |
596 } |
596 } |
597 case DOUBLELITERAL: { |
597 case DOUBLELITERAL: { |
598 String proper = token.radix() == 16 ? |
598 String proper = token.radix() == 16 ? |
599 ("0x"+ token.stringVal()) : |
599 ("0x"+ token.stringVal()) : |
608 if (n.doubleValue() == 0.0d && !isZero(proper)) |
608 if (n.doubleValue() == 0.0d && !isZero(proper)) |
609 error(token.pos, "fp.number.too.small"); |
609 error(token.pos, "fp.number.too.small"); |
610 else if (n.doubleValue() == Double.POSITIVE_INFINITY) |
610 else if (n.doubleValue() == Double.POSITIVE_INFINITY) |
611 error(token.pos, "fp.number.too.large"); |
611 error(token.pos, "fp.number.too.large"); |
612 else |
612 else |
613 t = F.at(pos).Literal(TypeTags.DOUBLE, n); |
613 t = F.at(pos).Literal(TypeTag.DOUBLE, n); |
614 break; |
614 break; |
615 } |
615 } |
616 case CHARLITERAL: |
616 case CHARLITERAL: |
617 t = F.at(pos).Literal( |
617 t = F.at(pos).Literal( |
618 TypeTags.CHAR, |
618 TypeTag.CHAR, |
619 token.stringVal().charAt(0) + 0); |
619 token.stringVal().charAt(0) + 0); |
620 break; |
620 break; |
621 case STRINGLITERAL: |
621 case STRINGLITERAL: |
622 t = F.at(pos).Literal( |
622 t = F.at(pos).Literal( |
623 TypeTags.CLASS, |
623 TypeTag.CLASS, |
624 token.stringVal()); |
624 token.stringVal()); |
625 break; |
625 break; |
626 case TRUE: case FALSE: |
626 case TRUE: case FALSE: |
627 t = F.at(pos).Literal( |
627 t = F.at(pos).Literal( |
628 TypeTags.BOOLEAN, |
628 TypeTag.BOOLEAN, |
629 (token.kind == TRUE ? 1 : 0)); |
629 (token.kind == TRUE ? 1 : 0)); |
630 break; |
630 break; |
631 case NULL: |
631 case NULL: |
632 t = F.at(pos).Literal( |
632 t = F.at(pos).Literal( |
633 TypeTags.BOT, |
633 TypeTag.BOT, |
634 null); |
634 null); |
635 break; |
635 break; |
636 default: |
636 default: |
637 Assert.error(); |
637 Assert.error(); |
638 } |
638 } |
812 t = odStack[0]; |
812 t = odStack[0]; |
813 |
813 |
814 if (t.hasTag(JCTree.Tag.PLUS)) { |
814 if (t.hasTag(JCTree.Tag.PLUS)) { |
815 StringBuilder buf = foldStrings(t); |
815 StringBuilder buf = foldStrings(t); |
816 if (buf != null) { |
816 if (buf != null) { |
817 t = toP(F.at(startPos).Literal(TypeTags.CLASS, buf.toString())); |
817 t = toP(F.at(startPos).Literal(TypeTag.CLASS, buf.toString())); |
818 } |
818 } |
819 } |
819 } |
820 |
820 |
821 odStackSupply.elems = savedOd; // optimization |
821 odStackSupply.elems = savedOd; // optimization |
822 opStackSupply.elems = savedOp; // optimization |
822 opStackSupply.elems = savedOp; // optimization |
844 return null; |
844 return null; |
845 List<String> buf = List.nil(); |
845 List<String> buf = List.nil(); |
846 while (true) { |
846 while (true) { |
847 if (tree.hasTag(LITERAL)) { |
847 if (tree.hasTag(LITERAL)) { |
848 JCLiteral lit = (JCLiteral) tree; |
848 JCLiteral lit = (JCLiteral) tree; |
849 if (lit.typetag == TypeTags.CLASS) { |
849 if (lit.typetag == TypeTag.CLASS) { |
850 StringBuilder sbuf = |
850 StringBuilder sbuf = |
851 new StringBuilder((String)lit.value); |
851 new StringBuilder((String)lit.value); |
852 while (buf.nonEmpty()) { |
852 while (buf.nonEmpty()) { |
853 sbuf.append(buf.head); |
853 sbuf.append(buf.head); |
854 buf = buf.tail; |
854 buf = buf.tail; |
857 } |
857 } |
858 } else if (tree.hasTag(JCTree.Tag.PLUS)) { |
858 } else if (tree.hasTag(JCTree.Tag.PLUS)) { |
859 JCBinary op = (JCBinary)tree; |
859 JCBinary op = (JCBinary)tree; |
860 if (op.rhs.hasTag(LITERAL)) { |
860 if (op.rhs.hasTag(LITERAL)) { |
861 JCLiteral lit = (JCLiteral) op.rhs; |
861 JCLiteral lit = (JCLiteral) op.rhs; |
862 if (lit.typetag == TypeTags.CLASS) { |
862 if (lit.typetag == TypeTag.CLASS) { |
863 buf = buf.prepend((String) lit.value); |
863 buf = buf.prepend((String) lit.value); |
864 tree = op.lhs; |
864 tree = op.lhs; |
865 continue; |
865 continue; |
866 } |
866 } |
867 } |
867 } |
1209 case VOID: |
1209 case VOID: |
1210 if (typeArgs != null) illegal(); |
1210 if (typeArgs != null) illegal(); |
1211 if ((mode & EXPR) != 0) { |
1211 if ((mode & EXPR) != 0) { |
1212 nextToken(); |
1212 nextToken(); |
1213 if (token.kind == DOT) { |
1213 if (token.kind == DOT) { |
1214 JCPrimitiveTypeTree ti = toP(F.at(pos).TypeIdent(TypeTags.VOID)); |
1214 JCPrimitiveTypeTree ti = toP(F.at(pos).TypeIdent(TypeTag.VOID)); |
1215 t = bracketsSuffix(ti); |
1215 t = bracketsSuffix(ti); |
1216 } else { |
1216 } else { |
1217 return illegal(pos); |
1217 return illegal(pos); |
1218 } |
1218 } |
1219 } else { |
1219 } else { |
1220 // Support the corner case of myMethodHandle.<void>invoke() by passing |
1220 // Support the corner case of myMethodHandle.<void>invoke() by passing |
1221 // a void type (like other primitive types) to the next phase. |
1221 // a void type (like other primitive types) to the next phase. |
1222 // The error will be reported in Attr.attribTypes or Attr.visitApply. |
1222 // The error will be reported in Attr.attribTypes or Attr.visitApply. |
1223 JCPrimitiveTypeTree ti = to(F.at(pos).TypeIdent(TypeTags.VOID)); |
1223 JCPrimitiveTypeTree ti = to(F.at(pos).TypeIdent(TypeTag.VOID)); |
1224 nextToken(); |
1224 nextToken(); |
1225 return ti; |
1225 return ti; |
1226 //return illegal(); |
1226 //return illegal(); |
1227 } |
1227 } |
1228 break; |
1228 break; |
2918 Token tk = token; |
2918 Token tk = token; |
2919 pos = token.pos; |
2919 pos = token.pos; |
2920 JCExpression type; |
2920 JCExpression type; |
2921 boolean isVoid = token.kind == VOID; |
2921 boolean isVoid = token.kind == VOID; |
2922 if (isVoid) { |
2922 if (isVoid) { |
2923 type = to(F.at(pos).TypeIdent(TypeTags.VOID)); |
2923 type = to(F.at(pos).TypeIdent(TypeTag.VOID)); |
2924 nextToken(); |
2924 nextToken(); |
2925 } else { |
2925 } else { |
2926 type = parseType(); |
2926 type = parseType(); |
2927 } |
2927 } |
2928 if (token.kind == LPAREN && !isInterface && type.hasTag(IDENT)) { |
2928 if (token.kind == LPAREN && !isInterface && type.hasTag(IDENT)) { |
3281 return NO_TAG; |
3281 return NO_TAG; |
3282 } |
3282 } |
3283 } |
3283 } |
3284 |
3284 |
3285 /** Return type tag of basic type represented by token, |
3285 /** Return type tag of basic type represented by token, |
3286 * -1 if token is not a basic type identifier. |
3286 * NONE if token is not a basic type identifier. |
3287 */ |
3287 */ |
3288 static int typetag(TokenKind token) { |
3288 static TypeTag typetag(TokenKind token) { |
3289 switch (token) { |
3289 switch (token) { |
3290 case BYTE: |
3290 case BYTE: |
3291 return TypeTags.BYTE; |
3291 return TypeTag.BYTE; |
3292 case CHAR: |
3292 case CHAR: |
3293 return TypeTags.CHAR; |
3293 return TypeTag.CHAR; |
3294 case SHORT: |
3294 case SHORT: |
3295 return TypeTags.SHORT; |
3295 return TypeTag.SHORT; |
3296 case INT: |
3296 case INT: |
3297 return TypeTags.INT; |
3297 return TypeTag.INT; |
3298 case LONG: |
3298 case LONG: |
3299 return TypeTags.LONG; |
3299 return TypeTag.LONG; |
3300 case FLOAT: |
3300 case FLOAT: |
3301 return TypeTags.FLOAT; |
3301 return TypeTag.FLOAT; |
3302 case DOUBLE: |
3302 case DOUBLE: |
3303 return TypeTags.DOUBLE; |
3303 return TypeTag.DOUBLE; |
3304 case BOOLEAN: |
3304 case BOOLEAN: |
3305 return TypeTags.BOOLEAN; |
3305 return TypeTag.BOOLEAN; |
3306 default: |
3306 default: |
3307 return -1; |
3307 return TypeTag.NONE; |
3308 } |
3308 } |
3309 } |
3309 } |
3310 |
3310 |
3311 void checkGenerics() { |
3311 void checkGenerics() { |
3312 if (!allowGenerics) { |
3312 if (!allowGenerics) { |