OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [c-exp.y] - Blame information for rev 262

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.