1 /* YACC parser for Java expressions, for GDB.
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 C 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.
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 yylhs java_yylhs
89 #define yylen java_yylen
90 #define yydefred java_yydefred
91 #define yydgoto java_yydgoto
92 #define yysindex java_yysindex
93 #define yyrindex java_yyrindex
94 #define yygindex java_yygindex
95 #define yytable java_yytable
96 #define yycheck java_yycheck
99 #define YYDEBUG 0 /* Default to no yydebug support */
103 yyparse PARAMS ((void));
106 yylex PARAMS ((void));
109 yyerror PARAMS ((char *));
111 static struct type * java_type_from_name PARAMS ((struct stoken));
112 static void push_expression_name PARAMS ((struct stoken));
113 static void push_fieldnames PARAMS ((struct stoken));
117 /* Although the yacc "value" of an expression is not used,
118 since the result is stored in the structure being created,
119 other node types do have values. */
136 struct symtoken ssym;
138 enum exp_opcode opcode;
139 struct internalvar *ivar;
144 /* YYSTYPE gets defined by %union */
146 parse_number PARAMS ((char *, int, int, YYSTYPE *));
149 %type <lval> rcurly Dims Dims_opt
150 %type <tval> ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */
151 %type <tval> IntegralType FloatingPointType NumericType PrimitiveType
153 %token <typed_val_int> INTEGER_LITERAL
154 %token <typed_val_float> FLOATING_POINT_LITERAL
156 %token <sval> IDENTIFIER
157 %token <sval> STRING_LITERAL
158 %token <lval> BOOLEAN_LITERAL
159 %token <tsym> TYPENAME
160 %type <sval> Name SimpleName QualifiedName ForcedName
162 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
163 but which would parse as a valid number in the current input radix.
164 E.g. "c" when input_radix==16. Depending on the parse, it will be
165 turned into a name or into a number. */
167 %token <sval> NAME_OR_INT
171 /* Special type cases, put in to allow the parser to distinguish different
173 %token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT
177 %token <opcode> ASSIGN_MODIFY
179 %token THIS SUPER NEW
182 %right '=' ASSIGN_MODIFY
190 %left '<' '>' LEQ GEQ
194 %right INCREMENT DECREMENT
201 /* | type_exp FIXME */
207 write_exp_elt_opcode (OP_STRING);
208 write_exp_string ($1);
209 write_exp_elt_opcode (OP_STRING);
215 { write_exp_elt_opcode (OP_LONG);
216 write_exp_elt_type ($1.type);
217 write_exp_elt_longcst ((LONGEST)($1.val));
218 write_exp_elt_opcode (OP_LONG); }
221 parse_number ($1.ptr, $1.length, 0, &val);
222 write_exp_elt_opcode (OP_LONG);
223 write_exp_elt_type (val.typed_val_int.type);
224 write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
225 write_exp_elt_opcode (OP_LONG);
227 | FLOATING_POINT_LITERAL
228 { write_exp_elt_opcode (OP_DOUBLE);
229 write_exp_elt_type ($1.type);
230 write_exp_elt_dblcst ($1.dval);
231 write_exp_elt_opcode (OP_DOUBLE); }
233 { write_exp_elt_opcode (OP_LONG);
234 write_exp_elt_type (java_boolean_type);
235 write_exp_elt_longcst ((LONGEST)$1);
236 write_exp_elt_opcode (OP_LONG); }
250 { $$ = java_boolean_type; }
260 { $$ = java_byte_type; }
262 { $$ = java_short_type; }
264 { $$ = java_int_type; }
266 { $$ = java_long_type; }
268 { $$ = java_char_type; }
273 { $$ = java_float_type; }
275 { $$ = java_double_type; }
285 ClassOrInterfaceType:
287 { $$ = java_type_from_name ($1); }
297 { $$ = java_array_type ($1, $2); }
299 { $$ = java_array_type (java_type_from_name ($1), $2); }
320 { $$.length = $1.length + $3.length + 1;
321 if ($1.ptr + $1.length + 1 == $3.ptr
322 && $1.ptr[$1.length] == '.')
323 $$.ptr = $1.ptr; /* Optimization. */
326 $$.ptr = (char *) malloc ($$.length + 1);
327 make_cleanup (free, $$.ptr);
328 sprintf ($$.ptr, "%.*s.%.*s",
329 $1.length, $1.ptr, $3.length, $3.ptr);
335 { write_exp_elt_opcode(OP_TYPE);
336 write_exp_elt_type($1);
337 write_exp_elt_opcode(OP_TYPE);}
341 /* Expressions, including the comma operator. */
343 | exp1 ',' Expression
344 { write_exp_elt_opcode (BINOP_COMMA); }
349 | ArrayCreationExpression
355 { write_exp_elt_opcode (OP_THIS);
356 write_exp_elt_opcode (OP_THIS); }
358 | ClassInstanceCreationExpression
362 | lcurly ArgumentList rcurly
363 { write_exp_elt_opcode (OP_ARRAY);
364 write_exp_elt_longcst ((LONGEST) 0);
365 write_exp_elt_longcst ((LONGEST) $3);
366 write_exp_elt_opcode (OP_ARRAY); }
371 { start_arglist (); }
376 { $$ = end_arglist () - 1; }
379 ClassInstanceCreationExpression:
380 NEW ClassType '(' ArgumentList_opt ')'
381 { error ("FIXME - ClassInstanceCreationExpression"); }
387 | ArgumentList ',' Expression
397 ArrayCreationExpression:
398 NEW PrimitiveType DimExprs Dims_opt
399 { error ("FIXME - ArrayCreatiionExpression"); }
400 | NEW ClassOrInterfaceType DimExprs Dims_opt
401 { error ("FIXME - ArrayCreatiionExpression"); }
427 Primary '.' SimpleName
428 { push_fieldnames ($3); }
429 | VARIABLE '.' SimpleName
430 { push_fieldnames ($3); }
431 /*| SUPER '.' SimpleName { FIXME } */
435 Name '(' ArgumentList_opt ')'
436 { error ("method invocation not implemented"); }
437 | Primary '.' SimpleName '(' ArgumentList_opt ')'
438 { error ("method invocation not implemented"); }
439 | SUPER '.' SimpleName '(' ArgumentList_opt ')'
440 { error ("method invocation not implemented"); }
444 Name '[' Expression ']'
445 /* FIXME - This is nasty - need to shuffle expr stack. */
446 { error ("`Name[Expr]' not implemented yet - try `(Name)[Expr]'"); }
447 | VARIABLE '[' Expression ']'
448 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
449 | PrimaryNoNewArray '[' Expression ']'
450 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
456 { push_expression_name ($1); }
458 /* Already written by write_dollar_variable. */
459 | PostIncrementExpression
460 | PostDecrementExpression
463 PostIncrementExpression:
464 PostfixExpression INCREMENT
465 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
468 PostDecrementExpression:
469 PostfixExpression DECREMENT
470 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
474 PreIncrementExpression
475 | PreDecrementExpression
476 | '+' UnaryExpression
477 | '-' UnaryExpression
478 { write_exp_elt_opcode (UNOP_NEG); }
479 | '*' UnaryExpression
480 { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java */
481 | UnaryExpressionNotPlusMinus
484 PreIncrementExpression:
485 INCREMENT UnaryExpression
486 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
489 PreDecrementExpression:
490 DECREMENT UnaryExpression
491 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
494 UnaryExpressionNotPlusMinus:
496 | '~' UnaryExpression
497 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
498 | '!' UnaryExpression
499 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
504 '(' PrimitiveType Dims_opt ')' UnaryExpression
505 { write_exp_elt_opcode (UNOP_CAST);
506 write_exp_elt_type (java_array_type ($2, $3));
507 write_exp_elt_opcode (UNOP_CAST); }
508 | '(' Expression ')' UnaryExpressionNotPlusMinus
510 int exp_size = expout_ptr;
511 int last_exp_size = length_of_subexp(expout, expout_ptr);
514 int base = expout_ptr - last_exp_size - 3;
515 if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)
516 error ("invalid cast expression");
517 type = expout->elts[base+1].type;
518 /* Remove the 'Expression' and slide the
519 UnaryExpressionNotPlusMinus down to replace it. */
520 for (i = 0; i < last_exp_size; i++)
521 expout->elts[base + i] = expout->elts[base + i + 3];
523 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
524 type = lookup_pointer_type (type);
525 write_exp_elt_opcode (UNOP_CAST);
526 write_exp_elt_type (type);
527 write_exp_elt_opcode (UNOP_CAST);
529 | '(' Name Dims ')' UnaryExpressionNotPlusMinus
530 { write_exp_elt_opcode (UNOP_CAST);
531 write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));
532 write_exp_elt_opcode (UNOP_CAST); }
536 MultiplicativeExpression:
538 | MultiplicativeExpression '*' UnaryExpression
539 { write_exp_elt_opcode (BINOP_MUL); }
540 | MultiplicativeExpression '/' UnaryExpression
541 { write_exp_elt_opcode (BINOP_DIV); }
542 | MultiplicativeExpression '%' UnaryExpression
543 { write_exp_elt_opcode (BINOP_REM); }
547 MultiplicativeExpression
548 | AdditiveExpression '+' MultiplicativeExpression
549 { write_exp_elt_opcode (BINOP_ADD); }
550 | AdditiveExpression '-' MultiplicativeExpression
551 { write_exp_elt_opcode (BINOP_SUB); }
556 | ShiftExpression LSH AdditiveExpression
557 { write_exp_elt_opcode (BINOP_LSH); }
558 | ShiftExpression RSH AdditiveExpression
559 { write_exp_elt_opcode (BINOP_RSH); }
560 /* | ShiftExpression >>> AdditiveExpression { FIXME } */
563 RelationalExpression:
565 | RelationalExpression '<' ShiftExpression
566 { write_exp_elt_opcode (BINOP_LESS); }
567 | RelationalExpression '>' ShiftExpression
568 { write_exp_elt_opcode (BINOP_GTR); }
569 | RelationalExpression LEQ ShiftExpression
570 { write_exp_elt_opcode (BINOP_LEQ); }
571 | RelationalExpression GEQ ShiftExpression
572 { write_exp_elt_opcode (BINOP_GEQ); }
573 /* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */
578 | EqualityExpression EQUAL RelationalExpression
579 { write_exp_elt_opcode (BINOP_EQUAL); }
580 | EqualityExpression NOTEQUAL RelationalExpression
581 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
586 | AndExpression '&' EqualityExpression
587 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
590 ExclusiveOrExpression:
592 | ExclusiveOrExpression '^' AndExpression
593 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
595 InclusiveOrExpression:
596 ExclusiveOrExpression
597 | InclusiveOrExpression '|' ExclusiveOrExpression
598 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
601 ConditionalAndExpression:
602 InclusiveOrExpression
603 | ConditionalAndExpression ANDAND InclusiveOrExpression
604 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
607 ConditionalOrExpression:
608 ConditionalAndExpression
609 | ConditionalOrExpression OROR ConditionalAndExpression
610 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
613 ConditionalExpression:
614 ConditionalOrExpression
615 | ConditionalOrExpression '?' Expression ':' ConditionalExpression
616 { write_exp_elt_opcode (TERNOP_COND); }
619 AssignmentExpression:
620 ConditionalExpression
625 LeftHandSide '=' ConditionalExpression
626 { write_exp_elt_opcode (BINOP_ASSIGN); }
627 | LeftHandSide ASSIGN_MODIFY ConditionalExpression
628 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
629 write_exp_elt_opcode ($2);
630 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
635 { push_expression_name ($1); }
637 /* Already written by write_dollar_variable. */
648 /* Take care of parsing a number (anything that starts with a digit).
649 Set yylval and return the token type; update lexptr.
650 LEN is the number of characters in it. */
652 /*** Needs some error checking for the float case ***/
655 parse_number (p, len, parsed_float, putithere)
661 register ULONGEST n = 0;
662 ULONGEST limit, limit_div_base;
665 register int base = input_radix;
671 /* It's a float since it contains a point or an exponent. */
673 int num = 0; /* number of tokens scanned by scanf */
674 char saved_char = p[len];
676 p[len] = 0; /* null-terminate the token */
677 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
678 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);
679 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
680 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);
683 #ifdef PRINTF_HAS_LONG_DOUBLE
684 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);
686 /* Scan it into a double, then assign it to the long double.
687 This at least wins with values representable in the range
690 num = sscanf (p, "%lg%c", &temp, &c);
691 putithere->typed_val_float.dval = temp;
694 p[len] = saved_char; /* restore the input stream */
695 if (num != 1) /* check scanf found ONLY a float ... */
697 /* See if it has `f' or `d' suffix (float or double). */
699 c = tolower (p[len - 1]);
701 if (c == 'f' || c == 'F')
702 putithere->typed_val_float.type = builtin_type_float;
703 else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
704 putithere->typed_val_float.type = builtin_type_double;
708 return FLOATING_POINT_LITERAL;
711 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
743 limit = (ULONGEST)0xffffffff;
744 if (c == 'l' || c == 'L')
746 type = java_long_type;
748 /* A paranoid calculation of (1<<64)-1. */
749 limit = ((limit << 16) << 16) | limit;
753 type = java_int_type;
755 limit_div_base = limit / (ULONGEST) base;
760 if (c >= '0' && c <= '9')
762 else if (c >= 'A' && c <= 'Z')
764 else if (c >= 'a' && c <= 'z')
767 return ERROR; /* Char not a digit */
770 if (n > limit_div_base
771 || (n *= base) > limit - c)
772 error ("Numeric constant too large.");
776 putithere->typed_val_int.val = n;
777 putithere->typed_val_int.type = type;
778 return INTEGER_LITERAL;
785 enum exp_opcode opcode;
788 static const struct token tokentab3[] =
790 {">>=", ASSIGN_MODIFY, BINOP_RSH},
791 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
794 static const struct token tokentab2[] =
796 {"+=", ASSIGN_MODIFY, BINOP_ADD},
797 {"-=", ASSIGN_MODIFY, BINOP_SUB},
798 {"*=", ASSIGN_MODIFY, BINOP_MUL},
799 {"/=", ASSIGN_MODIFY, BINOP_DIV},
800 {"%=", ASSIGN_MODIFY, BINOP_REM},
801 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
802 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
803 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
804 {"++", INCREMENT, BINOP_END},
805 {"--", DECREMENT, BINOP_END},
806 {"&&", ANDAND, BINOP_END},
807 {"||", OROR, BINOP_END},
808 {"<<", LSH, BINOP_END},
809 {">>", RSH, BINOP_END},
810 {"==", EQUAL, BINOP_END},
811 {"!=", NOTEQUAL, BINOP_END},
812 {"<=", LEQ, BINOP_END},
813 {">=", GEQ, BINOP_END}
816 /* Read one token, getting characters through lexptr. */
827 static char *tempbuf;
828 static int tempbufsize;
833 /* See if it is a special token of length 3. */
834 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
835 if (STREQN (tokstart, tokentab3[i].operator, 3))
838 yylval.opcode = tokentab3[i].opcode;
839 return tokentab3[i].token;
842 /* See if it is a special token of length 2. */
843 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
844 if (STREQN (tokstart, tokentab2[i].operator, 2))
847 yylval.opcode = tokentab2[i].opcode;
848 return tokentab2[i].token;
851 switch (c = *tokstart)
863 /* We either have a character constant ('0' or '\177' for example)
864 or we have a quoted symbol reference ('foo(int,int)' in C++
869 c = parse_escape (&lexptr);
871 error ("Empty character constant.");
873 yylval.typed_val_int.val = c;
874 yylval.typed_val_int.type = builtin_type_char;
879 namelen = skip_quoted (tokstart) - tokstart;
882 lexptr = tokstart + namelen;
883 if (lexptr[-1] != '\'')
884 error ("Unmatched single quote.");
889 error ("Invalid character constant.");
891 return INTEGER_LITERAL;
899 if (paren_depth == 0)
906 if (comma_terminates && paren_depth == 0)
912 /* Might be a floating point number. */
913 if (lexptr[1] < '0' || lexptr[1] > '9')
914 goto symbol; /* Nope, must be a symbol. */
915 /* FALL THRU into number case. */
929 int got_dot = 0, got_e = 0, toktype;
930 register char *p = tokstart;
931 int hex = input_radix > 10;
933 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
938 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
946 /* This test includes !hex because 'e' is a valid hex digit
947 and thus does not indicate a floating point number when
949 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
951 /* This test does not include !hex, because a '.' always indicates
952 a decimal floating point number regardless of the radix. */
953 else if (!got_dot && *p == '.')
955 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
956 && (*p == '-' || *p == '+'))
957 /* This is the sign of the exponent, not the end of the
960 /* We will take any letters or digits. parse_number will
961 complain if past the radix, or if L or U are not final. */
962 else if ((*p < '0' || *p > '9')
963 && ((*p < 'a' || *p > 'z')
964 && (*p < 'A' || *p > 'Z')))
967 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
968 if (toktype == ERROR)
970 char *err_copy = (char *) alloca (p - tokstart + 1);
972 memcpy (err_copy, tokstart, p - tokstart);
973 err_copy[p - tokstart] = 0;
974 error ("Invalid number \"%s\".", err_copy);
1005 /* Build the gdb internal form of the input string in tempbuf,
1006 translating any standard C escape forms seen. Note that the
1007 buffer is null byte terminated *only* for the convenience of
1008 debugging gdb itself and printing the buffer contents when
1009 the buffer contains no embedded nulls. Gdb does not depend
1010 upon the buffer being null byte terminated, it uses the length
1011 string instead. This allows gdb to handle C strings (as well
1012 as strings in other languages) with embedded null bytes */
1014 tokptr = ++tokstart;
1018 /* Grow the static temp buffer if necessary, including allocating
1019 the first one on demand. */
1020 if (tempbufindex + 1 >= tempbufsize)
1022 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1028 /* Do nothing, loop will terminate. */
1032 c = parse_escape (&tokptr);
1037 tempbuf[tempbufindex++] = c;
1040 tempbuf[tempbufindex++] = *tokptr++;
1043 } while ((*tokptr != '"') && (*tokptr != '\0'));
1044 if (*tokptr++ != '"')
1046 error ("Unterminated string in expression.");
1048 tempbuf[tempbufindex] = '\0'; /* See note above */
1049 yylval.sval.ptr = tempbuf;
1050 yylval.sval.length = tempbufindex;
1052 return (STRING_LITERAL);
1055 if (!(c == '_' || c == '$'
1056 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1057 /* We must have come across a bad character (e.g. ';'). */
1058 error ("Invalid character '%c' in expression.", c);
1060 /* It's a name. See how long it is. */
1062 for (c = tokstart[namelen];
1063 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1064 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1069 while (tokstart[++i] && tokstart[i] != '>');
1070 if (tokstart[i] == '>')
1073 c = tokstart[++namelen];
1076 /* The token "if" terminates the expression and is NOT
1077 removed from the input stream. */
1078 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1087 /* Catch specific keywords. Should be done with a data structure. */
1091 if (STREQN (tokstart, "boolean", 7))
1095 if (STREQN (tokstart, "double", 6))
1099 if (STREQN (tokstart, "short", 5))
1101 if (STREQN (tokstart, "false", 5))
1104 return BOOLEAN_LITERAL;
1106 if (STREQN (tokstart, "super", 5))
1108 if (STREQN (tokstart, "float", 5))
1112 if (STREQN (tokstart, "long", 4))
1114 if (STREQN (tokstart, "byte", 4))
1116 if (STREQN (tokstart, "char", 4))
1118 if (STREQN (tokstart, "true", 4))
1121 return BOOLEAN_LITERAL;
1123 if (current_language->la_language == language_cplus
1124 && STREQN (tokstart, "this", 4))
1126 static const char this_name[] =
1127 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1129 if (lookup_symbol (this_name, expression_context_block,
1130 VAR_NAMESPACE, (int *) NULL,
1131 (struct symtab **) NULL))
1136 if (STREQN (tokstart, "int", 3))
1138 if (STREQN (tokstart, "new", 3))
1145 yylval.sval.ptr = tokstart;
1146 yylval.sval.length = namelen;
1148 if (*tokstart == '$')
1150 write_dollar_variable (yylval.sval);
1154 /* Input names that aren't symbols but ARE valid hex numbers,
1155 when the input radix permits them, can be names or numbers
1156 depending on the parse. Note we support radixes > 16 here. */
1157 if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1158 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1160 YYSTYPE newlval; /* Its value is ignored. */
1161 int hextype = parse_number (tokstart, namelen, 0, &newlval);
1162 if (hextype == INTEGER_LITERAL)
1172 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1175 static struct type *
1176 java_type_from_name (name)
1180 char *tmp = copy_name (name);
1181 struct type *typ = java_lookup_class (tmp);
1182 if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
1183 error ("No class named %s.", tmp);
1187 /* If NAME is a valid variable name in this scope, push it and return 1.
1188 Otherwise, return 0. */
1191 push_variable (name)
1195 char *tmp = copy_name (name);
1196 int is_a_field_of_this = 0;
1198 sym = lookup_symbol (tmp, expression_context_block, VAR_NAMESPACE,
1199 &is_a_field_of_this, (struct symtab **) NULL);
1200 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1202 if (symbol_read_needs_frame (sym))
1204 if (innermost_block == 0 ||
1205 contained_in (block_found, innermost_block))
1206 innermost_block = block_found;
1209 write_exp_elt_opcode (OP_VAR_VALUE);
1210 /* We want to use the selected frame, not another more inner frame
1211 which happens to be in the same block. */
1212 write_exp_elt_block (NULL);
1213 write_exp_elt_sym (sym);
1214 write_exp_elt_opcode (OP_VAR_VALUE);
1217 if (is_a_field_of_this)
1219 /* it hangs off of `this'. Must not inadvertently convert from a
1220 method call to data ref. */
1221 if (innermost_block == 0 ||
1222 contained_in (block_found, innermost_block))
1223 innermost_block = block_found;
1224 write_exp_elt_opcode (OP_THIS);
1225 write_exp_elt_opcode (OP_THIS);
1226 write_exp_elt_opcode (STRUCTOP_PTR);
1227 write_exp_string (name);
1228 write_exp_elt_opcode (STRUCTOP_PTR);
1234 /* Assuming a reference expression has been pushed, emit the
1235 STRUCTOP_STRUCT ops to access the field named NAME. If NAME is a
1236 qualified name (has '.'), generate a field access for each part. */
1239 push_fieldnames (name)
1243 struct stoken token;
1244 token.ptr = name.ptr;
1247 if (i == name.length || name.ptr[i] == '.')
1249 /* token.ptr is start of current field name. */
1250 token.length = &name.ptr[i] - token.ptr;
1251 write_exp_elt_opcode (STRUCTOP_STRUCT);
1252 write_exp_string (token);
1253 write_exp_elt_opcode (STRUCTOP_STRUCT);
1254 token.ptr += token.length + 1;
1256 if (i >= name.length)
1261 /* Helper routine for push_expression_name.
1262 Handle a qualified name, where DOT_INDEX is the index of the first '.' */
1265 push_qualified_expression_name (name, dot_index)
1269 struct stoken token;
1273 token.ptr = name.ptr;
1274 token.length = dot_index;
1276 if (push_variable (token))
1278 token.ptr = name.ptr + dot_index + 1;
1279 token.length = name.length - dot_index - 1;
1280 push_fieldnames (token);
1284 token.ptr = name.ptr;
1287 token.length = dot_index;
1288 tmp = copy_name (token);
1289 typ = java_lookup_class (tmp);
1292 if (dot_index == name.length)
1294 write_exp_elt_opcode(OP_TYPE);
1295 write_exp_elt_type(typ);
1296 write_exp_elt_opcode(OP_TYPE);
1299 dot_index++; /* Skip '.' */
1300 name.ptr += dot_index;
1301 name.length -= dot_index;
1303 while (dot_index < name.length && name.ptr[dot_index] != '.')
1305 token.ptr = name.ptr;
1306 token.length = dot_index;
1307 write_exp_elt_opcode (OP_SCOPE);
1308 write_exp_elt_type (typ);
1309 write_exp_string (token);
1310 write_exp_elt_opcode (OP_SCOPE);
1311 if (dot_index < name.length)
1314 name.ptr += dot_index;
1315 name.length -= dot_index;
1316 push_fieldnames (name);
1320 else if (dot_index >= name.length)
1322 dot_index++; /* Skip '.' */
1323 while (dot_index < name.length && name.ptr[dot_index] != '.')
1326 error ("unknown type `%.*s'", name.length, name.ptr);
1329 /* Handle Name in an expression (or LHS).
1330 Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
1333 push_expression_name (name)
1341 for (i = 0; i < name.length; i++)
1343 if (name.ptr[i] == '.')
1345 /* It's a Qualified Expression Name. */
1346 push_qualified_expression_name (name, i);
1351 /* It's a Simple Expression Name. */
1353 if (push_variable (name))
1355 tmp = copy_name (name);
1356 typ = java_lookup_class (tmp);
1359 write_exp_elt_opcode(OP_TYPE);
1360 write_exp_elt_type(typ);
1361 write_exp_elt_opcode(OP_TYPE);
1365 struct minimal_symbol *msymbol;
1367 msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
1368 if (msymbol != NULL)
1370 write_exp_msymbol (msymbol,
1371 lookup_function_type (builtin_type_int),
1374 else if (!have_full_symbols () && !have_partial_symbols ())
1375 error ("No symbol table is loaded. Use the \"file\" command.");
1377 error ("No symbol \"%s\" in current context.", tmp);