1 /* YACC parser for Java expressions, for GDB.
2 Copyright (C) 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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* Parse a Java expression from text in a string,
23 and return the result as a struct expression pointer.
24 That structure contains arithmetic operations in reverse polish,
25 with constants represented by operations that are followed by special data.
26 See expression.h for the details of the format.
27 What is important here is that it can be built up sequentially
28 during the process of parsing; the lower levels of the tree always
29 come first in the result. Well, almost always; see ArrayAccess.
31 Note that malloc's and realloc's in this file are transformed to
32 xmalloc and xrealloc respectively by the same sed command in the
33 makefile that remaps any other malloc/realloc inserted by the parser
34 generator. Doing this with #defines and trying to control the interaction
35 with include files (<malloc.h> and <stdlib.h> for example) just became
36 too messy, particularly when such includes can be inserted at random
37 times by the parser generator. */
42 #include "gdb_string.h"
44 #include "expression.h"
46 #include "parser-defs.h"
49 #include "bfd.h" /* Required by objfiles.h. */
50 #include "symfile.h" /* Required by objfiles.h. */
51 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
54 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
55 as well as gratuitiously global symbol names, so we can have multiple
56 yacc generated parsers in gdb. Note that these are only the variables
57 produced by yacc. If other parser generators (bison, byacc, etc) produce
58 additional global names that conflict at link time, then those parser
59 generators need to be fixed instead of adding those names to this list. */
61 #define yymaxdepth java_maxdepth
62 #define yyparse java_parse
63 #define yylex java_lex
64 #define yyerror java_error
65 #define yylval java_lval
66 #define yychar java_char
67 #define yydebug java_debug
68 #define yypact java_pact
71 #define yydef java_def
72 #define yychk java_chk
73 #define yypgo java_pgo
74 #define yyact java_act
75 #define yyexca java_exca
76 #define yyerrflag java_errflag
77 #define yynerrs java_nerrs
81 #define yy_yys java_yys
82 #define yystate java_state
83 #define yytmp java_tmp
85 #define yy_yyv java_yyv
86 #define yyval java_val
87 #define yylloc java_lloc
88 #define yyreds java_reds /* With YYDEBUG defined */
89 #define yytoks java_toks /* With YYDEBUG defined */
90 #define yyname java_name /* With YYDEBUG defined */
91 #define yyrule java_rule /* With YYDEBUG defined */
92 #define yylhs java_yylhs
93 #define yylen java_yylen
94 #define yydefred java_yydefred
95 #define yydgoto java_yydgoto
96 #define yysindex java_yysindex
97 #define yyrindex java_yyrindex
98 #define yygindex java_yygindex
99 #define yytable java_yytable
100 #define yycheck java_yycheck
103 #define YYDEBUG 1 /* Default to yydebug support */
106 #define YYFPRINTF parser_fprintf
110 static int yylex (void);
112 void yyerror (char *);
114 static struct type *java_type_from_name (struct stoken);
115 static void push_expression_name (struct stoken);
116 static void push_fieldnames (struct stoken);
118 static struct expression *copy_exp (struct expression *, int);
119 static void insert_exp (int, struct expression *);
123 /* Although the yacc "value" of an expression is not used,
124 since the result is stored in the structure being created,
125 other node types do have values. */
142 struct symtoken ssym;
144 enum exp_opcode opcode;
145 struct internalvar *ivar;
150 /* YYSTYPE gets defined by %union */
151 static int parse_number (char *, int, int, YYSTYPE *);
154 %type <lval> rcurly Dims Dims_opt
155 %type <tval> ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */
156 %type <tval> IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType
158 %token <typed_val_int> INTEGER_LITERAL
159 %token <typed_val_float> FLOATING_POINT_LITERAL
161 %token <sval> IDENTIFIER
162 %token <sval> STRING_LITERAL
163 %token <lval> BOOLEAN_LITERAL
164 %token <tsym> TYPENAME
165 %type <sval> Name SimpleName QualifiedName ForcedName
167 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
168 but which would parse as a valid number in the current input radix.
169 E.g. "c" when input_radix==16. Depending on the parse, it will be
170 turned into a name or into a number. */
172 %token <sval> NAME_OR_INT
176 /* Special type cases, put in to allow the parser to distinguish different
178 %token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT
182 %token <opcode> ASSIGN_MODIFY
187 %right '=' ASSIGN_MODIFY
195 %left '<' '>' LEQ GEQ
199 %right INCREMENT DECREMENT
209 type_exp: PrimitiveOrArrayType
211 write_exp_elt_opcode(OP_TYPE);
212 write_exp_elt_type($1);
213 write_exp_elt_opcode(OP_TYPE);
217 PrimitiveOrArrayType:
225 write_exp_elt_opcode (OP_STRING);
226 write_exp_string ($1);
227 write_exp_elt_opcode (OP_STRING);
233 { write_exp_elt_opcode (OP_LONG);
234 write_exp_elt_type ($1.type);
235 write_exp_elt_longcst ((LONGEST)($1.val));
236 write_exp_elt_opcode (OP_LONG); }
239 parse_number ($1.ptr, $1.length, 0, &val);
240 write_exp_elt_opcode (OP_LONG);
241 write_exp_elt_type (val.typed_val_int.type);
242 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
243 write_exp_elt_opcode (OP_LONG);
245 | FLOATING_POINT_LITERAL
246 { write_exp_elt_opcode (OP_DOUBLE);
247 write_exp_elt_type ($1.type);
248 write_exp_elt_dblcst ($1.dval);
249 write_exp_elt_opcode (OP_DOUBLE); }
251 { write_exp_elt_opcode (OP_LONG);
252 write_exp_elt_type (java_boolean_type);
253 write_exp_elt_longcst ((LONGEST)$1);
254 write_exp_elt_opcode (OP_LONG); }
268 { $$ = java_boolean_type; }
278 { $$ = java_byte_type; }
280 { $$ = java_short_type; }
282 { $$ = java_int_type; }
284 { $$ = java_long_type; }
286 { $$ = java_char_type; }
291 { $$ = java_float_type; }
293 { $$ = java_double_type; }
303 ClassOrInterfaceType:
305 { $$ = java_type_from_name ($1); }
314 { $$ = java_array_type ($1, $2); }
316 { $$ = java_array_type (java_type_from_name ($1), $2); }
336 { $$.length = $1.length + $3.length + 1;
337 if ($1.ptr + $1.length + 1 == $3.ptr
338 && $1.ptr[$1.length] == '.')
339 $$.ptr = $1.ptr; /* Optimization. */
342 $$.ptr = (char *) malloc ($$.length + 1);
343 make_cleanup (free, $$.ptr);
344 sprintf ($$.ptr, "%.*s.%.*s",
345 $1.length, $1.ptr, $3.length, $3.ptr);
351 { write_exp_elt_opcode(OP_TYPE);
352 write_exp_elt_type($1);
353 write_exp_elt_opcode(OP_TYPE);}
357 /* Expressions, including the comma operator. */
359 | exp1 ',' Expression
360 { write_exp_elt_opcode (BINOP_COMMA); }
365 | ArrayCreationExpression
371 | ClassInstanceCreationExpression
375 | lcurly ArgumentList rcurly
376 { write_exp_elt_opcode (OP_ARRAY);
377 write_exp_elt_longcst ((LONGEST) 0);
378 write_exp_elt_longcst ((LONGEST) $3);
379 write_exp_elt_opcode (OP_ARRAY); }
384 { start_arglist (); }
389 { $$ = end_arglist () - 1; }
392 ClassInstanceCreationExpression:
393 NEW ClassType '(' ArgumentList_opt ')'
394 { internal_error (__FILE__, __LINE__,
395 _("FIXME - ClassInstanceCreationExpression")); }
401 | ArgumentList ',' Expression
411 ArrayCreationExpression:
412 NEW PrimitiveType DimExprs Dims_opt
413 { internal_error (__FILE__, __LINE__,
414 _("FIXME - ArrayCreationExpression")); }
415 | NEW ClassOrInterfaceType DimExprs Dims_opt
416 { internal_error (__FILE__, __LINE__,
417 _("FIXME - ArrayCreationExpression")); }
443 Primary '.' SimpleName
444 { push_fieldnames ($3); }
445 | VARIABLE '.' SimpleName
446 { push_fieldnames ($3); }
447 /*| SUPER '.' SimpleName { FIXME } */
452 { push_expression_name ($1); }
459 { write_exp_elt_opcode (OP_FUNCALL);
460 write_exp_elt_longcst ((LONGEST) end_arglist ());
461 write_exp_elt_opcode (OP_FUNCALL); }
462 | Primary '.' SimpleName '(' ArgumentList_opt ')'
463 { error (_("Form of method invocation not implemented")); }
464 | SUPER '.' SimpleName '(' ArgumentList_opt ')'
465 { error (_("Form of method invocation not implemented")); }
469 Name '[' Expression ']'
471 /* Emit code for the Name now, then exchange it in the
472 expout array with the Expression's code. We could
473 introduce a OP_SWAP code or a reversed version of
474 BINOP_SUBSCRIPT, but that makes the rest of GDB pay
475 for our parsing kludges. */
476 struct expression *name_expr;
478 push_expression_name ($1);
479 name_expr = copy_exp (expout, expout_ptr);
480 expout_ptr -= name_expr->nelts;
481 insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),
484 write_exp_elt_opcode (BINOP_SUBSCRIPT);
486 | VARIABLE '[' Expression ']'
487 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
488 | PrimaryNoNewArray '[' Expression ']'
489 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
495 { push_expression_name ($1); }
497 /* Already written by write_dollar_variable. */
498 | PostIncrementExpression
499 | PostDecrementExpression
502 PostIncrementExpression:
503 PostfixExpression INCREMENT
504 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
507 PostDecrementExpression:
508 PostfixExpression DECREMENT
509 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
513 PreIncrementExpression
514 | PreDecrementExpression
515 | '+' UnaryExpression
516 | '-' UnaryExpression
517 { write_exp_elt_opcode (UNOP_NEG); }
518 | '*' UnaryExpression
519 { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java */
520 | UnaryExpressionNotPlusMinus
523 PreIncrementExpression:
524 INCREMENT UnaryExpression
525 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
528 PreDecrementExpression:
529 DECREMENT UnaryExpression
530 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
533 UnaryExpressionNotPlusMinus:
535 | '~' UnaryExpression
536 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
537 | '!' UnaryExpression
538 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
543 '(' PrimitiveType Dims_opt ')' UnaryExpression
544 { write_exp_elt_opcode (UNOP_CAST);
545 write_exp_elt_type (java_array_type ($2, $3));
546 write_exp_elt_opcode (UNOP_CAST); }
547 | '(' Expression ')' UnaryExpressionNotPlusMinus
549 int exp_size = expout_ptr;
550 int last_exp_size = length_of_subexp(expout, expout_ptr);
553 int base = expout_ptr - last_exp_size - 3;
554 if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)
555 error (_("Invalid cast expression"));
556 type = expout->elts[base+1].type;
557 /* Remove the 'Expression' and slide the
558 UnaryExpressionNotPlusMinus down to replace it. */
559 for (i = 0; i < last_exp_size; i++)
560 expout->elts[base + i] = expout->elts[base + i + 3];
562 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
563 type = lookup_pointer_type (type);
564 write_exp_elt_opcode (UNOP_CAST);
565 write_exp_elt_type (type);
566 write_exp_elt_opcode (UNOP_CAST);
568 | '(' Name Dims ')' UnaryExpressionNotPlusMinus
569 { write_exp_elt_opcode (UNOP_CAST);
570 write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));
571 write_exp_elt_opcode (UNOP_CAST); }
575 MultiplicativeExpression:
577 | MultiplicativeExpression '*' UnaryExpression
578 { write_exp_elt_opcode (BINOP_MUL); }
579 | MultiplicativeExpression '/' UnaryExpression
580 { write_exp_elt_opcode (BINOP_DIV); }
581 | MultiplicativeExpression '%' UnaryExpression
582 { write_exp_elt_opcode (BINOP_REM); }
586 MultiplicativeExpression
587 | AdditiveExpression '+' MultiplicativeExpression
588 { write_exp_elt_opcode (BINOP_ADD); }
589 | AdditiveExpression '-' MultiplicativeExpression
590 { write_exp_elt_opcode (BINOP_SUB); }
595 | ShiftExpression LSH AdditiveExpression
596 { write_exp_elt_opcode (BINOP_LSH); }
597 | ShiftExpression RSH AdditiveExpression
598 { write_exp_elt_opcode (BINOP_RSH); }
599 /* | ShiftExpression >>> AdditiveExpression { FIXME } */
602 RelationalExpression:
604 | RelationalExpression '<' ShiftExpression
605 { write_exp_elt_opcode (BINOP_LESS); }
606 | RelationalExpression '>' ShiftExpression
607 { write_exp_elt_opcode (BINOP_GTR); }
608 | RelationalExpression LEQ ShiftExpression
609 { write_exp_elt_opcode (BINOP_LEQ); }
610 | RelationalExpression GEQ ShiftExpression
611 { write_exp_elt_opcode (BINOP_GEQ); }
612 /* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */
617 | EqualityExpression EQUAL RelationalExpression
618 { write_exp_elt_opcode (BINOP_EQUAL); }
619 | EqualityExpression NOTEQUAL RelationalExpression
620 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
625 | AndExpression '&' EqualityExpression
626 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
629 ExclusiveOrExpression:
631 | ExclusiveOrExpression '^' AndExpression
632 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
634 InclusiveOrExpression:
635 ExclusiveOrExpression
636 | InclusiveOrExpression '|' ExclusiveOrExpression
637 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
640 ConditionalAndExpression:
641 InclusiveOrExpression
642 | ConditionalAndExpression ANDAND InclusiveOrExpression
643 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
646 ConditionalOrExpression:
647 ConditionalAndExpression
648 | ConditionalOrExpression OROR ConditionalAndExpression
649 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
652 ConditionalExpression:
653 ConditionalOrExpression
654 | ConditionalOrExpression '?' Expression ':' ConditionalExpression
655 { write_exp_elt_opcode (TERNOP_COND); }
658 AssignmentExpression:
659 ConditionalExpression
664 LeftHandSide '=' ConditionalExpression
665 { write_exp_elt_opcode (BINOP_ASSIGN); }
666 | LeftHandSide ASSIGN_MODIFY ConditionalExpression
667 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
668 write_exp_elt_opcode ($2);
669 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
674 { push_expression_name ($1); }
676 /* Already written by write_dollar_variable. */
687 /* Take care of parsing a number (anything that starts with a digit).
688 Set yylval and return the token type; update lexptr.
689 LEN is the number of characters in it. */
691 /*** Needs some error checking for the float case ***/
694 parse_number (p, len, parsed_float, putithere)
701 ULONGEST limit, limit_div_base;
704 int base = input_radix;
710 /* It's a float since it contains a point or an exponent. */
712 int num = 0; /* number of tokens scanned by scanf */
713 char saved_char = p[len];
715 p[len] = 0; /* null-terminate the token */
716 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
717 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);
718 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
719 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);
722 #ifdef SCANF_HAS_LONG_DOUBLE
723 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);
725 /* Scan it into a double, then assign it to the long double.
726 This at least wins with values representable in the range
729 num = sscanf (p, "%lg%c", &temp, &c);
730 putithere->typed_val_float.dval = temp;
733 p[len] = saved_char; /* restore the input stream */
734 if (num != 1) /* check scanf found ONLY a float ... */
736 /* See if it has `f' or `d' suffix (float or double). */
738 c = tolower (p[len - 1]);
740 if (c == 'f' || c == 'F')
741 putithere->typed_val_float.type = builtin_type_float;
742 else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
743 putithere->typed_val_float.type = builtin_type_double;
747 return FLOATING_POINT_LITERAL;
750 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
782 /* A paranoid calculation of (1<<64)-1. */
783 limit = (ULONGEST)0xffffffff;
784 limit = ((limit << 16) << 16) | limit;
785 if (c == 'l' || c == 'L')
787 type = java_long_type;
792 type = java_int_type;
794 limit_div_base = limit / (ULONGEST) base;
799 if (c >= '0' && c <= '9')
801 else if (c >= 'A' && c <= 'Z')
803 else if (c >= 'a' && c <= 'z')
806 return ERROR; /* Char not a digit */
809 if (n > limit_div_base
810 || (n *= base) > limit - c)
811 error (_("Numeric constant too large"));
815 /* If the type is bigger than a 32-bit signed integer can be, implicitly
816 promote to long. Java does not do this, so mark it as builtin_type_uint64
817 rather than java_long_type. 0x80000000 will become -0x80000000 instead
818 of 0x80000000L, because we don't know the sign at this point.
820 if (type == java_int_type && n > (ULONGEST)0x80000000)
821 type = builtin_type_uint64;
823 putithere->typed_val_int.val = n;
824 putithere->typed_val_int.type = type;
826 return INTEGER_LITERAL;
833 enum exp_opcode opcode;
836 static const struct token tokentab3[] =
838 {">>=", ASSIGN_MODIFY, BINOP_RSH},
839 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
842 static const struct token tokentab2[] =
844 {"+=", ASSIGN_MODIFY, BINOP_ADD},
845 {"-=", ASSIGN_MODIFY, BINOP_SUB},
846 {"*=", ASSIGN_MODIFY, BINOP_MUL},
847 {"/=", ASSIGN_MODIFY, BINOP_DIV},
848 {"%=", ASSIGN_MODIFY, BINOP_REM},
849 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
850 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
851 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
852 {"++", INCREMENT, BINOP_END},
853 {"--", DECREMENT, BINOP_END},
854 {"&&", ANDAND, BINOP_END},
855 {"||", OROR, BINOP_END},
856 {"<<", LSH, BINOP_END},
857 {">>", RSH, BINOP_END},
858 {"==", EQUAL, BINOP_END},
859 {"!=", NOTEQUAL, BINOP_END},
860 {"<=", LEQ, BINOP_END},
861 {">=", GEQ, BINOP_END}
864 /* Read one token, getting characters through lexptr. */
875 static char *tempbuf;
876 static int tempbufsize;
880 prev_lexptr = lexptr;
883 /* See if it is a special token of length 3. */
884 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
885 if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
888 yylval.opcode = tokentab3[i].opcode;
889 return tokentab3[i].token;
892 /* See if it is a special token of length 2. */
893 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
894 if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
897 yylval.opcode = tokentab2[i].opcode;
898 return tokentab2[i].token;
901 switch (c = *tokstart)
913 /* We either have a character constant ('0' or '\177' for example)
914 or we have a quoted symbol reference ('foo(int,int)' in C++
919 c = parse_escape (&lexptr);
921 error (_("Empty character constant"));
923 yylval.typed_val_int.val = c;
924 yylval.typed_val_int.type = java_char_type;
929 namelen = skip_quoted (tokstart) - tokstart;
932 lexptr = tokstart + namelen;
933 if (lexptr[-1] != '\'')
934 error (_("Unmatched single quote"));
939 error (_("Invalid character constant"));
941 return INTEGER_LITERAL;
949 if (paren_depth == 0)
956 if (comma_terminates && paren_depth == 0)
962 /* Might be a floating point number. */
963 if (lexptr[1] < '0' || lexptr[1] > '9')
964 goto symbol; /* Nope, must be a symbol. */
965 /* FALL THRU into number case. */
979 int got_dot = 0, got_e = 0, toktype;
981 int hex = input_radix > 10;
983 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
988 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
996 /* This test includes !hex because 'e' is a valid hex digit
997 and thus does not indicate a floating point number when
999 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1000 got_dot = got_e = 1;
1001 /* This test does not include !hex, because a '.' always indicates
1002 a decimal floating point number regardless of the radix. */
1003 else if (!got_dot && *p == '.')
1005 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1006 && (*p == '-' || *p == '+'))
1007 /* This is the sign of the exponent, not the end of the
1010 /* We will take any letters or digits. parse_number will
1011 complain if past the radix, or if L or U are not final. */
1012 else if ((*p < '0' || *p > '9')
1013 && ((*p < 'a' || *p > 'z')
1014 && (*p < 'A' || *p > 'Z')))
1017 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1018 if (toktype == ERROR)
1020 char *err_copy = (char *) alloca (p - tokstart + 1);
1022 memcpy (err_copy, tokstart, p - tokstart);
1023 err_copy[p - tokstart] = 0;
1024 error (_("Invalid number \"%s\""), err_copy);
1055 /* Build the gdb internal form of the input string in tempbuf,
1056 translating any standard C escape forms seen. Note that the
1057 buffer is null byte terminated *only* for the convenience of
1058 debugging gdb itself and printing the buffer contents when
1059 the buffer contains no embedded nulls. Gdb does not depend
1060 upon the buffer being null byte terminated, it uses the length
1061 string instead. This allows gdb to handle C strings (as well
1062 as strings in other languages) with embedded null bytes */
1064 tokptr = ++tokstart;
1068 /* Grow the static temp buffer if necessary, including allocating
1069 the first one on demand. */
1070 if (tempbufindex + 1 >= tempbufsize)
1072 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1078 /* Do nothing, loop will terminate. */
1082 c = parse_escape (&tokptr);
1087 tempbuf[tempbufindex++] = c;
1090 tempbuf[tempbufindex++] = *tokptr++;
1093 } while ((*tokptr != '"') && (*tokptr != '\0'));
1094 if (*tokptr++ != '"')
1096 error (_("Unterminated string in expression"));
1098 tempbuf[tempbufindex] = '\0'; /* See note above */
1099 yylval.sval.ptr = tempbuf;
1100 yylval.sval.length = tempbufindex;
1102 return (STRING_LITERAL);
1105 if (!(c == '_' || c == '$'
1106 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1107 /* We must have come across a bad character (e.g. ';'). */
1108 error (_("Invalid character '%c' in expression"), c);
1110 /* It's a name. See how long it is. */
1112 for (c = tokstart[namelen];
1115 || (c >= '0' && c <= '9')
1116 || (c >= 'a' && c <= 'z')
1117 || (c >= 'A' && c <= 'Z')
1124 while (tokstart[++i] && tokstart[i] != '>');
1125 if (tokstart[i] == '>')
1128 c = tokstart[++namelen];
1131 /* The token "if" terminates the expression and is NOT
1132 removed from the input stream. */
1133 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1142 /* Catch specific keywords. Should be done with a data structure. */
1146 if (DEPRECATED_STREQN (tokstart, "boolean", 7))
1150 if (DEPRECATED_STREQN (tokstart, "double", 6))
1154 if (DEPRECATED_STREQN (tokstart, "short", 5))
1156 if (DEPRECATED_STREQN (tokstart, "false", 5))
1159 return BOOLEAN_LITERAL;
1161 if (DEPRECATED_STREQN (tokstart, "super", 5))
1163 if (DEPRECATED_STREQN (tokstart, "float", 5))
1167 if (DEPRECATED_STREQN (tokstart, "long", 4))
1169 if (DEPRECATED_STREQN (tokstart, "byte", 4))
1171 if (DEPRECATED_STREQN (tokstart, "char", 4))
1173 if (DEPRECATED_STREQN (tokstart, "true", 4))
1176 return BOOLEAN_LITERAL;
1180 if (strncmp (tokstart, "int", 3) == 0)
1182 if (strncmp (tokstart, "new", 3) == 0)
1189 yylval.sval.ptr = tokstart;
1190 yylval.sval.length = namelen;
1192 if (*tokstart == '$')
1194 write_dollar_variable (yylval.sval);
1198 /* Input names that aren't symbols but ARE valid hex numbers,
1199 when the input radix permits them, can be names or numbers
1200 depending on the parse. Note we support radixes > 16 here. */
1201 if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1202 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1204 YYSTYPE newlval; /* Its value is ignored. */
1205 int hextype = parse_number (tokstart, namelen, 0, &newlval);
1206 if (hextype == INTEGER_LITERAL)
1217 lexptr = prev_lexptr;
1220 error (_("%s: near `%s'"), msg, lexptr);
1222 error (_("error in expression, near `%s'"), lexptr);
1225 static struct type *
1226 java_type_from_name (name)
1230 char *tmp = copy_name (name);
1231 struct type *typ = java_lookup_class (tmp);
1232 if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
1233 error (_("No class named `%s'"), tmp);
1237 /* If NAME is a valid variable name in this scope, push it and return 1.
1238 Otherwise, return 0. */
1241 push_variable (struct stoken name)
1243 char *tmp = copy_name (name);
1244 int is_a_field_of_this = 0;
1246 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
1247 &is_a_field_of_this, (struct symtab **) NULL);
1248 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1250 if (symbol_read_needs_frame (sym))
1252 if (innermost_block == 0 ||
1253 contained_in (block_found, innermost_block))
1254 innermost_block = block_found;
1257 write_exp_elt_opcode (OP_VAR_VALUE);
1258 /* We want to use the selected frame, not another more inner frame
1259 which happens to be in the same block. */
1260 write_exp_elt_block (NULL);
1261 write_exp_elt_sym (sym);
1262 write_exp_elt_opcode (OP_VAR_VALUE);
1265 if (is_a_field_of_this)
1267 /* it hangs off of `this'. Must not inadvertently convert from a
1268 method call to data ref. */
1269 if (innermost_block == 0 ||
1270 contained_in (block_found, innermost_block))
1271 innermost_block = block_found;
1272 write_exp_elt_opcode (OP_THIS);
1273 write_exp_elt_opcode (OP_THIS);
1274 write_exp_elt_opcode (STRUCTOP_PTR);
1275 write_exp_string (name);
1276 write_exp_elt_opcode (STRUCTOP_PTR);
1282 /* Assuming a reference expression has been pushed, emit the
1283 STRUCTOP_STRUCT ops to access the field named NAME. If NAME is a
1284 qualified name (has '.'), generate a field access for each part. */
1287 push_fieldnames (name)
1291 struct stoken token;
1292 token.ptr = name.ptr;
1295 if (i == name.length || name.ptr[i] == '.')
1297 /* token.ptr is start of current field name. */
1298 token.length = &name.ptr[i] - token.ptr;
1299 write_exp_elt_opcode (STRUCTOP_STRUCT);
1300 write_exp_string (token);
1301 write_exp_elt_opcode (STRUCTOP_STRUCT);
1302 token.ptr += token.length + 1;
1304 if (i >= name.length)
1309 /* Helper routine for push_expression_name.
1310 Handle a qualified name, where DOT_INDEX is the index of the first '.' */
1313 push_qualified_expression_name (struct stoken name, int dot_index)
1315 struct stoken token;
1319 token.ptr = name.ptr;
1320 token.length = dot_index;
1322 if (push_variable (token))
1324 token.ptr = name.ptr + dot_index + 1;
1325 token.length = name.length - dot_index - 1;
1326 push_fieldnames (token);
1330 token.ptr = name.ptr;
1333 token.length = dot_index;
1334 tmp = copy_name (token);
1335 typ = java_lookup_class (tmp);
1338 if (dot_index == name.length)
1340 write_exp_elt_opcode(OP_TYPE);
1341 write_exp_elt_type(typ);
1342 write_exp_elt_opcode(OP_TYPE);
1345 dot_index++; /* Skip '.' */
1346 name.ptr += dot_index;
1347 name.length -= dot_index;
1349 while (dot_index < name.length && name.ptr[dot_index] != '.')
1351 token.ptr = name.ptr;
1352 token.length = dot_index;
1353 write_exp_elt_opcode (OP_SCOPE);
1354 write_exp_elt_type (typ);
1355 write_exp_string (token);
1356 write_exp_elt_opcode (OP_SCOPE);
1357 if (dot_index < name.length)
1360 name.ptr += dot_index;
1361 name.length -= dot_index;
1362 push_fieldnames (name);
1366 else if (dot_index >= name.length)
1368 dot_index++; /* Skip '.' */
1369 while (dot_index < name.length && name.ptr[dot_index] != '.')
1372 error (_("unknown type `%.*s'"), name.length, name.ptr);
1375 /* Handle Name in an expression (or LHS).
1376 Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
1379 push_expression_name (name)
1387 for (i = 0; i < name.length; i++)
1389 if (name.ptr[i] == '.')
1391 /* It's a Qualified Expression Name. */
1392 push_qualified_expression_name (name, i);
1397 /* It's a Simple Expression Name. */
1399 if (push_variable (name))
1401 tmp = copy_name (name);
1402 typ = java_lookup_class (tmp);
1405 write_exp_elt_opcode(OP_TYPE);
1406 write_exp_elt_type(typ);
1407 write_exp_elt_opcode(OP_TYPE);
1411 struct minimal_symbol *msymbol;
1413 msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
1414 if (msymbol != NULL)
1416 write_exp_msymbol (msymbol,
1417 lookup_function_type (builtin_type_int),
1420 else if (!have_full_symbols () && !have_partial_symbols ())
1421 error (_("No symbol table is loaded. Use the \"file\" command"));
1423 error (_("No symbol \"%s\" in current context"), tmp);
1429 /* The following two routines, copy_exp and insert_exp, aren't specific to
1430 Java, so they could go in parse.c, but their only purpose is to support
1431 the parsing kludges we use in this file, so maybe it's best to isolate
1434 /* Copy the expression whose last element is at index ENDPOS - 1 in EXPR
1435 into a freshly malloc'ed struct expression. Its language_defn is set
1437 static struct expression *
1438 copy_exp (expr, endpos)
1439 struct expression *expr;
1442 int len = length_of_subexp (expr, endpos);
1443 struct expression *new
1444 = (struct expression *) malloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len));
1446 memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len));
1447 new->language_defn = 0;
1452 /* Insert the expression NEW into the current expression (expout) at POS. */
1454 insert_exp (pos, new)
1456 struct expression *new;
1458 int newlen = new->nelts;
1460 /* Grow expout if necessary. In this function's only use at present,
1461 this should never be necessary. */
1462 if (expout_ptr + newlen > expout_size)
1464 expout_size = max (expout_size * 2, expout_ptr + newlen + 10);
1465 expout = (struct expression *)
1466 realloc ((char *) expout, (sizeof (struct expression)
1467 + EXP_ELEM_TO_BYTES (expout_size)));
1473 for (i = expout_ptr - 1; i >= pos; i--)
1474 expout->elts[i + newlen] = expout->elts[i];
1477 memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen));
1478 expout_ptr += newlen;