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 /*| SUPER '.' SimpleName { FIXME } */
433 Name '(' ArgumentList_opt ')'
434 { error ("method invocation not implemented"); }
435 | Primary '.' SimpleName '(' ArgumentList_opt ')'
436 { error ("method invocation not implemented"); }
437 | SUPER '.' SimpleName '(' ArgumentList_opt ')'
438 { error ("method invocation not implemented"); }
442 Name '[' Expression ']'
443 /* FIXME - This is nasty - need to shuffle expr stack. */
444 { error ("`Name[Expr]' not implemented yet - try `(Name)[Expr]'"); }
445 | PrimaryNoNewArray '[' Expression ']'
447 warning("array subscripts not implemented for Java");
448 write_exp_elt_opcode (BINOP_SUBSCRIPT); }
454 { push_expression_name ($1); }
456 /* Already written by write_dollar_variable. */
457 | PostIncrementExpression
458 | PostDecrementExpression
461 PostIncrementExpression:
462 PostfixExpression INCREMENT
463 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
466 PostDecrementExpression:
467 PostfixExpression DECREMENT
468 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
472 PreIncrementExpression
473 | PreDecrementExpression
474 | '+' UnaryExpression
475 | '-' UnaryExpression
476 { write_exp_elt_opcode (UNOP_NEG); }
477 | '*' UnaryExpression
478 { write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java */
479 | UnaryExpressionNotPlusMinus
482 PreIncrementExpression:
483 INCREMENT UnaryExpression
484 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
487 PreDecrementExpression:
488 DECREMENT UnaryExpression
489 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
492 UnaryExpressionNotPlusMinus:
494 | '~' UnaryExpression
495 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
496 | '!' UnaryExpression
497 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
502 '(' PrimitiveType Dims_opt ')' UnaryExpression
503 { write_exp_elt_opcode (UNOP_CAST);
504 write_exp_elt_type (java_array_type ($2, $3));
505 write_exp_elt_opcode (UNOP_CAST); }
506 | '(' Expression ')' UnaryExpressionNotPlusMinus /* FIXME */
507 | '(' Name Dims ')' UnaryExpressionNotPlusMinus
508 { write_exp_elt_opcode (UNOP_CAST);
509 write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));
510 write_exp_elt_opcode (UNOP_CAST); }
514 MultiplicativeExpression:
516 | MultiplicativeExpression '*' UnaryExpression
517 { write_exp_elt_opcode (BINOP_MUL); }
518 | MultiplicativeExpression '/' UnaryExpression
519 { write_exp_elt_opcode (BINOP_DIV); }
520 | MultiplicativeExpression '%' UnaryExpression
521 { write_exp_elt_opcode (BINOP_REM); }
525 MultiplicativeExpression
526 | AdditiveExpression '+' MultiplicativeExpression
527 { write_exp_elt_opcode (BINOP_ADD); }
528 | AdditiveExpression '-' MultiplicativeExpression
529 { write_exp_elt_opcode (BINOP_SUB); }
534 | ShiftExpression LSH AdditiveExpression
535 { write_exp_elt_opcode (BINOP_LSH); }
536 | ShiftExpression RSH AdditiveExpression
537 { write_exp_elt_opcode (BINOP_RSH); }
538 /* | ShiftExpression >>> AdditiveExpression { FIXME } */
541 RelationalExpression:
543 | RelationalExpression '<' ShiftExpression
544 { write_exp_elt_opcode (BINOP_LESS); }
545 | RelationalExpression '>' ShiftExpression
546 { write_exp_elt_opcode (BINOP_GTR); }
547 | RelationalExpression LEQ ShiftExpression
548 { write_exp_elt_opcode (BINOP_LEQ); }
549 | RelationalExpression GEQ ShiftExpression
550 { write_exp_elt_opcode (BINOP_GEQ); }
551 /* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */
556 | EqualityExpression EQUAL RelationalExpression
557 { write_exp_elt_opcode (BINOP_EQUAL); }
558 | EqualityExpression NOTEQUAL RelationalExpression
559 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
564 | AndExpression '&' EqualityExpression
565 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
568 ExclusiveOrExpression:
570 | ExclusiveOrExpression '^' AndExpression
571 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
573 InclusiveOrExpression:
574 ExclusiveOrExpression
575 | InclusiveOrExpression '|' ExclusiveOrExpression
576 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
579 ConditionalAndExpression:
580 InclusiveOrExpression
581 | ConditionalAndExpression ANDAND InclusiveOrExpression
582 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
585 ConditionalOrExpression:
586 ConditionalAndExpression
587 | ConditionalOrExpression OROR ConditionalAndExpression
588 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
591 ConditionalExpression:
592 ConditionalOrExpression
593 | ConditionalOrExpression '?' Expression ':' ConditionalExpression
594 { write_exp_elt_opcode (TERNOP_COND); }
597 AssignmentExpression:
598 ConditionalExpression
603 LeftHandSide '=' ConditionalExpression
604 { write_exp_elt_opcode (BINOP_ASSIGN); }
605 | LeftHandSide ASSIGN_MODIFY ConditionalExpression
606 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
607 write_exp_elt_opcode ($2);
608 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
613 { push_expression_name ($1); }
615 /* Already written by write_dollar_variable. */
626 /* Take care of parsing a number (anything that starts with a digit).
627 Set yylval and return the token type; update lexptr.
628 LEN is the number of characters in it. */
630 /*** Needs some error checking for the float case ***/
633 parse_number (p, len, parsed_float, putithere)
639 register ULONGEST n = 0;
640 ULONGEST limit, limit_div_base;
643 register int base = input_radix;
649 /* It's a float since it contains a point or an exponent. */
651 int num = 0; /* number of tokens scanned by scanf */
652 char saved_char = p[len];
654 p[len] = 0; /* null-terminate the token */
655 if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
656 num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);
657 else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
658 num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);
661 #ifdef PRINTF_HAS_LONG_DOUBLE
662 num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);
664 /* Scan it into a double, then assign it to the long double.
665 This at least wins with values representable in the range
668 num = sscanf (p, "%lg%c", &temp, &c);
669 putithere->typed_val_float.dval = temp;
672 p[len] = saved_char; /* restore the input stream */
673 if (num != 1) /* check scanf found ONLY a float ... */
675 /* See if it has `f' or `d' suffix (float or double). */
677 c = tolower (p[len - 1]);
679 if (c == 'f' || c == 'F')
680 putithere->typed_val_float.type = builtin_type_float;
681 else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
682 putithere->typed_val_float.type = builtin_type_double;
686 return FLOATING_POINT_LITERAL;
689 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
721 limit = (ULONGEST)0xffffffff;
722 if (c == 'l' || c == 'L')
724 type = java_long_type;
726 /* A paranoid calculation of (1<<64)-1. */
727 limit = ((limit << 16) << 16) | limit;
731 type = java_int_type;
733 limit_div_base = limit / (ULONGEST) base;
738 if (c >= '0' && c <= '9')
740 else if (c >= 'A' && c <= 'Z')
742 else if (c >= 'a' && c <= 'z')
745 return ERROR; /* Char not a digit */
748 if (n > limit_div_base
749 || (n *= base) > limit - c)
750 error ("Numeric constant too large.");
754 putithere->typed_val_int.val = n;
755 putithere->typed_val_int.type = type;
756 return INTEGER_LITERAL;
763 enum exp_opcode opcode;
766 static const struct token tokentab3[] =
768 {">>=", ASSIGN_MODIFY, BINOP_RSH},
769 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
772 static const struct token tokentab2[] =
774 {"+=", ASSIGN_MODIFY, BINOP_ADD},
775 {"-=", ASSIGN_MODIFY, BINOP_SUB},
776 {"*=", ASSIGN_MODIFY, BINOP_MUL},
777 {"/=", ASSIGN_MODIFY, BINOP_DIV},
778 {"%=", ASSIGN_MODIFY, BINOP_REM},
779 {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
780 {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
781 {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
782 {"++", INCREMENT, BINOP_END},
783 {"--", DECREMENT, BINOP_END},
784 {"&&", ANDAND, BINOP_END},
785 {"||", OROR, BINOP_END},
786 {"<<", LSH, BINOP_END},
787 {">>", RSH, BINOP_END},
788 {"==", EQUAL, BINOP_END},
789 {"!=", NOTEQUAL, BINOP_END},
790 {"<=", LEQ, BINOP_END},
791 {">=", GEQ, BINOP_END}
794 /* Read one token, getting characters through lexptr. */
805 static char *tempbuf;
806 static int tempbufsize;
811 /* See if it is a special token of length 3. */
812 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
813 if (STREQN (tokstart, tokentab3[i].operator, 3))
816 yylval.opcode = tokentab3[i].opcode;
817 return tokentab3[i].token;
820 /* See if it is a special token of length 2. */
821 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
822 if (STREQN (tokstart, tokentab2[i].operator, 2))
825 yylval.opcode = tokentab2[i].opcode;
826 return tokentab2[i].token;
829 switch (c = *tokstart)
841 /* We either have a character constant ('0' or '\177' for example)
842 or we have a quoted symbol reference ('foo(int,int)' in C++
847 c = parse_escape (&lexptr);
849 error ("Empty character constant.");
851 yylval.typed_val_int.val = c;
852 yylval.typed_val_int.type = builtin_type_char;
857 namelen = skip_quoted (tokstart) - tokstart;
860 lexptr = tokstart + namelen;
861 if (lexptr[-1] != '\'')
862 error ("Unmatched single quote.");
867 error ("Invalid character constant.");
869 return INTEGER_LITERAL;
877 if (paren_depth == 0)
884 if (comma_terminates && paren_depth == 0)
890 /* Might be a floating point number. */
891 if (lexptr[1] < '0' || lexptr[1] > '9')
892 goto symbol; /* Nope, must be a symbol. */
893 /* FALL THRU into number case. */
907 int got_dot = 0, got_e = 0, toktype;
908 register char *p = tokstart;
909 int hex = input_radix > 10;
911 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
916 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
924 /* This test includes !hex because 'e' is a valid hex digit
925 and thus does not indicate a floating point number when
927 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
929 /* This test does not include !hex, because a '.' always indicates
930 a decimal floating point number regardless of the radix. */
931 else if (!got_dot && *p == '.')
933 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
934 && (*p == '-' || *p == '+'))
935 /* This is the sign of the exponent, not the end of the
938 /* We will take any letters or digits. parse_number will
939 complain if past the radix, or if L or U are not final. */
940 else if ((*p < '0' || *p > '9')
941 && ((*p < 'a' || *p > 'z')
942 && (*p < 'A' || *p > 'Z')))
945 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
946 if (toktype == ERROR)
948 char *err_copy = (char *) alloca (p - tokstart + 1);
950 memcpy (err_copy, tokstart, p - tokstart);
951 err_copy[p - tokstart] = 0;
952 error ("Invalid number \"%s\".", err_copy);
983 /* Build the gdb internal form of the input string in tempbuf,
984 translating any standard C escape forms seen. Note that the
985 buffer is null byte terminated *only* for the convenience of
986 debugging gdb itself and printing the buffer contents when
987 the buffer contains no embedded nulls. Gdb does not depend
988 upon the buffer being null byte terminated, it uses the length
989 string instead. This allows gdb to handle C strings (as well
990 as strings in other languages) with embedded null bytes */
996 /* Grow the static temp buffer if necessary, including allocating
997 the first one on demand. */
998 if (tempbufindex + 1 >= tempbufsize)
1000 tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1006 /* Do nothing, loop will terminate. */
1010 c = parse_escape (&tokptr);
1015 tempbuf[tempbufindex++] = c;
1018 tempbuf[tempbufindex++] = *tokptr++;
1021 } while ((*tokptr != '"') && (*tokptr != '\0'));
1022 if (*tokptr++ != '"')
1024 error ("Unterminated string in expression.");
1026 tempbuf[tempbufindex] = '\0'; /* See note above */
1027 yylval.sval.ptr = tempbuf;
1028 yylval.sval.length = tempbufindex;
1030 return (STRING_LITERAL);
1033 if (!(c == '_' || c == '$'
1034 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1035 /* We must have come across a bad character (e.g. ';'). */
1036 error ("Invalid character '%c' in expression.", c);
1038 /* It's a name. See how long it is. */
1040 for (c = tokstart[namelen];
1041 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1042 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1047 while (tokstart[++i] && tokstart[i] != '>');
1048 if (tokstart[i] == '>')
1051 c = tokstart[++namelen];
1054 /* The token "if" terminates the expression and is NOT
1055 removed from the input stream. */
1056 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1065 /* Catch specific keywords. Should be done with a data structure. */
1069 if (STREQN (tokstart, "boolean", 7))
1073 if (STREQN (tokstart, "double", 6))
1077 if (STREQN (tokstart, "short", 5))
1079 if (STREQN (tokstart, "false", 5))
1082 return BOOLEAN_LITERAL;
1084 if (STREQN (tokstart, "super", 5))
1086 if (STREQN (tokstart, "float", 5))
1090 if (STREQN (tokstart, "long", 4))
1092 if (STREQN (tokstart, "byte", 4))
1094 if (STREQN (tokstart, "char", 4))
1096 if (STREQN (tokstart, "true", 4))
1099 return BOOLEAN_LITERAL;
1101 if (current_language->la_language == language_cplus
1102 && STREQN (tokstart, "this", 4))
1104 static const char this_name[] =
1105 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1107 if (lookup_symbol (this_name, expression_context_block,
1108 VAR_NAMESPACE, (int *) NULL,
1109 (struct symtab **) NULL))
1114 if (STREQN (tokstart, "int", 3))
1116 if (STREQN (tokstart, "new", 3))
1123 yylval.sval.ptr = tokstart;
1124 yylval.sval.length = namelen;
1126 if (*tokstart == '$')
1128 write_dollar_variable (yylval.sval);
1132 /* Input names that aren't symbols but ARE valid hex numbers,
1133 when the input radix permits them, can be names or numbers
1134 depending on the parse. Note we support radixes > 16 here. */
1135 if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1136 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1138 YYSTYPE newlval; /* Its value is ignored. */
1139 int hextype = parse_number (tokstart, namelen, 0, &newlval);
1140 if (hextype == INTEGER_LITERAL)
1150 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1153 static struct type *
1154 java_type_from_name (name)
1158 char *tmp = copy_name (name);
1159 struct type *typ = java_lookup_class (tmp);
1160 if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
1161 error ("No class named %s.", tmp);
1165 /* If NAME is a valid variable name in this scope, push it and return 1.
1166 Otherwise, return 0. */
1169 push_variable (name)
1173 char *tmp = copy_name (name);
1174 int is_a_field_of_this = 0;
1176 sym = lookup_symbol (tmp, expression_context_block, VAR_NAMESPACE,
1177 &is_a_field_of_this, (struct symtab **) NULL);
1178 if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1180 if (symbol_read_needs_frame (sym))
1182 if (innermost_block == 0 ||
1183 contained_in (block_found, innermost_block))
1184 innermost_block = block_found;
1187 write_exp_elt_opcode (OP_VAR_VALUE);
1188 /* We want to use the selected frame, not another more inner frame
1189 which happens to be in the same block. */
1190 write_exp_elt_block (NULL);
1191 write_exp_elt_sym (sym);
1192 write_exp_elt_opcode (OP_VAR_VALUE);
1195 if (is_a_field_of_this)
1197 /* it hangs off of `this'. Must not inadvertently convert from a
1198 method call to data ref. */
1199 if (innermost_block == 0 ||
1200 contained_in (block_found, innermost_block))
1201 innermost_block = block_found;
1202 write_exp_elt_opcode (OP_THIS);
1203 write_exp_elt_opcode (OP_THIS);
1204 write_exp_elt_opcode (STRUCTOP_PTR);
1205 write_exp_string (name);
1206 write_exp_elt_opcode (STRUCTOP_PTR);
1212 /* Assuming a reference expression has been pushed, emit the
1213 STRUCTOP_STRUCT ops to access the field named NAME. If NAME is a
1214 qualified name (has '.'), generate a field access for each part. */
1217 push_fieldnames (name)
1221 struct stoken token;
1222 token.ptr = name.ptr;
1225 if (i == name.length || name.ptr[i] == '.')
1227 /* token.ptr is start of current field name. */
1228 token.length = &name.ptr[i] - token.ptr;
1229 write_exp_elt_opcode (STRUCTOP_STRUCT);
1230 write_exp_string (token);
1231 write_exp_elt_opcode (STRUCTOP_STRUCT);
1232 token.ptr += token.length + 1;
1234 if (i >= name.length)
1239 /* Helper routine for push_expression_name.
1240 Handle a qualified name, where DOT_INDEX is the index of the first '.' */
1243 push_qualified_expression_name (name, dot_index)
1247 struct stoken token;
1251 token.ptr = name.ptr;
1252 token.length = dot_index;
1254 if (push_variable (token))
1256 token.ptr = name.ptr + dot_index + 1;
1257 token.length = name.length - dot_index - 1;
1258 push_fieldnames (token);
1262 token.ptr = name.ptr;
1265 token.length = dot_index;
1266 tmp = copy_name (token);
1267 typ = java_lookup_class (tmp);
1270 if (dot_index == name.length)
1272 write_exp_elt_opcode(OP_TYPE);
1273 write_exp_elt_type(typ);
1274 write_exp_elt_opcode(OP_TYPE);
1277 dot_index++; /* Skip '.' */
1278 name.ptr += dot_index;
1279 name.length -= dot_index;
1280 while (dot_index < name.length && name.ptr[dot_index] != '.')
1282 token.ptr = name.ptr;
1283 token.length = dot_index;
1284 write_exp_elt_opcode (OP_SCOPE);
1285 write_exp_elt_type (typ);
1286 write_exp_string (token);
1287 write_exp_elt_opcode (OP_SCOPE);
1288 if (dot_index < name.length)
1291 name.ptr += dot_index;
1292 name.length -= dot_index;
1293 push_fieldnames (name);
1297 else if (dot_index >= name.length)
1299 dot_index++; /* Skip '.' */
1300 while (dot_index < name.length && name.ptr[dot_index] != '.')
1303 error ("unknown type `%.*s'", name.length, name.ptr);
1306 /* Handle Name in an expression (or LHS).
1307 Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
1310 push_expression_name (name)
1318 for (i = 0; i < name.length; i++)
1320 if (name.ptr[i] == '.')
1322 /* It's a Qualified Expression Name. */
1323 push_qualified_expression_name (name, i);
1328 /* It's a Simple Expression Name. */
1330 if (push_variable (name))
1332 tmp = copy_name (name);
1333 typ = java_lookup_class (tmp);
1336 write_exp_elt_opcode(OP_TYPE);
1337 write_exp_elt_type(typ);
1338 write_exp_elt_opcode(OP_TYPE);
1342 struct minimal_symbol *msymbol;
1344 msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
1345 if (msymbol != NULL)
1347 write_exp_msymbol (msymbol,
1348 lookup_function_type (builtin_type_int),
1351 else if (!have_full_symbols () && !have_partial_symbols ())
1352 error ("No symbol table is loaded. Use the \"file\" command.");
1354 error ("No symbol \"%s\" in current context.", tmp);