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