gdb/jv-exp.y - gdb
- %{
- #include "defs.h"
- #include <ctype.h>
- #include "expression.h"
- #include "value.h"
- #include "parser-defs.h"
- #include "language.h"
- #include "jv-lang.h"
- #include "bfd.h"
- #include "symfile.h"
- #include "objfiles.h"
- #include "block.h"
- #include "completer.h"
- #define parse_type(ps) builtin_type (parse_gdbarch (ps))
- #define parse_java_type(ps) builtin_java_type (parse_gdbarch (ps))
- #define yymaxdepth java_maxdepth
- #define yyparse java_parse_internal
- #define yylex java_lex
- #define yyerror java_error
- #define yylval java_lval
- #define yychar java_char
- #define yydebug java_debug
- #define yypact java_pact
- #define yyr1 java_r1
- #define yyr2 java_r2
- #define yydef java_def
- #define yychk java_chk
- #define yypgo java_pgo
- #define yyact java_act
- #define yyexca java_exca
- #define yyerrflag java_errflag
- #define yynerrs java_nerrs
- #define yyps java_ps
- #define yypv java_pv
- #define yys java_s
- #define yy_yys java_yys
- #define yystate java_state
- #define yytmp java_tmp
- #define yyv java_v
- #define yy_yyv java_yyv
- #define yyval java_val
- #define yylloc java_lloc
- #define yyreds java_reds
- #define yytoks java_toks
- #define yyname java_name
- #define yyrule java_rule
- #define yylhs java_yylhs
- #define yylen java_yylen
- #define yydefred java_yydefred
- #define yydgoto java_yydgoto
- #define yysindex java_yysindex
- #define yyrindex java_yyrindex
- #define yygindex java_yygindex
- #define yytable java_yytable
- #define yycheck java_yycheck
- #define yyss java_yyss
- #define yysslim java_yysslim
- #define yyssp java_yyssp
- #define yystacksize java_yystacksize
- #define yyvs java_yyvs
- #define yyvsp java_yyvsp
- #ifndef YYDEBUG
- #define YYDEBUG 1
- #endif
- #define YYFPRINTF parser_fprintf
- staticstructNULL
- intvoid
- staticintvoid
- voidchar
- staticstructstruct
- staticvoidstructstruct
- staticvoidstructstruct
- staticstructstructint
- staticvoidstructintstruct
- %}
- %union
- {
- LONGEST lval;
- struct {
- LONGEST val;
- struct type *type;
- } typed_val_int;
- struct {
- DOUBLEST dval;
- struct type *type;
- } typed_val_float;
- struct symbol *sym;
- struct type *tval;
- struct stoken sval;
- struct ttype tsym;
- struct symtoken ssym;
- struct block *bval;
- enum exp_opcode opcode;
- struct internalvar *ivar;
- int *ivec;
- }
- %{
- staticintstructconstcharint
- int
- %}
- %type <lval> rcurly Dims Dims_opt
- %type <tval> ClassOrInterfaceType ClassType
- %type <tval> IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType
- %token <typed_val_int> INTEGER_LITERAL
- %token <typed_val_float> FLOATING_POINT_LITERAL
- %token <sval> IDENTIFIER
- %token <sval> STRING_LITERAL
- %token <lval> BOOLEAN_LITERAL
- %token <tsym> TYPENAME
- %type <sval> Name SimpleName QualifiedName ForcedName
- %token <sval> NAME_OR_INT
- %token ERROR
- %token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT
- %token VARIABLE
- %token <opcode> ASSIGN_MODIFY
- %token SUPER NEW
- %left ','
- %right '=' ASSIGN_MODIFY
- %right '?'
- %left OROR
- %left ANDAND
- %left '|'
- %left '^'
- %left '&'
- %left EQUAL NOTEQUAL
- %left '<' '>' LEQ GEQ
- %left LSH RSH
- %left '+' '-'
- %left '*' '/' '%'
- %right INCREMENT DECREMENT
- %right '.' '[' '('
- %%
- start : exp1
- | type_exp
- ;
- type_exp: PrimitiveOrArrayType
- {
- write_exp_elt_opcode (pstate, OP_TYPE);
- write_exp_elt_type (pstate, $1);
- write_exp_elt_opcode (pstate, OP_TYPE);
- }
- ;
- PrimitiveOrArrayType:
- PrimitiveType
- | ArrayType
- ;
- StringLiteral:
- STRING_LITERAL
- {
- write_exp_elt_opcode (pstate, OP_STRING);
- write_exp_string (pstate, $1);
- write_exp_elt_opcode (pstate, OP_STRING);
- }
- ;
- Literal:
- INTEGER_LITERAL
- { write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate, $1.type);
- write_exp_elt_longcst (pstate, (LONGEST)($1.val));
- write_exp_elt_opcode (pstate, OP_LONG); }
- | NAME_OR_INT
- { YYSTYPE val;
- parse_number (pstate, $1.ptr, $1.length, 0, &val);
- write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate, val.typed_val_int.type);
- write_exp_elt_longcst (pstate,
- (LONGEST) val.typed_val_int.val);
- write_exp_elt_opcode (pstate, OP_LONG);
- }
- | FLOATING_POINT_LITERAL
- { write_exp_elt_opcode (pstate, OP_DOUBLE);
- write_exp_elt_type (pstate, $1.type);
- write_exp_elt_dblcst (pstate, $1.dval);
- write_exp_elt_opcode (pstate, OP_DOUBLE); }
- | BOOLEAN_LITERAL
- { write_exp_elt_opcode (pstate, OP_LONG);
- write_exp_elt_type (pstate,
- parse_java_type (pstate)->builtin_boolean);
- write_exp_elt_longcst (pstate, (LONGEST)$1);
- write_exp_elt_opcode (pstate, OP_LONG); }
- | StringLiteral
- ;
- /* UNUSED:
- Type:
- PrimitiveType
- | ReferenceType
- ;
- */
- PrimitiveType:
- NumericType
- | BOOLEAN
- { $$ = parse_java_type (pstate)->builtin_boolean; }
- ;
- NumericType:
- IntegralType
- | FloatingPointType
- ;
- IntegralType:
- BYTE
- { $$ = parse_java_type (pstate)->builtin_byte; }
- | SHORT
- { $$ = parse_java_type (pstate)->builtin_short; }
- | INT
- { $$ = parse_java_type (pstate)->builtin_int; }
- | LONG
- { $$ = parse_java_type (pstate)->builtin_long; }
- | CHAR
- { $$ = parse_java_type (pstate)->builtin_char; }
- ;
- FloatingPointType:
- FLOAT
- { $$ = parse_java_type (pstate)->builtin_float; }
- | DOUBLE
- { $$ = parse_java_type (pstate)->builtin_double; }
- ;
- /* UNUSED:
- ReferenceType:
- ClassOrInterfaceType
- | ArrayType
- ;
- */
- ClassOrInterfaceType:
- Name
- { $$ = java_type_from_name ($1); }
- ;
- ClassType:
- ClassOrInterfaceType
- ;
- ArrayType:
- PrimitiveType Dims
- { $$ = java_array_type ($1, $2); }
- | Name Dims
- { $$ = java_array_type (java_type_from_name ($1), $2); }
- ;
- Name:
- IDENTIFIER
- | QualifiedName
- ;
- ForcedName:
- SimpleName
- | QualifiedName
- ;
- SimpleName:
- IDENTIFIER
- | NAME_OR_INT
- ;
- QualifiedName:
- Name '.' SimpleName
- { $$.length = $1.length + $3.length + 1;
- if ($1.ptr + $1.length + 1 == $3.ptr
- && $1.ptr[$1.length] == '.')
- $$.ptr = $1.ptr;
- else
- {
- char *buf;
- buf = malloc ($$.length + 1);
- make_cleanup (free, buf);
- sprintf (buf, "%.*s.%.*s",
- $1.length, $1.ptr, $3.length, $3.ptr);
- $$.ptr = buf;
- } }
- ;
- /*
- type_exp: type
- { write_exp_elt_opcode(OP_TYPE);
- write_exp_elt_type($1);
- write_exp_elt_opcode(OP_TYPE);}
- ;
- */
- /* Expressions, including the comma operator. */
- exp1 : Expression
- | exp1 ',' Expression
- { write_exp_elt_opcode (pstate, BINOP_COMMA); }
- ;
- Primary:
- PrimaryNoNewArray
- | ArrayCreationExpression
- ;
- PrimaryNoNewArray:
- Literal
- | '(' Expression ')'
- | ClassInstanceCreationExpression
- | FieldAccess
- | MethodInvocation
- | ArrayAccess
- | lcurly ArgumentList rcurly
- { write_exp_elt_opcode (pstate, OP_ARRAY);
- write_exp_elt_longcst (pstate, (LONGEST) 0);
- write_exp_elt_longcst (pstate, (LONGEST) $3);
- write_exp_elt_opcode (pstate, OP_ARRAY); }
- ;
- lcurly:
- '{'
- { start_arglist (); }
- ;
- rcurly:
- '}'
- { $$ = end_arglist () - 1; }
- ;
- ClassInstanceCreationExpression:
- NEW ClassType '(' ArgumentList_opt ')'
- { internal_error (__FILE__, __LINE__,
- _("FIXME - ClassInstanceCreationExpression")); }
- ;
- ArgumentList:
- Expression
- { arglist_len = 1; }
- | ArgumentList ',' Expression
- { arglist_len++; }
- ;
- ArgumentList_opt:
-
- { arglist_len = 0; }
- | ArgumentList
- ;
- ArrayCreationExpression:
- NEW PrimitiveType DimExprs Dims_opt
- { internal_error (__FILE__, __LINE__,
- _("FIXME - ArrayCreationExpression")); }
- | NEW ClassOrInterfaceType DimExprs Dims_opt
- { internal_error (__FILE__, __LINE__,
- _("FIXME - ArrayCreationExpression")); }
- ;
- DimExprs:
- DimExpr
- | DimExprs DimExpr
- ;
- DimExpr:
- '[' Expression ']'
- ;
- Dims:
- '[' ']'
- { $$ = 1; }
- | Dims '[' ']'
- { $$ = $1 + 1; }
- ;
- Dims_opt:
- Dims
- |
- { $$ = 0; }
- ;
- FieldAccess:
- Primary '.' SimpleName
- { push_fieldnames (pstate, $3); }
- | VARIABLE '.' SimpleName
- { push_fieldnames (pstate, $3); }
- ;
- FuncStart:
- Name '('
- { push_expression_name (pstate, $1); }
- ;
- MethodInvocation:
- FuncStart
- { start_arglist(); }
- ArgumentList_opt ')'
- { write_exp_elt_opcode (pstate, OP_FUNCALL);
- write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
- write_exp_elt_opcode (pstate, OP_FUNCALL); }
- | Primary '.' SimpleName '(' ArgumentList_opt ')'
- { error (_("Form of method invocation not implemented")); }
- | SUPER '.' SimpleName '(' ArgumentList_opt ')'
- { error (_("Form of method invocation not implemented")); }
- ;
- ArrayAccess:
- Name '[' Expression ']'
- {
-
- struct expression *name_expr;
- push_expression_name (pstate, $1);
- name_expr = copy_exp (pstate->expout, pstate->expout_ptr);
- pstate->expout_ptr -= name_expr->nelts;
- insert_exp (pstate,
- pstate->expout_ptr
- - length_of_subexp (pstate->expout,
- pstate->expout_ptr),
- name_expr);
- free (name_expr);
- write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT);
- }
- | VARIABLE '[' Expression ']'
- { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
- | PrimaryNoNewArray '[' Expression ']'
- { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
- ;
- PostfixExpression:
- Primary
- | Name
- { push_expression_name (pstate, $1); }
- | VARIABLE
-
- | PostIncrementExpression
- | PostDecrementExpression
- ;
- PostIncrementExpression:
- PostfixExpression INCREMENT
- { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); }
- ;
- PostDecrementExpression:
- PostfixExpression DECREMENT
- { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); }
- ;
- UnaryExpression:
- PreIncrementExpression
- | PreDecrementExpression
- | '+' UnaryExpression
- | '-' UnaryExpression
- { write_exp_elt_opcode (pstate, UNOP_NEG); }
- | '*' UnaryExpression
- { write_exp_elt_opcode (pstate,
- UNOP_IND); }
- | UnaryExpressionNotPlusMinus
- ;
- PreIncrementExpression:
- INCREMENT UnaryExpression
- { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
- ;
- PreDecrementExpression:
- DECREMENT UnaryExpression
- { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); }
- ;
- UnaryExpressionNotPlusMinus:
- PostfixExpression
- | '~' UnaryExpression
- { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
- | '!' UnaryExpression
- { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
- | CastExpression
- ;
- CastExpression:
- '(' PrimitiveType Dims_opt ')' UnaryExpression
- { write_exp_elt_opcode (pstate, UNOP_CAST);
- write_exp_elt_type (pstate, java_array_type ($2, $3));
- write_exp_elt_opcode (pstate, UNOP_CAST); }
- | '(' Expression ')' UnaryExpressionNotPlusMinus
- {
- int last_exp_size = length_of_subexp (pstate->expout,
- pstate->expout_ptr);
- struct type *type;
- int i;
- int base = pstate->expout_ptr - last_exp_size - 3;
- if (base < 0
- || pstate->expout->elts[base+2].opcode != OP_TYPE)
- error (_("Invalid cast expression"));
- type = pstate->expout->elts[base+1].type;
-
- for (i = 0; i < last_exp_size; i++)
- pstate->expout->elts[base + i]
- = pstate->expout->elts[base + i + 3];
- pstate->expout_ptr -= 3;
- if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
- type = lookup_pointer_type (type);
- write_exp_elt_opcode (pstate, UNOP_CAST);
- write_exp_elt_type (pstate, type);
- write_exp_elt_opcode (pstate, UNOP_CAST);
- }
- | '(' Name Dims ')' UnaryExpressionNotPlusMinus
- { write_exp_elt_opcode (pstate, UNOP_CAST);
- write_exp_elt_type (pstate,
- java_array_type (java_type_from_name
- ($2), $3));
- write_exp_elt_opcode (pstate, UNOP_CAST); }
- ;
- MultiplicativeExpression:
- UnaryExpression
- | MultiplicativeExpression '*' UnaryExpression
- { write_exp_elt_opcode (pstate, BINOP_MUL); }
- | MultiplicativeExpression '/' UnaryExpression
- { write_exp_elt_opcode (pstate, BINOP_DIV); }
- | MultiplicativeExpression '%' UnaryExpression
- { write_exp_elt_opcode (pstate, BINOP_REM); }
- ;
- AdditiveExpression:
- MultiplicativeExpression
- | AdditiveExpression '+' MultiplicativeExpression
- { write_exp_elt_opcode (pstate, BINOP_ADD); }
- | AdditiveExpression '-' MultiplicativeExpression
- { write_exp_elt_opcode (pstate, BINOP_SUB); }
- ;
- ShiftExpression:
- AdditiveExpression
- | ShiftExpression LSH AdditiveExpression
- { write_exp_elt_opcode (pstate, BINOP_LSH); }
- | ShiftExpression RSH AdditiveExpression
- { write_exp_elt_opcode (pstate, BINOP_RSH); }
- ;
- RelationalExpression:
- ShiftExpression
- | RelationalExpression '<' ShiftExpression
- { write_exp_elt_opcode (pstate, BINOP_LESS); }
- | RelationalExpression '>' ShiftExpression
- { write_exp_elt_opcode (pstate, BINOP_GTR); }
- | RelationalExpression LEQ ShiftExpression
- { write_exp_elt_opcode (pstate, BINOP_LEQ); }
- | RelationalExpression GEQ ShiftExpression
- { write_exp_elt_opcode (pstate, BINOP_GEQ); }
- ;
- EqualityExpression:
- RelationalExpression
- | EqualityExpression EQUAL RelationalExpression
- { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
- | EqualityExpression NOTEQUAL RelationalExpression
- { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
- ;
- AndExpression:
- EqualityExpression
- | AndExpression '&' EqualityExpression
- { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
- ;
- ExclusiveOrExpression:
- AndExpression
- | ExclusiveOrExpression '^' AndExpression
- { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
- ;
- InclusiveOrExpression:
- ExclusiveOrExpression
- | InclusiveOrExpression '|' ExclusiveOrExpression
- { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
- ;
- ConditionalAndExpression:
- InclusiveOrExpression
- | ConditionalAndExpression ANDAND InclusiveOrExpression
- { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
- ;
- ConditionalOrExpression:
- ConditionalAndExpression
- | ConditionalOrExpression OROR ConditionalAndExpression
- { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
- ;
- ConditionalExpression:
- ConditionalOrExpression
- | ConditionalOrExpression '?' Expression ':' ConditionalExpression
- { write_exp_elt_opcode (pstate, TERNOP_COND); }
- ;
- AssignmentExpression:
- ConditionalExpression
- | Assignment
- ;
- Assignment:
- LeftHandSide '=' ConditionalExpression
- { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
- | LeftHandSide ASSIGN_MODIFY ConditionalExpression
- { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
- write_exp_elt_opcode (pstate, $2);
- write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
- ;
- LeftHandSide:
- ForcedName
- { push_expression_name (pstate, $1); }
- | VARIABLE
-
- | FieldAccess
- | ArrayAccess
- ;
- Expression:
- AssignmentExpression
- ;
- %%
- static int
- parse_number (struct parser_state *par_state,
- const char *p, int len, int parsed_float, YYSTYPE *putithere)
- {
- ULONGEST n = 0;
- ULONGEST limit, limit_div_base;
- int c;
- int base = input_radix;
- struct type *type;
- if (parsed_float)
- {
- const char *suffix;
- int suffix_len;
- if (! parse_float (p, len, &putithere->typed_val_float.dval, &suffix))
- return ERROR;
- suffix_len = p + len - suffix;
- if (suffix_len == 0)
- putithere->typed_val_float.type
- = parse_type (par_state)->builtin_double;
- else if (suffix_len == 1)
- {
-
- if (tolower (*suffix) == 'f')
- putithere->typed_val_float.type =
- parse_type (par_state)->builtin_float;
- else if (tolower (*suffix) == 'd')
- putithere->typed_val_float.type =
- parse_type (par_state)->builtin_double;
- else
- return ERROR;
- }
- else
- return ERROR;
- return FLOATING_POINT_LITERAL;
- }
-
- if (p[0] == '0')
- switch (p[1])
- {
- case 'x':
- case 'X':
- if (len >= 3)
- {
- p += 2;
- base = 16;
- len -= 2;
- }
- break;
- case 't':
- case 'T':
- case 'd':
- case 'D':
- if (len >= 3)
- {
- p += 2;
- base = 10;
- len -= 2;
- }
- break;
- default:
- base = 8;
- break;
- }
- c = p[len-1];
-
- limit = (ULONGEST)0xffffffff;
- limit = ((limit << 16) << 16) | limit;
- if (c == 'l' || c == 'L')
- {
- type = parse_java_type (par_state)->builtin_long;
- len--;
- }
- else
- {
- type = parse_java_type (par_state)->builtin_int;
- }
- limit_div_base = limit / (ULONGEST) base;
- while (--len >= 0)
- {
- c = *p++;
- if (c >= '0' && c <= '9')
- c -= '0';
- else if (c >= 'A' && c <= 'Z')
- c -= 'A' - 10;
- else if (c >= 'a' && c <= 'z')
- c -= 'a' - 10;
- else
- return ERROR;
- if (c >= base)
- return ERROR;
- if (n > limit_div_base
- || (n *= base) > limit - c)
- error (_("Numeric constant too large"));
- n += c;
- }
-
- if (type == parse_java_type (par_state)->builtin_int
- && n > (ULONGEST)0x80000000)
- type = parse_type (par_state)->builtin_uint64;
- putithere->typed_val_int.val = n;
- putithere->typed_val_int.type = type;
- return INTEGER_LITERAL;
- }
- struct token
- {
- char *operator;
- int token;
- enum exp_opcode opcode;
- };
- static const struct token tokentab3[] =
- {
- {">>=", ASSIGN_MODIFY, BINOP_RSH},
- {"<<=", ASSIGN_MODIFY, BINOP_LSH}
- };
- static const struct token tokentab2[] =
- {
- {"+=", ASSIGN_MODIFY, BINOP_ADD},
- {"-=", ASSIGN_MODIFY, BINOP_SUB},
- {"*=", ASSIGN_MODIFY, BINOP_MUL},
- {"/=", ASSIGN_MODIFY, BINOP_DIV},
- {"%=", ASSIGN_MODIFY, BINOP_REM},
- {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
- {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
- {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
- {"++", INCREMENT, BINOP_END},
- {"--", DECREMENT, BINOP_END},
- {"&&", ANDAND, BINOP_END},
- {"||", OROR, BINOP_END},
- {"<<", LSH, BINOP_END},
- {">>", RSH, BINOP_END},
- {"==", EQUAL, BINOP_END},
- {"!=", NOTEQUAL, BINOP_END},
- {"<=", LEQ, BINOP_END},
- {">=", GEQ, BINOP_END}
- };
- static int
- yylex (void)
- {
- int c;
- int namelen;
- unsigned int i;
- const char *tokstart;
- const char *tokptr;
- int tempbufindex;
- static char *tempbuf;
- static int tempbufsize;
- retry:
- prev_lexptr = lexptr;
- tokstart = lexptr;
-
- for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
- if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
- {
- lexptr += 3;
- yylval.opcode = tokentab3[i].opcode;
- return tokentab3[i].token;
- }
-
- for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
- if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
- {
- lexptr += 2;
- yylval.opcode = tokentab2[i].opcode;
- return tokentab2[i].token;
- }
- switch (c = *tokstart)
- {
- case 0:
- return 0;
- case ' ':
- case '\t':
- case '\n':
- lexptr++;
- goto retry;
- case '\'':
-
- lexptr++;
- c = *lexptr++;
- if (c == '\\')
- c = parse_escape (parse_gdbarch (pstate), &lexptr);
- else if (c == '\'')
- error (_("Empty character constant"));
- yylval.typed_val_int.val = c;
- yylval.typed_val_int.type = parse_java_type (pstate)->builtin_char;
- c = *lexptr++;
- if (c != '\'')
- {
- namelen = skip_quoted (tokstart) - tokstart;
- if (namelen > 2)
- {
- lexptr = tokstart + namelen;
- if (lexptr[-1] != '\'')
- error (_("Unmatched single quote"));
- namelen -= 2;
- tokstart++;
- goto tryname;
- }
- error (_("Invalid character constant"));
- }
- return INTEGER_LITERAL;
- case '(':
- paren_depth++;
- lexptr++;
- return c;
- case ')':
- if (paren_depth == 0)
- return 0;
- paren_depth--;
- lexptr++;
- return c;
- case ',':
- if (comma_terminates && paren_depth == 0)
- return 0;
- lexptr++;
- return c;
- case '.':
-
- if (lexptr[1] < '0' || lexptr[1] > '9')
- goto symbol;
-
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- {
-
- int got_dot = 0, got_e = 0, toktype;
- const char *p = tokstart;
- int hex = input_radix > 10;
- if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
- {
- p += 2;
- hex = 1;
- }
- else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
- {
- p += 2;
- hex = 0;
- }
- for (;; ++p)
- {
-
- if (!hex && !got_e && (*p == 'e' || *p == 'E'))
- got_dot = got_e = 1;
-
- else if (!got_dot && *p == '.')
- got_dot = 1;
- else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
- && (*p == '-' || *p == '+'))
-
- continue;
-
- else if ((*p < '0' || *p > '9')
- && ((*p < 'a' || *p > 'z')
- && (*p < 'A' || *p > 'Z')))
- break;
- }
- toktype = parse_number (pstate, tokstart, p - tokstart,
- got_dot|got_e, &yylval);
- if (toktype == ERROR)
- {
- char *err_copy = (char *) alloca (p - tokstart + 1);
- memcpy (err_copy, tokstart, p - tokstart);
- err_copy[p - tokstart] = 0;
- error (_("Invalid number \"%s\""), err_copy);
- }
- lexptr = p;
- return toktype;
- }
- case '+':
- case '-':
- case '*':
- case '/':
- case '%':
- case '|':
- case '&':
- case '^':
- case '~':
- case '!':
- case '<':
- case '>':
- case '[':
- case ']':
- case '?':
- case ':':
- case '=':
- case '{':
- case '}':
- symbol:
- lexptr++;
- return c;
- case '"':
-
- tokptr = ++tokstart;
- tempbufindex = 0;
- do {
-
- if (tempbufindex + 1 >= tempbufsize)
- {
- tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
- }
- switch (*tokptr)
- {
- case '\0':
- case '"':
-
- break;
- case '\\':
- tokptr++;
- c = parse_escape (parse_gdbarch (pstate), &tokptr);
- if (c == -1)
- {
- continue;
- }
- tempbuf[tempbufindex++] = c;
- break;
- default:
- tempbuf[tempbufindex++] = *tokptr++;
- break;
- }
- } while ((*tokptr != '"') && (*tokptr != '\0'));
- if (*tokptr++ != '"')
- {
- error (_("Unterminated string in expression"));
- }
- tempbuf[tempbufindex] = '\0';
- yylval.sval.ptr = tempbuf;
- yylval.sval.length = tempbufindex;
- lexptr = tokptr;
- return (STRING_LITERAL);
- }
- if (!(c == '_' || c == '$'
- || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
-
- error (_("Invalid character '%c' in expression"), c);
-
- namelen = 0;
- for (c = tokstart[namelen];
- (c == '_'
- || c == '$'
- || (c >= '0' && c <= '9')
- || (c >= 'a' && c <= 'z')
- || (c >= 'A' && c <= 'Z')
- || c == '<');
- )
- {
- if (c == '<')
- {
- int i = namelen;
- while (tokstart[++i] && tokstart[i] != '>');
- if (tokstart[i] == '>')
- namelen = i;
- }
- c = tokstart[++namelen];
- }
-
- if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
- {
- return 0;
- }
- lexptr += namelen;
- tryname:
-
- switch (namelen)
- {
- case 7:
- if (strncmp (tokstart, "boolean", 7) == 0)
- return BOOLEAN;
- break;
- case 6:
- if (strncmp (tokstart, "double", 6) == 0)
- return DOUBLE;
- break;
- case 5:
- if (strncmp (tokstart, "short", 5) == 0)
- return SHORT;
- if (strncmp (tokstart, "false", 5) == 0)
- {
- yylval.lval = 0;
- return BOOLEAN_LITERAL;
- }
- if (strncmp (tokstart, "super", 5) == 0)
- return SUPER;
- if (strncmp (tokstart, "float", 5) == 0)
- return FLOAT;
- break;
- case 4:
- if (strncmp (tokstart, "long", 4) == 0)
- return LONG;
- if (strncmp (tokstart, "byte", 4) == 0)
- return BYTE;
- if (strncmp (tokstart, "char", 4) == 0)
- return CHAR;
- if (strncmp (tokstart, "true", 4) == 0)
- {
- yylval.lval = 1;
- return BOOLEAN_LITERAL;
- }
- break;
- case 3:
- if (strncmp (tokstart, "int", 3) == 0)
- return INT;
- if (strncmp (tokstart, "new", 3) == 0)
- return NEW;
- break;
- default:
- break;
- }
- yylval.sval.ptr = tokstart;
- yylval.sval.length = namelen;
- if (*tokstart == '$')
- {
- write_dollar_variable (pstate, yylval.sval);
- return VARIABLE;
- }
-
- if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
- (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
- {
- YYSTYPE newlval;
- int hextype = parse_number (pstate, tokstart, namelen, 0, &newlval);
- if (hextype == INTEGER_LITERAL)
- return NAME_OR_INT;
- }
- return IDENTIFIER;
- }
- int
- java_parse (struct parser_state *par_state)
- {
- int result;
- struct cleanup *c = make_cleanup_clear_parser_state (&pstate);
-
- gdb_assert (par_state != NULL);
- pstate = par_state;
- result = yyparse ();
- do_cleanups (c);
- return result;
- }
- void
- yyerror (char *msg)
- {
- if (prev_lexptr)
- lexptr = prev_lexptr;
- if (msg)
- error (_("%s: near `%s'"), msg, lexptr);
- else
- error (_("error in expression, near `%s'"), lexptr);
- }
- static struct type *
- java_type_from_name (struct stoken name)
- {
- char *tmp = copy_name (name);
- struct type *typ = java_lookup_class (tmp);
- if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
- error (_("No class named `%s'"), tmp);
- return typ;
- }
- static int
- push_variable (struct parser_state *par_state, struct stoken name)
- {
- char *tmp = copy_name (name);
- struct field_of_this_result is_a_field_of_this;
- struct symbol *sym;
- sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
- &is_a_field_of_this);
- if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
- {
- if (symbol_read_needs_frame (sym))
- {
- if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
- innermost_block = block_found;
- }
- write_exp_elt_opcode (par_state, OP_VAR_VALUE);
-
- write_exp_elt_block (par_state, NULL);
- write_exp_elt_sym (par_state, sym);
- write_exp_elt_opcode (par_state, OP_VAR_VALUE);
- return 1;
- }
- if (is_a_field_of_this.type != NULL)
- {
-
- if (innermost_block == 0 ||
- contained_in (block_found, innermost_block))
- innermost_block = block_found;
- write_exp_elt_opcode (par_state, OP_THIS);
- write_exp_elt_opcode (par_state, OP_THIS);
- write_exp_elt_opcode (par_state, STRUCTOP_PTR);
- write_exp_string (par_state, name);
- write_exp_elt_opcode (par_state, STRUCTOP_PTR);
- return 1;
- }
- return 0;
- }
- static void
- push_fieldnames (struct parser_state *par_state, struct stoken name)
- {
- int i;
- struct stoken token;
- token.ptr = name.ptr;
- for (i = 0; ; i++)
- {
- if (i == name.length || name.ptr[i] == '.')
- {
-
- token.length = &name.ptr[i] - token.ptr;
- write_exp_elt_opcode (par_state, STRUCTOP_PTR);
- write_exp_string (par_state, token);
- write_exp_elt_opcode (par_state, STRUCTOP_PTR);
- token.ptr += token.length + 1;
- }
- if (i >= name.length)
- break;
- }
- }
- static void
- push_qualified_expression_name (struct parser_state *par_state,
- struct stoken name, int dot_index)
- {
- struct stoken token;
- char *tmp;
- struct type *typ;
- token.ptr = name.ptr;
- token.length = dot_index;
- if (push_variable (par_state, token))
- {
- token.ptr = name.ptr + dot_index + 1;
- token.length = name.length - dot_index - 1;
- push_fieldnames (par_state, token);
- return;
- }
- token.ptr = name.ptr;
- for (;;)
- {
- token.length = dot_index;
- tmp = copy_name (token);
- typ = java_lookup_class (tmp);
- if (typ != NULL)
- {
- if (dot_index == name.length)
- {
- write_exp_elt_opcode (par_state, OP_TYPE);
- write_exp_elt_type (par_state, typ);
- write_exp_elt_opcode (par_state, OP_TYPE);
- return;
- }
- dot_index++;
- name.ptr += dot_index;
- name.length -= dot_index;
- dot_index = 0;
- while (dot_index < name.length && name.ptr[dot_index] != '.')
- dot_index++;
- token.ptr = name.ptr;
- token.length = dot_index;
- write_exp_elt_opcode (par_state, OP_SCOPE);
- write_exp_elt_type (par_state, typ);
- write_exp_string (par_state, token);
- write_exp_elt_opcode (par_state, OP_SCOPE);
- if (dot_index < name.length)
- {
- dot_index++;
- name.ptr += dot_index;
- name.length -= dot_index;
- push_fieldnames (par_state, name);
- }
- return;
- }
- else if (dot_index >= name.length)
- break;
- dot_index++;
- while (dot_index < name.length && name.ptr[dot_index] != '.')
- dot_index++;
- }
- error (_("unknown type `%.*s'"), name.length, name.ptr);
- }
- static void
- push_expression_name (struct parser_state *par_state, struct stoken name)
- {
- char *tmp;
- struct type *typ;
- int i;
- for (i = 0; i < name.length; i++)
- {
- if (name.ptr[i] == '.')
- {
-
- push_qualified_expression_name (par_state, name, i);
- return;
- }
- }
-
- if (push_variable (par_state, name))
- return;
- tmp = copy_name (name);
- typ = java_lookup_class (tmp);
- if (typ != NULL)
- {
- write_exp_elt_opcode (par_state, OP_TYPE);
- write_exp_elt_type (par_state, typ);
- write_exp_elt_opcode (par_state, OP_TYPE);
- }
- else
- {
- struct bound_minimal_symbol msymbol;
- msymbol = lookup_bound_minimal_symbol (tmp);
- if (msymbol.minsym != NULL)
- write_exp_msymbol (par_state, msymbol);
- else if (!have_full_symbols () && !have_partial_symbols ())
- error (_("No symbol table is loaded. Use the \"file\" command"));
- else
- error (_("No symbol \"%s\" in current context."), tmp);
- }
- }
- static struct expression *
- copy_exp (struct expression *expr, int endpos)
- {
- int len = length_of_subexp (expr, endpos);
- struct expression *new
- = (struct expression *) malloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len));
- new->nelts = len;
- memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len));
- new->language_defn = 0;
- return new;
- }
- static void
- insert_exp (struct parser_state *par_state, int pos, struct expression *new)
- {
- int newlen = new->nelts;
- int i;
-
- increase_expout_size (par_state, newlen);
- for (i = par_state->expout_ptr - 1; i >= pos; i--)
- par_state->expout->elts[i + newlen] = par_state->expout->elts[i];
- memcpy (par_state->expout->elts + pos, new->elts,
- EXP_ELEM_TO_BYTES (newlen));
- par_state->expout_ptr += newlen;
- }