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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [objc-exp.y] - Blame information for rev 227

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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