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