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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [c-exp.y] - Blame information for rev 104

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

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

powered by: WebSVN 2.1.0

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