projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Oops, forgot depend!
[deliverable/binutils-gdb.git] / gdb / c-exp.y
CommitLineData
3d6b6a90
JG		 1/* YACC parser for C expressions, for GDB.
2 Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc.
3
4This file is part of GDB.
5
6This program is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2 of the License, or
9(at your option) any later version.
10
11This program is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with this program; if not, write to the Free Software
18Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20/* Parse a C expression from text in a string,
21 and return the result as a struct expression pointer.
22 That structure contains arithmetic operations in reverse polish,
23 with constants represented by operations that are followed by special data.
24 See expression.h for the details of the format.
25 What is important here is that it can be built up sequentially
26 during the process of parsing; the lower levels of the tree always
27 come first in the result. */
28
29%{
30
31#include <stdio.h>
32#include <string.h>
33#include "defs.h"
3d6b6a90 34#include "symtab.h"
1ab3bf1b 35#include "gdbtypes.h"
3d6b6a90
JG		 36#include "frame.h"
37#include "expression.h"
38#include "parser-defs.h"
39#include "value.h"
40#include "language.h"
ac88ca20
JG		 41#include "bfd.h"
42#include "symfile.h"
43#include "objfiles.h"
3d6b6a90 44
318bf84f
FF		 45/* Ensure that if the generated parser contains any calls to malloc/realloc,
46 that they get mapped to xmalloc/xrealloc. */
47
48#define malloc xmalloc
49#define realloc xrealloc
50
3d6b6a90
JG		 51/* These MUST be included in any grammar file!!!!
52 Please choose unique names! */
d018c8a6 53#define yymaxdepth c_maxdepth
3d6b6a90
JG		 54#define yyparse c_parse
55#define yylex c_lex
56#define yyerror c_error
57#define yylval c_lval
58#define yychar c_char
59#define yydebug c_debug
60#define yypact c_pact
61#define yyr1 c_r1
62#define yyr2 c_r2
63#define yydef c_def
64#define yychk c_chk
65#define yypgo c_pgo
66#define yyact c_act
67#define yyexca c_exca
9ce7cb7c
SG		 68#define yyerrflag c_errflag
69#define yynerrs c_nerrs
39bf5952
JG		 70#define yyps c_ps
71#define yypv c_pv
72#define yys c_s
d018c8a6 73#define yy_yys c_yys
39bf5952
JG		 74#define yystate c_state
75#define yytmp c_tmp
76#define yyv c_v
d018c8a6 77#define yy_yyv c_yyv
39bf5952
JG		 78#define yyval c_val
79#define yylloc c_lloc
3d6b6a90 80
d26b50b7 81int
1ab3bf1b
JG		 82yyparse PARAMS ((void));
83
84int
85yylex PARAMS ((void));
86
87void
88yyerror PARAMS ((char *));
3d6b6a90
JG		 89
90/* #define YYDEBUG 1 */
91
92%}
93
94/* Although the yacc "value" of an expression is not used,
95 since the result is stored in the structure being created,
96 other node types do have values. */
97
98%union
99 {
100 LONGEST lval;
101 unsigned LONGEST ulval;
102 double dval;
103 struct symbol *sym;
104 struct type *tval;
105 struct stoken sval;
106 struct ttype tsym;
107 struct symtoken ssym;
108 int voidval;
109 struct block *bval;
110 enum exp_opcode opcode;
111 struct internalvar *ivar;
112
113 struct type **tvec;
114 int *ivec;
115 }
116
1ab3bf1b
JG		 117%{
118/* YYSTYPE gets defined by %union */
119static int
120parse_number PARAMS ((char *, int, int, YYSTYPE *));
121%}
122
01be6913 123%type <voidval> exp exp1 type_exp start variable qualified_name
3d6b6a90
JG		 124%type <tval> type typebase
125%type <tvec> nonempty_typelist
126/* %type <bval> block */
127
128/* Fancy type parsing. */
129%type <voidval> func_mod direct_abs_decl abs_decl
130%type <tval> ptype
131%type <lval> array_mod
132
133%token <lval> INT CHAR
134%token <ulval> UINT
135%token <dval> FLOAT
136
137/* Both NAME and TYPENAME tokens represent symbols in the input,
138 and both convey their data as strings.
139 But a TYPENAME is a string that happens to be defined as a typedef
140 or builtin type name (such as int or char)
141 and a NAME is any other symbol.
142 Contexts where this distinction is not important can use the
143 nonterminal "name", which matches either NAME or TYPENAME. */
144
145%token <sval> STRING
146%token <ssym> NAME /* BLOCKNAME defined below to give it higher precedence. */
147%token <tsym> TYPENAME
148%type <sval> name
149%type <ssym> name_not_typename
150%type <tsym> typename
151
152/* A NAME_OR_INT is a symbol which is not known in the symbol table,
153 but which would parse as a valid number in the current input radix.
154 E.g. "c" when input_radix==16. Depending on the parse, it will be
155 turned into a name or into a number. NAME_OR_UINT ditto. */
156
157%token <ssym> NAME_OR_INT NAME_OR_UINT
158
159%token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON
4c53d9ca 160%token TEMPLATE
3d6b6a90
JG		 161%token ERROR
162
163/* Special type cases, put in to allow the parser to distinguish different
164 legal basetypes. */
088c3a0b 165%token SIGNED_KEYWORD LONG SHORT INT_KEYWORD
3d6b6a90
JG		 166
167%token <lval> LAST REGNAME
168
169%token <ivar> VARIABLE
170
171%token <opcode> ASSIGN_MODIFY
172
173/* C++ */
174%token THIS
175
176%left ','
177%left ABOVE_COMMA
178%right '=' ASSIGN_MODIFY
179%right '?'
088c3a0b
JG		 180%left OROR
181%left ANDAND
3d6b6a90
JG		 182%left '|'
183%left '^'
184%left '&'
185%left EQUAL NOTEQUAL
186%left '<' '>' LEQ GEQ
187%left LSH RSH
188%left '@'
189%left '+' '-'
190%left '*' '/' '%'
191%right UNARY INCREMENT DECREMENT
192%right ARROW '.' '[' '('
193%token <ssym> BLOCKNAME
194%type <bval> block
195%left COLONCOLON
196\f
197%%
198
199start : exp1
200 | type_exp
201 ;
202
203type_exp: type
204 { write_exp_elt_opcode(OP_TYPE);
205 write_exp_elt_type($1);
206 write_exp_elt_opcode(OP_TYPE);}
207 ;
208
209/* Expressions, including the comma operator. */
210exp1 : exp
211 | exp1 ',' exp
212 { write_exp_elt_opcode (BINOP_COMMA); }
213 ;
214
215/* Expressions, not including the comma operator. */
216exp : '*' exp %prec UNARY
217 { write_exp_elt_opcode (UNOP_IND); }
218
219exp : '&' exp %prec UNARY
220 { write_exp_elt_opcode (UNOP_ADDR); }
221
222exp : '-' exp %prec UNARY
223 { write_exp_elt_opcode (UNOP_NEG); }
224 ;
225
226exp : '!' exp %prec UNARY
227 { write_exp_elt_opcode (UNOP_ZEROP); }
228 ;
229
230exp : '~' exp %prec UNARY
231 { write_exp_elt_opcode (UNOP_LOGNOT); }
232 ;
233
234exp : INCREMENT exp %prec UNARY
235 { write_exp_elt_opcode (UNOP_PREINCREMENT); }
236 ;
237
238exp : DECREMENT exp %prec UNARY
239 { write_exp_elt_opcode (UNOP_PREDECREMENT); }
240 ;
241
242exp : exp INCREMENT %prec UNARY
243 { write_exp_elt_opcode (UNOP_POSTINCREMENT); }
244 ;
245
246exp : exp DECREMENT %prec UNARY
247 { write_exp_elt_opcode (UNOP_POSTDECREMENT); }
248 ;
249
250exp : SIZEOF exp %prec UNARY
251 { write_exp_elt_opcode (UNOP_SIZEOF); }
252 ;
253
254exp : exp ARROW name
255 { write_exp_elt_opcode (STRUCTOP_PTR);
256 write_exp_string ($3);
257 write_exp_elt_opcode (STRUCTOP_PTR); }
258 ;
259
01be6913
PB		 260exp : exp ARROW qualified_name
261 { /* exp->type::name becomes exp->*(&type::name) */
262 /* Note: this doesn't work if name is a
263 static member! FIXME */
264 write_exp_elt_opcode (UNOP_ADDR);
265 write_exp_elt_opcode (STRUCTOP_MPTR); }
266 ;
3d6b6a90
JG		 267exp : exp ARROW '*' exp
268 { write_exp_elt_opcode (STRUCTOP_MPTR); }
269 ;
270
271exp : exp '.' name
272 { write_exp_elt_opcode (STRUCTOP_STRUCT);
273 write_exp_string ($3);
274 write_exp_elt_opcode (STRUCTOP_STRUCT); }
275 ;
276
01be6913
PB		 277exp : exp '.' qualified_name
278 { /* exp.type::name becomes exp.*(&type::name) */
279 /* Note: this doesn't work if name is a
280 static member! FIXME */
281 write_exp_elt_opcode (UNOP_ADDR);
282 write_exp_elt_opcode (STRUCTOP_MEMBER); }
283 ;
284
3d6b6a90
JG		 285exp : exp '.' '*' exp
286 { write_exp_elt_opcode (STRUCTOP_MEMBER); }
287 ;
288
289exp : exp '[' exp1 ']'
290 { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
291 ;
292
293exp : exp '('
294 /* This is to save the value of arglist_len
295 being accumulated by an outer function call. */
296 { start_arglist (); }
297 arglist ')' %prec ARROW
298 { write_exp_elt_opcode (OP_FUNCALL);
299 write_exp_elt_longcst ((LONGEST) end_arglist ());
300 write_exp_elt_opcode (OP_FUNCALL); }
301 ;
302
303arglist :
304 ;
305
306arglist : exp
307 { arglist_len = 1; }
308 ;
309
310arglist : arglist ',' exp %prec ABOVE_COMMA
311 { arglist_len++; }
312 ;
313
314exp : '{' type '}' exp %prec UNARY
315 { write_exp_elt_opcode (UNOP_MEMVAL);
316 write_exp_elt_type ($2);
317 write_exp_elt_opcode (UNOP_MEMVAL); }
318 ;
319
320exp : '(' type ')' exp %prec UNARY
321 { write_exp_elt_opcode (UNOP_CAST);
322 write_exp_elt_type ($2);
323 write_exp_elt_opcode (UNOP_CAST); }
324 ;
325
326exp : '(' exp1 ')'
327 { }
328 ;
329
330/* Binary operators in order of decreasing precedence. */
331
332exp : exp '@' exp
333 { write_exp_elt_opcode (BINOP_REPEAT); }
334 ;
335
336exp : exp '*' exp
337 { write_exp_elt_opcode (BINOP_MUL); }
338 ;
339
340exp : exp '/' exp
341 { write_exp_elt_opcode (BINOP_DIV); }
342 ;
343
344exp : exp '%' exp
345 { write_exp_elt_opcode (BINOP_REM); }
346 ;
347
348exp : exp '+' exp
349 { write_exp_elt_opcode (BINOP_ADD); }
350 ;
351
352exp : exp '-' exp
353 { write_exp_elt_opcode (BINOP_SUB); }
354 ;
355
356exp : exp LSH exp
357 { write_exp_elt_opcode (BINOP_LSH); }
358 ;
359
360exp : exp RSH exp
361 { write_exp_elt_opcode (BINOP_RSH); }
362 ;
363
364exp : exp EQUAL exp
365 { write_exp_elt_opcode (BINOP_EQUAL); }
366 ;
367
368exp : exp NOTEQUAL exp
369 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
370 ;
371
372exp : exp LEQ exp
373 { write_exp_elt_opcode (BINOP_LEQ); }
374 ;
375
376exp : exp GEQ exp
377 { write_exp_elt_opcode (BINOP_GEQ); }
378 ;
379
380exp : exp '<' exp
381 { write_exp_elt_opcode (BINOP_LESS); }
382 ;
383
384exp : exp '>' exp
385 { write_exp_elt_opcode (BINOP_GTR); }
386 ;
387
388exp : exp '&' exp
389 { write_exp_elt_opcode (BINOP_LOGAND); }
390 ;
391
392exp : exp '^' exp
393 { write_exp_elt_opcode (BINOP_LOGXOR); }
394 ;
395
396exp : exp '|' exp
397 { write_exp_elt_opcode (BINOP_LOGIOR); }
398 ;
399
088c3a0b 400exp : exp ANDAND exp
3d6b6a90
JG		 401 { write_exp_elt_opcode (BINOP_AND); }
402 ;
403
088c3a0b 404exp : exp OROR exp
3d6b6a90
JG		 405 { write_exp_elt_opcode (BINOP_OR); }
406 ;
407
408exp : exp '?' exp ':' exp %prec '?'
409 { write_exp_elt_opcode (TERNOP_COND); }
410 ;
411
412exp : exp '=' exp
413 { write_exp_elt_opcode (BINOP_ASSIGN); }
414 ;
415
416exp : exp ASSIGN_MODIFY exp
417 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
418 write_exp_elt_opcode ($2);
419 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
420 ;
421
422exp : INT
423 { write_exp_elt_opcode (OP_LONG);
424 if ($1 == (int) $1 || $1 == (unsigned int) $1)
425 write_exp_elt_type (builtin_type_int);
426 else
427 write_exp_elt_type (BUILTIN_TYPE_LONGEST);
428 write_exp_elt_longcst ((LONGEST) $1);
429 write_exp_elt_opcode (OP_LONG); }
430 ;
431
432exp : NAME_OR_INT
433 { YYSTYPE val;
434 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
435 write_exp_elt_opcode (OP_LONG);
436 if (val.lval == (int) val.lval ||
437 val.lval == (unsigned int) val.lval)
438 write_exp_elt_type (builtin_type_int);
439 else
440 write_exp_elt_type (BUILTIN_TYPE_LONGEST);
441 write_exp_elt_longcst (val.lval);
442 write_exp_elt_opcode (OP_LONG); }
443 ;
444
445exp : UINT
446 {
447 write_exp_elt_opcode (OP_LONG);
448 if ($1 == (unsigned int) $1)
449 write_exp_elt_type (builtin_type_unsigned_int);
450 else
451 write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
452 write_exp_elt_longcst ((LONGEST) $1);
453 write_exp_elt_opcode (OP_LONG);
454 }
455 ;
456
457exp : NAME_OR_UINT
458 { YYSTYPE val;
459 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
460 write_exp_elt_opcode (OP_LONG);
461 if (val.ulval == (unsigned int) val.ulval)
462 write_exp_elt_type (builtin_type_unsigned_int);
463 else
464 write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST);
465 write_exp_elt_longcst ((LONGEST)val.ulval);
466 write_exp_elt_opcode (OP_LONG);
467 }
468 ;
469
470exp : CHAR
471 { write_exp_elt_opcode (OP_LONG);
472 write_exp_elt_type (builtin_type_char);
473 write_exp_elt_longcst ((LONGEST) $1);
474 write_exp_elt_opcode (OP_LONG); }
475 ;
476
477exp : FLOAT
478 { write_exp_elt_opcode (OP_DOUBLE);
479 write_exp_elt_type (builtin_type_double);
480 write_exp_elt_dblcst ($1);
481 write_exp_elt_opcode (OP_DOUBLE); }
482 ;
483
484exp : variable
485 ;
486
487exp : LAST
488 { write_exp_elt_opcode (OP_LAST);
489 write_exp_elt_longcst ((LONGEST) $1);
490 write_exp_elt_opcode (OP_LAST); }
491 ;
492
493exp : REGNAME
494 { write_exp_elt_opcode (OP_REGISTER);
495 write_exp_elt_longcst ((LONGEST) $1);
496 write_exp_elt_opcode (OP_REGISTER); }
497 ;
498
499exp : VARIABLE
500 { write_exp_elt_opcode (OP_INTERNALVAR);
501 write_exp_elt_intern ($1);
502 write_exp_elt_opcode (OP_INTERNALVAR); }
503 ;
504
505exp : SIZEOF '(' type ')' %prec UNARY
506 { write_exp_elt_opcode (OP_LONG);
507 write_exp_elt_type (builtin_type_int);
508 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
509 write_exp_elt_opcode (OP_LONG); }
510 ;
511
512exp : STRING
513 { write_exp_elt_opcode (OP_STRING);
514 write_exp_string ($1);
515 write_exp_elt_opcode (OP_STRING); }
516 ;
517
518/* C++. */
519exp : THIS
520 { write_exp_elt_opcode (OP_THIS);
521 write_exp_elt_opcode (OP_THIS); }
522 ;
523
524/* end of C++. */
525
526block : BLOCKNAME
527 {
528 if ($1.sym != 0)
529 $$ = SYMBOL_BLOCK_VALUE ($1.sym);
530 else
531 {
532 struct symtab *tem =
533 lookup_symtab (copy_name ($1.stoken));
534 if (tem)
535 $$ = BLOCKVECTOR_BLOCK
536 (BLOCKVECTOR (tem), STATIC_BLOCK);
537 else
538 error ("No file or function \"%s\".",
539 copy_name ($1.stoken));
540 }
541 }
542 ;
543
544block : block COLONCOLON name
545 { struct symbol *tem
546 = lookup_symbol (copy_name ($3), $1,
547 VAR_NAMESPACE, 0, NULL);
548 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
549 error ("No function \"%s\" in specified context.",
550 copy_name ($3));
551 $$ = SYMBOL_BLOCK_VALUE (tem); }
552 ;
553
554variable: block COLONCOLON name
555 { struct symbol *sym;
556 sym = lookup_symbol (copy_name ($3), $1,
557 VAR_NAMESPACE, 0, NULL);
558 if (sym == 0)
559 error ("No symbol \"%s\" in specified context.",
560 copy_name ($3));
561
562 write_exp_elt_opcode (OP_VAR_VALUE);
563 write_exp_elt_sym (sym);
564 write_exp_elt_opcode (OP_VAR_VALUE); }
565 ;
566
01be6913 567qualified_name: typebase COLONCOLON name
3d6b6a90
JG		 568 {
569 struct type *type = $1;
570 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
571 && TYPE_CODE (type) != TYPE_CODE_UNION)
572 error ("`%s' is not defined as an aggregate type.",
573 TYPE_NAME (type));
574
575 write_exp_elt_opcode (OP_SCOPE);
576 write_exp_elt_type (type);
577 write_exp_string ($3);
578 write_exp_elt_opcode (OP_SCOPE);
579 }
580 | typebase COLONCOLON '~' name
581 {
582 struct type *type = $1;
01be6913 583 struct stoken tmp_token;
3d6b6a90
JG		 584 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
585 && TYPE_CODE (type) != TYPE_CODE_UNION)
586 error ("`%s' is not defined as an aggregate type.",
587 TYPE_NAME (type));
588
589 if (strcmp (type_name_no_tag (type), $4.ptr))
590 error ("invalid destructor `%s::~%s'",
591 type_name_no_tag (type), $4.ptr);
592
01be6913
PB		 593 tmp_token.ptr = (char*) alloca ($4.length + 2);
594 tmp_token.length = $4.length + 1;
595 tmp_token.ptr[0] = '~';
596 memcpy (tmp_token.ptr+1, $4.ptr, $4.length);
597 tmp_token.ptr[tmp_token.length] = 0;
3d6b6a90
JG		 598 write_exp_elt_opcode (OP_SCOPE);
599 write_exp_elt_type (type);
01be6913 600 write_exp_string (tmp_token);
3d6b6a90 601 write_exp_elt_opcode (OP_SCOPE);
3d6b6a90 602 }
01be6913
PB		 603 ;
604
605variable: qualified_name
3d6b6a90
JG		 606 | COLONCOLON name
607 {
608 char *name = copy_name ($2);
609 struct symbol *sym;
1ab3bf1b 610 struct minimal_symbol *msymbol;
3d6b6a90
JG		 611
612 sym =
613 lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
614 if (sym)
615 {
616 write_exp_elt_opcode (OP_VAR_VALUE);
617 write_exp_elt_sym (sym);
618 write_exp_elt_opcode (OP_VAR_VALUE);
619 break;
620 }
3d6b6a90 621
1ab3bf1b
JG		 622 msymbol = lookup_minimal_symbol (name,
623 (struct objfile *) NULL);
624 if (msymbol != NULL)
3d6b6a90 625 {
3d6b6a90
JG		 626 write_exp_elt_opcode (OP_LONG);
627 write_exp_elt_type (builtin_type_int);
1ab3bf1b 628 write_exp_elt_longcst ((LONGEST) msymbol -> address);
3d6b6a90
JG		 629 write_exp_elt_opcode (OP_LONG);
630 write_exp_elt_opcode (UNOP_MEMVAL);
1ab3bf1b
JG		 631 if (msymbol -> type == mst_data ||
632 msymbol -> type == mst_bss)
3d6b6a90 633 write_exp_elt_type (builtin_type_int);
1ab3bf1b 634 else if (msymbol -> type == mst_text)
3d6b6a90
JG		 635 write_exp_elt_type (lookup_function_type (builtin_type_int));
636 else
637 write_exp_elt_type (builtin_type_char);
638 write_exp_elt_opcode (UNOP_MEMVAL);
639 }
640 else
1ab3bf1b 641 if (!have_full_symbols () && !have_partial_symbols ())
3d6b6a90
JG		 642 error ("No symbol table is loaded. Use the \"file\" command.");
643 else
644 error ("No symbol \"%s\" in current context.", name);
645 }
646 ;
647
648variable: name_not_typename
649 { struct symbol *sym = $1.sym;
650
651 if (sym)
652 {
5b0a744f 653 switch (SYMBOL_CLASS (sym))
3d6b6a90
JG		 654 {
655 case LOC_REGISTER:
656 case LOC_ARG:
657 case LOC_REF_ARG:
658 case LOC_REGPARM:
659 case LOC_LOCAL:
660 case LOC_LOCAL_ARG:
661 if (innermost_block == 0 ||
662 contained_in (block_found,
663 innermost_block))
664 innermost_block = block_found;
665 case LOC_UNDEF:
666 case LOC_CONST:
667 case LOC_STATIC:
668 case LOC_TYPEDEF:
669 case LOC_LABEL:
670 case LOC_BLOCK:
671 case LOC_CONST_BYTES:
672
673 /* In this case the expression can
674 be evaluated regardless of what
675 frame we are in, so there is no
676 need to check for the
677 innermost_block. These cases are
678 listed so that gcc -Wall will
679 report types that may not have
680 been considered. */
681
682 break;
683 }
684 write_exp_elt_opcode (OP_VAR_VALUE);
685 write_exp_elt_sym (sym);
686 write_exp_elt_opcode (OP_VAR_VALUE);
687 }
688 else if ($1.is_a_field_of_this)
689 {
690 /* C++: it hangs off of `this'. Must
691 not inadvertently convert from a method call
692 to data ref. */
693 if (innermost_block == 0 ||
694 contained_in (block_found, innermost_block))
695 innermost_block = block_found;
696 write_exp_elt_opcode (OP_THIS);
697 write_exp_elt_opcode (OP_THIS);
698 write_exp_elt_opcode (STRUCTOP_PTR);
699 write_exp_string ($1.stoken);
700 write_exp_elt_opcode (STRUCTOP_PTR);
701 }
702 else
703 {
1ab3bf1b 704 struct minimal_symbol *msymbol;
3d6b6a90
JG		 705 register char *arg = copy_name ($1.stoken);
706
1ab3bf1b
JG		 707 msymbol = lookup_minimal_symbol (arg,
708 (struct objfile *) NULL);
709 if (msymbol != NULL)
3d6b6a90 710 {
3d6b6a90
JG		 711 write_exp_elt_opcode (OP_LONG);
712 write_exp_elt_type (builtin_type_int);
1ab3bf1b 713 write_exp_elt_longcst ((LONGEST) msymbol -> address);
3d6b6a90
JG		 714 write_exp_elt_opcode (OP_LONG);
715 write_exp_elt_opcode (UNOP_MEMVAL);
1ab3bf1b
JG		 716 if (msymbol -> type == mst_data ||
717 msymbol -> type == mst_bss)
3d6b6a90 718 write_exp_elt_type (builtin_type_int);
1ab3bf1b 719 else if (msymbol -> type == mst_text)
3d6b6a90
JG		 720 write_exp_elt_type (lookup_function_type (builtin_type_int));
721 else
722 write_exp_elt_type (builtin_type_char);
723 write_exp_elt_opcode (UNOP_MEMVAL);
724 }
1ab3bf1b 725 else if (!have_full_symbols () && !have_partial_symbols ())
3d6b6a90
JG		 726 error ("No symbol table is loaded. Use the \"file\" command.");
727 else
728 error ("No symbol \"%s\" in current context.",
729 copy_name ($1.stoken));
730 }
731 }
732 ;
733
734
735ptype : typebase
736 | typebase abs_decl
737 {
738 /* This is where the interesting stuff happens. */
739 int done = 0;
740 int array_size;
741 struct type *follow_type = $1;
742
743 while (!done)
744 switch (pop_type ())
745 {
746 case tp_end:
747 done = 1;
748 break;
749 case tp_pointer:
750 follow_type = lookup_pointer_type (follow_type);
751 break;
752 case tp_reference:
753 follow_type = lookup_reference_type (follow_type);
754 break;
755 case tp_array:
756 array_size = pop_type_int ();
757 if (array_size != -1)
758 follow_type = create_array_type (follow_type,
759 array_size);
760 else
761 follow_type = lookup_pointer_type (follow_type);
762 break;
763 case tp_function:
764 follow_type = lookup_function_type (follow_type);
765 break;
766 }
767 $$ = follow_type;
768 }
769 ;
770
771abs_decl: '*'
772 { push_type (tp_pointer); $$ = 0; }
773 | '*' abs_decl
774 { push_type (tp_pointer); $$ = $2; }
775 | '&'
776 { push_type (tp_reference); $$ = 0; }
777 | '&' abs_decl
778 { push_type (tp_reference); $$ = $2; }
779 | direct_abs_decl
780 ;
781
782direct_abs_decl: '(' abs_decl ')'
783 { $$ = $2; }
784 | direct_abs_decl array_mod
785 {
786 push_type_int ($2);
787 push_type (tp_array);
788 }
789 | array_mod
790 {
791 push_type_int ($1);
792 push_type (tp_array);
793 $$ = 0;
794 }
795 | direct_abs_decl func_mod
796 { push_type (tp_function); }
797 | func_mod
798 { push_type (tp_function); }
799 ;
800
801array_mod: '[' ']'
802 { $$ = -1; }
803 | '[' INT ']'
804 { $$ = $2; }
805 ;
806
807func_mod: '(' ')'
808 { $$ = 0; }
0e2a896c 809 | '(' nonempty_typelist ')'
be772100 810 { free ((PTR)$2); $$ = 0; }
3d6b6a90
JG		 811 ;
812
813type : ptype
814 | typebase COLONCOLON '*'
815 { $$ = lookup_member_type (builtin_type_int, $1); }
816 | type '(' typebase COLONCOLON '*' ')'
817 { $$ = lookup_member_type ($1, $3); }
818 | type '(' typebase COLONCOLON '*' ')' '(' ')'
819 { $$ = lookup_member_type
820 (lookup_function_type ($1), $3); }
821 | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')'
822 { $$ = lookup_member_type
823 (lookup_function_type ($1), $3);
be772100 824 free ((PTR)$8); }
3d6b6a90
JG		 825 ;
826
827typebase
828 : TYPENAME
829 { $$ = $1.type; }
830 | INT_KEYWORD
831 { $$ = builtin_type_int; }
832 | LONG
833 { $$ = builtin_type_long; }
834 | SHORT
835 { $$ = builtin_type_short; }
836 | LONG INT_KEYWORD
837 { $$ = builtin_type_long; }
838 | UNSIGNED LONG INT_KEYWORD
839 { $$ = builtin_type_unsigned_long; }
840 | LONG LONG
841 { $$ = builtin_type_long_long; }
842 | LONG LONG INT_KEYWORD
843 { $$ = builtin_type_long_long; }
844 | UNSIGNED LONG LONG
845 { $$ = builtin_type_unsigned_long_long; }
846 | UNSIGNED LONG LONG INT_KEYWORD
847 { $$ = builtin_type_unsigned_long_long; }
848 | SHORT INT_KEYWORD
849 { $$ = builtin_type_short; }
850 | UNSIGNED SHORT INT_KEYWORD
851 { $$ = builtin_type_unsigned_short; }
852 | STRUCT name
853 { $$ = lookup_struct (copy_name ($2),
854 expression_context_block); }
855 | UNION name
856 { $$ = lookup_union (copy_name ($2),
857 expression_context_block); }
858 | ENUM name
859 { $$ = lookup_enum (copy_name ($2),
860 expression_context_block); }
861 | UNSIGNED typename
862 { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); }
863 | UNSIGNED
864 { $$ = builtin_type_unsigned_int; }
088c3a0b 865 | SIGNED_KEYWORD typename
3d6b6a90 866 { $$ = $2.type; }
088c3a0b 867 | SIGNED_KEYWORD
3d6b6a90 868 { $$ = builtin_type_int; }
4c53d9ca
DHW		 869 | TEMPLATE name '<' type '>'
870 { $$ = lookup_template_type(copy_name($2), $4,
871 expression_context_block);
872 }
3d6b6a90
JG		 873 ;
874
875typename: TYPENAME
876 | INT_KEYWORD
877 {
878 $$.stoken.ptr = "int";
879 $$.stoken.length = 3;
880 $$.type = builtin_type_int;
881 }
882 | LONG
883 {
884 $$.stoken.ptr = "long";
885 $$.stoken.length = 4;
886 $$.type = builtin_type_long;
887 }
888 | SHORT
889 {
890 $$.stoken.ptr = "short";
891 $$.stoken.length = 5;
892 $$.type = builtin_type_short;
893 }
894 ;
895
896nonempty_typelist
897 : type
6c316cfd
FF		 898 { $$ = (struct type **) xmalloc (sizeof (struct type *) * 2);
899 $<ivec>$[0] = 1; /* Number of types in vector */
3d6b6a90
JG		 900 $$[1] = $1;
901 }
902 | nonempty_typelist ',' type
6c316cfd
FF		 903 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
904 $$ = (struct type **) xrealloc ((char *) $1, len);
3d6b6a90
JG		 905 $$[$<ivec>$[0]] = $3;
906 }
907 ;
908
909name : NAME { $$ = $1.stoken; }
910 | BLOCKNAME { $$ = $1.stoken; }
911 | TYPENAME { $$ = $1.stoken; }
912 | NAME_OR_INT { $$ = $1.stoken; }
913 | NAME_OR_UINT { $$ = $1.stoken; }
914 ;
915
916name_not_typename : NAME
917 | BLOCKNAME
918/* These would be useful if name_not_typename was useful, but it is just
919 a fake for "variable", so these cause reduce/reduce conflicts because
920 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
921 =exp) or just an exp. If name_not_typename was ever used in an lvalue
922 context where only a name could occur, this might be useful.
923 | NAME_OR_INT
924 | NAME_OR_UINT
925 */
926 ;
927
928%%
929
930/* Take care of parsing a number (anything that starts with a digit).
931 Set yylval and return the token type; update lexptr.
932 LEN is the number of characters in it. */
933
934/*** Needs some error checking for the float case ***/
935
936static int
937parse_number (p, len, parsed_float, putithere)
938 register char *p;
939 register int len;
940 int parsed_float;
941 YYSTYPE *putithere;
942{
943 register LONGEST n = 0;
944 register LONGEST prevn = 0;
945 register int i;
946 register int c;
947 register int base = input_radix;
948 int unsigned_p = 0;
949
3d6b6a90
JG		 950 if (parsed_float)
951 {
952 /* It's a float since it contains a point or an exponent. */
953 putithere->dval = atof (p);
954 return FLOAT;
955 }
956
957 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
958 if (p[0] == '0')
959 switch (p[1])
960 {
961 case 'x':
962 case 'X':
963 if (len >= 3)
964 {
965 p += 2;
966 base = 16;
967 len -= 2;
968 }
969 break;
970
971 case 't':
972 case 'T':
973 case 'd':
974 case 'D':
975 if (len >= 3)
976 {
977 p += 2;
978 base = 10;
979 len -= 2;
980 }
981 break;
982
983 default:
984 base = 8;
985 break;
986 }
987
988 while (len-- > 0)
989 {
990 c = *p++;
991 if (c >= 'A' && c <= 'Z')
992 c += 'a' - 'A';
993 if (c != 'l' && c != 'u')
994 n *= base;
995 if (c >= '0' && c <= '9')
996 n += i = c - '0';
997 else
998 {
999 if (base > 10 && c >= 'a' && c <= 'f')
1000 n += i = c - 'a' + 10;
1001 else if (len == 0 && c == 'l')
1002 ;
1003 else if (len == 0 && c == 'u')
1004 unsigned_p = 1;
1005 else
1006 return ERROR; /* Char not a digit */
1007 }
1008 if (i >= base)
1009 return ERROR; /* Invalid digit in this base */
2a5ec41d
JG		 1010 /* Portably test for overflow (only works for nonzero values, so make
1011 a second check for zero). */
1012 if((prevn >= n) && n != 0)
3d6b6a90 1013 unsigned_p=1; /* Try something unsigned */
2a5ec41d 1014 /* If range checking enabled, portably test for unsigned overflow. */
3d6b6a90
JG		 1015 if(RANGE_CHECK && n!=0)
1016 {
1017 if((unsigned_p && (unsigned)prevn >= (unsigned)n))
1018 range_error("Overflow on numeric constant.");
1019 }
1020 prevn=n;
1021 }
1022
1023 if (unsigned_p)
1024 {
1025 putithere->ulval = n;
1026 return UINT;
1027 }
1028 else
1029 {
1030 putithere->lval = n;
1031 return INT;
1032 }
1033}
1034
1035struct token
1036{
1037 char *operator;
1038 int token;
1039 enum exp_opcode opcode;
1040};
1041
1042const static struct token tokentab3[] =
1043 {
1044 {">>=", ASSIGN_MODIFY, BINOP_RSH},
1045 {"<<=", ASSIGN_MODIFY, BINOP_LSH}
1046 };
1047
1048const static struct token tokentab2[] =
1049 {
1050 {"+=", ASSIGN_MODIFY, BINOP_ADD},
1051 {"-=", ASSIGN_MODIFY, BINOP_SUB},
1052 {"*=", ASSIGN_MODIFY, BINOP_MUL},
1053 {"/=", ASSIGN_MODIFY, BINOP_DIV},
1054 {"%=", ASSIGN_MODIFY, BINOP_REM},
1055 {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
1056 {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
1057 {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
1058 {"++", INCREMENT, BINOP_END},
1059 {"--", DECREMENT, BINOP_END},
1060 {"->", ARROW, BINOP_END},
088c3a0b
JG		 1061 {"&&", ANDAND, BINOP_END},
1062 {"||", OROR, BINOP_END},
3d6b6a90
JG		 1063 {"::", COLONCOLON, BINOP_END},
1064 {"<<", LSH, BINOP_END},
1065 {">>", RSH, BINOP_END},
1066 {"==", EQUAL, BINOP_END},
1067 {"!=", NOTEQUAL, BINOP_END},
1068 {"<=", LEQ, BINOP_END},
1069 {">=", GEQ, BINOP_END}
1070 };
1071
1072/* Read one token, getting characters through lexptr. */
1073
1074int
1075yylex ()
1076{
1077 register int c;
1078 register int namelen;
1079 register unsigned i;
1080 register char *tokstart;
1081
1082 retry:
1083
1084 tokstart = lexptr;
1085 /* See if it is a special token of length 3. */
1086 for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++)
1087 if (!strncmp (tokstart, tokentab3[i].operator, 3))
1088 {
1089 lexptr += 3;
1090 yylval.opcode = tokentab3[i].opcode;
1091 return tokentab3[i].token;
1092 }
1093
1094 /* See if it is a special token of length 2. */
1095 for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++)
1096 if (!strncmp (tokstart, tokentab2[i].operator, 2))
1097 {
1098 lexptr += 2;
1099 yylval.opcode = tokentab2[i].opcode;
1100 return tokentab2[i].token;
1101 }
1102
1103 switch (c = *tokstart)
1104 {
1105 case 0:
1106 return 0;
1107
1108 case ' ':
1109 case '\t':
1110 case '\n':
1111 lexptr++;
1112 goto retry;
1113
1114 case '\'':
d630b615
FF		 1115 /* We either have a character constant ('0' or '\177' for example)
1116 or we have a quoted symbol reference ('foo(int,int)' in C++
1117 for example). */
3d6b6a90
JG		 1118 lexptr++;
1119 c = *lexptr++;
1120 if (c == '\\')
1121 c = parse_escape (&lexptr);
1122 yylval.lval = c;
1123 c = *lexptr++;
1124 if (c != '\'')
d630b615
FF		 1125 {
1126 namelen = skip_quoted (tokstart) - tokstart;
1127 if (namelen > 2)
1128 {
1129 lexptr = tokstart + namelen;
1130 namelen -= 2;
1131 tokstart++;
1132 goto tryname;
1133 }
1134 error ("Invalid character constant.");
1135 }
3d6b6a90
JG		 1136 return CHAR;
1137
1138 case '(':
1139 paren_depth++;
1140 lexptr++;
1141 return c;
1142
1143 case ')':
1144 if (paren_depth == 0)
1145 return 0;
1146 paren_depth--;
1147 lexptr++;
1148 return c;
1149
1150 case ',':
1151 if (comma_terminates && paren_depth == 0)
1152 return 0;
1153 lexptr++;
1154 return c;
1155
1156 case '.':
1157 /* Might be a floating point number. */
1158 if (lexptr[1] < '0' || lexptr[1] > '9')
1159 goto symbol; /* Nope, must be a symbol. */
1160 /* FALL THRU into number case. */
1161
1162 case '0':
1163 case '1':
1164 case '2':
1165 case '3':
1166 case '4':
1167 case '5':
1168 case '6':
1169 case '7':
1170 case '8':
1171 case '9':
1172 {
1173 /* It's a number. */
1174 int got_dot = 0, got_e = 0, toktype;
1175 register char *p = tokstart;
1176 int hex = input_radix > 10;
1177
1178 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1179 {
1180 p += 2;
1181 hex = 1;
1182 }
1183 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1184 {
1185 p += 2;
1186 hex = 0;
1187 }
1188
1189 for (;; ++p)
1190 {
1191 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1192 got_dot = got_e = 1;
1193 else if (!hex && !got_dot && *p == '.')
1194 got_dot = 1;
1195 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
1196 && (*p == '-' || *p == '+'))
1197 /* This is the sign of the exponent, not the end of the
1198 number. */
1199 continue;
1200 /* We will take any letters or digits. parse_number will
1201 complain if past the radix, or if L or U are not final. */
1202 else if ((*p < '0' || *p > '9')
1203 && ((*p < 'a' || *p > 'z')
1204 && (*p < 'A' || *p > 'Z')))
1205 break;
1206 }
1207 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval);
1208 if (toktype == ERROR)
1209 {
1210 char *err_copy = (char *) alloca (p - tokstart + 1);
1211
1212 bcopy (tokstart, err_copy, p - tokstart);
1213 err_copy[p - tokstart] = 0;
1214 error ("Invalid number \"%s\".", err_copy);
1215 }
1216 lexptr = p;
1217 return toktype;
1218 }
1219
1220 case '+':
1221 case '-':
1222 case '*':
1223 case '/':
1224 case '%':
1225 case '|':
1226 case '&':
1227 case '^':
1228 case '~':
1229 case '!':
1230 case '@':
1231 case '<':
1232 case '>':
1233 case '[':
1234 case ']':
1235 case '?':
1236 case ':':
1237 case '=':
1238 case '{':
1239 case '}':
1240 symbol:
1241 lexptr++;
1242 return c;
1243
1244 case '"':
1245 for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++)
1246 if (c == '\\')
1247 {
1248 c = tokstart[++namelen];
1249 if (c >= '0' && c <= '9')
1250 {
1251 c = tokstart[++namelen];
1252 if (c >= '0' && c <= '9')
1253 c = tokstart[++namelen];
1254 }
1255 }
1256 yylval.sval.ptr = tokstart + 1;
1257 yylval.sval.length = namelen - 1;
1258 lexptr += namelen + 1;
1259 return STRING;
1260 }
1261
1262 if (!(c == '_' || c == '$'
1263 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1264 /* We must have come across a bad character (e.g. ';'). */
1265 error ("Invalid character '%c' in expression.", c);
1266
1267 /* It's a name. See how long it is. */
1268 namelen = 0;
1269 for (c = tokstart[namelen];
1270 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1271 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1272 c = tokstart[++namelen])
1273 ;
1274
1275 /* The token "if" terminates the expression and is NOT
1276 removed from the input stream. */
1277 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1278 {
1279 return 0;
1280 }
1281
1282 lexptr += namelen;
1283
1284 /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1)
1285 and $$digits (equivalent to $<-digits> if you could type that).
1286 Make token type LAST, and put the number (the digits) in yylval. */
1287
d630b615 1288 tryname:
3d6b6a90
JG		 1289 if (*tokstart == '$')
1290 {
1291 register int negate = 0;
1292 c = 1;
1293 /* Double dollar means negate the number and add -1 as well.
1294 Thus $$ alone means -1. */
1295 if (namelen >= 2 && tokstart[1] == '$')
1296 {
1297 negate = 1;
1298 c = 2;
1299 }
1300 if (c == namelen)
1301 {
1302 /* Just dollars (one or two) */
1303 yylval.lval = - negate;
1304 return LAST;
1305 }
1306 /* Is the rest of the token digits? */
1307 for (; c < namelen; c++)
1308 if (!(tokstart[c] >= '0' && tokstart[c] <= '9'))
1309 break;
1310 if (c == namelen)
1311 {
1312 yylval.lval = atoi (tokstart + 1 + negate);
1313 if (negate)
1314 yylval.lval = - yylval.lval;
1315 return LAST;
1316 }
1317 }
1318
1319 /* Handle tokens that refer to machine registers:
1320 $ followed by a register name. */
1321
1322 if (*tokstart == '$') {
1323 for (c = 0; c < NUM_REGS; c++)
1324 if (namelen - 1 == strlen (reg_names[c])
1325 && !strncmp (tokstart + 1, reg_names[c], namelen - 1))
1326 {
1327 yylval.lval = c;
1328 return REGNAME;
1329 }
1330 for (c = 0; c < num_std_regs; c++)
1331 if (namelen - 1 == strlen (std_regs[c].name)
1332 && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1))
1333 {
1334 yylval.lval = std_regs[c].regnum;
1335 return REGNAME;
1336 }
1337 }
1338 /* Catch specific keywords. Should be done with a data structure. */
1339 switch (namelen)
1340 {
1341 case 8:
1342 if (!strncmp (tokstart, "unsigned", 8))
1343 return UNSIGNED;
5a4e7215
JG		 1344 if (current_language->la_language == language_cplus
1345 && !strncmp (tokstart, "template", 8))
4c53d9ca 1346 return TEMPLATE;
3d6b6a90
JG		 1347 break;
1348 case 6:
1349 if (!strncmp (tokstart, "struct", 6))
1350 return STRUCT;
1351 if (!strncmp (tokstart, "signed", 6))
088c3a0b 1352 return SIGNED_KEYWORD;
3d6b6a90
JG		 1353 if (!strncmp (tokstart, "sizeof", 6))
1354 return SIZEOF;
1355 break;
1356 case 5:
1357 if (!strncmp (tokstart, "union", 5))
1358 return UNION;
1359 if (!strncmp (tokstart, "short", 5))
1360 return SHORT;
1361 break;
1362 case 4:
1363 if (!strncmp (tokstart, "enum", 4))
1364 return ENUM;
1365 if (!strncmp (tokstart, "long", 4))
1366 return LONG;
5a4e7215
JG		 1367 if (current_language->la_language == language_cplus
1368 && !strncmp (tokstart, "this", 4))
3d6b6a90
JG		 1369 {
1370 static const char this_name[] =
1371 { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' };
1372
1373 if (lookup_symbol (this_name, expression_context_block,
1374 VAR_NAMESPACE, 0, NULL))
1375 return THIS;
1376 }
1377 break;
1378 case 3:
1379 if (!strncmp (tokstart, "int", 3))
1380 return INT_KEYWORD;
1381 break;
1382 default:
1383 break;
1384 }
1385
1386 yylval.sval.ptr = tokstart;
1387 yylval.sval.length = namelen;
1388
1389 /* Any other names starting in $ are debugger internal variables. */
1390
1391 if (*tokstart == '$')
1392 {
1393 yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1);
1394 return VARIABLE;
1395 }
1396
1397 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1398 functions or symtabs. If this is not so, then ...
1399 Use token-type TYPENAME for symbols that happen to be defined
1400 currently as names of types; NAME for other symbols.
1401 The caller is not constrained to care about the distinction. */
1402 {
1403 char *tmp = copy_name (yylval.sval);
1404 struct symbol *sym;
1405 int is_a_field_of_this = 0;
1406 int hextype;
1407
1408 sym = lookup_symbol (tmp, expression_context_block,
545af6ce
PB		 1409 VAR_NAMESPACE,
1410 current_language->la_language == language_cplus
1411 ? &is_a_field_of_this : NULL,
1412 NULL);
3d6b6a90
JG		 1413 if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) ||
1414 lookup_partial_symtab (tmp))
1415 {
1416 yylval.ssym.sym = sym;
1417 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1418 return BLOCKNAME;
1419 }
1420 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1421 {
1422 yylval.tsym.type = SYMBOL_TYPE (sym);
1423 return TYPENAME;
1424 }
1425 if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0)
1426 return TYPENAME;
1427
1428 /* Input names that aren't symbols but ARE valid hex numbers,
1429 when the input radix permits them, can be names or numbers
1430 depending on the parse. Note we support radixes > 16 here. */
1431 if (!sym &&
1432 ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) ||
1433 (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1434 {
1435 YYSTYPE newlval; /* Its value is ignored. */
1436 hextype = parse_number (tokstart, namelen, 0, &newlval);
1437 if (hextype == INT)
1438 {
1439 yylval.ssym.sym = sym;
1440 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1441 return NAME_OR_INT;
1442 }
1443 if (hextype == UINT)
1444 {
1445 yylval.ssym.sym = sym;
1446 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1447 return NAME_OR_UINT;
1448 }
1449 }
1450
1451 /* Any other kind of symbol */
1452 yylval.ssym.sym = sym;
1453 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1454 return NAME;
1455 }
1456}
1457
1458void
1459yyerror (msg)
1460 char *msg;
1461{
d671e293 1462 error (msg ? msg : "Invalid syntax in expression.");
3d6b6a90
JG		 1463}
1464\f
1465/* Table mapping opcodes into strings for printing operators
1466 and precedences of the operators. */
1467
1468const static struct op_print c_op_print_tab[] =
1469 {
1470 {",", BINOP_COMMA, PREC_COMMA, 0},
1471 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
1472 {"||", BINOP_OR, PREC_OR, 0},
1473 {"&&", BINOP_AND, PREC_AND, 0},
1474 {"|", BINOP_LOGIOR, PREC_LOGIOR, 0},
1475 {"&", BINOP_LOGAND, PREC_LOGAND, 0},
1476 {"^", BINOP_LOGXOR, PREC_LOGXOR, 0},
1477 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
1478 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
1479 {"<=", BINOP_LEQ, PREC_ORDER, 0},
1480 {">=", BINOP_GEQ, PREC_ORDER, 0},
1481 {">", BINOP_GTR, PREC_ORDER, 0},
1482 {"<", BINOP_LESS, PREC_ORDER, 0},
1483 {">>", BINOP_RSH, PREC_SHIFT, 0},
1484 {"<<", BINOP_LSH, PREC_SHIFT, 0},
1485 {"+", BINOP_ADD, PREC_ADD, 0},
1486 {"-", BINOP_SUB, PREC_ADD, 0},
1487 {"*", BINOP_MUL, PREC_MUL, 0},
1488 {"/", BINOP_DIV, PREC_MUL, 0},
1489 {"%", BINOP_REM, PREC_MUL, 0},
1490 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
1491 {"-", UNOP_NEG, PREC_PREFIX, 0},
1492 {"!", UNOP_ZEROP, PREC_PREFIX, 0},
1493 {"~", UNOP_LOGNOT, PREC_PREFIX, 0},
1494 {"*", UNOP_IND, PREC_PREFIX, 0},
1495 {"&", UNOP_ADDR, PREC_PREFIX, 0},
1496 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
1497 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
1498 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
1499 /* C++ */
1500 {"::", BINOP_SCOPE, PREC_PREFIX, 0},
1501};
1502\f
1503/* These variables point to the objects
1504 representing the predefined C data types. */
1505
1506struct type *builtin_type_void;
1507struct type *builtin_type_char;
1508struct type *builtin_type_short;
1509struct type *builtin_type_int;
1510struct type *builtin_type_long;
1511struct type *builtin_type_long_long;
04f27ddc 1512struct type *builtin_type_signed_char;
3d6b6a90
JG		 1513struct type *builtin_type_unsigned_char;
1514struct type *builtin_type_unsigned_short;
1515struct type *builtin_type_unsigned_int;
1516struct type *builtin_type_unsigned_long;
1517struct type *builtin_type_unsigned_long_long;
1518struct type *builtin_type_float;
1519struct type *builtin_type_double;
e2aab031
FF		 1520struct type *builtin_type_long_double;
1521struct type *builtin_type_complex;
1522struct type *builtin_type_double_complex;
3d6b6a90 1523
9dffe475 1524struct type ** const (c_builtin_types[]) =
3d6b6a90
JG		 1525{
1526 &builtin_type_int,
1527 &builtin_type_long,
1528 &builtin_type_short,
1529 &builtin_type_char,
1530 &builtin_type_float,
1531 &builtin_type_double,
1532 &builtin_type_void,
1533 &builtin_type_long_long,
04f27ddc 1534 &builtin_type_signed_char,
3d6b6a90
JG		 1535 &builtin_type_unsigned_char,
1536 &builtin_type_unsigned_short,
1537 &builtin_type_unsigned_int,
1538 &builtin_type_unsigned_long,
1539 &builtin_type_unsigned_long_long,
e2aab031
FF		 1540 &builtin_type_long_double,
1541 &builtin_type_complex,
1542 &builtin_type_double_complex,
3d6b6a90
JG		 1543 0
1544};
1545
9dffe475 1546const struct language_defn c_language_defn = {
3d6b6a90
JG		 1547 "c", /* Language name */
1548 language_c,
1549 c_builtin_types,
1550 range_check_off,
1551 type_check_off,
1552 c_parse,
1553 c_error,
1554 &BUILTIN_TYPE_LONGEST, /* longest signed integral type */
1555 &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
e2aab031 1556 &builtin_type_double, /* longest floating point type */ /*FIXME*/
3d6b6a90
JG		 1557 "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
1558 "0%o", "0%", "o", /* Octal format, prefix, suffix */
1559 c_op_print_tab, /* expression operators for printing */
1560 LANG_MAGIC
1561};
1562
545af6ce
PB		 1563const struct language_defn cplus_language_defn = {
1564 "c++", /* Language name */
1565 language_cplus,
1566 c_builtin_types,
1567 range_check_off,
1568 type_check_off,
1569 c_parse,
1570 c_error,
1571 &BUILTIN_TYPE_LONGEST, /* longest signed integral type */
1572 &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
1573 &builtin_type_double, /* longest floating point type */ /*FIXME*/
1574 "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
1575 "0%o", "0%", "o", /* Octal format, prefix, suffix */
1576 c_op_print_tab, /* expression operators for printing */
1577 LANG_MAGIC
1578};
1579
3d6b6a90
JG		 1580void
1581_initialize_c_exp ()
1582{
e2aab031 1583 builtin_type_void =
1ab3bf1b 1584 init_type (TYPE_CODE_VOID, 1,
1867b3be 1585 0,
1ab3bf1b 1586 "void", (struct objfile *) NULL);
e2aab031 1587 builtin_type_char =
1ab3bf1b 1588 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1867b3be 1589 0,
1ab3bf1b 1590 "char", (struct objfile *) NULL);
04f27ddc
PB		 1591 builtin_type_signed_char =
1592 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1867b3be 1593 TYPE_FLAG_SIGNED,
04f27ddc 1594 "signed char", (struct objfile *) NULL);
e2aab031 1595 builtin_type_unsigned_char =
1ab3bf1b 1596 init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
1867b3be 1597 TYPE_FLAG_UNSIGNED,
1ab3bf1b 1598 "unsigned char", (struct objfile *) NULL);
e2aab031 1599 builtin_type_short =
1ab3bf1b 1600 init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1867b3be 1601 0,
1ab3bf1b 1602 "short", (struct objfile *) NULL);
e2aab031 1603 builtin_type_unsigned_short =
1ab3bf1b 1604 init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
1867b3be 1605 TYPE_FLAG_UNSIGNED,
1ab3bf1b 1606 "unsigned short", (struct objfile *) NULL);
e2aab031 1607 builtin_type_int =
1ab3bf1b 1608 init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1867b3be 1609 0,
1ab3bf1b 1610 "int", (struct objfile *) NULL);
e2aab031 1611 builtin_type_unsigned_int =
1ab3bf1b 1612 init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
1867b3be 1613 TYPE_FLAG_UNSIGNED,
1ab3bf1b 1614 "unsigned int", (struct objfile *) NULL);
e2aab031 1615 builtin_type_long =
1ab3bf1b 1616 init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1867b3be 1617 0,
1ab3bf1b 1618 "long", (struct objfile *) NULL);
e2aab031 1619 builtin_type_unsigned_long =
1ab3bf1b 1620 init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
1867b3be 1621 TYPE_FLAG_UNSIGNED,
1ab3bf1b 1622 "unsigned long", (struct objfile *) NULL);
3d6b6a90 1623 builtin_type_long_long =
1ab3bf1b 1624 init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1867b3be 1625 0,
1ab3bf1b 1626 "long long", (struct objfile *) NULL);
3d6b6a90 1627 builtin_type_unsigned_long_long =
1ab3bf1b 1628 init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
1867b3be 1629 TYPE_FLAG_UNSIGNED,
1ab3bf1b 1630 "unsigned long long", (struct objfile *) NULL);
e2aab031 1631 builtin_type_float =
1ab3bf1b 1632 init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
1867b3be 1633 0,
1ab3bf1b 1634 "float", (struct objfile *) NULL);
e2aab031 1635 builtin_type_double =
1ab3bf1b 1636 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
1867b3be 1637 0,
1ab3bf1b 1638 "double", (struct objfile *) NULL);
e2aab031 1639 builtin_type_long_double =
1ab3bf1b 1640 init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
1867b3be 1641 0,
1ab3bf1b 1642 "long double", (struct objfile *) NULL);
e2aab031 1643 builtin_type_complex =
1ab3bf1b 1644 init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
1867b3be 1645 0,
1ab3bf1b 1646 "complex", (struct objfile *) NULL);
e2aab031 1647 builtin_type_double_complex =
1ab3bf1b 1648 init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
1867b3be 1649 0,
1ab3bf1b 1650 "double complex", (struct objfile *) NULL);
3d6b6a90
JG		 1651
1652 add_language (&c_language_defn);
545af6ce 1653 add_language (&cplus_language_defn);
3d6b6a90 1654}
GDB Binutils - Deliverables
This page took 0.113665 seconds and 4 git commands to generate.