diff options
Diffstat (limited to 'gdb/jv-exp.y')
| -rw-r--r-- | gdb/jv-exp.y | 1466 |
1 files changed, 1466 insertions, 0 deletions
diff --git a/gdb/jv-exp.y b/gdb/jv-exp.y new file mode 100644 index 00000000000..d17c4f3a8b9 --- /dev/null +++ b/gdb/jv-exp.y @@ -0,0 +1,1466 @@ +/* YACC parser for Java expressions, for GDB. + Copyright (C) 1997, 1998, 1999. + Free Software Foundation, Inc. + +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 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* Parse a Java expression from text in a string, + and return the result as a struct expression pointer. + That structure contains arithmetic operations in reverse polish, + with constants represented by operations that are followed by special data. + See expression.h for the details of the format. + What is important here is that it can be built up sequentially + during the process of parsing; the lower levels of the tree always + come first in the result. Well, almost always; see ArrayAccess. + + Note that malloc's and realloc's in this file are transformed to + xmalloc and xrealloc respectively by the same sed command in the + makefile that remaps any other malloc/realloc inserted by the parser + generator. Doing this with #defines and trying to control the interaction + with include files (<malloc.h> and <stdlib.h> for example) just became + too messy, particularly when such includes can be inserted at random + times by the parser generator. */ + +%{ + +#include "defs.h" +#include "gdb_string.h" +#include <ctype.h> +#include "expression.h" +#include "value.h" +#include "parser-defs.h" +#include "language.h" +#include "jv-lang.h" +#include "bfd.h" /* Required by objfiles.h. */ +#include "symfile.h" /* Required by objfiles.h. */ +#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ + +/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), + as well as gratuitiously global symbol names, so we can have multiple + yacc generated parsers in gdb. Note that these are only the variables + produced by yacc. If other parser generators (bison, byacc, etc) produce + additional global names that conflict at link time, then those parser + generators need to be fixed instead of adding those names to this list. */ + +#define yymaxdepth java_maxdepth +#define yyparse java_parse +#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 /* With YYDEBUG defined */ +#define yytoks java_toks /* With YYDEBUG defined */ +#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 + +#ifndef YYDEBUG +#define YYDEBUG 0 /* Default to no yydebug support */ +#endif + +int +yyparse PARAMS ((void)); + +static int +yylex PARAMS ((void)); + +void +yyerror PARAMS ((char *)); + +static struct type * java_type_from_name PARAMS ((struct stoken)); +static void push_expression_name PARAMS ((struct stoken)); +static void push_fieldnames PARAMS ((struct stoken)); + +static struct expression *copy_exp PARAMS ((struct expression *, int)); +static void insert_exp PARAMS ((int, struct expression *)); + +%} + +/* Although the yacc "value" of an expression is not used, + since the result is stored in the structure being created, + other node types do have values. */ + +%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; + } + +%{ +/* YYSTYPE gets defined by %union */ +static int +parse_number PARAMS ((char *, int, int, YYSTYPE *)); +%} + +%type <lval> rcurly Dims Dims_opt +%type <tval> ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */ +%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 + +/* A NAME_OR_INT is a symbol which is not known in the symbol table, + but which would parse as a valid number in the current input radix. + E.g. "c" when input_radix==16. Depending on the parse, it will be + turned into a name or into a number. */ + +%token <sval> NAME_OR_INT + +%token ERROR + +/* Special type cases, put in to allow the parser to distinguish different + legal basetypes. */ +%token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT + +%token VARIABLE + +%token <opcode> ASSIGN_MODIFY + +%token THIS 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(OP_TYPE); + write_exp_elt_type($1); + write_exp_elt_opcode(OP_TYPE); + } + ; + +PrimitiveOrArrayType: + PrimitiveType + | ArrayType + ; + +StringLiteral: + STRING_LITERAL + { + write_exp_elt_opcode (OP_STRING); + write_exp_string ($1); + write_exp_elt_opcode (OP_STRING); + } +; + +Literal: + INTEGER_LITERAL + { write_exp_elt_opcode (OP_LONG); + write_exp_elt_type ($1.type); + write_exp_elt_longcst ((LONGEST)($1.val)); + write_exp_elt_opcode (OP_LONG); } +| NAME_OR_INT + { YYSTYPE val; + parse_number ($1.ptr, $1.length, 0, &val); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (val.typed_val_int.type); + write_exp_elt_longcst ((LONGEST)val.typed_val_int.val); + write_exp_elt_opcode (OP_LONG); + } +| FLOATING_POINT_LITERAL + { write_exp_elt_opcode (OP_DOUBLE); + write_exp_elt_type ($1.type); + write_exp_elt_dblcst ($1.dval); + write_exp_elt_opcode (OP_DOUBLE); } +| BOOLEAN_LITERAL + { write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (java_boolean_type); + write_exp_elt_longcst ((LONGEST)$1); + write_exp_elt_opcode (OP_LONG); } +| StringLiteral + ; + +/* UNUSED: +Type: + PrimitiveType +| ReferenceType +; +*/ + +PrimitiveType: + NumericType +| BOOLEAN + { $$ = java_boolean_type; } +; + +NumericType: + IntegralType +| FloatingPointType +; + +IntegralType: + BYTE + { $$ = java_byte_type; } +| SHORT + { $$ = java_short_type; } +| INT + { $$ = java_int_type; } +| LONG + { $$ = java_long_type; } +| CHAR + { $$ = java_char_type; } +; + +FloatingPointType: + FLOAT + { $$ = java_float_type; } +| DOUBLE + { $$ = java_double_type; } +; + +/* 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; /* Optimization. */ + else + { + $$.ptr = (char *) malloc ($$.length + 1); + make_cleanup (free, $$.ptr); + sprintf ($$.ptr, "%.*s.%.*s", + $1.length, $1.ptr, $3.length, $3.ptr); + } } +; + +/* +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 (BINOP_COMMA); } + ; + +Primary: + PrimaryNoNewArray +| ArrayCreationExpression +; + +PrimaryNoNewArray: + Literal +| THIS + { write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (OP_THIS); } +| '(' Expression ')' +| ClassInstanceCreationExpression +| FieldAccess +| MethodInvocation +| ArrayAccess +| lcurly ArgumentList rcurly + { write_exp_elt_opcode (OP_ARRAY); + write_exp_elt_longcst ((LONGEST) 0); + write_exp_elt_longcst ((LONGEST) $3); + write_exp_elt_opcode (OP_ARRAY); } +; + +lcurly: + '{' + { start_arglist (); } +; + +rcurly: + '}' + { $$ = end_arglist () - 1; } +; + +ClassInstanceCreationExpression: + NEW ClassType '(' ArgumentList_opt ')' + { error ("FIXME - ClassInstanceCreationExpression"); } +; + +ArgumentList: + Expression + { arglist_len = 1; } +| ArgumentList ',' Expression + { arglist_len++; } +; + +ArgumentList_opt: + /* EMPTY */ + { arglist_len = 0; } +| ArgumentList +; + +ArrayCreationExpression: + NEW PrimitiveType DimExprs Dims_opt + { error ("FIXME - ArrayCreatiionExpression"); } +| NEW ClassOrInterfaceType DimExprs Dims_opt + { error ("FIXME - ArrayCreatiionExpression"); } +; + +DimExprs: + DimExpr +| DimExprs DimExpr +; + +DimExpr: + '[' Expression ']' +; + +Dims: + '[' ']' + { $$ = 1; } +| Dims '[' ']' + { $$ = $1 + 1; } +; + +Dims_opt: + Dims +| /* EMPTY */ + { $$ = 0; } +; + +FieldAccess: + Primary '.' SimpleName + { push_fieldnames ($3); } +| VARIABLE '.' SimpleName + { push_fieldnames ($3); } +/*| SUPER '.' SimpleName { FIXME } */ +; + +MethodInvocation: + Name '(' ArgumentList_opt ')' + { error ("method invocation not implemented"); } +| Primary '.' SimpleName '(' ArgumentList_opt ')' + { error ("method invocation not implemented"); } +| SUPER '.' SimpleName '(' ArgumentList_opt ')' + { error ("method invocation not implemented"); } +; + +ArrayAccess: + Name '[' Expression ']' + { + /* Emit code for the Name now, then exchange it in the + expout array with the Expression's code. We could + introduce a OP_SWAP code or a reversed version of + BINOP_SUBSCRIPT, but that makes the rest of GDB pay + for our parsing kludges. */ + struct expression *name_expr; + + push_expression_name ($1); + name_expr = copy_exp (expout, expout_ptr); + expout_ptr -= name_expr->nelts; + insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr), + name_expr); + free (name_expr); + write_exp_elt_opcode (BINOP_SUBSCRIPT); + } +| VARIABLE '[' Expression ']' + { write_exp_elt_opcode (BINOP_SUBSCRIPT); } +| PrimaryNoNewArray '[' Expression ']' + { write_exp_elt_opcode (BINOP_SUBSCRIPT); } +; + +PostfixExpression: + Primary +| Name + { push_expression_name ($1); } +| VARIABLE + /* Already written by write_dollar_variable. */ +| PostIncrementExpression +| PostDecrementExpression +; + +PostIncrementExpression: + PostfixExpression INCREMENT + { write_exp_elt_opcode (UNOP_POSTINCREMENT); } +; + +PostDecrementExpression: + PostfixExpression DECREMENT + { write_exp_elt_opcode (UNOP_POSTDECREMENT); } +; + +UnaryExpression: + PreIncrementExpression +| PreDecrementExpression +| '+' UnaryExpression +| '-' UnaryExpression + { write_exp_elt_opcode (UNOP_NEG); } +| '*' UnaryExpression + { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java */ +| UnaryExpressionNotPlusMinus +; + +PreIncrementExpression: + INCREMENT UnaryExpression + { write_exp_elt_opcode (UNOP_PREINCREMENT); } +; + +PreDecrementExpression: + DECREMENT UnaryExpression + { write_exp_elt_opcode (UNOP_PREDECREMENT); } +; + +UnaryExpressionNotPlusMinus: + PostfixExpression +| '~' UnaryExpression + { write_exp_elt_opcode (UNOP_COMPLEMENT); } +| '!' UnaryExpression + { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } +| CastExpression + ; + +CastExpression: + '(' PrimitiveType Dims_opt ')' UnaryExpression + { write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_type (java_array_type ($2, $3)); + 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; + int base = expout_ptr - last_exp_size - 3; + if (base < 0 || expout->elts[base+2].opcode != OP_TYPE) + error ("invalid cast expression"); + type = expout->elts[base+1].type; + /* Remove the 'Expression' and slide the + UnaryExpressionNotPlusMinus down to replace it. */ + for (i = 0; i < last_exp_size; i++) + expout->elts[base + i] = expout->elts[base + i + 3]; + expout_ptr -= 3; + if (TYPE_CODE (type) == TYPE_CODE_STRUCT) + type = lookup_pointer_type (type); + write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_type (type); + write_exp_elt_opcode (UNOP_CAST); + } +| '(' Name Dims ')' UnaryExpressionNotPlusMinus + { write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_type (java_array_type (java_type_from_name ($2), $3)); + write_exp_elt_opcode (UNOP_CAST); } +; + + +MultiplicativeExpression: + UnaryExpression +| MultiplicativeExpression '*' UnaryExpression + { write_exp_elt_opcode (BINOP_MUL); } +| MultiplicativeExpression '/' UnaryExpression + { write_exp_elt_opcode (BINOP_DIV); } +| MultiplicativeExpression '%' UnaryExpression + { write_exp_elt_opcode (BINOP_REM); } +; + +AdditiveExpression: + MultiplicativeExpression +| AdditiveExpression '+' MultiplicativeExpression + { write_exp_elt_opcode (BINOP_ADD); } +| AdditiveExpression '-' MultiplicativeExpression + { write_exp_elt_opcode (BINOP_SUB); } +; + +ShiftExpression: + AdditiveExpression +| ShiftExpression LSH AdditiveExpression + { write_exp_elt_opcode (BINOP_LSH); } +| ShiftExpression RSH AdditiveExpression + { write_exp_elt_opcode (BINOP_RSH); } +/* | ShiftExpression >>> AdditiveExpression { FIXME } */ +; + +RelationalExpression: + ShiftExpression +| RelationalExpression '<' ShiftExpression + { write_exp_elt_opcode (BINOP_LESS); } +| RelationalExpression '>' ShiftExpression + { write_exp_elt_opcode (BINOP_GTR); } +| RelationalExpression LEQ ShiftExpression + { write_exp_elt_opcode (BINOP_LEQ); } +| RelationalExpression GEQ ShiftExpression + { write_exp_elt_opcode (BINOP_GEQ); } +/* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */ +; + +EqualityExpression: + RelationalExpression +| EqualityExpression EQUAL RelationalExpression + { write_exp_elt_opcode (BINOP_EQUAL); } +| EqualityExpression NOTEQUAL RelationalExpression + { write_exp_elt_opcode (BINOP_NOTEQUAL); } +; + +AndExpression: + EqualityExpression +| AndExpression '&' EqualityExpression + { write_exp_elt_opcode (BINOP_BITWISE_AND); } +; + +ExclusiveOrExpression: + AndExpression +| ExclusiveOrExpression '^' AndExpression + { write_exp_elt_opcode (BINOP_BITWISE_XOR); } +; +InclusiveOrExpression: + ExclusiveOrExpression +| InclusiveOrExpression '|' ExclusiveOrExpression + { write_exp_elt_opcode (BINOP_BITWISE_IOR); } +; + +ConditionalAndExpression: + InclusiveOrExpression +| ConditionalAndExpression ANDAND InclusiveOrExpression + { write_exp_elt_opcode (BINOP_LOGICAL_AND); } +; + +ConditionalOrExpression: + ConditionalAndExpression +| ConditionalOrExpression OROR ConditionalAndExpression + { write_exp_elt_opcode (BINOP_LOGICAL_OR); } +; + +ConditionalExpression: + ConditionalOrExpression +| ConditionalOrExpression '?' Expression ':' ConditionalExpression + { write_exp_elt_opcode (TERNOP_COND); } +; + +AssignmentExpression: + ConditionalExpression +| Assignment +; + +Assignment: + LeftHandSide '=' ConditionalExpression + { write_exp_elt_opcode (BINOP_ASSIGN); } +| LeftHandSide ASSIGN_MODIFY ConditionalExpression + { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); + write_exp_elt_opcode ($2); + write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } +; + +LeftHandSide: + ForcedName + { push_expression_name ($1); } +| VARIABLE + /* Already written by write_dollar_variable. */ +| FieldAccess +| ArrayAccess +; + + +Expression: + AssignmentExpression +; + +%% +/* Take care of parsing a number (anything that starts with a digit). + Set yylval and return the token type; update lexptr. + LEN is the number of characters in it. */ + +/*** Needs some error checking for the float case ***/ + +static int +parse_number (p, len, parsed_float, putithere) + register char *p; + register int len; + int parsed_float; + YYSTYPE *putithere; +{ + register ULONGEST n = 0; + ULONGEST limit, limit_div_base; + + register int c; + register int base = input_radix; + + struct type *type; + + 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 */ + if (sizeof (putithere->typed_val_float.dval) <= sizeof (float)) + num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c); + else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double)) + num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c); + else + { +#ifdef SCANF_HAS_LONG_DOUBLE + num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c); +#else + /* Scan it into a double, then assign it to the long double. + This at least wins with values representable in the range + of doubles. */ + double temp; + num = sscanf (p, "%lg%c", &temp, &c); + putithere->typed_val_float.dval = temp; +#endif + } + p[len] = saved_char; /* restore the input stream */ + if (num != 1) /* check scanf found ONLY a float ... */ + return ERROR; + /* See if it has `f' or `d' suffix (float or double). */ + + c = tolower (p[len - 1]); + + if (c == 'f' || c == 'F') + putithere->typed_val_float.type = builtin_type_float; + else if (isdigit (c) || c == '.' || c == 'd' || c == 'D') + putithere->typed_val_float.type = builtin_type_double; + else + return ERROR; + + return FLOATING_POINT_LITERAL; + } + + /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ + 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; + if (c == 'l' || c == 'L') + { + type = java_long_type; + len--; + /* A paranoid calculation of (1<<64)-1. */ + limit = ((limit << 16) << 16) | limit; + } + else + { + type = java_int_type; + } + 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; /* Char not a digit */ + if (c >= base) + return ERROR; + if (n > limit_div_base + || (n *= base) > limit - c) + error ("Numeric constant too large."); + n += c; + } + + 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} + }; + +/* Read one token, getting characters through lexptr. */ + +static int +yylex () +{ + int c; + int namelen; + unsigned int i; + char *tokstart; + char *tokptr; + int tempbufindex; + static char *tempbuf; + static int tempbufsize; + + retry: + + tokstart = lexptr; + /* See if it is a special token of length 3. */ + for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) + if (STREQN (tokstart, tokentab3[i].operator, 3)) + { + lexptr += 3; + yylval.opcode = tokentab3[i].opcode; + return tokentab3[i].token; + } + + /* See if it is a special token of length 2. */ + for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) + if (STREQN (tokstart, tokentab2[i].operator, 2)) + { + 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 '\'': + /* We either have a character constant ('0' or '\177' for example) + or we have a quoted symbol reference ('foo(int,int)' in C++ + for example). */ + lexptr++; + c = *lexptr++; + if (c == '\\') + c = parse_escape (&lexptr); + else if (c == '\'') + error ("Empty character constant."); + + yylval.typed_val_int.val = c; + yylval.typed_val_int.type = builtin_type_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 '.': + /* Might be a floating point number. */ + if (lexptr[1] < '0' || lexptr[1] > '9') + goto symbol; /* Nope, must be a symbol. */ + /* FALL THRU into number case. */ + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + /* It's a number. */ + int got_dot = 0, got_e = 0, toktype; + register 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) + { + /* This test includes !hex because 'e' is a valid hex digit + and thus does not indicate a floating point number when + the radix is hex. */ + if (!hex && !got_e && (*p == 'e' || *p == 'E')) + got_dot = got_e = 1; + /* This test does not include !hex, because a '.' always indicates + a decimal floating point number regardless of the radix. */ + else if (!got_dot && *p == '.') + got_dot = 1; + else if (got_e && (p[-1] == 'e' || p[-1] == 'E') + && (*p == '-' || *p == '+')) + /* This is the sign of the exponent, not the end of the + number. */ + continue; + /* We will take any letters or digits. parse_number will + complain if past the radix, or if L or U are not final. */ + else if ((*p < '0' || *p > '9') + && ((*p < 'a' || *p > 'z') + && (*p < 'A' || *p > 'Z'))) + break; + } + toktype = parse_number (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 '"': + + /* Build the gdb internal form of the input string in tempbuf, + translating any standard C escape forms seen. Note that the + buffer is null byte terminated *only* for the convenience of + debugging gdb itself and printing the buffer contents when + the buffer contains no embedded nulls. Gdb does not depend + upon the buffer being null byte terminated, it uses the length + string instead. This allows gdb to handle C strings (as well + as strings in other languages) with embedded null bytes */ + + tokptr = ++tokstart; + tempbufindex = 0; + + do { + /* Grow the static temp buffer if necessary, including allocating + the first one on demand. */ + if (tempbufindex + 1 >= tempbufsize) + { + tempbuf = (char *) realloc (tempbuf, tempbufsize += 64); + } + switch (*tokptr) + { + case '\0': + case '"': + /* Do nothing, loop will terminate. */ + break; + case '\\': + tokptr++; + c = parse_escape (&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'; /* See note above */ + yylval.sval.ptr = tempbuf; + yylval.sval.length = tempbufindex; + lexptr = tokptr; + return (STRING_LITERAL); + } + + if (!(c == '_' || c == '$' + || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) + /* We must have come across a bad character (e.g. ';'). */ + error ("Invalid character '%c' in expression.", c); + + /* It's a name. See how long it is. */ + 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]; + } + + /* The token "if" terminates the expression and is NOT + removed from the input stream. */ + if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') + { + return 0; + } + + lexptr += namelen; + + tryname: + + /* Catch specific keywords. Should be done with a data structure. */ + switch (namelen) + { + case 7: + if (STREQN (tokstart, "boolean", 7)) + return BOOLEAN; + break; + case 6: + if (STREQN (tokstart, "double", 6)) + return DOUBLE; + break; + case 5: + if (STREQN (tokstart, "short", 5)) + return SHORT; + if (STREQN (tokstart, "false", 5)) + { + yylval.lval = 0; + return BOOLEAN_LITERAL; + } + if (STREQN (tokstart, "super", 5)) + return SUPER; + if (STREQN (tokstart, "float", 5)) + return FLOAT; + break; + case 4: + if (STREQN (tokstart, "long", 4)) + return LONG; + if (STREQN (tokstart, "byte", 4)) + return BYTE; + if (STREQN (tokstart, "char", 4)) + return CHAR; + if (STREQN (tokstart, "true", 4)) + { + yylval.lval = 1; + return BOOLEAN_LITERAL; + } + if (current_language->la_language == language_cplus + && STREQN (tokstart, "this", 4)) + { + static const char this_name[] = + { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' }; + + if (lookup_symbol (this_name, expression_context_block, + VAR_NAMESPACE, (int *) NULL, + (struct symtab **) NULL)) + return THIS; + } + break; + case 3: + if (STREQN (tokstart, "int", 3)) + return INT; + if (STREQN (tokstart, "new", 3)) + return NEW; + break; + default: + break; + } + + yylval.sval.ptr = tokstart; + yylval.sval.length = namelen; + + if (*tokstart == '$') + { + write_dollar_variable (yylval.sval); + return VARIABLE; + } + + /* Input names that aren't symbols but ARE valid hex numbers, + when the input radix permits them, can be names or numbers + depending on the parse. Note we support radixes > 16 here. */ + if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) || + (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) + { + YYSTYPE newlval; /* Its value is ignored. */ + int hextype = parse_number (tokstart, namelen, 0, &newlval); + if (hextype == INTEGER_LITERAL) + return NAME_OR_INT; + } + return IDENTIFIER; +} + +void +yyerror (msg) + char *msg; +{ + error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); +} + +static struct type * +java_type_from_name (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; +} + +/* If NAME is a valid variable name in this scope, push it and return 1. + Otherwise, return 0. */ + +static int +push_variable (name) + struct stoken name; + +{ + char *tmp = copy_name (name); + int is_a_field_of_this = 0; + struct symbol *sym; + sym = lookup_symbol (tmp, expression_context_block, VAR_NAMESPACE, + &is_a_field_of_this, (struct symtab **) NULL); + 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 (OP_VAR_VALUE); + /* We want to use the selected frame, not another more inner frame + which happens to be in the same block. */ + write_exp_elt_block (NULL); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); + return 1; + } + if (is_a_field_of_this) + { + /* it hangs off of `this'. Must not inadvertently convert from a + method call to data ref. */ + if (innermost_block == 0 || + contained_in (block_found, innermost_block)) + innermost_block = block_found; + write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string (name); + write_exp_elt_opcode (STRUCTOP_PTR); + return 1; + } + return 0; +} + +/* Assuming a reference expression has been pushed, emit the + STRUCTOP_STRUCT ops to access the field named NAME. If NAME is a + qualified name (has '.'), generate a field access for each part. */ + +static void +push_fieldnames (name) + struct stoken name; +{ + int i; + struct stoken token; + token.ptr = name.ptr; + for (i = 0; ; i++) + { + if (i == name.length || name.ptr[i] == '.') + { + /* token.ptr is start of current field name. */ + token.length = &name.ptr[i] - token.ptr; + write_exp_elt_opcode (STRUCTOP_STRUCT); + write_exp_string (token); + write_exp_elt_opcode (STRUCTOP_STRUCT); + token.ptr += token.length + 1; + } + if (i >= name.length) + break; + } +} + +/* Helper routine for push_expression_name. + Handle a qualified name, where DOT_INDEX is the index of the first '.' */ + +static void +push_qualified_expression_name (name, dot_index) + 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 (token)) + { + token.ptr = name.ptr + dot_index + 1; + token.length = name.length - dot_index - 1; + push_fieldnames (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(OP_TYPE); + write_exp_elt_type(typ); + write_exp_elt_opcode(OP_TYPE); + return; + } + dot_index++; /* Skip '.' */ + 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 (OP_SCOPE); + write_exp_elt_type (typ); + write_exp_string (token); + write_exp_elt_opcode (OP_SCOPE); + if (dot_index < name.length) + { + dot_index++; + name.ptr += dot_index; + name.length -= dot_index; + push_fieldnames (name); + } + return; + } + else if (dot_index >= name.length) + break; + dot_index++; /* Skip '.' */ + while (dot_index < name.length && name.ptr[dot_index] != '.') + dot_index++; + } + error ("unknown type `%.*s'", name.length, name.ptr); +} + +/* Handle Name in an expression (or LHS). + Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */ + +static void +push_expression_name (name) + struct stoken name; +{ + char *tmp; + struct type *typ; + char *ptr; + int i; + + for (i = 0; i < name.length; i++) + { + if (name.ptr[i] == '.') + { + /* It's a Qualified Expression Name. */ + push_qualified_expression_name (name, i); + return; + } + } + + /* It's a Simple Expression Name. */ + + if (push_variable (name)) + return; + tmp = copy_name (name); + typ = java_lookup_class (tmp); + if (typ != NULL) + { + write_exp_elt_opcode(OP_TYPE); + write_exp_elt_type(typ); + write_exp_elt_opcode(OP_TYPE); + } + else + { + struct minimal_symbol *msymbol; + + msymbol = lookup_minimal_symbol (tmp, NULL, NULL); + if (msymbol != NULL) + { + write_exp_msymbol (msymbol, + lookup_function_type (builtin_type_int), + builtin_type_int); + } + 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); + } + +} + + +/* The following two routines, copy_exp and insert_exp, aren't specific to + Java, so they could go in parse.c, but their only purpose is to support + the parsing kludges we use in this file, so maybe it's best to isolate + them here. */ + +/* Copy the expression whose last element is at index ENDPOS - 1 in EXPR + into a freshly malloc'ed struct expression. Its language_defn is set + to null. */ +static struct expression * +copy_exp (expr, endpos) + 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; +} + +/* Insert the expression NEW into the current expression (expout) at POS. */ +static void +insert_exp (pos, new) + int pos; + struct expression *new; +{ + int newlen = new->nelts; + + /* Grow expout if necessary. In this function's only use at present, + this should never be necessary. */ + if (expout_ptr + newlen > expout_size) + { + expout_size = max (expout_size * 2, expout_ptr + newlen + 10); + expout = (struct expression *) + realloc ((char *) expout, (sizeof (struct expression) + + EXP_ELEM_TO_BYTES (expout_size))); + } + + { + int i; + + for (i = expout_ptr - 1; i >= pos; i--) + expout->elts[i + newlen] = expout->elts[i]; + } + + memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen)); + expout_ptr += newlen; +} |