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