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