1025
1026 /**
1027 * Is the given character a valid escape char after "\" ?
1028 *
1029 * @param ch character to be checked
1030 * @return if the given character is valid after "\"
1031 */
1032 protected boolean isEscapeCharacter(final char ch) {
1033 return true;
1034 }
1035
1036 /**
1037 * Convert string to number.
1038 *
1039 * @param valueString String to convert.
1040 * @param radix Numeric base.
1041 * @return Converted number.
1042 */
1043 private static Number valueOf(final String valueString, final int radix) throws NumberFormatException {
1044 try {
1045 final long value = Long.parseLong(valueString, radix);
1046 if(value >= MIN_INT_L && value <= MAX_INT_L) {
1047 return Integer.valueOf((int)value);
1048 }
1049 return Long.valueOf(value);
1050 } catch (final NumberFormatException e) {
1051 if (radix == 10) {
1052 return Double.valueOf(valueString);
1053 }
1054
1055 double value = 0.0;
1056
1057 for (int i = 0; i < valueString.length(); i++) {
1058 final char ch = valueString.charAt(i);
1059 // Preverified, should always be a valid digit.
1060 final int digit = convertDigit(ch, radix);
1061 value *= radix;
1062 value += digit;
1063 }
1064
1065 return value;
1066 }
1067 }
1068
1069 /**
1638 case DECIMAL:
1639 return Lexer.valueOf(source.getString(start, len), 10); // number
1640 case OCTAL:
1641 return Lexer.valueOf(source.getString(start, len), 8); // number
1642 case HEXADECIMAL:
1643 return Lexer.valueOf(source.getString(start + 2, len - 2), 16); // number
1644 case FLOATING:
1645 final String str = source.getString(start, len);
1646 final double value = Double.valueOf(str);
1647 if (str.indexOf('.') != -1) {
1648 return value; //number
1649 }
1650 //anything without an explicit decimal point is still subject to a
1651 //"representable as int or long" check. Then the programmer does not
1652 //explicitly code something as a double. For example new Color(int, int, int)
1653 //and new Color(float, float, float) will get ambiguous for cases like
1654 //new Color(1.0, 1.5, 1.5) if we don't respect the decimal point.
1655 //yet we don't want e.g. 1e6 to be a double unnecessarily
1656 if (JSType.isStrictlyRepresentableAsInt(value)) {
1657 return (int)value;
1658 } else if (JSType.isStrictlyRepresentableAsLong(value)) {
1659 return (long)value;
1660 }
1661 return value;
1662 case STRING:
1663 return source.getString(start, len); // String
1664 case ESCSTRING:
1665 return valueOfString(start, len, strict); // String
1666 case IDENT:
1667 return valueOfIdent(start, len); // String
1668 case REGEX:
1669 return valueOfPattern(start, len); // RegexToken::LexerToken
1670 case XML:
1671 return valueOfXML(start, len); // XMLToken::LexerToken
1672 case DIRECTIVE_COMMENT:
1673 return source.getString(start, len);
1674 default:
1675 break;
1676 }
1677
1678 return null;
1679 }
|
1025
1026 /**
1027 * Is the given character a valid escape char after "\" ?
1028 *
1029 * @param ch character to be checked
1030 * @return if the given character is valid after "\"
1031 */
1032 protected boolean isEscapeCharacter(final char ch) {
1033 return true;
1034 }
1035
1036 /**
1037 * Convert string to number.
1038 *
1039 * @param valueString String to convert.
1040 * @param radix Numeric base.
1041 * @return Converted number.
1042 */
1043 private static Number valueOf(final String valueString, final int radix) throws NumberFormatException {
1044 try {
1045 return Integer.parseInt(valueString, radix);
1046 } catch (final NumberFormatException e) {
1047 if (radix == 10) {
1048 return Double.valueOf(valueString);
1049 }
1050
1051 double value = 0.0;
1052
1053 for (int i = 0; i < valueString.length(); i++) {
1054 final char ch = valueString.charAt(i);
1055 // Preverified, should always be a valid digit.
1056 final int digit = convertDigit(ch, radix);
1057 value *= radix;
1058 value += digit;
1059 }
1060
1061 return value;
1062 }
1063 }
1064
1065 /**
1634 case DECIMAL:
1635 return Lexer.valueOf(source.getString(start, len), 10); // number
1636 case OCTAL:
1637 return Lexer.valueOf(source.getString(start, len), 8); // number
1638 case HEXADECIMAL:
1639 return Lexer.valueOf(source.getString(start + 2, len - 2), 16); // number
1640 case FLOATING:
1641 final String str = source.getString(start, len);
1642 final double value = Double.valueOf(str);
1643 if (str.indexOf('.') != -1) {
1644 return value; //number
1645 }
1646 //anything without an explicit decimal point is still subject to a
1647 //"representable as int or long" check. Then the programmer does not
1648 //explicitly code something as a double. For example new Color(int, int, int)
1649 //and new Color(float, float, float) will get ambiguous for cases like
1650 //new Color(1.0, 1.5, 1.5) if we don't respect the decimal point.
1651 //yet we don't want e.g. 1e6 to be a double unnecessarily
1652 if (JSType.isStrictlyRepresentableAsInt(value)) {
1653 return (int)value;
1654 }
1655 return value;
1656 case STRING:
1657 return source.getString(start, len); // String
1658 case ESCSTRING:
1659 return valueOfString(start, len, strict); // String
1660 case IDENT:
1661 return valueOfIdent(start, len); // String
1662 case REGEX:
1663 return valueOfPattern(start, len); // RegexToken::LexerToken
1664 case XML:
1665 return valueOfXML(start, len); // XMLToken::LexerToken
1666 case DIRECTIVE_COMMENT:
1667 return source.getString(start, len);
1668 default:
1669 break;
1670 }
1671
1672 return null;
1673 }
|