1 /* YACC parser for Java expressions, for GDB.
2 Copyright 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* Parse a Java expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result. Well, almost always; see ArrayAccess.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
41 #include "gdb_string.h"
43 #include "expression.h"
45 #include "parser-defs.h"
48 #include "bfd.h" /* Required by objfiles.h. */
49 #include "symfile.h" /* Required by objfiles.h. */
50 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
52 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
53 as well as gratuitiously global symbol names, so we can have multiple
54 yacc generated parsers in gdb. Note that these are only the variables
55 produced by yacc. If other parser generators (bison, byacc, etc) produce
56 additional global names that conflict at link time, then those parser
57 generators need to be fixed instead of adding those names to this list. */
59 #define yymaxdepth java_maxdepth
60 #define yyparse java_parse
61 #define yylex java_lex
62 #define yyerror java_error
63 #define yylval java_lval
64 #define yychar java_char
65 #define yydebug java_debug
66 #define yypact java_pact
69 #define yydef java_def
70 #define yychk java_chk
71 #define yypgo java_pgo
72 #define yyact java_act
73 #define yyexca java_exca
74 #define yyerrflag java_errflag
75 #define yynerrs java_nerrs
79 #define yy_yys java_yys
80 #define yystate java_state
81 #define yytmp java_tmp
83 #define yy_yyv java_yyv
84 #define yyval java_val
85 #define yylloc java_lloc
86 #define yyreds java_reds /* With YYDEBUG defined */
87 #define yytoks java_toks /* With YYDEBUG defined */
88 #define yyname java_name /* With YYDEBUG defined */
89 #define yyrule java_rule /* With YYDEBUG defined */
90 #define yylhs java_yylhs
91 #define yylen java_yylen
92 #define yydefred java_yydefred
93 #define yydgoto java_yydgoto
94 #define yysindex java_yysindex
95 #define yyrindex java_yyrindex
96 #define yygindex java_yygindex
97 #define yytable java_yytable
98 #define yycheck java_yycheck
101 #define YYDEBUG 1 /* Default to yydebug support */
104 #define YYFPRINTF parser_fprintf
108 static int yylex (void);
110 void yyerror (char *);
112 static struct type *java_type_from_name (struct stoken);
113 static void push_expression_name (struct stoken);
114 static void push_fieldnames (struct stoken);
116 static struct expression *copy_exp (struct expression *, int);
117 static void insert_exp (int, struct expression *);
121 /* Although the yacc "value" of an expression is not used,
122 since the result is stored in the structure being created,
123 other node types do have values. */
140 struct symtoken ssym;
142 enum exp_opcode opcode;
143 struct internalvar *ivar;
148 /* YYSTYPE gets defined by %union */
149 static int parse_number (char *, int, int, YYSTYPE *);
152 %type <lval> rcurly Dims Dims_opt
153 %type <tval> ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */
154 %type <tval> IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType
156 %token <typed_val_int> INTEGER_LITERAL
157 %token <typed_val_float> FLOATING_POINT_LITERAL
159 %token <sval> IDENTIFIER
160 %token <sval> STRING_LITERAL
161 %token <lval> BOOLEAN_LITERAL
162 %token <tsym> TYPENAME
163 %type <sval> Name SimpleName QualifiedName ForcedName
165 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
166 but which would parse as a valid number in the current input radix.
167 E.g. "c" when input_radix==16. Depending on the parse, it will be
168 turned into a name or into a number. */
170 %token <sval> NAME_OR_INT
174 /* Special type cases, put in to allow the parser to distinguish different
176 %token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT
180 %token <opcode> ASSIGN_MODIFY
185 %right '=' ASSIGN_MODIFY
193 %left '<' '>' LEQ GEQ
197 %right INCREMENT DECREMENT
207 type_exp: PrimitiveOrArrayType
209 write_exp_elt_opcode(OP_TYPE);
210 write_exp_elt_type($1);
211 write_exp_elt_opcode(OP_TYPE);
215 PrimitiveOrArrayType:
223 write_exp_elt_opcode (OP_STRING);
224 write_exp_string ($1);
225 write_exp_elt_opcode (OP_STRING);
231 { write_exp_elt_opcode (OP_LONG);
232 write_exp_elt_type ($1.type);
233 write_exp_elt_longcst ((LONGEST)($1.val));
234 write_exp_elt_opcode (OP_LONG); }
237 parse_number ($1.ptr, $1.length, 0, &val);
238 write_exp_elt_opcode (OP_LONG);
239 write_exp_elt_type (val.typed_val_int.type);
240 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
241 write_exp_elt_opcode (OP_LONG);
243 | FLOATING_POINT_LITERAL
244 { write_exp_elt_opcode (OP_DOUBLE);
245 write_exp_elt_type ($1.type);
246 write_exp_elt_dblcst ($1.dval);
247 write_exp_elt_opcode (OP_DOUBLE); }
249 { write_exp_elt_opcode (OP_LONG);
250 write_exp_elt_type (java_boolean_type);
251 write_exp_elt_longcst ((LONGEST)$1);
252 write_exp_elt_opcode (OP_LONG); }
266 { $$ = java_boolean_type; }
276 { $$ = java_byte_type; }
278 { $$ = java_short_type; }
280 { $$ = java_int_type; }
282 { $$ = java_long_type; }
284 { $$ = java_char_type; }
289 { $$ = java_float_type; }
291 { $$ = java_double_type; }
301 ClassOrInterfaceType:
303 { $$ = java_type_from_name ($1); }
312 { $$ = java_array_type ($1, $2); }
314 { $$ = java_array_type (java_type_from_name ($1), $2); }
334 { $$.length = $1.length + $3.length + 1;
335 if ($1.ptr + $1.length + 1 == $3.ptr
336 && $1.ptr[$1.length] == '.')
337 $$.ptr = $1.ptr; /* Optimization. */
340 $$.ptr = (char *) malloc ($$.length + 1);
341 make_cleanup (free, $$.ptr);
342 sprintf ($$.ptr, "%.*s.%.*s",
343 $1.length, $1.ptr, $3.length, $3.ptr);
349 { write_exp_elt_opcode(OP_TYPE);
350 write_exp_elt_type($1);
351 write_exp_elt_opcode(OP_TYPE);}
355 /* Expressions, including the comma operator. */
357 | exp1 ',' Expression
358 { write_exp_elt_opcode (BINOP_COMMA); }
363 | ArrayCreationExpression
369 | ClassInstanceCreationExpression
373 | lcurly ArgumentList rcurly
374 { write_exp_elt_opcode (OP_ARRAY);
375 write_exp_elt_longcst ((LONGEST) 0);
376 write_exp_elt_longcst ((LONGEST) $3);
377 write_exp_elt_opcode (OP_ARRAY); }
382 { start_arglist (); }
387 { $$ = end_arglist () - 1; }
390 ClassInstanceCreationExpression:
391 NEW ClassType '(' ArgumentList_opt ')'
392 { internal_error (__FILE__, __LINE__,
393 _("FIXME - ClassInstanceCreationExpression")); }
399 | ArgumentList ',' Expression
409 ArrayCreationExpression:
410 NEW PrimitiveType DimExprs Dims_opt
411 { internal_error (__FILE__, __LINE__,
412 _("FIXME - ArrayCreationExpression")); }
413 | NEW ClassOrInterfaceType DimExprs Dims_opt
414 { internal_error (__FILE__, __LINE__,
415 _("FIXME - ArrayCreationExpression")); }
441 Primary '.' SimpleName
442 { push_fieldnames ($3); }
443 | VARIABLE '.' SimpleName
444 { push_fieldnames ($3); }
445 /*| SUPER '.' SimpleName { FIXME } */
449 Name '(' ArgumentList_opt ')'
450 { error (_("Method invocation not implemented")); }
451 | Primary '.' SimpleName '(' ArgumentList_opt ')'
452 { error (_("Method invocation not implemented")); }
453 | SUPER '.' SimpleName '(' ArgumentList_opt ')'
454 { error (_("Method invocation not implemented")); }
458 Name '[' Expression ']'
460 /* Emit code for the Name now, then exchange it in the
461 expout array with the Expression's code. We could
462 introduce a OP_SWAP code or a reversed version of
463 BINOP_SUBSCRIPT, but that makes the rest of GDB pay
464 for our parsing kludges. */
465 struct expression *name_expr;
467 push_expression_name ($1);
468 name_expr = copy_exp (expout, expout_ptr);
469 expout_ptr -= name_expr->nelts;
470 insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),
473 write_exp_elt_opcode (BINOP_SUBSCRIPT);
475 | VARIABLE '[' Expression ']'
476 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
477 | PrimaryNoNewArray '[' Expression ']'
478 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
484 { push_expression_name ($1); }
486 /* Already written by write_dollar_variable. */
487 | PostIncrementExpression
488 | PostDecrementExpression
491 PostIncrementExpression:
492 PostfixExpression INCREMENT
493 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
496 PostDecrementExpression:
497 PostfixExpression DECREMENT
498 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
502 PreIncrementExpression
503 | PreDecrementExpression
504 | '+' UnaryExpression
505 | '-' UnaryExpression
506 { write_exp_elt_opcode (UNOP_NEG); }
507 | '*' UnaryExpression
508 { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java */
509 | UnaryExpressionNotPlusMinus
512 PreIncrementExpression:
513 INCREMENT UnaryExpression
514 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
517 PreDecrementExpression:
518 DECREMENT UnaryExpression
519 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
522 UnaryExpressionNotPlusMinus:
524 | '~' UnaryExpression
525 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
526 | '!' UnaryExpression
527 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
532 '(' PrimitiveType Dims_opt ')' UnaryExpression
533 { write_exp_elt_opcode (UNOP_CAST);
534 write_exp_elt_type (java_array_type ($2, $3));
535 write_exp_elt_opcode (UNOP_CAST); }
536 | '(' Expression ')' UnaryExpressionNotPlusMinus
538 int exp_size = expout_ptr;
539 int last_exp_size = length_of_subexp(expout, expout_ptr);
542 int base = expout_ptr - last_exp_size - 3;
543 if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)
544 error (_("Invalid cast expression"));
545 type = expout->elts[base+1].type;
546 /* Remove the 'Expression' and slide the
547 UnaryExpressionNotPlusMinus down to replace it. */
548 for (i = 0; i < last_exp_size; i++)
549 expout->elts[base + i] = expout->elts[base + i + 3];
551 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
552 type = lookup_pointer_type (type);
553 write_exp_elt_opcode (UNOP_CAST);
554 write_exp_elt_type (type);
555 write_exp_elt_opcode (UNOP_CAST);
557 | '(' Name Dims ')' UnaryExpressionNotPlusMinus
558 { write_exp_elt_opcode (UNOP_CAST);
559 write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));
560 write_exp_elt_opcode (UNOP_CAST); }
564 MultiplicativeExpression:
566 | MultiplicativeExpression '*' UnaryExpression
567 { write_exp_elt_opcode (BINOP_MUL); }
568 | MultiplicativeExpression '/' UnaryExpression
569 { write_exp_elt_opcode (BINOP_DIV); }
570 | MultiplicativeExpression '%' UnaryExpression
571 { write_exp_elt_opcode (BINOP_REM); }
575 MultiplicativeExpression
576 | AdditiveExpression '+' MultiplicativeExpression
577 { write_exp_elt_opcode (BINOP_ADD); }
578 | AdditiveExpression '-' MultiplicativeExpression
579 { write_exp_elt_opcode (BINOP_SUB); }
584 | ShiftExpression LSH AdditiveExpression
585 { write_exp_elt_opcode (BINOP_LSH); }
586 | ShiftExpression RSH AdditiveExpression
587 { write_exp_elt_opcode (BINOP_RSH); }
588 /* | ShiftExpression >>> AdditiveExpression { FIXME } */
591 RelationalExpression:
593 | RelationalExpression '<' ShiftExpression
594 { write_exp_elt_opcode (BINOP_LESS); }
595 | RelationalExpression '>' ShiftExpression
596 { write_exp_elt_opcode (BINOP_GTR); }
597 | RelationalExpression LEQ ShiftExpression
598 { write_exp_elt_opcode (BINOP_LEQ); }
599 | RelationalExpression GEQ ShiftExpression
600 { write_exp_elt_opcode (BINOP_GEQ); }
601 /* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */
606 | EqualityExpression EQUAL RelationalExpression
607 { write_exp_elt_opcode (BINOP_EQUAL); }
608 | EqualityExpression NOTEQUAL RelationalExpression
609 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
614 | AndExpression '&' EqualityExpression
615 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
618 ExclusiveOrExpression:
620 | ExclusiveOrExpression '^' AndExpression
621 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
623 InclusiveOrExpression:
624 ExclusiveOrExpression
625 | InclusiveOrExpression '|' ExclusiveOrExpression
626 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
629 ConditionalAndExpression:
630 InclusiveOrExpression
631 | ConditionalAndExpression ANDAND InclusiveOrExpression
632 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
635 ConditionalOrExpression:
636 ConditionalAndExpression
637 | ConditionalOrExpression OROR ConditionalAndExpression
638 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
641 ConditionalExpression:
642 ConditionalOrExpression
643 | ConditionalOrExpression '?' Expression ':' ConditionalExpression
644 { write_exp_elt_opcode (TERNOP_COND); }
647 AssignmentExpression:
648 ConditionalExpression
653 LeftHandSide '=' ConditionalExpression
654 { write_exp_elt_opcode (BINOP_ASSIGN); }
655 | LeftHandSide ASSIGN_MODIFY ConditionalExpression
656 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
657 write_exp_elt_opcode ($2);
658 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
663 { push_expression_name ($1); }
665 /* Already written by write_dollar_variable. */
676 /* Take care of parsing a number (anything that starts with a digit).
677 Set yylval and return the token type; update lexptr.
678 LEN is the number of characters in it. */
680 /*** Needs some error checking for the float case ***/
683 parse_number (p, len, parsed_float, putithere)
689 register ULONGEST n = 0;
690 ULONGEST limit, limit_div_base;
693 register int base = input_radix;
699 /* It's a float since it contains a point or an exponent. */
701 int num = 0; /* number of tokens scanned by scanf */
702 char saved_char = p[len];
704 p[len] = 0; /* null-terminate the token */
705 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
706 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);
707 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
708 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);
711 #ifdef SCANF_HAS_LONG_DOUBLE
712 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);
714 /* Scan it into a double, then assign it to the long double.
715 This at least wins with values representable in the range
718 num = sscanf (p, "%lg%c", &temp, &c);
719 putithere->typed_val_float.dval = temp;
722 p[len] = saved_char; /* restore the input stream */
723 if (num != 1) /* check scanf found ONLY a float ... */
725 /* See if it has `f' or `d' suffix (float or double). */
727 c = tolower (p[len - 1]);
729 if (c == 'f' || c == 'F')
730 putithere->typed_val_float.type = builtin_type_float;
731 else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
732 putithere->typed_val_float.type = builtin_type_double;
736 return FLOATING_POINT_LITERAL;
739 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
771 /* A paranoid calculation of (1<<64)-1. */
772 limit = (ULONGEST)0xffffffff;
773 limit = ((limit << 16) << 16) | limit;
774 if (c == 'l' || c == 'L')
776 type = java_long_type;
781 type = java_int_type;
783 limit_div_base = limit / (ULONGEST) base;
788 if (c >= '0' && c <= '9')
790 else if (c >= 'A' && c <= 'Z')
792 else if (c >= 'a' && c <= 'z')
795 return ERROR; /* Char not a digit */
798 if (n > limit_div_base
799 || (n *= base) > limit - c)
800 error (_("Numeric constant too large"));
804 /* If the type is bigger than a 32-bit signed integer can be, implicitly
805 promote to long. Java does not do this, so mark it as builtin_type_uint64
806 rather than java_long_type. 0x80000000 will become -0x80000000 instead
807 of 0x80000000L, because we don't know the sign at this point.
809 if (type == java_int_type && n > (ULONGEST)0x80000000)
810 type = builtin_type_uint64;
812 putithere->typed_val_int.val = n;
813 putithere->typed_val_int.type = type;
815 return INTEGER_LITERAL;
822 enum exp_opcode opcode;
825 static const struct token tokentab3[] =
827 {">>=", ASSIGN_MODIFY, BINOP_RSH},
828 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
831 static const struct token tokentab2[] =
833 {"+=", ASSIGN_MODIFY, BINOP_ADD},
834 {"-=", ASSIGN_MODIFY, BINOP_SUB},
835 {"*=", ASSIGN_MODIFY, BINOP_MUL},
836 {"/=", ASSIGN_MODIFY, BINOP_DIV},
837 {"%=", ASSIGN_MODIFY, BINOP_REM},
838 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
839 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
840 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
841 {"++", INCREMENT, BINOP_END},
842 {"--", DECREMENT, BINOP_END},
843 {"&&", ANDAND, BINOP_END},
844 {"||", OROR, BINOP_END},
845 {"<<", LSH, BINOP_END},
846 {">>", RSH, BINOP_END},
847 {"==", EQUAL, BINOP_END},
848 {"!=", NOTEQUAL, BINOP_END},
849 {"<=", LEQ, BINOP_END},
850 {">=", GEQ, BINOP_END}
853 /* Read one token, getting characters through lexptr. */
864 static char *tempbuf;
865 static int tempbufsize;
869 prev_lexptr = lexptr;
872 /* See if it is a special token of length 3. */
873 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
874 if (STREQN (tokstart, tokentab3[i].operator, 3))
877 yylval.opcode = tokentab3[i].opcode;
878 return tokentab3[i].token;
881 /* See if it is a special token of length 2. */
882 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
883 if (STREQN (tokstart, tokentab2[i].operator, 2))
886 yylval.opcode = tokentab2[i].opcode;
887 return tokentab2[i].token;
890 switch (c = *tokstart)
902 /* We either have a character constant ('0' or '\177' for example)
903 or we have a quoted symbol reference ('foo(int,int)' in C++
908 c = parse_escape (&lexptr);
910 error (_("Empty character constant"));
912 yylval.typed_val_int.val = c;
913 yylval.typed_val_int.type = java_char_type;
918 namelen = skip_quoted (tokstart) - tokstart;
921 lexptr = tokstart + namelen;
922 if (lexptr[-1] != '\'')
923 error (_("Unmatched single quote"));
928 error (_("Invalid character constant"));
930 return INTEGER_LITERAL;
938 if (paren_depth == 0)
945 if (comma_terminates && paren_depth == 0)
951 /* Might be a floating point number. */
952 if (lexptr[1] < '0' || lexptr[1] > '9')
953 goto symbol; /* Nope, must be a symbol. */
954 /* FALL THRU into number case. */
968 int got_dot = 0, got_e = 0, toktype;
969 register char *p = tokstart;
970 int hex = input_radix > 10;
972 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
977 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
985 /* This test includes !hex because 'e' is a valid hex digit
986 and thus does not indicate a floating point number when
988 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
990 /* This test does not include !hex, because a '.' always indicates
991 a decimal floating point number regardless of the radix. */
992 else if (!got_dot && *p == '.')
994 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
995 && (*p == '-' || *p == '+'))
996 /* This is the sign of the exponent, not the end of the
999 /* We will take any letters or digits. parse_number will
1000 complain if past the radix, or if L or U are not final. */
1001 else if ((*p < '0' || *p > '9')
1002 && ((*p < 'a' || *p > 'z')
1003 && (*p < 'A' || *p > 'Z')))
1006 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1007 if (toktype == ERROR)
1009 char *err_copy = (char *) alloca (p - tokstart + 1);
1011 memcpy (err_copy, tokstart, p - tokstart);
1012 err_copy[p - tokstart] = 0;
1013 error (_("Invalid number \"%s\""), err_copy);
1044 /* Build the gdb internal form of the input string in tempbuf,
1045 translating any standard C escape forms seen. Note that the
1046 buffer is null byte terminated *only* for the convenience of
1047 debugging gdb itself and printing the buffer contents when
1048 the buffer contains no embedded nulls. Gdb does not depend
1049 upon the buffer being null byte terminated, it uses the length
1050 string instead. This allows gdb to handle C strings (as well
1051 as strings in other languages) with embedded null bytes */
1053 tokptr = ++tokstart;
1057 /* Grow the static temp buffer if necessary, including allocating
1058 the first one on demand. */
1059 if (tempbufindex + 1 >= tempbufsize)
1061 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1067 /* Do nothing, loop will terminate. */
1071 c = parse_escape (&tokptr);
1076 tempbuf[tempbufindex++] = c;
1079 tempbuf[tempbufindex++] = *tokptr++;
1082 } while ((*tokptr != '"') && (*tokptr != '\0'));
1083 if (*tokptr++ != '"')
1085 error (_("Unterminated string in expression"));
1087 tempbuf[tempbufindex] = '\0'; /* See note above */
1088 yylval.sval.ptr = tempbuf;
1089 yylval.sval.length = tempbufindex;
1091 return (STRING_LITERAL);
1094 if (!(c == '_' || c == '$'
1095 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1096 /* We must have come across a bad character (e.g. ';'). */
1097 error (_("Invalid character '%c' in expression"), c);
1099 /* It's a name. See how long it is. */
1101 for (c = tokstart[namelen];
1104 || (c >= '0' && c <= '9')
1105 || (c >= 'a' && c <= 'z')
1106 || (c >= 'A' && c <= 'Z')
1113 while (tokstart[++i] && tokstart[i] != '>');
1114 if (tokstart[i] == '>')
1117 c = tokstart[++namelen];
1120 /* The token "if" terminates the expression and is NOT
1121 removed from the input stream. */
1122 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1131 /* Catch specific keywords. Should be done with a data structure. */
1135 if (STREQN (tokstart, "boolean", 7))
1139 if (STREQN (tokstart, "double", 6))
1143 if (STREQN (tokstart, "short", 5))
1145 if (STREQN (tokstart, "false", 5))
1148 return BOOLEAN_LITERAL;
1150 if (STREQN (tokstart, "super", 5))
1152 if (STREQN (tokstart, "float", 5))
1156 if (STREQN (tokstart, "long", 4))
1158 if (STREQN (tokstart, "byte", 4))
1160 if (STREQN (tokstart, "char", 4))
1162 if (STREQN (tokstart, "true", 4))
1165 return BOOLEAN_LITERAL;
1169 if (STREQN (tokstart, "int", 3))
1171 if (STREQN (tokstart, "new", 3))
1178 yylval.sval.ptr = tokstart;
1179 yylval.sval.length = namelen;
1181 if (*tokstart == '$')
1183 write_dollar_variable (yylval.sval);
1187 /* Input names that aren't symbols but ARE valid hex numbers,
1188 when the input radix permits them, can be names or numbers
1189 depending on the parse. Note we support radixes > 16 here. */
1190 if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1191 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1193 YYSTYPE newlval; /* Its value is ignored. */
1194 int hextype = parse_number (tokstart, namelen, 0, &newlval);
1195 if (hextype == INTEGER_LITERAL)
1206 lexptr = prev_lexptr;
1209 error (_("%s: near `%s'"), msg, lexptr);
1211 error (_("error in expression, near `%s'"), lexptr);
1214 static struct type *
1215 java_type_from_name (name)
1219 char *tmp = copy_name (name);
1220 struct type *typ = java_lookup_class (tmp);
1221 if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
1222 error (_("No class named `%s'"), tmp);
1226 /* If NAME is a valid variable name in this scope, push it and return 1.
1227 Otherwise, return 0. */
1230 push_variable (name)
1234 char *tmp = copy_name (name);
1235 int is_a_field_of_this = 0;
1237 sym = lookup_symbol (tmp, expression_context_block, VAR_NAMESPACE,
1238 &is_a_field_of_this, (struct symtab **) NULL);
1239 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1241 if (symbol_read_needs_frame (sym))
1243 if (innermost_block == 0 ||
1244 contained_in (block_found, innermost_block))
1245 innermost_block = block_found;
1248 write_exp_elt_opcode (OP_VAR_VALUE);
1249 /* We want to use the selected frame, not another more inner frame
1250 which happens to be in the same block. */
1251 write_exp_elt_block (NULL);
1252 write_exp_elt_sym (sym);
1253 write_exp_elt_opcode (OP_VAR_VALUE);
1256 if (is_a_field_of_this)
1258 /* it hangs off of `this'. Must not inadvertently convert from a
1259 method call to data ref. */
1260 if (innermost_block == 0 ||
1261 contained_in (block_found, innermost_block))
1262 innermost_block = block_found;
1263 write_exp_elt_opcode (OP_THIS);
1264 write_exp_elt_opcode (OP_THIS);
1265 write_exp_elt_opcode (STRUCTOP_PTR);
1266 write_exp_string (name);
1267 write_exp_elt_opcode (STRUCTOP_PTR);
1273 /* Assuming a reference expression has been pushed, emit the
1274 STRUCTOP_STRUCT ops to access the field named NAME. If NAME is a
1275 qualified name (has '.'), generate a field access for each part. */
1278 push_fieldnames (name)
1282 struct stoken token;
1283 token.ptr = name.ptr;
1286 if (i == name.length || name.ptr[i] == '.')
1288 /* token.ptr is start of current field name. */
1289 token.length = &name.ptr[i] - token.ptr;
1290 write_exp_elt_opcode (STRUCTOP_STRUCT);
1291 write_exp_string (token);
1292 write_exp_elt_opcode (STRUCTOP_STRUCT);
1293 token.ptr += token.length + 1;
1295 if (i >= name.length)
1300 /* Helper routine for push_expression_name.
1301 Handle a qualified name, where DOT_INDEX is the index of the first '.' */
1304 push_qualified_expression_name (name, dot_index)
1308 struct stoken token;
1312 token.ptr = name.ptr;
1313 token.length = dot_index;
1315 if (push_variable (token))
1317 token.ptr = name.ptr + dot_index + 1;
1318 token.length = name.length - dot_index - 1;
1319 push_fieldnames (token);
1323 token.ptr = name.ptr;
1326 token.length = dot_index;
1327 tmp = copy_name (token);
1328 typ = java_lookup_class (tmp);
1331 if (dot_index == name.length)
1333 write_exp_elt_opcode(OP_TYPE);
1334 write_exp_elt_type(typ);
1335 write_exp_elt_opcode(OP_TYPE);
1338 dot_index++; /* Skip '.' */
1339 name.ptr += dot_index;
1340 name.length -= dot_index;
1342 while (dot_index < name.length && name.ptr[dot_index] != '.')
1344 token.ptr = name.ptr;
1345 token.length = dot_index;
1346 write_exp_elt_opcode (OP_SCOPE);
1347 write_exp_elt_type (typ);
1348 write_exp_string (token);
1349 write_exp_elt_opcode (OP_SCOPE);
1350 if (dot_index < name.length)
1353 name.ptr += dot_index;
1354 name.length -= dot_index;
1355 push_fieldnames (name);
1359 else if (dot_index >= name.length)
1361 dot_index++; /* Skip '.' */
1362 while (dot_index < name.length && name.ptr[dot_index] != '.')
1365 error (_("unknown type `%.*s'"), name.length, name.ptr);
1368 /* Handle Name in an expression (or LHS).
1369 Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
1372 push_expression_name (name)
1380 for (i = 0; i < name.length; i++)
1382 if (name.ptr[i] == '.')
1384 /* It's a Qualified Expression Name. */
1385 push_qualified_expression_name (name, i);
1390 /* It's a Simple Expression Name. */
1392 if (push_variable (name))
1394 tmp = copy_name (name);
1395 typ = java_lookup_class (tmp);
1398 write_exp_elt_opcode(OP_TYPE);
1399 write_exp_elt_type(typ);
1400 write_exp_elt_opcode(OP_TYPE);
1404 struct minimal_symbol *msymbol;
1406 msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
1407 if (msymbol != NULL)
1409 write_exp_msymbol (msymbol,
1410 lookup_function_type (builtin_type_int),
1413 else if (!have_full_symbols () && !have_partial_symbols ())
1414 error (_("No symbol table is loaded. Use the \"file\" command"));
1416 error (_("No symbol \"%s\" in current context"), tmp);
1422 /* The following two routines, copy_exp and insert_exp, aren't specific to
1423 Java, so they could go in parse.c, but their only purpose is to support
1424 the parsing kludges we use in this file, so maybe it's best to isolate
1427 /* Copy the expression whose last element is at index ENDPOS - 1 in EXPR
1428 into a freshly malloc'ed struct expression. Its language_defn is set
1430 static struct expression *
1431 copy_exp (expr, endpos)
1432 struct expression *expr;
1435 int len = length_of_subexp (expr, endpos);
1436 struct expression *new
1437 = (struct expression *) malloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len));
1439 memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len));
1440 new->language_defn = 0;
1445 /* Insert the expression NEW into the current expression (expout) at POS. */
1447 insert_exp (pos, new)
1449 struct expression *new;
1451 int newlen = new->nelts;
1453 /* Grow expout if necessary. In this function's only use at present,
1454 this should never be necessary. */
1455 if (expout_ptr + newlen > expout_size)
1457 expout_size = max (expout_size * 2, expout_ptr + newlen + 10);
1458 expout = (struct expression *)
1459 realloc ((char *) expout, (sizeof (struct expression)
1460 + EXP_ELEM_TO_BYTES (expout_size)));
1466 for (i = expout_ptr - 1; i >= pos; i--)
1467 expout->elts[i + newlen] = expout->elts[i];
1470 memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen));
1471 expout_ptr += newlen;