1/* YACC parser for Java expressions, for GDB.
2   Copyright 1997, 1998, 1999, 2000
3   Free Software Foundation, Inc.
4
5This file is part of GDB.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
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.
29
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.  */
37
38%{
39
40#include "defs.h"
41#include "gdb_string.h"
42#include <ctype.h>
43#include "expression.h"
44#include "value.h"
45#include "parser-defs.h"
46#include "language.h"
47#include "jv-lang.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 */
51#include "block.h"
52
53/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
54   as well as gratuitiously global symbol names, so we can have multiple
55   yacc generated parsers in gdb.  Note that these are only the variables
56   produced by yacc.  If other parser generators (bison, byacc, etc) produce
57   additional global names that conflict at link time, then those parser
58   generators need to be fixed instead of adding those names to this list. */
59
60#define	yymaxdepth java_maxdepth
61#define	yyparse	java_parse
62#define	yylex	java_lex
63#define	yyerror	java_error
64#define	yylval	java_lval
65#define	yychar	java_char
66#define	yydebug	java_debug
67#define	yypact	java_pact
68#define	yyr1	java_r1
69#define	yyr2	java_r2
70#define	yydef	java_def
71#define	yychk	java_chk
72#define	yypgo	java_pgo
73#define	yyact	java_act
74#define	yyexca	java_exca
75#define yyerrflag java_errflag
76#define yynerrs	java_nerrs
77#define	yyps	java_ps
78#define	yypv	java_pv
79#define	yys	java_s
80#define	yy_yys	java_yys
81#define	yystate	java_state
82#define	yytmp	java_tmp
83#define	yyv	java_v
84#define	yy_yyv	java_yyv
85#define	yyval	java_val
86#define	yylloc	java_lloc
87#define yyreds	java_reds		/* With YYDEBUG defined */
88#define yytoks	java_toks		/* With YYDEBUG defined */
89#define yyname	java_name		/* With YYDEBUG defined */
90#define yyrule	java_rule		/* With YYDEBUG defined */
91#define yylhs	java_yylhs
92#define yylen	java_yylen
93#define yydefred java_yydefred
94#define yydgoto	java_yydgoto
95#define yysindex java_yysindex
96#define yyrindex java_yyrindex
97#define yygindex java_yygindex
98#define yytable	 java_yytable
99#define yycheck	 java_yycheck
100
101#ifndef YYDEBUG
102#define	YYDEBUG 1		/* Default to yydebug support */
103#endif
104
105#define YYFPRINTF parser_fprintf
106
107int yyparse (void);
108
109static int yylex (void);
110
111void yyerror (char *);
112
113static struct type *java_type_from_name (struct stoken);
114static void push_expression_name (struct stoken);
115static void push_fieldnames (struct stoken);
116
117static struct expression *copy_exp (struct expression *, int);
118static void insert_exp (int, struct expression *);
119
120%}
121
122/* Although the yacc "value" of an expression is not used,
123   since the result is stored in the structure being created,
124   other node types do have values.  */
125
126%union
127  {
128    LONGEST lval;
129    struct {
130      LONGEST val;
131      struct type *type;
132    } typed_val_int;
133    struct {
134      DOUBLEST dval;
135      struct type *type;
136    } typed_val_float;
137    struct symbol *sym;
138    struct type *tval;
139    struct stoken sval;
140    struct ttype tsym;
141    struct symtoken ssym;
142    struct block *bval;
143    enum exp_opcode opcode;
144    struct internalvar *ivar;
145    int *ivec;
146  }
147
148%{
149/* YYSTYPE gets defined by %union */
150static int parse_number (char *, int, int, YYSTYPE *);
151%}
152
153%type <lval> rcurly Dims Dims_opt
154%type <tval> ClassOrInterfaceType ClassType /* ReferenceType Type ArrayType */
155%type <tval> IntegralType FloatingPointType NumericType PrimitiveType ArrayType PrimitiveOrArrayType
156
157%token <typed_val_int> INTEGER_LITERAL
158%token <typed_val_float> FLOATING_POINT_LITERAL
159
160%token <sval> IDENTIFIER
161%token <sval> STRING_LITERAL
162%token <lval> BOOLEAN_LITERAL
163%token <tsym> TYPENAME
164%type <sval> Name SimpleName QualifiedName ForcedName
165
166/* A NAME_OR_INT is a symbol which is not known in the symbol table,
167   but which would parse as a valid number in the current input radix.
168   E.g. "c" when input_radix==16.  Depending on the parse, it will be
169   turned into a name or into a number.  */
170
171%token <sval> NAME_OR_INT
172
173%token ERROR
174
175/* Special type cases, put in to allow the parser to distinguish different
176   legal basetypes.  */
177%token LONG SHORT BYTE INT CHAR BOOLEAN DOUBLE FLOAT
178
179%token VARIABLE
180
181%token <opcode> ASSIGN_MODIFY
182
183%token SUPER NEW
184
185%left ','
186%right '=' ASSIGN_MODIFY
187%right '?'
188%left OROR
189%left ANDAND
190%left '|'
191%left '^'
192%left '&'
193%left EQUAL NOTEQUAL
194%left '<' '>' LEQ GEQ
195%left LSH RSH
196%left '+' '-'
197%left '*' '/' '%'
198%right INCREMENT DECREMENT
199%right '.' '[' '('
200
201
202%%
203
204start   :	exp1
205	|	type_exp
206	;
207
208type_exp:	PrimitiveOrArrayType
209		{
210		  write_exp_elt_opcode(OP_TYPE);
211		  write_exp_elt_type($1);
212		  write_exp_elt_opcode(OP_TYPE);
213		}
214	;
215
216PrimitiveOrArrayType:
217		PrimitiveType
218	|	ArrayType
219	;
220
221StringLiteral:
222	STRING_LITERAL
223		{
224		  write_exp_elt_opcode (OP_STRING);
225		  write_exp_string ($1);
226		  write_exp_elt_opcode (OP_STRING);
227		}
228;
229
230Literal:
231	INTEGER_LITERAL
232		{ write_exp_elt_opcode (OP_LONG);
233		  write_exp_elt_type ($1.type);
234		  write_exp_elt_longcst ((LONGEST)($1.val));
235		  write_exp_elt_opcode (OP_LONG); }
236|	NAME_OR_INT
237		{ YYSTYPE val;
238		  parse_number ($1.ptr, $1.length, 0, &val);
239		  write_exp_elt_opcode (OP_LONG);
240		  write_exp_elt_type (val.typed_val_int.type);
241		  write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
242		  write_exp_elt_opcode (OP_LONG);
243		}
244|	FLOATING_POINT_LITERAL
245		{ write_exp_elt_opcode (OP_DOUBLE);
246		  write_exp_elt_type ($1.type);
247		  write_exp_elt_dblcst ($1.dval);
248		  write_exp_elt_opcode (OP_DOUBLE); }
249|	BOOLEAN_LITERAL
250		{ write_exp_elt_opcode (OP_LONG);
251		  write_exp_elt_type (java_boolean_type);
252		  write_exp_elt_longcst ((LONGEST)$1);
253		  write_exp_elt_opcode (OP_LONG); }
254|	StringLiteral
255	;
256
257/* UNUSED:
258Type:
259	PrimitiveType
260|	ReferenceType
261;
262*/
263
264PrimitiveType:
265	NumericType
266|	BOOLEAN
267		{ $$ = java_boolean_type; }
268;
269
270NumericType:
271	IntegralType
272|	FloatingPointType
273;
274
275IntegralType:
276	BYTE
277		{ $$ = java_byte_type; }
278|	SHORT
279		{ $$ = java_short_type; }
280|	INT
281		{ $$ = java_int_type; }
282|	LONG
283		{ $$ = java_long_type; }
284|	CHAR
285		{ $$ = java_char_type; }
286;
287
288FloatingPointType:
289	FLOAT
290		{ $$ = java_float_type; }
291|	DOUBLE
292		{ $$ = java_double_type; }
293;
294
295/* UNUSED:
296ReferenceType:
297	ClassOrInterfaceType
298|	ArrayType
299;
300*/
301
302ClassOrInterfaceType:
303	Name
304		{ $$ = java_type_from_name ($1); }
305;
306
307ClassType:
308	ClassOrInterfaceType
309;
310
311ArrayType:
312	PrimitiveType Dims
313		{ $$ = java_array_type ($1, $2); }
314|	Name Dims
315		{ $$ = java_array_type (java_type_from_name ($1), $2); }
316;
317
318Name:
319	IDENTIFIER
320|	QualifiedName
321;
322
323ForcedName:
324	SimpleName
325|	QualifiedName
326;
327
328SimpleName:
329	IDENTIFIER
330|	NAME_OR_INT
331;
332
333QualifiedName:
334	Name '.' SimpleName
335		{ $$.length = $1.length + $3.length + 1;
336		  if ($1.ptr + $1.length + 1 == $3.ptr
337		      && $1.ptr[$1.length] == '.')
338		    $$.ptr = $1.ptr;  /* Optimization. */
339		  else
340		    {
341		      $$.ptr = (char *) malloc ($$.length + 1);
342		      make_cleanup (free, $$.ptr);
343		      sprintf ($$.ptr, "%.*s.%.*s",
344			       $1.length, $1.ptr, $3.length, $3.ptr);
345		} }
346;
347
348/*
349type_exp:	type
350			{ write_exp_elt_opcode(OP_TYPE);
351			  write_exp_elt_type($1);
352			  write_exp_elt_opcode(OP_TYPE);}
353	;
354	*/
355
356/* Expressions, including the comma operator.  */
357exp1	:	Expression
358	|	exp1 ',' Expression
359			{ write_exp_elt_opcode (BINOP_COMMA); }
360	;
361
362Primary:
363	PrimaryNoNewArray
364|	ArrayCreationExpression
365;
366
367PrimaryNoNewArray:
368	Literal
369|	'(' Expression ')'
370|	ClassInstanceCreationExpression
371|	FieldAccess
372|	MethodInvocation
373|	ArrayAccess
374|	lcurly ArgumentList rcurly
375		{ write_exp_elt_opcode (OP_ARRAY);
376		  write_exp_elt_longcst ((LONGEST) 0);
377		  write_exp_elt_longcst ((LONGEST) $3);
378		  write_exp_elt_opcode (OP_ARRAY); }
379;
380
381lcurly:
382	'{'
383		{ start_arglist (); }
384;
385
386rcurly:
387	'}'
388		{ $$ = end_arglist () - 1; }
389;
390
391ClassInstanceCreationExpression:
392	NEW ClassType '(' ArgumentList_opt ')'
393		{ internal_error (__FILE__, __LINE__,
394				  _("FIXME - ClassInstanceCreationExpression")); }
395;
396
397ArgumentList:
398	Expression
399		{ arglist_len = 1; }
400|	ArgumentList ',' Expression
401		{ arglist_len++; }
402;
403
404ArgumentList_opt:
405	/* EMPTY */
406		{ arglist_len = 0; }
407| ArgumentList
408;
409
410ArrayCreationExpression:
411	NEW PrimitiveType DimExprs Dims_opt
412		{ internal_error (__FILE__, __LINE__,
413				  _("FIXME - ArrayCreationExpression")); }
414|	NEW ClassOrInterfaceType DimExprs Dims_opt
415		{ internal_error (__FILE__, __LINE__,
416				  _("FIXME - ArrayCreationExpression")); }
417;
418
419DimExprs:
420	DimExpr
421|	DimExprs DimExpr
422;
423
424DimExpr:
425	'[' Expression ']'
426;
427
428Dims:
429	'[' ']'
430		{ $$ = 1; }
431|	Dims '[' ']'
432	{ $$ = $1 + 1; }
433;
434
435Dims_opt:
436	Dims
437|	/* EMPTY */
438		{ $$ = 0; }
439;
440
441FieldAccess:
442	Primary '.' SimpleName
443		{ push_fieldnames ($3); }
444|	VARIABLE '.' SimpleName
445		{ push_fieldnames ($3); }
446/*|	SUPER '.' SimpleName { FIXME } */
447;
448
449FuncStart:
450	Name '('
451                { push_expression_name ($1); }
452;
453
454MethodInvocation:
455	FuncStart
456                { start_arglist(); }
457	ArgumentList_opt ')'
458                { write_exp_elt_opcode (OP_FUNCALL);
459		  write_exp_elt_longcst ((LONGEST) end_arglist ());
460		  write_exp_elt_opcode (OP_FUNCALL); }
461|	Primary '.' SimpleName '(' ArgumentList_opt ')'
462		{ error (_("Form of method invocation not implemented")); }
463|	SUPER '.' SimpleName '(' ArgumentList_opt ')'
464		{ error (_("Form of method invocation not implemented")); }
465;
466
467ArrayAccess:
468	Name '[' Expression ']'
469                {
470                  /* Emit code for the Name now, then exchange it in the
471		     expout array with the Expression's code.  We could
472		     introduce a OP_SWAP code or a reversed version of
473		     BINOP_SUBSCRIPT, but that makes the rest of GDB pay
474		     for our parsing kludges.  */
475		  struct expression *name_expr;
476
477		  push_expression_name ($1);
478		  name_expr = copy_exp (expout, expout_ptr);
479		  expout_ptr -= name_expr->nelts;
480		  insert_exp (expout_ptr-length_of_subexp (expout, expout_ptr),
481			      name_expr);
482		  free (name_expr);
483		  write_exp_elt_opcode (BINOP_SUBSCRIPT);
484		}
485|	VARIABLE '[' Expression ']'
486		{ write_exp_elt_opcode (BINOP_SUBSCRIPT); }
487|	PrimaryNoNewArray '[' Expression ']'
488		{ write_exp_elt_opcode (BINOP_SUBSCRIPT); }
489;
490
491PostfixExpression:
492	Primary
493|	Name
494		{ push_expression_name ($1); }
495|	VARIABLE
496		/* Already written by write_dollar_variable. */
497|	PostIncrementExpression
498|	PostDecrementExpression
499;
500
501PostIncrementExpression:
502	PostfixExpression INCREMENT
503		{ write_exp_elt_opcode (UNOP_POSTINCREMENT); }
504;
505
506PostDecrementExpression:
507	PostfixExpression DECREMENT
508		{ write_exp_elt_opcode (UNOP_POSTDECREMENT); }
509;
510
511UnaryExpression:
512	PreIncrementExpression
513|	PreDecrementExpression
514|	'+' UnaryExpression
515|	'-' UnaryExpression
516		{ write_exp_elt_opcode (UNOP_NEG); }
517|	'*' UnaryExpression
518		{ write_exp_elt_opcode (UNOP_IND); } /*FIXME not in Java  */
519|	UnaryExpressionNotPlusMinus
520;
521
522PreIncrementExpression:
523	INCREMENT UnaryExpression
524		{ write_exp_elt_opcode (UNOP_PREINCREMENT); }
525;
526
527PreDecrementExpression:
528	DECREMENT UnaryExpression
529		{ write_exp_elt_opcode (UNOP_PREDECREMENT); }
530;
531
532UnaryExpressionNotPlusMinus:
533	PostfixExpression
534|	'~' UnaryExpression
535		{ write_exp_elt_opcode (UNOP_COMPLEMENT); }
536|	'!' UnaryExpression
537		{ write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
538|	CastExpression
539	;
540
541CastExpression:
542	'(' PrimitiveType Dims_opt ')' UnaryExpression
543		{ write_exp_elt_opcode (UNOP_CAST);
544		  write_exp_elt_type (java_array_type ($2, $3));
545		  write_exp_elt_opcode (UNOP_CAST); }
546|	'(' Expression ')' UnaryExpressionNotPlusMinus
547		{
548		  int exp_size = expout_ptr;
549		  int last_exp_size = length_of_subexp(expout, expout_ptr);
550		  struct type *type;
551		  int i;
552		  int base = expout_ptr - last_exp_size - 3;
553		  if (base < 0 || expout->elts[base+2].opcode != OP_TYPE)
554		    error (_("Invalid cast expression"));
555		  type = expout->elts[base+1].type;
556		  /* Remove the 'Expression' and slide the
557		     UnaryExpressionNotPlusMinus down to replace it. */
558		  for (i = 0;  i < last_exp_size;  i++)
559		    expout->elts[base + i] = expout->elts[base + i + 3];
560		  expout_ptr -= 3;
561		  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
562		    type = lookup_pointer_type (type);
563		  write_exp_elt_opcode (UNOP_CAST);
564		  write_exp_elt_type (type);
565		  write_exp_elt_opcode (UNOP_CAST);
566		}
567|	'(' Name Dims ')' UnaryExpressionNotPlusMinus
568		{ write_exp_elt_opcode (UNOP_CAST);
569		  write_exp_elt_type (java_array_type (java_type_from_name ($2), $3));
570		  write_exp_elt_opcode (UNOP_CAST); }
571;
572
573
574MultiplicativeExpression:
575	UnaryExpression
576|	MultiplicativeExpression '*' UnaryExpression
577		{ write_exp_elt_opcode (BINOP_MUL); }
578|	MultiplicativeExpression '/' UnaryExpression
579		{ write_exp_elt_opcode (BINOP_DIV); }
580|	MultiplicativeExpression '%' UnaryExpression
581		{ write_exp_elt_opcode (BINOP_REM); }
582;
583
584AdditiveExpression:
585	MultiplicativeExpression
586|	AdditiveExpression '+' MultiplicativeExpression
587		{ write_exp_elt_opcode (BINOP_ADD); }
588|	AdditiveExpression '-' MultiplicativeExpression
589		{ write_exp_elt_opcode (BINOP_SUB); }
590;
591
592ShiftExpression:
593	AdditiveExpression
594|	ShiftExpression LSH AdditiveExpression
595		{ write_exp_elt_opcode (BINOP_LSH); }
596|	ShiftExpression RSH AdditiveExpression
597		{ write_exp_elt_opcode (BINOP_RSH); }
598/* |	ShiftExpression >>> AdditiveExpression { FIXME } */
599;
600
601RelationalExpression:
602	ShiftExpression
603|	RelationalExpression '<' ShiftExpression
604		{ write_exp_elt_opcode (BINOP_LESS); }
605|	RelationalExpression '>' ShiftExpression
606		{ write_exp_elt_opcode (BINOP_GTR); }
607|	RelationalExpression LEQ ShiftExpression
608		{ write_exp_elt_opcode (BINOP_LEQ); }
609|	RelationalExpression GEQ ShiftExpression
610		{ write_exp_elt_opcode (BINOP_GEQ); }
611/* | RelationalExpresion INSTANCEOF ReferenceType { FIXME } */
612;
613
614EqualityExpression:
615	RelationalExpression
616|	EqualityExpression EQUAL RelationalExpression
617		{ write_exp_elt_opcode (BINOP_EQUAL); }
618|	EqualityExpression NOTEQUAL RelationalExpression
619		{ write_exp_elt_opcode (BINOP_NOTEQUAL); }
620;
621
622AndExpression:
623	EqualityExpression
624|	AndExpression '&' EqualityExpression
625		{ write_exp_elt_opcode (BINOP_BITWISE_AND); }
626;
627
628ExclusiveOrExpression:
629	AndExpression
630|	ExclusiveOrExpression '^' AndExpression
631		{ write_exp_elt_opcode (BINOP_BITWISE_XOR); }
632;
633InclusiveOrExpression:
634	ExclusiveOrExpression
635|	InclusiveOrExpression '|' ExclusiveOrExpression
636		{ write_exp_elt_opcode (BINOP_BITWISE_IOR); }
637;
638
639ConditionalAndExpression:
640	InclusiveOrExpression
641|	ConditionalAndExpression ANDAND InclusiveOrExpression
642		{ write_exp_elt_opcode (BINOP_LOGICAL_AND); }
643;
644
645ConditionalOrExpression:
646	ConditionalAndExpression
647|	ConditionalOrExpression OROR ConditionalAndExpression
648		{ write_exp_elt_opcode (BINOP_LOGICAL_OR); }
649;
650
651ConditionalExpression:
652	ConditionalOrExpression
653|	ConditionalOrExpression '?' Expression ':' ConditionalExpression
654		{ write_exp_elt_opcode (TERNOP_COND); }
655;
656
657AssignmentExpression:
658	ConditionalExpression
659|	Assignment
660;
661
662Assignment:
663	LeftHandSide '=' ConditionalExpression
664		{ write_exp_elt_opcode (BINOP_ASSIGN); }
665|	LeftHandSide ASSIGN_MODIFY ConditionalExpression
666		{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
667		  write_exp_elt_opcode ($2);
668		  write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
669;
670
671LeftHandSide:
672	ForcedName
673		{ push_expression_name ($1); }
674|	VARIABLE
675		/* Already written by write_dollar_variable. */
676|	FieldAccess
677|	ArrayAccess
678;
679
680
681Expression:
682	AssignmentExpression
683;
684
685%%
686/* Take care of parsing a number (anything that starts with a digit).
687   Set yylval and return the token type; update lexptr.
688   LEN is the number of characters in it.  */
689
690/*** Needs some error checking for the float case ***/
691
692static int
693parse_number (p, len, parsed_float, putithere)
694     char *p;
695     int len;
696     int parsed_float;
697     YYSTYPE *putithere;
698{
699  ULONGEST n = 0;
700  ULONGEST limit, limit_div_base;
701
702  int c;
703  int base = input_radix;
704
705  struct type *type;
706
707  if (parsed_float)
708    {
709      /* It's a float since it contains a point or an exponent.  */
710      char c;
711      int num = 0;	/* number of tokens scanned by scanf */
712      char saved_char = p[len];
713
714      p[len] = 0;	/* null-terminate the token */
715      if (sizeof (putithere->typed_val_float.dval) <= sizeof (float))
716	num = sscanf (p, "%g%c", (float *) &putithere->typed_val_float.dval, &c);
717      else if (sizeof (putithere->typed_val_float.dval) <= sizeof (double))
718	num = sscanf (p, "%lg%c", (double *) &putithere->typed_val_float.dval, &c);
719      else
720	{
721#ifdef SCANF_HAS_LONG_DOUBLE
722	  num = sscanf (p, "%Lg%c", &putithere->typed_val_float.dval, &c);
723#else
724	  /* Scan it into a double, then assign it to the long double.
725	     This at least wins with values representable in the range
726	     of doubles. */
727	  double temp;
728	  num = sscanf (p, "%lg%c", &temp, &c);
729	  putithere->typed_val_float.dval = temp;
730#endif
731	}
732      p[len] = saved_char;	/* restore the input stream */
733      if (num != 1) 		/* check scanf found ONLY a float ... */
734	return ERROR;
735      /* See if it has `f' or `d' suffix (float or double).  */
736
737      c = tolower (p[len - 1]);
738
739      if (c == 'f' || c == 'F')
740	putithere->typed_val_float.type = builtin_type_float;
741      else if (isdigit (c) || c == '.' || c == 'd' || c == 'D')
742	putithere->typed_val_float.type = builtin_type_double;
743      else
744	return ERROR;
745
746      return FLOATING_POINT_LITERAL;
747    }
748
749  /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
750  if (p[0] == '0')
751    switch (p[1])
752      {
753      case 'x':
754      case 'X':
755	if (len >= 3)
756	  {
757	    p += 2;
758	    base = 16;
759	    len -= 2;
760	  }
761	break;
762
763      case 't':
764      case 'T':
765      case 'd':
766      case 'D':
767	if (len >= 3)
768	  {
769	    p += 2;
770	    base = 10;
771	    len -= 2;
772	  }
773	break;
774
775      default:
776	base = 8;
777	break;
778      }
779
780  c = p[len-1];
781  /* A paranoid calculation of (1<<64)-1. */
782  limit = (ULONGEST)0xffffffff;
783  limit = ((limit << 16) << 16) | limit;
784  if (c == 'l' || c == 'L')
785    {
786      type = java_long_type;
787      len--;
788    }
789  else
790    {
791      type = java_int_type;
792    }
793  limit_div_base = limit / (ULONGEST) base;
794
795  while (--len >= 0)
796    {
797      c = *p++;
798      if (c >= '0' && c <= '9')
799	c -= '0';
800      else if (c >= 'A' && c <= 'Z')
801	c -= 'A' - 10;
802      else if (c >= 'a' && c <= 'z')
803	c -= 'a' - 10;
804      else
805	return ERROR;	/* Char not a digit */
806      if (c >= base)
807	return ERROR;
808      if (n > limit_div_base
809	  || (n *= base) > limit - c)
810	error (_("Numeric constant too large"));
811      n += c;
812	}
813
814  /* If the type is bigger than a 32-bit signed integer can be, implicitly
815     promote to long.  Java does not do this, so mark it as builtin_type_uint64
816     rather than java_long_type.  0x80000000 will become -0x80000000 instead
817     of 0x80000000L, because we don't know the sign at this point.
818  */
819  if (type == java_int_type && n > (ULONGEST)0x80000000)
820    type = builtin_type_uint64;
821
822  putithere->typed_val_int.val = n;
823  putithere->typed_val_int.type = type;
824
825  return INTEGER_LITERAL;
826}
827
828struct token
829{
830  char *operator;
831  int token;
832  enum exp_opcode opcode;
833};
834
835static const struct token tokentab3[] =
836  {
837    {">>=", ASSIGN_MODIFY, BINOP_RSH},
838    {"<<=", ASSIGN_MODIFY, BINOP_LSH}
839  };
840
841static const struct token tokentab2[] =
842  {
843    {"+=", ASSIGN_MODIFY, BINOP_ADD},
844    {"-=", ASSIGN_MODIFY, BINOP_SUB},
845    {"*=", ASSIGN_MODIFY, BINOP_MUL},
846    {"/=", ASSIGN_MODIFY, BINOP_DIV},
847    {"%=", ASSIGN_MODIFY, BINOP_REM},
848    {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
849    {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
850    {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
851    {"++", INCREMENT, BINOP_END},
852    {"--", DECREMENT, BINOP_END},
853    {"&&", ANDAND, BINOP_END},
854    {"||", OROR, BINOP_END},
855    {"<<", LSH, BINOP_END},
856    {">>", RSH, BINOP_END},
857    {"==", EQUAL, BINOP_END},
858    {"!=", NOTEQUAL, BINOP_END},
859    {"<=", LEQ, BINOP_END},
860    {">=", GEQ, BINOP_END}
861  };
862
863/* Read one token, getting characters through lexptr.  */
864
865static int
866yylex ()
867{
868  int c;
869  int namelen;
870  unsigned int i;
871  char *tokstart;
872  char *tokptr;
873  int tempbufindex;
874  static char *tempbuf;
875  static int tempbufsize;
876
877 retry:
878
879  prev_lexptr = lexptr;
880
881  tokstart = lexptr;
882  /* See if it is a special token of length 3.  */
883  for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
884    if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
885      {
886	lexptr += 3;
887	yylval.opcode = tokentab3[i].opcode;
888	return tokentab3[i].token;
889      }
890
891  /* See if it is a special token of length 2.  */
892  for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
893    if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
894      {
895	lexptr += 2;
896	yylval.opcode = tokentab2[i].opcode;
897	return tokentab2[i].token;
898      }
899
900  switch (c = *tokstart)
901    {
902    case 0:
903      return 0;
904
905    case ' ':
906    case '\t':
907    case '\n':
908      lexptr++;
909      goto retry;
910
911    case '\'':
912      /* We either have a character constant ('0' or '\177' for example)
913	 or we have a quoted symbol reference ('foo(int,int)' in C++
914	 for example). */
915      lexptr++;
916      c = *lexptr++;
917      if (c == '\\')
918	c = parse_escape (&lexptr);
919      else if (c == '\'')
920	error (_("Empty character constant"));
921
922      yylval.typed_val_int.val = c;
923      yylval.typed_val_int.type = java_char_type;
924
925      c = *lexptr++;
926      if (c != '\'')
927	{
928	  namelen = skip_quoted (tokstart) - tokstart;
929	  if (namelen > 2)
930	    {
931	      lexptr = tokstart + namelen;
932	      if (lexptr[-1] != '\'')
933		error (_("Unmatched single quote"));
934	      namelen -= 2;
935	      tokstart++;
936	      goto tryname;
937	    }
938	  error (_("Invalid character constant"));
939	}
940      return INTEGER_LITERAL;
941
942    case '(':
943      paren_depth++;
944      lexptr++;
945      return c;
946
947    case ')':
948      if (paren_depth == 0)
949	return 0;
950      paren_depth--;
951      lexptr++;
952      return c;
953
954    case ',':
955      if (comma_terminates && paren_depth == 0)
956	return 0;
957      lexptr++;
958      return c;
959
960    case '.':
961      /* Might be a floating point number.  */
962      if (lexptr[1] < '0' || lexptr[1] > '9')
963	goto symbol;		/* Nope, must be a symbol. */
964      /* FALL THRU into number case.  */
965
966    case '0':
967    case '1':
968    case '2':
969    case '3':
970    case '4':
971    case '5':
972    case '6':
973    case '7':
974    case '8':
975    case '9':
976      {
977	/* It's a number.  */
978	int got_dot = 0, got_e = 0, toktype;
979	char *p = tokstart;
980	int hex = input_radix > 10;
981
982	if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
983	  {
984	    p += 2;
985	    hex = 1;
986	  }
987	else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
988	  {
989	    p += 2;
990	    hex = 0;
991	  }
992
993	for (;; ++p)
994	  {
995	    /* This test includes !hex because 'e' is a valid hex digit
996	       and thus does not indicate a floating point number when
997	       the radix is hex.  */
998	    if (!hex && !got_e && (*p == 'e' || *p == 'E'))
999	      got_dot = got_e = 1;
1000	    /* This test does not include !hex, because a '.' always indicates
1001	       a decimal floating point number regardless of the radix.  */
1002	    else if (!got_dot && *p == '.')
1003	      got_dot = 1;
1004	    else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1005		     && (*p == '-' || *p == '+'))
1006	      /* This is the sign of the exponent, not the end of the
1007		 number.  */
1008	      continue;
1009	    /* We will take any letters or digits.  parse_number will
1010	       complain if past the radix, or if L or U are not final.  */
1011	    else if ((*p < '0' || *p > '9')
1012		     && ((*p < 'a' || *p > 'z')
1013				  && (*p < 'A' || *p > 'Z')))
1014	      break;
1015	  }
1016	toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1017        if (toktype == ERROR)
1018	  {
1019	    char *err_copy = (char *) alloca (p - tokstart + 1);
1020
1021	    memcpy (err_copy, tokstart, p - tokstart);
1022	    err_copy[p - tokstart] = 0;
1023	    error (_("Invalid number \"%s\""), err_copy);
1024	  }
1025	lexptr = p;
1026	return toktype;
1027      }
1028
1029    case '+':
1030    case '-':
1031    case '*':
1032    case '/':
1033    case '%':
1034    case '|':
1035    case '&':
1036    case '^':
1037    case '~':
1038    case '!':
1039    case '<':
1040    case '>':
1041    case '[':
1042    case ']':
1043    case '?':
1044    case ':':
1045    case '=':
1046    case '{':
1047    case '}':
1048    symbol:
1049      lexptr++;
1050      return c;
1051
1052    case '"':
1053
1054      /* Build the gdb internal form of the input string in tempbuf,
1055	 translating any standard C escape forms seen.  Note that the
1056	 buffer is null byte terminated *only* for the convenience of
1057	 debugging gdb itself and printing the buffer contents when
1058	 the buffer contains no embedded nulls.  Gdb does not depend
1059	 upon the buffer being null byte terminated, it uses the length
1060	 string instead.  This allows gdb to handle C strings (as well
1061	 as strings in other languages) with embedded null bytes */
1062
1063      tokptr = ++tokstart;
1064      tempbufindex = 0;
1065
1066      do {
1067	/* Grow the static temp buffer if necessary, including allocating
1068	   the first one on demand. */
1069	if (tempbufindex + 1 >= tempbufsize)
1070	  {
1071	    tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1072	  }
1073	switch (*tokptr)
1074	  {
1075	  case '\0':
1076	  case '"':
1077	    /* Do nothing, loop will terminate. */
1078	    break;
1079	  case '\\':
1080	    tokptr++;
1081	    c = parse_escape (&tokptr);
1082	    if (c == -1)
1083	      {
1084		continue;
1085	      }
1086	    tempbuf[tempbufindex++] = c;
1087	    break;
1088	  default:
1089	    tempbuf[tempbufindex++] = *tokptr++;
1090	    break;
1091	  }
1092      } while ((*tokptr != '"') && (*tokptr != '\0'));
1093      if (*tokptr++ != '"')
1094	{
1095	  error (_("Unterminated string in expression"));
1096	}
1097      tempbuf[tempbufindex] = '\0';	/* See note above */
1098      yylval.sval.ptr = tempbuf;
1099      yylval.sval.length = tempbufindex;
1100      lexptr = tokptr;
1101      return (STRING_LITERAL);
1102    }
1103
1104  if (!(c == '_' || c == '$'
1105	|| (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1106    /* We must have come across a bad character (e.g. ';').  */
1107    error (_("Invalid character '%c' in expression"), c);
1108
1109  /* It's a name.  See how long it is.  */
1110  namelen = 0;
1111  for (c = tokstart[namelen];
1112       (c == '_'
1113	|| c == '$'
1114	|| (c >= '0' && c <= '9')
1115	|| (c >= 'a' && c <= 'z')
1116	|| (c >= 'A' && c <= 'Z')
1117	|| c == '<');
1118       )
1119    {
1120      if (c == '<')
1121	{
1122	  int i = namelen;
1123	  while (tokstart[++i] && tokstart[i] != '>');
1124	  if (tokstart[i] == '>')
1125	    namelen = i;
1126	}
1127       c = tokstart[++namelen];
1128     }
1129
1130  /* The token "if" terminates the expression and is NOT
1131     removed from the input stream.  */
1132  if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1133    {
1134      return 0;
1135    }
1136
1137  lexptr += namelen;
1138
1139  tryname:
1140
1141  /* Catch specific keywords.  Should be done with a data structure.  */
1142  switch (namelen)
1143    {
1144    case 7:
1145      if (DEPRECATED_STREQN (tokstart, "boolean", 7))
1146	return BOOLEAN;
1147      break;
1148    case 6:
1149      if (DEPRECATED_STREQN (tokstart, "double", 6))
1150	return DOUBLE;
1151      break;
1152    case 5:
1153      if (DEPRECATED_STREQN (tokstart, "short", 5))
1154	return SHORT;
1155      if (DEPRECATED_STREQN (tokstart, "false", 5))
1156	{
1157	  yylval.lval = 0;
1158	  return BOOLEAN_LITERAL;
1159	}
1160      if (DEPRECATED_STREQN (tokstart, "super", 5))
1161	return SUPER;
1162      if (DEPRECATED_STREQN (tokstart, "float", 5))
1163	return FLOAT;
1164      break;
1165    case 4:
1166      if (DEPRECATED_STREQN (tokstart, "long", 4))
1167	return LONG;
1168      if (DEPRECATED_STREQN (tokstart, "byte", 4))
1169	return BYTE;
1170      if (DEPRECATED_STREQN (tokstart, "char", 4))
1171	return CHAR;
1172      if (DEPRECATED_STREQN (tokstart, "true", 4))
1173	{
1174	  yylval.lval = 1;
1175	  return BOOLEAN_LITERAL;
1176	}
1177      break;
1178    case 3:
1179      if (strncmp (tokstart, "int", 3) == 0)
1180	return INT;
1181      if (strncmp (tokstart, "new", 3) == 0)
1182	return NEW;
1183      break;
1184    default:
1185      break;
1186    }
1187
1188  yylval.sval.ptr = tokstart;
1189  yylval.sval.length = namelen;
1190
1191  if (*tokstart == '$')
1192    {
1193      write_dollar_variable (yylval.sval);
1194      return VARIABLE;
1195    }
1196
1197  /* Input names that aren't symbols but ARE valid hex numbers,
1198     when the input radix permits them, can be names or numbers
1199     depending on the parse.  Note we support radixes > 16 here.  */
1200  if (((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1201       (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1202    {
1203      YYSTYPE newlval;	/* Its value is ignored.  */
1204      int hextype = parse_number (tokstart, namelen, 0, &newlval);
1205      if (hextype == INTEGER_LITERAL)
1206	return NAME_OR_INT;
1207    }
1208  return IDENTIFIER;
1209}
1210
1211void
1212yyerror (msg)
1213     char *msg;
1214{
1215  if (prev_lexptr)
1216    lexptr = prev_lexptr;
1217
1218  if (msg)
1219    error (_("%s: near `%s'"), msg, lexptr);
1220  else
1221    error (_("error in expression, near `%s'"), lexptr);
1222}
1223
1224static struct type *
1225java_type_from_name (name)
1226     struct stoken name;
1227
1228{
1229  char *tmp = copy_name (name);
1230  struct type *typ = java_lookup_class (tmp);
1231  if (typ == NULL || TYPE_CODE (typ) != TYPE_CODE_STRUCT)
1232    error (_("No class named `%s'"), tmp);
1233  return typ;
1234}
1235
1236/* If NAME is a valid variable name in this scope, push it and return 1.
1237   Otherwise, return 0. */
1238
1239static int
1240push_variable (struct stoken name)
1241{
1242  char *tmp = copy_name (name);
1243  int is_a_field_of_this = 0;
1244  struct symbol *sym;
1245  sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN,
1246		       &is_a_field_of_this, (struct symtab **) NULL);
1247  if (sym && SYMBOL_CLASS (sym) != LOC_TYPEDEF)
1248    {
1249      if (symbol_read_needs_frame (sym))
1250	{
1251	  if (innermost_block == 0 ||
1252	      contained_in (block_found, innermost_block))
1253	    innermost_block = block_found;
1254	}
1255
1256      write_exp_elt_opcode (OP_VAR_VALUE);
1257      /* We want to use the selected frame, not another more inner frame
1258	 which happens to be in the same block.  */
1259      write_exp_elt_block (NULL);
1260      write_exp_elt_sym (sym);
1261      write_exp_elt_opcode (OP_VAR_VALUE);
1262      return 1;
1263    }
1264  if (is_a_field_of_this)
1265    {
1266      /* it hangs off of `this'.  Must not inadvertently convert from a
1267	 method call to data ref.  */
1268      if (innermost_block == 0 ||
1269	  contained_in (block_found, innermost_block))
1270	innermost_block = block_found;
1271      write_exp_elt_opcode (OP_THIS);
1272      write_exp_elt_opcode (OP_THIS);
1273      write_exp_elt_opcode (STRUCTOP_PTR);
1274      write_exp_string (name);
1275      write_exp_elt_opcode (STRUCTOP_PTR);
1276      return 1;
1277    }
1278  return 0;
1279}
1280
1281/* Assuming a reference expression has been pushed, emit the
1282   STRUCTOP_STRUCT ops to access the field named NAME.  If NAME is a
1283   qualified name (has '.'), generate a field access for each part. */
1284
1285static void
1286push_fieldnames (name)
1287     struct stoken name;
1288{
1289  int i;
1290  struct stoken token;
1291  token.ptr = name.ptr;
1292  for (i = 0;  ;  i++)
1293    {
1294      if (i == name.length || name.ptr[i] == '.')
1295	{
1296	  /* token.ptr is start of current field name. */
1297	  token.length = &name.ptr[i] - token.ptr;
1298	  write_exp_elt_opcode (STRUCTOP_STRUCT);
1299	  write_exp_string (token);
1300	  write_exp_elt_opcode (STRUCTOP_STRUCT);
1301	  token.ptr += token.length + 1;
1302	}
1303      if (i >= name.length)
1304	break;
1305    }
1306}
1307
1308/* Helper routine for push_expression_name.
1309   Handle a qualified name, where DOT_INDEX is the index of the first '.' */
1310
1311static void
1312push_qualified_expression_name (struct stoken name, int dot_index)
1313{
1314  struct stoken token;
1315  char *tmp;
1316  struct type *typ;
1317
1318  token.ptr = name.ptr;
1319  token.length = dot_index;
1320
1321  if (push_variable (token))
1322    {
1323      token.ptr = name.ptr + dot_index + 1;
1324      token.length = name.length - dot_index - 1;
1325      push_fieldnames (token);
1326      return;
1327    }
1328
1329  token.ptr = name.ptr;
1330  for (;;)
1331    {
1332      token.length = dot_index;
1333      tmp = copy_name (token);
1334      typ = java_lookup_class (tmp);
1335      if (typ != NULL)
1336	{
1337	  if (dot_index == name.length)
1338	    {
1339	      write_exp_elt_opcode(OP_TYPE);
1340	      write_exp_elt_type(typ);
1341	      write_exp_elt_opcode(OP_TYPE);
1342	      return;
1343	    }
1344	  dot_index++;  /* Skip '.' */
1345	  name.ptr += dot_index;
1346	  name.length -= dot_index;
1347	  dot_index = 0;
1348	  while (dot_index < name.length && name.ptr[dot_index] != '.')
1349	    dot_index++;
1350	  token.ptr = name.ptr;
1351	  token.length = dot_index;
1352	  write_exp_elt_opcode (OP_SCOPE);
1353	  write_exp_elt_type (typ);
1354	  write_exp_string (token);
1355	  write_exp_elt_opcode (OP_SCOPE);
1356	  if (dot_index < name.length)
1357	    {
1358	      dot_index++;
1359	      name.ptr += dot_index;
1360	      name.length -= dot_index;
1361	      push_fieldnames (name);
1362	    }
1363	  return;
1364	}
1365      else if (dot_index >= name.length)
1366	break;
1367      dot_index++;  /* Skip '.' */
1368      while (dot_index < name.length && name.ptr[dot_index] != '.')
1369	dot_index++;
1370    }
1371  error (_("unknown type `%.*s'"), name.length, name.ptr);
1372}
1373
1374/* Handle Name in an expression (or LHS).
1375   Handle VAR, TYPE, TYPE.FIELD1....FIELDN and VAR.FIELD1....FIELDN. */
1376
1377static void
1378push_expression_name (name)
1379     struct stoken name;
1380{
1381  char *tmp;
1382  struct type *typ;
1383  char *ptr;
1384  int i;
1385
1386  for (i = 0;  i < name.length;  i++)
1387    {
1388      if (name.ptr[i] == '.')
1389	{
1390	  /* It's a Qualified Expression Name. */
1391	  push_qualified_expression_name (name, i);
1392	  return;
1393	}
1394    }
1395
1396  /* It's a Simple Expression Name. */
1397
1398  if (push_variable (name))
1399    return;
1400  tmp = copy_name (name);
1401  typ = java_lookup_class (tmp);
1402  if (typ != NULL)
1403    {
1404      write_exp_elt_opcode(OP_TYPE);
1405      write_exp_elt_type(typ);
1406      write_exp_elt_opcode(OP_TYPE);
1407    }
1408  else
1409    {
1410      struct minimal_symbol *msymbol;
1411
1412      msymbol = lookup_minimal_symbol (tmp, NULL, NULL);
1413      if (msymbol != NULL)
1414	{
1415	  write_exp_msymbol (msymbol,
1416			     lookup_function_type (builtin_type_int),
1417			     builtin_type_int);
1418	}
1419      else if (!have_full_symbols () && !have_partial_symbols ())
1420	error (_("No symbol table is loaded.  Use the \"file\" command"));
1421      else
1422	error (_("No symbol \"%s\" in current context"), tmp);
1423    }
1424
1425}
1426
1427
1428/* The following two routines, copy_exp and insert_exp, aren't specific to
1429   Java, so they could go in parse.c, but their only purpose is to support
1430   the parsing kludges we use in this file, so maybe it's best to isolate
1431   them here.  */
1432
1433/* Copy the expression whose last element is at index ENDPOS - 1 in EXPR
1434   into a freshly malloc'ed struct expression.  Its language_defn is set
1435   to null.  */
1436static struct expression *
1437copy_exp (expr, endpos)
1438     struct expression *expr;
1439     int endpos;
1440{
1441  int len = length_of_subexp (expr, endpos);
1442  struct expression *new
1443    = (struct expression *) malloc (sizeof (*new) + EXP_ELEM_TO_BYTES (len));
1444  new->nelts = len;
1445  memcpy (new->elts, expr->elts + endpos - len, EXP_ELEM_TO_BYTES (len));
1446  new->language_defn = 0;
1447
1448  return new;
1449}
1450
1451/* Insert the expression NEW into the current expression (expout) at POS.  */
1452static void
1453insert_exp (pos, new)
1454     int pos;
1455     struct expression *new;
1456{
1457  int newlen = new->nelts;
1458
1459  /* Grow expout if necessary.  In this function's only use at present,
1460     this should never be necessary.  */
1461  if (expout_ptr + newlen > expout_size)
1462    {
1463      expout_size = max (expout_size * 2, expout_ptr + newlen + 10);
1464      expout = (struct expression *)
1465	realloc ((char *) expout, (sizeof (struct expression)
1466				    + EXP_ELEM_TO_BYTES (expout_size)));
1467    }
1468
1469  {
1470    int i;
1471
1472    for (i = expout_ptr - 1; i >= pos; i--)
1473      expout->elts[i + newlen] = expout->elts[i];
1474  }
1475
1476  memcpy (expout->elts + pos, new->elts, EXP_ELEM_TO_BYTES (newlen));
1477  expout_ptr += newlen;
1478}
1479