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