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