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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [c-exp.y] - Blame information for rev 1774

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

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

powered by: WebSVN 2.1.0

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