/* YACC parser for Java expressions, for GDB.
- Copyright (C) 1997, 1998, 1999, 2000, 2006, 2007, 2008
+ Copyright (C) 1997, 1998, 1999, 2000, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Parse a Java expression from text in a string,
and return the result as a struct expression pointer.
#include "block.h"
#define parse_type builtin_type (parse_gdbarch)
+#define parse_java_type builtin_java_type (parse_gdbarch)
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
as well as gratuitiously global symbol names, so we can have multiple
write_exp_elt_opcode (OP_DOUBLE); }
| BOOLEAN_LITERAL
{ write_exp_elt_opcode (OP_LONG);
- write_exp_elt_type (java_boolean_type);
+ write_exp_elt_type (parse_java_type->builtin_boolean);
write_exp_elt_longcst ((LONGEST)$1);
write_exp_elt_opcode (OP_LONG); }
| StringLiteral
PrimitiveType:
NumericType
| BOOLEAN
- { $$ = java_boolean_type; }
+ { $$ = parse_java_type->builtin_boolean; }
;
NumericType:
IntegralType:
BYTE
- { $$ = java_byte_type; }
+ { $$ = parse_java_type->builtin_byte; }
| SHORT
- { $$ = java_short_type; }
+ { $$ = parse_java_type->builtin_short; }
| INT
- { $$ = java_int_type; }
+ { $$ = parse_java_type->builtin_int; }
| LONG
- { $$ = java_long_type; }
+ { $$ = parse_java_type->builtin_long; }
| CHAR
- { $$ = java_char_type; }
+ { $$ = parse_java_type->builtin_char; }
;
FloatingPointType:
FLOAT
- { $$ = java_float_type; }
+ { $$ = parse_java_type->builtin_float; }
| DOUBLE
- { $$ = java_double_type; }
+ { $$ = parse_java_type->builtin_double; }
;
/* UNUSED:
write_exp_elt_opcode (UNOP_CAST); }
| '(' Expression ')' UnaryExpressionNotPlusMinus
{
- int exp_size = expout_ptr;
int last_exp_size = length_of_subexp(expout, expout_ptr);
struct type *type;
int i;
if (parsed_float)
{
- /* It's a float since it contains a point or an exponent. */
- char c;
- int num = 0; /* number of tokens scanned by scanf */
- char saved_char = p[len];
-
- p[len] = 0; /* null-terminate the token */
- num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c",
- &putithere->typed_val_float.dval, &c);
- p[len] = saved_char; /* restore the input stream */
- if (num != 1) /* check scanf found ONLY a float ... */
+ const char *suffix;
+ int suffix_len;
+
+ if (! parse_float (p, len, &putithere->typed_val_float.dval, &suffix))
return ERROR;
- /* See if it has `f' or `d' suffix (float or double). */
- c = tolower (p[len - 1]);
+ suffix_len = p + len - suffix;
- if (c == 'f' || c == 'F')
- putithere->typed_val_float.type = parse_type->builtin_float;
- else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
+ if (suffix_len == 0)
putithere->typed_val_float.type = parse_type->builtin_double;
+ else if (suffix_len == 1)
+ {
+ /* See if it has `f' or `d' suffix (float or double). */
+ if (tolower (*suffix) == 'f')
+ putithere->typed_val_float.type =
+ parse_type->builtin_float;
+ else if (tolower (*suffix) == 'd')
+ putithere->typed_val_float.type =
+ parse_type->builtin_double;
+ else
+ return ERROR;
+ }
else
return ERROR;
limit = ((limit << 16) << 16) | limit;
if (c == 'l' || c == 'L')
{
- type = java_long_type;
+ type = parse_java_type->builtin_long;
len--;
}
else
{
- type = java_int_type;
+ type = parse_java_type->builtin_int;
}
limit_div_base = limit / (ULONGEST) base;
}
/* If the type is bigger than a 32-bit signed integer can be, implicitly
- promote to long. Java does not do this, so mark it as builtin_type_uint64
- rather than java_long_type. 0x80000000 will become -0x80000000 instead
- of 0x80000000L, because we don't know the sign at this point.
- */
- if (type == java_int_type && n > (ULONGEST)0x80000000)
- type = builtin_type_uint64;
+ promote to long. Java does not do this, so mark it as
+ parse_type->builtin_uint64 rather than parse_java_type->builtin_long.
+ 0x80000000 will become -0x80000000 instead of 0x80000000L, because we
+ don't know the sign at this point. */
+ if (type == parse_java_type->builtin_int && n > (ULONGEST)0x80000000)
+ type = parse_type->builtin_uint64;
putithere->typed_val_int.val = n;
putithere->typed_val_int.type = type;
lexptr++;
c = *lexptr++;
if (c == '\\')
- c = parse_escape (&lexptr);
+ c = parse_escape (parse_gdbarch, &lexptr);
else if (c == '\'')
error (_("Empty character constant"));
yylval.typed_val_int.val = c;
- yylval.typed_val_int.type = java_char_type;
+ yylval.typed_val_int.type = parse_java_type->builtin_char;
c = *lexptr++;
if (c != '\'')
break;
case '\\':
tokptr++;
- c = parse_escape (&tokptr);
+ c = parse_escape (parse_gdbarch, &tokptr);
if (c == -1)
{
continue;
{
char *tmp;
struct type *typ;
- char *ptr;
int i;
for (i = 0; i < name.length; i++)