2007-08-17 Michael Snyder <msnyder@access-company.com>
[platform/upstream/binutils.git] / gdb / c-exp.y
1 /* YACC parser for C expressions, for GDB.
2    Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3    1998, 1999, 2000, 2003, 2004, 2006, 2007 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.  */
21
22 /* Parse a C 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.
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 "c-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 "charset.h"
53 #include "block.h"
54 #include "cp-support.h"
55
56 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
57    as well as gratuitiously global symbol names, so we can have multiple
58    yacc generated parsers in gdb.  Note that these are only the variables
59    produced by yacc.  If other parser generators (bison, byacc, etc) produce
60    additional global names that conflict at link time, then those parser
61    generators need to be fixed instead of adding those names to this list. */
62
63 #define yymaxdepth c_maxdepth
64 #define yyparse c_parse
65 #define yylex   c_lex
66 #define yyerror c_error
67 #define yylval  c_lval
68 #define yychar  c_char
69 #define yydebug c_debug
70 #define yypact  c_pact  
71 #define yyr1    c_r1                    
72 #define yyr2    c_r2                    
73 #define yydef   c_def           
74 #define yychk   c_chk           
75 #define yypgo   c_pgo           
76 #define yyact   c_act           
77 #define yyexca  c_exca
78 #define yyerrflag c_errflag
79 #define yynerrs c_nerrs
80 #define yyps    c_ps
81 #define yypv    c_pv
82 #define yys     c_s
83 #define yy_yys  c_yys
84 #define yystate c_state
85 #define yytmp   c_tmp
86 #define yyv     c_v
87 #define yy_yyv  c_yyv
88 #define yyval   c_val
89 #define yylloc  c_lloc
90 #define yyreds  c_reds          /* With YYDEBUG defined */
91 #define yytoks  c_toks          /* With YYDEBUG defined */
92 #define yyname  c_name          /* With YYDEBUG defined */
93 #define yyrule  c_rule          /* With YYDEBUG defined */
94 #define yylhs   c_yylhs
95 #define yylen   c_yylen
96 #define yydefred c_yydefred
97 #define yydgoto c_yydgoto
98 #define yysindex c_yysindex
99 #define yyrindex c_yyrindex
100 #define yygindex c_yygindex
101 #define yytable  c_yytable
102 #define yycheck  c_yycheck
103
104 #ifndef YYDEBUG
105 #define YYDEBUG 1               /* Default to yydebug support */
106 #endif
107
108 #define YYFPRINTF parser_fprintf
109
110 int yyparse (void);
111
112 static int yylex (void);
113
114 void yyerror (char *);
115
116 %}
117
118 /* Although the yacc "value" of an expression is not used,
119    since the result is stored in the structure being created,
120    other node types do have values.  */
121
122 %union
123   {
124     LONGEST lval;
125     struct {
126       LONGEST val;
127       struct type *type;
128     } typed_val_int;
129     struct {
130       DOUBLEST dval;
131       struct type *type;
132     } typed_val_float;
133     struct symbol *sym;
134     struct type *tval;
135     struct stoken sval;
136     struct ttype tsym;
137     struct symtoken ssym;
138     int voidval;
139     struct block *bval;
140     enum exp_opcode opcode;
141     struct internalvar *ivar;
142
143     struct type **tvec;
144     int *ivec;
145   }
146
147 %{
148 /* YYSTYPE gets defined by %union */
149 static int parse_number (char *, int, int, YYSTYPE *);
150 %}
151
152 %type <voidval> exp exp1 type_exp start variable qualified_name lcurly
153 %type <lval> rcurly
154 %type <tval> type typebase qualified_type
155 %type <tvec> nonempty_typelist
156 /* %type <bval> block */
157
158 /* Fancy type parsing.  */
159 %type <voidval> func_mod direct_abs_decl abs_decl
160 %type <tval> ptype
161 %type <lval> array_mod
162
163 %token <typed_val_int> INT
164 %token <typed_val_float> FLOAT
165
166 /* Both NAME and TYPENAME tokens represent symbols in the input,
167    and both convey their data as strings.
168    But a TYPENAME is a string that happens to be defined as a typedef
169    or builtin type name (such as int or char)
170    and a NAME is any other symbol.
171    Contexts where this distinction is not important can use the
172    nonterminal "name", which matches either NAME or TYPENAME.  */
173
174 %token <sval> STRING
175 %token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
176 %token <tsym> TYPENAME
177 %type <sval> name
178 %type <ssym> name_not_typename
179 %type <tsym> typename
180
181 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
182    but which would parse as a valid number in the current input radix.
183    E.g. "c" when input_radix==16.  Depending on the parse, it will be
184    turned into a name or into a number.  */
185
186 %token <ssym> NAME_OR_INT 
187
188 %token STRUCT CLASS UNION ENUM SIZEOF UNSIGNED COLONCOLON
189 %token TEMPLATE
190 %token ERROR
191
192 /* Special type cases, put in to allow the parser to distinguish different
193    legal basetypes.  */
194 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
195
196 %token <voidval> VARIABLE
197
198 %token <opcode> ASSIGN_MODIFY
199
200 /* C++ */
201 %token TRUEKEYWORD
202 %token FALSEKEYWORD
203
204
205 %left ','
206 %left ABOVE_COMMA
207 %right '=' ASSIGN_MODIFY
208 %right '?'
209 %left OROR
210 %left ANDAND
211 %left '|'
212 %left '^'
213 %left '&'
214 %left EQUAL NOTEQUAL
215 %left '<' '>' LEQ GEQ
216 %left LSH RSH
217 %left '@'
218 %left '+' '-'
219 %left '*' '/' '%'
220 %right UNARY INCREMENT DECREMENT
221 %right ARROW '.' '[' '('
222 %token <ssym> BLOCKNAME 
223 %token <bval> FILENAME
224 %type <bval> block
225 %left COLONCOLON
226
227 \f
228 %%
229
230 start   :       exp1
231         |       type_exp
232         ;
233
234 type_exp:       type
235                         { write_exp_elt_opcode(OP_TYPE);
236                           write_exp_elt_type($1);
237                           write_exp_elt_opcode(OP_TYPE);}
238         ;
239
240 /* Expressions, including the comma operator.  */
241 exp1    :       exp
242         |       exp1 ',' exp
243                         { write_exp_elt_opcode (BINOP_COMMA); }
244         ;
245
246 /* Expressions, not including the comma operator.  */
247 exp     :       '*' exp    %prec UNARY
248                         { write_exp_elt_opcode (UNOP_IND); }
249         ;
250
251 exp     :       '&' exp    %prec UNARY
252                         { write_exp_elt_opcode (UNOP_ADDR); }
253         ;
254
255 exp     :       '-' exp    %prec UNARY
256                         { write_exp_elt_opcode (UNOP_NEG); }
257         ;
258
259 exp     :       '+' exp    %prec UNARY
260                         { write_exp_elt_opcode (UNOP_PLUS); }
261         ;
262
263 exp     :       '!' exp    %prec UNARY
264                         { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
265         ;
266
267 exp     :       '~' exp    %prec UNARY
268                         { write_exp_elt_opcode (UNOP_COMPLEMENT); }
269         ;
270
271 exp     :       INCREMENT exp    %prec UNARY
272                         { write_exp_elt_opcode (UNOP_PREINCREMENT); }
273         ;
274
275 exp     :       DECREMENT exp    %prec UNARY
276                         { write_exp_elt_opcode (UNOP_PREDECREMENT); }
277         ;
278
279 exp     :       exp INCREMENT    %prec UNARY
280                         { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
281         ;
282
283 exp     :       exp DECREMENT    %prec UNARY
284                         { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
285         ;
286
287 exp     :       SIZEOF exp       %prec UNARY
288                         { write_exp_elt_opcode (UNOP_SIZEOF); }
289         ;
290
291 exp     :       exp ARROW name
292                         { write_exp_elt_opcode (STRUCTOP_PTR);
293                           write_exp_string ($3);
294                           write_exp_elt_opcode (STRUCTOP_PTR); }
295         ;
296
297 exp     :       exp ARROW qualified_name
298                         { /* exp->type::name becomes exp->*(&type::name) */
299                           /* Note: this doesn't work if name is a
300                              static member!  FIXME */
301                           write_exp_elt_opcode (UNOP_ADDR);
302                           write_exp_elt_opcode (STRUCTOP_MPTR); }
303         ;
304
305 exp     :       exp ARROW '*' exp
306                         { write_exp_elt_opcode (STRUCTOP_MPTR); }
307         ;
308
309 exp     :       exp '.' name
310                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
311                           write_exp_string ($3);
312                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
313         ;
314
315 exp     :       exp '.' qualified_name
316                         { /* exp.type::name becomes exp.*(&type::name) */
317                           /* Note: this doesn't work if name is a
318                              static member!  FIXME */
319                           write_exp_elt_opcode (UNOP_ADDR);
320                           write_exp_elt_opcode (STRUCTOP_MEMBER); }
321         ;
322
323 exp     :       exp '.' '*' exp
324                         { write_exp_elt_opcode (STRUCTOP_MEMBER); }
325         ;
326
327 exp     :       exp '[' exp1 ']'
328                         { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
329         ;
330
331 exp     :       exp '(' 
332                         /* This is to save the value of arglist_len
333                            being accumulated by an outer function call.  */
334                         { start_arglist (); }
335                 arglist ')'     %prec ARROW
336                         { write_exp_elt_opcode (OP_FUNCALL);
337                           write_exp_elt_longcst ((LONGEST) end_arglist ());
338                           write_exp_elt_opcode (OP_FUNCALL); }
339         ;
340
341 lcurly  :       '{'
342                         { start_arglist (); }
343         ;
344
345 arglist :
346         ;
347
348 arglist :       exp
349                         { arglist_len = 1; }
350         ;
351
352 arglist :       arglist ',' exp   %prec ABOVE_COMMA
353                         { arglist_len++; }
354         ;
355
356 rcurly  :       '}'
357                         { $$ = end_arglist () - 1; }
358         ;
359 exp     :       lcurly arglist rcurly   %prec ARROW
360                         { write_exp_elt_opcode (OP_ARRAY);
361                           write_exp_elt_longcst ((LONGEST) 0);
362                           write_exp_elt_longcst ((LONGEST) $3);
363                           write_exp_elt_opcode (OP_ARRAY); }
364         ;
365
366 exp     :       lcurly type rcurly exp  %prec UNARY
367                         { write_exp_elt_opcode (UNOP_MEMVAL);
368                           write_exp_elt_type ($2);
369                           write_exp_elt_opcode (UNOP_MEMVAL); }
370         ;
371
372 exp     :       '(' type ')' exp  %prec UNARY
373                         { write_exp_elt_opcode (UNOP_CAST);
374                           write_exp_elt_type ($2);
375                           write_exp_elt_opcode (UNOP_CAST); }
376         ;
377
378 exp     :       '(' exp1 ')'
379                         { }
380         ;
381
382 /* Binary operators in order of decreasing precedence.  */
383
384 exp     :       exp '@' exp
385                         { write_exp_elt_opcode (BINOP_REPEAT); }
386         ;
387
388 exp     :       exp '*' exp
389                         { write_exp_elt_opcode (BINOP_MUL); }
390         ;
391
392 exp     :       exp '/' exp
393                         { write_exp_elt_opcode (BINOP_DIV); }
394         ;
395
396 exp     :       exp '%' exp
397                         { write_exp_elt_opcode (BINOP_REM); }
398         ;
399
400 exp     :       exp '+' exp
401                         { write_exp_elt_opcode (BINOP_ADD); }
402         ;
403
404 exp     :       exp '-' exp
405                         { write_exp_elt_opcode (BINOP_SUB); }
406         ;
407
408 exp     :       exp LSH exp
409                         { write_exp_elt_opcode (BINOP_LSH); }
410         ;
411
412 exp     :       exp RSH exp
413                         { write_exp_elt_opcode (BINOP_RSH); }
414         ;
415
416 exp     :       exp EQUAL exp
417                         { write_exp_elt_opcode (BINOP_EQUAL); }
418         ;
419
420 exp     :       exp NOTEQUAL exp
421                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
422         ;
423
424 exp     :       exp LEQ exp
425                         { write_exp_elt_opcode (BINOP_LEQ); }
426         ;
427
428 exp     :       exp GEQ exp
429                         { write_exp_elt_opcode (BINOP_GEQ); }
430         ;
431
432 exp     :       exp '<' exp
433                         { write_exp_elt_opcode (BINOP_LESS); }
434         ;
435
436 exp     :       exp '>' exp
437                         { write_exp_elt_opcode (BINOP_GTR); }
438         ;
439
440 exp     :       exp '&' exp
441                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
442         ;
443
444 exp     :       exp '^' exp
445                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
446         ;
447
448 exp     :       exp '|' exp
449                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
450         ;
451
452 exp     :       exp ANDAND exp
453                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
454         ;
455
456 exp     :       exp OROR exp
457                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
458         ;
459
460 exp     :       exp '?' exp ':' exp     %prec '?'
461                         { write_exp_elt_opcode (TERNOP_COND); }
462         ;
463                           
464 exp     :       exp '=' exp
465                         { write_exp_elt_opcode (BINOP_ASSIGN); }
466         ;
467
468 exp     :       exp ASSIGN_MODIFY exp
469                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
470                           write_exp_elt_opcode ($2);
471                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
472         ;
473
474 exp     :       INT
475                         { write_exp_elt_opcode (OP_LONG);
476                           write_exp_elt_type ($1.type);
477                           write_exp_elt_longcst ((LONGEST)($1.val));
478                           write_exp_elt_opcode (OP_LONG); }
479         ;
480
481 exp     :       NAME_OR_INT
482                         { YYSTYPE val;
483                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
484                           write_exp_elt_opcode (OP_LONG);
485                           write_exp_elt_type (val.typed_val_int.type);
486                           write_exp_elt_longcst ((LONGEST)val.typed_val_int.val);
487                           write_exp_elt_opcode (OP_LONG);
488                         }
489         ;
490
491
492 exp     :       FLOAT
493                         { write_exp_elt_opcode (OP_DOUBLE);
494                           write_exp_elt_type ($1.type);
495                           write_exp_elt_dblcst ($1.dval);
496                           write_exp_elt_opcode (OP_DOUBLE); }
497         ;
498
499 exp     :       variable
500         ;
501
502 exp     :       VARIABLE
503                         /* Already written by write_dollar_variable. */
504         ;
505
506 exp     :       SIZEOF '(' type ')'     %prec UNARY
507                         { write_exp_elt_opcode (OP_LONG);
508                           write_exp_elt_type (builtin_type (current_gdbarch)->builtin_int);
509                           CHECK_TYPEDEF ($3);
510                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
511                           write_exp_elt_opcode (OP_LONG); }
512         ;
513
514 exp     :       STRING
515                         { /* C strings are converted into array constants with
516                              an explicit null byte added at the end.  Thus
517                              the array upper bound is the string length.
518                              There is no such thing in C as a completely empty
519                              string. */
520                           char *sp = $1.ptr; int count = $1.length;
521                           while (count-- > 0)
522                             {
523                               write_exp_elt_opcode (OP_LONG);
524                               write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
525                               write_exp_elt_longcst ((LONGEST)(*sp++));
526                               write_exp_elt_opcode (OP_LONG);
527                             }
528                           write_exp_elt_opcode (OP_LONG);
529                           write_exp_elt_type (builtin_type (current_gdbarch)->builtin_char);
530                           write_exp_elt_longcst ((LONGEST)'\0');
531                           write_exp_elt_opcode (OP_LONG);
532                           write_exp_elt_opcode (OP_ARRAY);
533                           write_exp_elt_longcst ((LONGEST) 0);
534                           write_exp_elt_longcst ((LONGEST) ($1.length));
535                           write_exp_elt_opcode (OP_ARRAY); }
536         ;
537
538 /* C++.  */
539 exp     :       TRUEKEYWORD    
540                         { write_exp_elt_opcode (OP_LONG);
541                           write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
542                           write_exp_elt_longcst ((LONGEST) 1);
543                           write_exp_elt_opcode (OP_LONG); }
544         ;
545
546 exp     :       FALSEKEYWORD   
547                         { write_exp_elt_opcode (OP_LONG);
548                           write_exp_elt_type (builtin_type (current_gdbarch)->builtin_bool);
549                           write_exp_elt_longcst ((LONGEST) 0);
550                           write_exp_elt_opcode (OP_LONG); }
551         ;
552
553 /* end of C++.  */
554
555 block   :       BLOCKNAME
556                         {
557                           if ($1.sym)
558                             $$ = SYMBOL_BLOCK_VALUE ($1.sym);
559                           else
560                             error ("No file or function \"%s\".",
561                                    copy_name ($1.stoken));
562                         }
563         |       FILENAME
564                         {
565                           $$ = $1;
566                         }
567         ;
568
569 block   :       block COLONCOLON name
570                         { struct symbol *tem
571                             = lookup_symbol (copy_name ($3), $1,
572                                              VAR_DOMAIN, (int *) NULL,
573                                              (struct symtab **) NULL);
574                           if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
575                             error ("No function \"%s\" in specified context.",
576                                    copy_name ($3));
577                           $$ = SYMBOL_BLOCK_VALUE (tem); }
578         ;
579
580 variable:       block COLONCOLON name
581                         { struct symbol *sym;
582                           sym = lookup_symbol (copy_name ($3), $1,
583                                                VAR_DOMAIN, (int *) NULL,
584                                                (struct symtab **) NULL);
585                           if (sym == 0)
586                             error ("No symbol \"%s\" in specified context.",
587                                    copy_name ($3));
588
589                           write_exp_elt_opcode (OP_VAR_VALUE);
590                           /* block_found is set by lookup_symbol.  */
591                           write_exp_elt_block (block_found);
592                           write_exp_elt_sym (sym);
593                           write_exp_elt_opcode (OP_VAR_VALUE); }
594         ;
595
596 qualified_name: typebase COLONCOLON name
597                         {
598                           struct type *type = $1;
599                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
600                               && TYPE_CODE (type) != TYPE_CODE_UNION
601                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
602                             error ("`%s' is not defined as an aggregate type.",
603                                    TYPE_NAME (type));
604
605                           write_exp_elt_opcode (OP_SCOPE);
606                           write_exp_elt_type (type);
607                           write_exp_string ($3);
608                           write_exp_elt_opcode (OP_SCOPE);
609                         }
610         |       typebase COLONCOLON '~' name
611                         {
612                           struct type *type = $1;
613                           struct stoken tmp_token;
614                           if (TYPE_CODE (type) != TYPE_CODE_STRUCT
615                               && TYPE_CODE (type) != TYPE_CODE_UNION
616                               && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
617                             error ("`%s' is not defined as an aggregate type.",
618                                    TYPE_NAME (type));
619
620                           tmp_token.ptr = (char*) alloca ($4.length + 2);
621                           tmp_token.length = $4.length + 1;
622                           tmp_token.ptr[0] = '~';
623                           memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
624                           tmp_token.ptr[tmp_token.length] = 0;
625
626                           /* Check for valid destructor name.  */
627                           destructor_name_p (tmp_token.ptr, type);
628                           write_exp_elt_opcode (OP_SCOPE);
629                           write_exp_elt_type (type);
630                           write_exp_string (tmp_token);
631                           write_exp_elt_opcode (OP_SCOPE);
632                         }
633         ;
634
635 variable:       qualified_name
636         |       COLONCOLON name
637                         {
638                           char *name = copy_name ($2);
639                           struct symbol *sym;
640                           struct minimal_symbol *msymbol;
641
642                           sym =
643                             lookup_symbol (name, (const struct block *) NULL,
644                                            VAR_DOMAIN, (int *) NULL,
645                                            (struct symtab **) NULL);
646                           if (sym)
647                             {
648                               write_exp_elt_opcode (OP_VAR_VALUE);
649                               write_exp_elt_block (NULL);
650                               write_exp_elt_sym (sym);
651                               write_exp_elt_opcode (OP_VAR_VALUE);
652                               break;
653                             }
654
655                           msymbol = lookup_minimal_symbol (name, NULL, NULL);
656                           if (msymbol != NULL)
657                             {
658                               write_exp_msymbol (msymbol,
659                                                  lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
660                                                  builtin_type (current_gdbarch)->builtin_int);
661                             }
662                           else
663                             if (!have_full_symbols () && !have_partial_symbols ())
664                               error ("No symbol table is loaded.  Use the \"file\" command.");
665                             else
666                               error ("No symbol \"%s\" in current context.", name);
667                         }
668         ;
669
670 variable:       name_not_typename
671                         { struct symbol *sym = $1.sym;
672
673                           if (sym)
674                             {
675                               if (symbol_read_needs_frame (sym))
676                                 {
677                                   if (innermost_block == 0 ||
678                                       contained_in (block_found, 
679                                                     innermost_block))
680                                     innermost_block = block_found;
681                                 }
682
683                               write_exp_elt_opcode (OP_VAR_VALUE);
684                               /* We want to use the selected frame, not
685                                  another more inner frame which happens to
686                                  be in the same block.  */
687                               write_exp_elt_block (NULL);
688                               write_exp_elt_sym (sym);
689                               write_exp_elt_opcode (OP_VAR_VALUE);
690                             }
691                           else if ($1.is_a_field_of_this)
692                             {
693                               /* C++: it hangs off of `this'.  Must
694                                  not inadvertently convert from a method call
695                                  to data ref.  */
696                               if (innermost_block == 0 || 
697                                   contained_in (block_found, innermost_block))
698                                 innermost_block = block_found;
699                               write_exp_elt_opcode (OP_THIS);
700                               write_exp_elt_opcode (OP_THIS);
701                               write_exp_elt_opcode (STRUCTOP_PTR);
702                               write_exp_string ($1.stoken);
703                               write_exp_elt_opcode (STRUCTOP_PTR);
704                             }
705                           else
706                             {
707                               struct minimal_symbol *msymbol;
708                               char *arg = copy_name ($1.stoken);
709
710                               msymbol =
711                                 lookup_minimal_symbol (arg, NULL, NULL);
712                               if (msymbol != NULL)
713                                 {
714                                   write_exp_msymbol (msymbol,
715                                                      lookup_function_type (builtin_type (current_gdbarch)->builtin_int),
716                                                      builtin_type (current_gdbarch)->builtin_int);
717                                 }
718                               else if (!have_full_symbols () && !have_partial_symbols ())
719                                 error ("No symbol table is loaded.  Use the \"file\" command.");
720                               else
721                                 error ("No symbol \"%s\" in current context.",
722                                        copy_name ($1.stoken));
723                             }
724                         }
725         ;
726
727 space_identifier : '@' NAME
728                 { push_type_address_space (copy_name ($2.stoken));
729                   push_type (tp_space_identifier);
730                 }
731         ;
732
733 const_or_volatile: const_or_volatile_noopt
734         |
735         ;
736
737 cv_with_space_id : const_or_volatile space_identifier const_or_volatile
738         ;
739
740 const_or_volatile_or_space_identifier_noopt: cv_with_space_id
741         | const_or_volatile_noopt 
742         ;
743
744 const_or_volatile_or_space_identifier: 
745                 const_or_volatile_or_space_identifier_noopt
746         |
747         ;
748
749 abs_decl:       '*'
750                         { push_type (tp_pointer); $$ = 0; }
751         |       '*' abs_decl
752                         { push_type (tp_pointer); $$ = $2; }
753         |       '&'
754                         { push_type (tp_reference); $$ = 0; }
755         |       '&' abs_decl
756                         { push_type (tp_reference); $$ = $2; }
757         |       direct_abs_decl
758         ;
759
760 direct_abs_decl: '(' abs_decl ')'
761                         { $$ = $2; }
762         |       direct_abs_decl array_mod
763                         {
764                           push_type_int ($2);
765                           push_type (tp_array);
766                         }
767         |       array_mod
768                         {
769                           push_type_int ($1);
770                           push_type (tp_array);
771                           $$ = 0;
772                         }
773
774         |       direct_abs_decl func_mod
775                         { push_type (tp_function); }
776         |       func_mod
777                         { push_type (tp_function); }
778         ;
779
780 array_mod:      '[' ']'
781                         { $$ = -1; }
782         |       '[' INT ']'
783                         { $$ = $2.val; }
784         ;
785
786 func_mod:       '(' ')'
787                         { $$ = 0; }
788         |       '(' nonempty_typelist ')'
789                         { free ($2); $$ = 0; }
790         ;
791
792 /* We used to try to recognize pointer to member types here, but
793    that didn't work (shift/reduce conflicts meant that these rules never
794    got executed).  The problem is that
795      int (foo::bar::baz::bizzle)
796    is a function type but
797      int (foo::bar::baz::bizzle::*)
798    is a pointer to member type.  Stroustrup loses again!  */
799
800 type    :       ptype
801         ;
802
803 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
804         :       TYPENAME
805                         { $$ = $1.type; }
806         |       INT_KEYWORD
807                         { $$ = builtin_type (current_gdbarch)->builtin_int; }
808         |       LONG
809                         { $$ = builtin_type (current_gdbarch)->builtin_long; }
810         |       SHORT
811                         { $$ = builtin_type (current_gdbarch)->builtin_short; }
812         |       LONG INT_KEYWORD
813                         { $$ = builtin_type (current_gdbarch)->builtin_long; }
814         |       LONG SIGNED_KEYWORD INT_KEYWORD
815                         { $$ = builtin_type (current_gdbarch)->builtin_long; }
816         |       LONG SIGNED_KEYWORD
817                         { $$ = builtin_type (current_gdbarch)->builtin_long; }
818         |       SIGNED_KEYWORD LONG INT_KEYWORD
819                         { $$ = builtin_type (current_gdbarch)->builtin_long; }
820         |       UNSIGNED LONG INT_KEYWORD
821                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
822         |       LONG UNSIGNED INT_KEYWORD
823                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
824         |       LONG UNSIGNED
825                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long; }
826         |       LONG LONG
827                         { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
828         |       LONG LONG INT_KEYWORD
829                         { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
830         |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
831                         { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
832         |       LONG LONG SIGNED_KEYWORD
833                         { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
834         |       SIGNED_KEYWORD LONG LONG
835                         { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
836         |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
837                         { $$ = builtin_type (current_gdbarch)->builtin_long_long; }
838         |       UNSIGNED LONG LONG
839                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
840         |       UNSIGNED LONG LONG INT_KEYWORD
841                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
842         |       LONG LONG UNSIGNED
843                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
844         |       LONG LONG UNSIGNED INT_KEYWORD
845                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_long_long; }
846         |       SHORT INT_KEYWORD
847                         { $$ = builtin_type (current_gdbarch)->builtin_short; }
848         |       SHORT SIGNED_KEYWORD INT_KEYWORD
849                         { $$ = builtin_type (current_gdbarch)->builtin_short; }
850         |       SHORT SIGNED_KEYWORD
851                         { $$ = builtin_type (current_gdbarch)->builtin_short; }
852         |       UNSIGNED SHORT INT_KEYWORD
853                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
854         |       SHORT UNSIGNED 
855                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
856         |       SHORT UNSIGNED INT_KEYWORD
857                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_short; }
858         |       DOUBLE_KEYWORD
859                         { $$ = builtin_type (current_gdbarch)->builtin_double; }
860         |       LONG DOUBLE_KEYWORD
861                         { $$ = builtin_type (current_gdbarch)->builtin_long_double; }
862         |       STRUCT name
863                         { $$ = lookup_struct (copy_name ($2),
864                                               expression_context_block); }
865         |       CLASS name
866                         { $$ = lookup_struct (copy_name ($2),
867                                               expression_context_block); }
868         |       UNION name
869                         { $$ = lookup_union (copy_name ($2),
870                                              expression_context_block); }
871         |       ENUM name
872                         { $$ = lookup_enum (copy_name ($2),
873                                             expression_context_block); }
874         |       UNSIGNED typename
875                         { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
876         |       UNSIGNED
877                         { $$ = builtin_type (current_gdbarch)->builtin_unsigned_int; }
878         |       SIGNED_KEYWORD typename
879                         { $$ = lookup_signed_typename (TYPE_NAME($2.type)); }
880         |       SIGNED_KEYWORD
881                         { $$ = builtin_type (current_gdbarch)->builtin_int; }
882                 /* It appears that this rule for templates is never
883                    reduced; template recognition happens by lookahead
884                    in the token processing code in yylex. */         
885         |       TEMPLATE name '<' type '>'
886                         { $$ = lookup_template_type(copy_name($2), $4,
887                                                     expression_context_block);
888                         }
889         | const_or_volatile_or_space_identifier_noopt typebase 
890                         { $$ = follow_types ($2); }
891         | typebase const_or_volatile_or_space_identifier_noopt 
892                         { $$ = follow_types ($1); }
893         | qualified_type
894         ;
895
896 /* FIXME: carlton/2003-09-25: This next bit leads to lots of
897    reduce-reduce conflicts, because the parser doesn't know whether or
898    not to use qualified_name or qualified_type: the rules are
899    identical.  If the parser is parsing 'A::B::x', then, when it sees
900    the second '::', it knows that the expression to the left of it has
901    to be a type, so it uses qualified_type.  But if it is parsing just
902    'A::B', then it doesn't have any way of knowing which rule to use,
903    so there's a reduce-reduce conflict; it picks qualified_name, since
904    that occurs earlier in this file than qualified_type.
905
906    There's no good way to fix this with the grammar as it stands; as
907    far as I can tell, some of the problems arise from ambiguities that
908    GDB introduces ('start' can be either an expression or a type), but
909    some of it is inherent to the nature of C++ (you want to treat the
910    input "(FOO)" fairly differently depending on whether FOO is an
911    expression or a type, and if FOO is a complex expression, this can
912    be hard to determine at the right time).  Fortunately, it works
913    pretty well in most cases.  For example, if you do 'ptype A::B',
914    where A::B is a nested type, then the parser will mistakenly
915    misidentify it as an expression; but evaluate_subexp will get
916    called with 'noside' set to EVAL_AVOID_SIDE_EFFECTS, and everything
917    will work out anyways.  But there are situations where the parser
918    will get confused: the most common one that I've run into is when
919    you want to do
920
921      print *((A::B *) x)"
922
923    where the parser doesn't realize that A::B has to be a type until
924    it hits the first right paren, at which point it's too late.  (The
925    workaround is to type "print *(('A::B' *) x)" instead.)  (And
926    another solution is to fix our symbol-handling code so that the
927    user never wants to type something like that in the first place,
928    because we get all the types right without the user's help!)
929
930    Perhaps we could fix this by making the lexer smarter.  Some of
931    this functionality used to be in the lexer, but in a way that
932    worked even less well than the current solution: that attempt
933    involved having the parser sometimes handle '::' and having the
934    lexer sometimes handle it, and without a clear division of
935    responsibility, it quickly degenerated into a big mess.  Probably
936    the eventual correct solution will give more of a role to the lexer
937    (ideally via code that is shared between the lexer and
938    decode_line_1), but I'm not holding my breath waiting for somebody
939    to get around to cleaning this up...  */
940
941 qualified_type: typebase COLONCOLON name
942                 {
943                   struct type *type = $1;
944                   struct type *new_type;
945                   char *ncopy = alloca ($3.length + 1);
946
947                   memcpy (ncopy, $3.ptr, $3.length);
948                   ncopy[$3.length] = '\0';
949
950                   if (TYPE_CODE (type) != TYPE_CODE_STRUCT
951                       && TYPE_CODE (type) != TYPE_CODE_UNION
952                       && TYPE_CODE (type) != TYPE_CODE_NAMESPACE)
953                     error ("`%s' is not defined as an aggregate type.",
954                            TYPE_NAME (type));
955
956                   new_type = cp_lookup_nested_type (type, ncopy,
957                                                     expression_context_block);
958                   if (new_type == NULL)
959                     error ("No type \"%s\" within class or namespace \"%s\".",
960                            ncopy, TYPE_NAME (type));
961                   
962                   $$ = new_type;
963                 }
964         ;
965
966 typename:       TYPENAME
967         |       INT_KEYWORD
968                 {
969                   $$.stoken.ptr = "int";
970                   $$.stoken.length = 3;
971                   $$.type = builtin_type (current_gdbarch)->builtin_int;
972                 }
973         |       LONG
974                 {
975                   $$.stoken.ptr = "long";
976                   $$.stoken.length = 4;
977                   $$.type = builtin_type (current_gdbarch)->builtin_long;
978                 }
979         |       SHORT
980                 {
981                   $$.stoken.ptr = "short";
982                   $$.stoken.length = 5;
983                   $$.type = builtin_type (current_gdbarch)->builtin_short;
984                 }
985         ;
986
987 nonempty_typelist
988         :       type
989                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
990                   $<ivec>$[0] = 1;      /* Number of types in vector */
991                   $$[1] = $1;
992                 }
993         |       nonempty_typelist ',' type
994                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
995                   $$ = (struct type **) realloc ((char *) $1, len);
996                   $$[$<ivec>$[0]] = $3;
997                 }
998         ;
999
1000 ptype   :       typebase
1001         |       ptype const_or_volatile_or_space_identifier abs_decl const_or_volatile_or_space_identifier
1002                 { $$ = follow_types ($1); }
1003         ;
1004
1005 const_and_volatile:     CONST_KEYWORD VOLATILE_KEYWORD
1006         |               VOLATILE_KEYWORD CONST_KEYWORD
1007         ;
1008
1009 const_or_volatile_noopt:        const_and_volatile 
1010                         { push_type (tp_const);
1011                           push_type (tp_volatile); 
1012                         }
1013         |               CONST_KEYWORD
1014                         { push_type (tp_const); }
1015         |               VOLATILE_KEYWORD
1016                         { push_type (tp_volatile); }
1017         ;
1018
1019 name    :       NAME { $$ = $1.stoken; }
1020         |       BLOCKNAME { $$ = $1.stoken; }
1021         |       TYPENAME { $$ = $1.stoken; }
1022         |       NAME_OR_INT  { $$ = $1.stoken; }
1023         ;
1024
1025 name_not_typename :     NAME
1026         |       BLOCKNAME
1027 /* These would be useful if name_not_typename was useful, but it is just
1028    a fake for "variable", so these cause reduce/reduce conflicts because
1029    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
1030    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
1031    context where only a name could occur, this might be useful.
1032         |       NAME_OR_INT
1033  */
1034         ;
1035
1036 %%
1037
1038 /* Take care of parsing a number (anything that starts with a digit).
1039    Set yylval and return the token type; update lexptr.
1040    LEN is the number of characters in it.  */
1041
1042 /*** Needs some error checking for the float case ***/
1043
1044 static int
1045 parse_number (p, len, parsed_float, putithere)
1046      char *p;
1047      int len;
1048      int parsed_float;
1049      YYSTYPE *putithere;
1050 {
1051   /* FIXME: Shouldn't these be unsigned?  We don't deal with negative values
1052      here, and we do kind of silly things like cast to unsigned.  */
1053   LONGEST n = 0;
1054   LONGEST prevn = 0;
1055   ULONGEST un;
1056
1057   int i = 0;
1058   int c;
1059   int base = input_radix;
1060   int unsigned_p = 0;
1061
1062   /* Number of "L" suffixes encountered.  */
1063   int long_p = 0;
1064
1065   /* We have found a "L" or "U" suffix.  */
1066   int found_suffix = 0;
1067
1068   ULONGEST high_bit;
1069   struct type *signed_type;
1070   struct type *unsigned_type;
1071
1072   if (parsed_float)
1073     {
1074       /* It's a float since it contains a point or an exponent.  */
1075       char *s = malloc (len);
1076       int num = 0;      /* number of tokens scanned by scanf */
1077       char saved_char = p[len];
1078
1079       p[len] = 0;       /* null-terminate the token */
1080       num = sscanf (p, DOUBLEST_SCAN_FORMAT "%s",
1081                     &putithere->typed_val_float.dval, s);
1082       p[len] = saved_char;      /* restore the input stream */
1083
1084       if (num == 1)
1085         putithere->typed_val_float.type = 
1086           builtin_type (current_gdbarch)->builtin_double;
1087
1088       if (num == 2 )
1089         {
1090           /* See if it has any float suffix: 'f' for float, 'l' for long 
1091              double.  */
1092           if (!strcasecmp (s, "f"))
1093             putithere->typed_val_float.type = 
1094               builtin_type (current_gdbarch)->builtin_float;
1095           else if (!strcasecmp (s, "l"))
1096             putithere->typed_val_float.type = 
1097               builtin_type (current_gdbarch)->builtin_long_double;
1098           else
1099             {
1100               free (s);
1101               return ERROR;
1102             }
1103         }
1104
1105       free (s);
1106       return FLOAT;
1107     }
1108
1109   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
1110   if (p[0] == '0')
1111     switch (p[1])
1112       {
1113       case 'x':
1114       case 'X':
1115         if (len >= 3)
1116           {
1117             p += 2;
1118             base = 16;
1119             len -= 2;
1120           }
1121         break;
1122
1123       case 't':
1124       case 'T':
1125       case 'd':
1126       case 'D':
1127         if (len >= 3)
1128           {
1129             p += 2;
1130             base = 10;
1131             len -= 2;
1132           }
1133         break;
1134
1135       default:
1136         base = 8;
1137         break;
1138       }
1139
1140   while (len-- > 0)
1141     {
1142       c = *p++;
1143       if (c >= 'A' && c <= 'Z')
1144         c += 'a' - 'A';
1145       if (c != 'l' && c != 'u')
1146         n *= base;
1147       if (c >= '0' && c <= '9')
1148         {
1149           if (found_suffix)
1150             return ERROR;
1151           n += i = c - '0';
1152         }
1153       else
1154         {
1155           if (base > 10 && c >= 'a' && c <= 'f')
1156             {
1157               if (found_suffix)
1158                 return ERROR;
1159               n += i = c - 'a' + 10;
1160             }
1161           else if (c == 'l')
1162             {
1163               ++long_p;
1164               found_suffix = 1;
1165             }
1166           else if (c == 'u')
1167             {
1168               unsigned_p = 1;
1169               found_suffix = 1;
1170             }
1171           else
1172             return ERROR;       /* Char not a digit */
1173         }
1174       if (i >= base)
1175         return ERROR;           /* Invalid digit in this base */
1176
1177       /* Portably test for overflow (only works for nonzero values, so make
1178          a second check for zero).  FIXME: Can't we just make n and prevn
1179          unsigned and avoid this?  */
1180       if (c != 'l' && c != 'u' && (prevn >= n) && n != 0)
1181         unsigned_p = 1;         /* Try something unsigned */
1182
1183       /* Portably test for unsigned overflow.
1184          FIXME: This check is wrong; for example it doesn't find overflow
1185          on 0x123456789 when LONGEST is 32 bits.  */
1186       if (c != 'l' && c != 'u' && n != 0)
1187         {       
1188           if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n))
1189             error ("Numeric constant too large.");
1190         }
1191       prevn = n;
1192     }
1193
1194   /* An integer constant is an int, a long, or a long long.  An L
1195      suffix forces it to be long; an LL suffix forces it to be long
1196      long.  If not forced to a larger size, it gets the first type of
1197      the above that it fits in.  To figure out whether it fits, we
1198      shift it right and see whether anything remains.  Note that we
1199      can't shift sizeof (LONGEST) * HOST_CHAR_BIT bits or more in one
1200      operation, because many compilers will warn about such a shift
1201      (which always produces a zero result).  Sometimes gdbarch_int_bit
1202      or gdbarch_long_bit will be that big, sometimes not.  To deal with
1203      the case where it is we just always shift the value more than
1204      once, with fewer bits each time.  */
1205
1206   un = (ULONGEST)n >> 2;
1207   if (long_p == 0
1208       && (un >> (gdbarch_int_bit (current_gdbarch) - 2)) == 0)
1209     {
1210       high_bit = ((ULONGEST)1) << (gdbarch_int_bit (current_gdbarch) - 1);
1211
1212       /* A large decimal (not hex or octal) constant (between INT_MAX
1213          and UINT_MAX) is a long or unsigned long, according to ANSI,
1214          never an unsigned int, but this code treats it as unsigned
1215          int.  This probably should be fixed.  GCC gives a warning on
1216          such constants.  */
1217
1218       unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_int;
1219       signed_type = builtin_type (current_gdbarch)->builtin_int;
1220     }
1221   else if (long_p <= 1
1222            && (un >> (gdbarch_long_bit (current_gdbarch) - 2)) == 0)
1223     {
1224       high_bit = ((ULONGEST)1) << (gdbarch_long_bit (current_gdbarch) - 1);
1225       unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long;
1226       signed_type = builtin_type (current_gdbarch)->builtin_long;
1227     }
1228   else
1229     {
1230       int shift;
1231       if (sizeof (ULONGEST) * HOST_CHAR_BIT 
1232           < gdbarch_long_long_bit (current_gdbarch))
1233         /* A long long does not fit in a LONGEST.  */
1234         shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
1235       else
1236         shift = (gdbarch_long_long_bit (current_gdbarch) - 1);
1237       high_bit = (ULONGEST) 1 << shift;
1238       unsigned_type = builtin_type (current_gdbarch)->builtin_unsigned_long_long;
1239       signed_type = builtin_type (current_gdbarch)->builtin_long_long;
1240     }
1241
1242    putithere->typed_val_int.val = n;
1243
1244    /* If the high bit of the worked out type is set then this number
1245       has to be unsigned. */
1246
1247    if (unsigned_p || (n & high_bit)) 
1248      {
1249        putithere->typed_val_int.type = unsigned_type;
1250      }
1251    else 
1252      {
1253        putithere->typed_val_int.type = signed_type;
1254      }
1255
1256    return INT;
1257 }
1258
1259 struct token
1260 {
1261   char *operator;
1262   int token;
1263   enum exp_opcode opcode;
1264 };
1265
1266 static const struct token tokentab3[] =
1267   {
1268     {">>=", ASSIGN_MODIFY, BINOP_RSH},
1269     {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1270   };
1271
1272 static const struct token tokentab2[] =
1273   {
1274     {"+=", ASSIGN_MODIFY, BINOP_ADD},
1275     {"-=", ASSIGN_MODIFY, BINOP_SUB},
1276     {"*=", ASSIGN_MODIFY, BINOP_MUL},
1277     {"/=", ASSIGN_MODIFY, BINOP_DIV},
1278     {"%=", ASSIGN_MODIFY, BINOP_REM},
1279     {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
1280     {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
1281     {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
1282     {"++", INCREMENT, BINOP_END},
1283     {"--", DECREMENT, BINOP_END},
1284     {"->", ARROW, BINOP_END},
1285     {"&&", ANDAND, BINOP_END},
1286     {"||", OROR, BINOP_END},
1287     {"::", COLONCOLON, BINOP_END},
1288     {"<<", LSH, BINOP_END},
1289     {">>", RSH, BINOP_END},
1290     {"==", EQUAL, BINOP_END},
1291     {"!=", NOTEQUAL, BINOP_END},
1292     {"<=", LEQ, BINOP_END},
1293     {">=", GEQ, BINOP_END}
1294   };
1295
1296 /* Read one token, getting characters through lexptr.  */
1297
1298 static int
1299 yylex ()
1300 {
1301   int c;
1302   int namelen;
1303   unsigned int i;
1304   char *tokstart;
1305   char *tokptr;
1306   int tempbufindex;
1307   static char *tempbuf;
1308   static int tempbufsize;
1309   char * token_string = NULL;
1310   int class_prefix = 0;
1311    
1312  retry:
1313
1314   /* Check if this is a macro invocation that we need to expand.  */
1315   if (! scanning_macro_expansion ())
1316     {
1317       char *expanded = macro_expand_next (&lexptr,
1318                                           expression_macro_lookup_func,
1319                                           expression_macro_lookup_baton);
1320
1321       if (expanded)
1322         scan_macro_expansion (expanded);
1323     }
1324
1325   prev_lexptr = lexptr;
1326
1327   tokstart = lexptr;
1328   /* See if it is a special token of length 3.  */
1329   for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1330     if (strncmp (tokstart, tokentab3[i].operator, 3) == 0)
1331       {
1332         lexptr += 3;
1333         yylval.opcode = tokentab3[i].opcode;
1334         return tokentab3[i].token;
1335       }
1336
1337   /* See if it is a special token of length 2.  */
1338   for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1339     if (strncmp (tokstart, tokentab2[i].operator, 2) == 0)
1340       {
1341         lexptr += 2;
1342         yylval.opcode = tokentab2[i].opcode;
1343         return tokentab2[i].token;
1344       }
1345
1346   switch (c = *tokstart)
1347     {
1348     case 0:
1349       /* If we were just scanning the result of a macro expansion,
1350          then we need to resume scanning the original text.
1351          Otherwise, we were already scanning the original text, and
1352          we're really done.  */
1353       if (scanning_macro_expansion ())
1354         {
1355           finished_macro_expansion ();
1356           goto retry;
1357         }
1358       else
1359         return 0;
1360
1361     case ' ':
1362     case '\t':
1363     case '\n':
1364       lexptr++;
1365       goto retry;
1366
1367     case '\'':
1368       /* We either have a character constant ('0' or '\177' for example)
1369          or we have a quoted symbol reference ('foo(int,int)' in C++
1370          for example). */
1371       lexptr++;
1372       c = *lexptr++;
1373       if (c == '\\')
1374         c = parse_escape (&lexptr);
1375       else if (c == '\'')
1376         error ("Empty character constant.");
1377       else if (! host_char_to_target (c, &c))
1378         {
1379           int toklen = lexptr - tokstart + 1;
1380           char *tok = alloca (toklen + 1);
1381           memcpy (tok, tokstart, toklen);
1382           tok[toklen] = '\0';
1383           error ("There is no character corresponding to %s in the target "
1384                  "character set `%s'.", tok, target_charset ());
1385         }
1386
1387       yylval.typed_val_int.val = c;
1388       yylval.typed_val_int.type = builtin_type (current_gdbarch)->builtin_char;
1389
1390       c = *lexptr++;
1391       if (c != '\'')
1392         {
1393           namelen = skip_quoted (tokstart) - tokstart;
1394           if (namelen > 2)
1395             {
1396               lexptr = tokstart + namelen;
1397               if (lexptr[-1] != '\'')
1398                 error ("Unmatched single quote.");
1399               namelen -= 2;
1400               tokstart++;
1401               goto tryname;
1402             }
1403           error ("Invalid character constant.");
1404         }
1405       return INT;
1406
1407     case '(':
1408       paren_depth++;
1409       lexptr++;
1410       return c;
1411
1412     case ')':
1413       if (paren_depth == 0)
1414         return 0;
1415       paren_depth--;
1416       lexptr++;
1417       return c;
1418
1419     case ',':
1420       if (comma_terminates
1421           && paren_depth == 0
1422           && ! scanning_macro_expansion ())
1423         return 0;
1424       lexptr++;
1425       return c;
1426
1427     case '.':
1428       /* Might be a floating point number.  */
1429       if (lexptr[1] < '0' || lexptr[1] > '9')
1430         goto symbol;            /* Nope, must be a symbol. */
1431       /* FALL THRU into number case.  */
1432
1433     case '0':
1434     case '1':
1435     case '2':
1436     case '3':
1437     case '4':
1438     case '5':
1439     case '6':
1440     case '7':
1441     case '8':
1442     case '9':
1443       {
1444         /* It's a number.  */
1445         int got_dot = 0, got_e = 0, toktype;
1446         char *p = tokstart;
1447         int hex = input_radix > 10;
1448
1449         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1450           {
1451             p += 2;
1452             hex = 1;
1453           }
1454         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1455           {
1456             p += 2;
1457             hex = 0;
1458           }
1459
1460         for (;; ++p)
1461           {
1462             /* This test includes !hex because 'e' is a valid hex digit
1463                and thus does not indicate a floating point number when
1464                the radix is hex.  */
1465             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1466               got_dot = got_e = 1;
1467             /* This test does not include !hex, because a '.' always indicates
1468                a decimal floating point number regardless of the radix.  */
1469             else if (!got_dot && *p == '.')
1470               got_dot = 1;
1471             else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1472                      && (*p == '-' || *p == '+'))
1473               /* This is the sign of the exponent, not the end of the
1474                  number.  */
1475               continue;
1476             /* We will take any letters or digits.  parse_number will
1477                complain if past the radix, or if L or U are not final.  */
1478             else if ((*p < '0' || *p > '9')
1479                      && ((*p < 'a' || *p > 'z')
1480                                   && (*p < 'A' || *p > 'Z')))
1481               break;
1482           }
1483         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1484         if (toktype == ERROR)
1485           {
1486             char *err_copy = (char *) alloca (p - tokstart + 1);
1487
1488             memcpy (err_copy, tokstart, p - tokstart);
1489             err_copy[p - tokstart] = 0;
1490             error ("Invalid number \"%s\".", err_copy);
1491           }
1492         lexptr = p;
1493         return toktype;
1494       }
1495
1496     case '+':
1497     case '-':
1498     case '*':
1499     case '/':
1500     case '%':
1501     case '|':
1502     case '&':
1503     case '^':
1504     case '~':
1505     case '!':
1506     case '@':
1507     case '<':
1508     case '>':
1509     case '[':
1510     case ']':
1511     case '?':
1512     case ':':
1513     case '=':
1514     case '{':
1515     case '}':
1516     symbol:
1517       lexptr++;
1518       return c;
1519
1520     case '"':
1521
1522       /* Build the gdb internal form of the input string in tempbuf,
1523          translating any standard C escape forms seen.  Note that the
1524          buffer is null byte terminated *only* for the convenience of
1525          debugging gdb itself and printing the buffer contents when
1526          the buffer contains no embedded nulls.  Gdb does not depend
1527          upon the buffer being null byte terminated, it uses the length
1528          string instead.  This allows gdb to handle C strings (as well
1529          as strings in other languages) with embedded null bytes */
1530
1531       tokptr = ++tokstart;
1532       tempbufindex = 0;
1533
1534       do {
1535         char *char_start_pos = tokptr;
1536
1537         /* Grow the static temp buffer if necessary, including allocating
1538            the first one on demand. */
1539         if (tempbufindex + 1 >= tempbufsize)
1540           {
1541             tempbuf = (char *) realloc (tempbuf, tempbufsize += 64);
1542           }
1543         switch (*tokptr)
1544           {
1545           case '\0':
1546           case '"':
1547             /* Do nothing, loop will terminate. */
1548             break;
1549           case '\\':
1550             tokptr++;
1551             c = parse_escape (&tokptr);
1552             if (c == -1)
1553               {
1554                 continue;
1555               }
1556             tempbuf[tempbufindex++] = c;
1557             break;
1558           default:
1559             c = *tokptr++;
1560             if (! host_char_to_target (c, &c))
1561               {
1562                 int len = tokptr - char_start_pos;
1563                 char *copy = alloca (len + 1);
1564                 memcpy (copy, char_start_pos, len);
1565                 copy[len] = '\0';
1566
1567                 error ("There is no character corresponding to `%s' "
1568                        "in the target character set `%s'.",
1569                        copy, target_charset ());
1570               }
1571             tempbuf[tempbufindex++] = c;
1572             break;
1573           }
1574       } while ((*tokptr != '"') && (*tokptr != '\0'));
1575       if (*tokptr++ != '"')
1576         {
1577           error ("Unterminated string in expression.");
1578         }
1579       tempbuf[tempbufindex] = '\0';     /* See note above */
1580       yylval.sval.ptr = tempbuf;
1581       yylval.sval.length = tempbufindex;
1582       lexptr = tokptr;
1583       return (STRING);
1584     }
1585
1586   if (!(c == '_' || c == '$'
1587         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1588     /* We must have come across a bad character (e.g. ';').  */
1589     error ("Invalid character '%c' in expression.", c);
1590
1591   /* It's a name.  See how long it is.  */
1592   namelen = 0;
1593   for (c = tokstart[namelen];
1594        (c == '_' || c == '$' || (c >= '0' && c <= '9')
1595         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '<');)
1596     {
1597       /* Template parameter lists are part of the name.
1598          FIXME: This mishandles `print $a<4&&$a>3'.  */
1599
1600       if (c == '<')
1601         { 
1602                /* Scan ahead to get rest of the template specification.  Note
1603                   that we look ahead only when the '<' adjoins non-whitespace
1604                   characters; for comparison expressions, e.g. "a < b > c",
1605                   there must be spaces before the '<', etc. */
1606                
1607                char * p = find_template_name_end (tokstart + namelen);
1608                if (p)
1609                  namelen = p - tokstart;
1610                break;
1611         }
1612       c = tokstart[++namelen];
1613     }
1614
1615   /* The token "if" terminates the expression and is NOT removed from
1616      the input stream.  It doesn't count if it appears in the
1617      expansion of a macro.  */
1618   if (namelen == 2
1619       && tokstart[0] == 'i'
1620       && tokstart[1] == 'f'
1621       && ! scanning_macro_expansion ())
1622     {
1623       return 0;
1624     }
1625
1626   lexptr += namelen;
1627
1628   tryname:
1629
1630   /* Catch specific keywords.  Should be done with a data structure.  */
1631   switch (namelen)
1632     {
1633     case 8:
1634       if (strncmp (tokstart, "unsigned", 8) == 0)
1635         return UNSIGNED;
1636       if (current_language->la_language == language_cplus
1637           && strncmp (tokstart, "template", 8) == 0)
1638         return TEMPLATE;
1639       if (strncmp (tokstart, "volatile", 8) == 0)
1640         return VOLATILE_KEYWORD;
1641       break;
1642     case 6:
1643       if (strncmp (tokstart, "struct", 6) == 0)
1644         return STRUCT;
1645       if (strncmp (tokstart, "signed", 6) == 0)
1646         return SIGNED_KEYWORD;
1647       if (strncmp (tokstart, "sizeof", 6) == 0)
1648         return SIZEOF;
1649       if (strncmp (tokstart, "double", 6) == 0)
1650         return DOUBLE_KEYWORD;
1651       break;
1652     case 5:
1653       if (current_language->la_language == language_cplus)
1654         {
1655           if (strncmp (tokstart, "false", 5) == 0)
1656             return FALSEKEYWORD;
1657           if (strncmp (tokstart, "class", 5) == 0)
1658             return CLASS;
1659         }
1660       if (strncmp (tokstart, "union", 5) == 0)
1661         return UNION;
1662       if (strncmp (tokstart, "short", 5) == 0)
1663         return SHORT;
1664       if (strncmp (tokstart, "const", 5) == 0)
1665         return CONST_KEYWORD;
1666       break;
1667     case 4:
1668       if (strncmp (tokstart, "enum", 4) == 0)
1669         return ENUM;
1670       if (strncmp (tokstart, "long", 4) == 0)
1671         return LONG;
1672       if (current_language->la_language == language_cplus)
1673           {
1674             if (strncmp (tokstart, "true", 4) == 0)
1675               return TRUEKEYWORD;
1676           }
1677       break;
1678     case 3:
1679       if (strncmp (tokstart, "int", 3) == 0)
1680         return INT_KEYWORD;
1681       break;
1682     default:
1683       break;
1684     }
1685
1686   yylval.sval.ptr = tokstart;
1687   yylval.sval.length = namelen;
1688
1689   if (*tokstart == '$')
1690     {
1691       write_dollar_variable (yylval.sval);
1692       return VARIABLE;
1693     }
1694   
1695   /* Use token-type BLOCKNAME for symbols that happen to be defined as
1696      functions or symtabs.  If this is not so, then ...
1697      Use token-type TYPENAME for symbols that happen to be defined
1698      currently as names of types; NAME for other symbols.
1699      The caller is not constrained to care about the distinction.  */
1700   {
1701     char *tmp = copy_name (yylval.sval);
1702     struct symbol *sym;
1703     int is_a_field_of_this = 0;
1704     int hextype;
1705
1706     sym = lookup_symbol (tmp, expression_context_block,
1707                          VAR_DOMAIN,
1708                          current_language->la_language == language_cplus
1709                          ? &is_a_field_of_this : (int *) NULL,
1710                          (struct symtab **) NULL);
1711     /* Call lookup_symtab, not lookup_partial_symtab, in case there are
1712        no psymtabs (coff, xcoff, or some future change to blow away the
1713        psymtabs once once symbols are read).  */
1714     if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1715       {
1716         yylval.ssym.sym = sym;
1717         yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1718         return BLOCKNAME;
1719       }
1720     else if (!sym)
1721       {                         /* See if it's a file name. */
1722         struct symtab *symtab;
1723
1724         symtab = lookup_symtab (tmp);
1725
1726         if (symtab)
1727           {
1728             yylval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1729             return FILENAME;
1730           }
1731       }
1732
1733     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1734         {
1735           /* NOTE: carlton/2003-09-25: There used to be code here to
1736              handle nested types.  It didn't work very well.  See the
1737              comment before qualified_type for more info.  */
1738           yylval.tsym.type = SYMBOL_TYPE (sym);
1739           return TYPENAME;
1740         }
1741     yylval.tsym.type
1742       = language_lookup_primitive_type_by_name (current_language,
1743                                                 current_gdbarch, tmp);
1744     if (yylval.tsym.type != NULL)
1745       return TYPENAME;
1746
1747     /* Input names that aren't symbols but ARE valid hex numbers,
1748        when the input radix permits them, can be names or numbers
1749        depending on the parse.  Note we support radixes > 16 here.  */
1750     if (!sym && 
1751         ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1752          (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1753       {
1754         YYSTYPE newlval;        /* Its value is ignored.  */
1755         hextype = parse_number (tokstart, namelen, 0, &newlval);
1756         if (hextype == INT)
1757           {
1758             yylval.ssym.sym = sym;
1759             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1760             return NAME_OR_INT;
1761           }
1762       }
1763
1764     /* Any other kind of symbol */
1765     yylval.ssym.sym = sym;
1766     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1767     return NAME;
1768   }
1769 }
1770
1771 void
1772 yyerror (msg)
1773      char *msg;
1774 {
1775   if (prev_lexptr)
1776     lexptr = prev_lexptr;
1777
1778   error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1779 }