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

Subversion Repositories openrisc_me

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

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

Line No. Rev Author Line
1 227 jeremybenn
/* YACC grammar for Modula-2 expressions, for GDB.
2
   Copyright (C) 1986, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999,
3
   2000, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
4
   Generated from expread.y (now c-exp.y) and contributed by the Department
5
   of Computer Science at the State University of New York at Buffalo, 1991.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see .  */
21
 
22
/* Parse a Modula-2 expression from text in a string,
23
   and return the result as a  struct expression  pointer.
24
   That structure contains arithmetic operations in reverse polish,
25
   with constants represented by operations that are followed by special data.
26
   See expression.h for the details of the format.
27
   What is important here is that it can be built up sequentially
28
   during the process of parsing; the lower levels of the tree always
29
   come first in the result.
30
 
31
   Note that malloc's and realloc's in this file are transformed to
32
   xmalloc and xrealloc respectively by the same sed command in the
33
   makefile that remaps any other malloc/realloc inserted by the parser
34
   generator.  Doing this with #defines and trying to control the interaction
35
   with include files ( and  for example) just became
36
   too messy, particularly when such includes can be inserted at random
37
   times by the parser generator. */
38
 
39
%{
40
 
41
#include "defs.h"
42
#include "gdb_string.h"
43
#include "expression.h"
44
#include "language.h"
45
#include "value.h"
46
#include "parser-defs.h"
47
#include "m2-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 "block.h"
52
 
53
#define parse_type builtin_type (parse_gdbarch)
54
#define parse_m2_type builtin_m2_type (parse_gdbarch)
55
 
56
/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
57
   as well as gratuitiously global symbol names, so we can have multiple
58
   yacc generated parsers in gdb.  Note that these are only the variables
59
   produced by yacc.  If other parser generators (bison, byacc, etc) produce
60
   additional global names that conflict at link time, then those parser
61
   generators need to be fixed instead of adding those names to this list. */
62
 
63
#define yymaxdepth m2_maxdepth
64
#define yyparse m2_parse
65
#define yylex   m2_lex
66
#define yyerror m2_error
67
#define yylval  m2_lval
68
#define yychar  m2_char
69
#define yydebug m2_debug
70
#define yypact  m2_pact
71
#define yyr1    m2_r1
72
#define yyr2    m2_r2
73
#define yydef   m2_def
74
#define yychk   m2_chk
75
#define yypgo   m2_pgo
76
#define yyact   m2_act
77
#define yyexca  m2_exca
78
#define yyerrflag m2_errflag
79
#define yynerrs m2_nerrs
80
#define yyps    m2_ps
81
#define yypv    m2_pv
82
#define yys     m2_s
83
#define yy_yys  m2_yys
84
#define yystate m2_state
85
#define yytmp   m2_tmp
86
#define yyv     m2_v
87
#define yy_yyv  m2_yyv
88
#define yyval   m2_val
89
#define yylloc  m2_lloc
90
#define yyreds  m2_reds         /* With YYDEBUG defined */
91
#define yytoks  m2_toks         /* With YYDEBUG defined */
92
#define yyname  m2_name         /* With YYDEBUG defined */
93
#define yyrule  m2_rule         /* With YYDEBUG defined */
94
#define yylhs   m2_yylhs
95
#define yylen   m2_yylen
96
#define yydefred m2_yydefred
97
#define yydgoto m2_yydgoto
98
#define yysindex m2_yysindex
99
#define yyrindex m2_yyrindex
100
#define yygindex m2_yygindex
101
#define yytable  m2_yytable
102
#define yycheck  m2_yycheck
103
 
104
#ifndef YYDEBUG
105
#define YYDEBUG 1               /* Default to yydebug support */
106
#endif
107
 
108
#define YYFPRINTF parser_fprintf
109
 
110
int yyparse (void);
111
 
112
static int yylex (void);
113
 
114
void yyerror (char *);
115
 
116
#if 0
117
static char *make_qualname (char *, char *);
118
#endif
119
 
120
static int parse_number (int);
121
 
122
/* The sign of the number being parsed. */
123
static int number_sign = 1;
124
 
125
/* The block that the module specified by the qualifer on an identifer is
126
   contained in, */
127
#if 0
128
static struct block *modblock=0;
129
#endif
130
 
131
%}
132
 
133
/* Although the yacc "value" of an expression is not used,
134
   since the result is stored in the structure being created,
135
   other node types do have values.  */
136
 
137
%union
138
  {
139
    LONGEST lval;
140
    ULONGEST ulval;
141
    DOUBLEST dval;
142
    struct symbol *sym;
143
    struct type *tval;
144
    struct stoken sval;
145
    int voidval;
146
    struct block *bval;
147
    enum exp_opcode opcode;
148
    struct internalvar *ivar;
149
 
150
    struct type **tvec;
151
    int *ivec;
152
  }
153
 
154
%type  exp type_exp start set
155
%type  variable
156
%type  type
157
%type  block
158
%type  fblock
159
 
160
%token  INT HEX ERROR
161
%token  UINT M2_TRUE M2_FALSE CHAR
162
%token  FLOAT
163
 
164
/* Both NAME and TYPENAME tokens represent symbols in the input,
165
   and both convey their data as strings.
166
   But a TYPENAME is a string that happens to be defined as a typedef
167
   or builtin type name (such as int or char)
168
   and a NAME is any other symbol.
169
 
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 IDENT VARNAME
175
%token  TYPENAME
176
 
177
%token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC
178
%token TSIZE
179
%token INC DEC INCL EXCL
180
 
181
/* The GDB scope operator */
182
%token COLONCOLON
183
 
184
%token  INTERNAL_VAR
185
 
186
/* M2 tokens */
187
%left ','
188
%left ABOVE_COMMA
189
%nonassoc ASSIGN
190
%left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
191
%left OROR
192
%left LOGICAL_AND '&'
193
%left '@'
194
%left '+' '-'
195
%left '*' '/' DIV MOD
196
%right UNARY
197
%right '^' DOT '[' '('
198
%right NOT '~'
199
%left COLONCOLON QID
200
/* This is not an actual token ; it is used for precedence.
201
%right QID
202
*/
203
 
204
 
205
%%
206
 
207
start   :       exp
208
        |       type_exp
209
        ;
210
 
211
type_exp:       type
212
                { write_exp_elt_opcode(OP_TYPE);
213
                  write_exp_elt_type($1);
214
                  write_exp_elt_opcode(OP_TYPE);
215
                }
216
        ;
217
 
218
/* Expressions */
219
 
220
exp     :       exp '^'   %prec UNARY
221
                        { write_exp_elt_opcode (UNOP_IND); }
222
        ;
223
 
224
exp     :       '-'
225
                        { number_sign = -1; }
226
                exp    %prec UNARY
227
                        { number_sign = 1;
228
                          write_exp_elt_opcode (UNOP_NEG); }
229
        ;
230
 
231
exp     :       '+' exp    %prec UNARY
232
                { write_exp_elt_opcode(UNOP_PLUS); }
233
        ;
234
 
235
exp     :       not_exp exp %prec UNARY
236
                        { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
237
        ;
238
 
239
not_exp :       NOT
240
        |       '~'
241
        ;
242
 
243
exp     :       CAP '(' exp ')'
244
                        { write_exp_elt_opcode (UNOP_CAP); }
245
        ;
246
 
247
exp     :       ORD '(' exp ')'
248
                        { write_exp_elt_opcode (UNOP_ORD); }
249
        ;
250
 
251
exp     :       ABS '(' exp ')'
252
                        { write_exp_elt_opcode (UNOP_ABS); }
253
        ;
254
 
255
exp     :       HIGH '(' exp ')'
256
                        { write_exp_elt_opcode (UNOP_HIGH); }
257
        ;
258
 
259
exp     :       MIN_FUNC '(' type ')'
260
                        { write_exp_elt_opcode (UNOP_MIN);
261
                          write_exp_elt_type ($3);
262
                          write_exp_elt_opcode (UNOP_MIN); }
263
        ;
264
 
265
exp     :       MAX_FUNC '(' type ')'
266
                        { write_exp_elt_opcode (UNOP_MAX);
267
                          write_exp_elt_type ($3);
268
                          write_exp_elt_opcode (UNOP_MAX); }
269
        ;
270
 
271
exp     :       FLOAT_FUNC '(' exp ')'
272
                        { write_exp_elt_opcode (UNOP_FLOAT); }
273
        ;
274
 
275
exp     :       VAL '(' type ',' exp ')'
276
                        { write_exp_elt_opcode (BINOP_VAL);
277
                          write_exp_elt_type ($3);
278
                          write_exp_elt_opcode (BINOP_VAL); }
279
        ;
280
 
281
exp     :       CHR '(' exp ')'
282
                        { write_exp_elt_opcode (UNOP_CHR); }
283
        ;
284
 
285
exp     :       ODD '(' exp ')'
286
                        { write_exp_elt_opcode (UNOP_ODD); }
287
        ;
288
 
289
exp     :       TRUNC '(' exp ')'
290
                        { write_exp_elt_opcode (UNOP_TRUNC); }
291
        ;
292
 
293
exp     :       TSIZE '(' exp ')'
294
                        { write_exp_elt_opcode (UNOP_SIZEOF); }
295
        ;
296
 
297
exp     :       SIZE exp       %prec UNARY
298
                        { write_exp_elt_opcode (UNOP_SIZEOF); }
299
        ;
300
 
301
 
302
exp     :       INC '(' exp ')'
303
                        { write_exp_elt_opcode(UNOP_PREINCREMENT); }
304
        ;
305
 
306
exp     :       INC '(' exp ',' exp ')'
307
                        { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
308
                          write_exp_elt_opcode(BINOP_ADD);
309
                          write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); }
310
        ;
311
 
312
exp     :       DEC '(' exp ')'
313
                        { write_exp_elt_opcode(UNOP_PREDECREMENT);}
314
        ;
315
 
316
exp     :       DEC '(' exp ',' exp ')'
317
                        { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY);
318
                          write_exp_elt_opcode(BINOP_SUB);
319
                          write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); }
320
        ;
321
 
322
exp     :       exp DOT NAME
323
                        { write_exp_elt_opcode (STRUCTOP_STRUCT);
324
                          write_exp_string ($3);
325
                          write_exp_elt_opcode (STRUCTOP_STRUCT); }
326
        ;
327
 
328
exp     :       set
329
        ;
330
 
331
exp     :       exp IN set
332
                        { error("Sets are not implemented.");}
333
        ;
334
 
335
exp     :       INCL '(' exp ',' exp ')'
336
                        { error("Sets are not implemented.");}
337
        ;
338
 
339
exp     :       EXCL '(' exp ',' exp ')'
340
                        { error("Sets are not implemented.");}
341
        ;
342
 
343
set     :       '{' arglist '}'
344
                        { error("Sets are not implemented.");}
345
        |       type '{' arglist '}'
346
                        { error("Sets are not implemented.");}
347
        ;
348
 
349
 
350
/* Modula-2 array subscript notation [a,b,c...] */
351
exp     :       exp '['
352
                        /* This function just saves the number of arguments
353
                           that follow in the list.  It is *not* specific to
354
                           function types */
355
                        { start_arglist(); }
356
                non_empty_arglist ']'  %prec DOT
357
                        { write_exp_elt_opcode (MULTI_SUBSCRIPT);
358
                          write_exp_elt_longcst ((LONGEST) end_arglist());
359
                          write_exp_elt_opcode (MULTI_SUBSCRIPT); }
360
        ;
361
 
362
exp     :       exp '[' exp ']'
363
                        { write_exp_elt_opcode (BINOP_SUBSCRIPT); }
364
        ;
365
 
366
exp     :       exp '('
367
                        /* This is to save the value of arglist_len
368
                           being accumulated by an outer function call.  */
369
                        { start_arglist (); }
370
                arglist ')'     %prec DOT
371
                        { write_exp_elt_opcode (OP_FUNCALL);
372
                          write_exp_elt_longcst ((LONGEST) end_arglist ());
373
                          write_exp_elt_opcode (OP_FUNCALL); }
374
        ;
375
 
376
arglist :
377
        ;
378
 
379
arglist :       exp
380
                        { arglist_len = 1; }
381
        ;
382
 
383
arglist :       arglist ',' exp   %prec ABOVE_COMMA
384
                        { arglist_len++; }
385
        ;
386
 
387
non_empty_arglist
388
        :       exp
389
                        { arglist_len = 1; }
390
        ;
391
 
392
non_empty_arglist
393
        :       non_empty_arglist ',' exp %prec ABOVE_COMMA
394
                        { arglist_len++; }
395
        ;
396
 
397
/* GDB construct */
398
exp     :       '{' type '}' exp  %prec UNARY
399
                        { write_exp_elt_opcode (UNOP_MEMVAL);
400
                          write_exp_elt_type ($2);
401
                          write_exp_elt_opcode (UNOP_MEMVAL); }
402
        ;
403
 
404
exp     :       type '(' exp ')' %prec UNARY
405
                        { write_exp_elt_opcode (UNOP_CAST);
406
                          write_exp_elt_type ($1);
407
                          write_exp_elt_opcode (UNOP_CAST); }
408
        ;
409
 
410
exp     :       '(' exp ')'
411
                        { }
412
        ;
413
 
414
/* Binary operators in order of decreasing precedence.  Note that some
415
   of these operators are overloaded!  (ie. sets) */
416
 
417
/* GDB construct */
418
exp     :       exp '@' exp
419
                        { write_exp_elt_opcode (BINOP_REPEAT); }
420
        ;
421
 
422
exp     :       exp '*' exp
423
                        { write_exp_elt_opcode (BINOP_MUL); }
424
        ;
425
 
426
exp     :       exp '/' exp
427
                        { write_exp_elt_opcode (BINOP_DIV); }
428
        ;
429
 
430
exp     :       exp DIV exp
431
                        { write_exp_elt_opcode (BINOP_INTDIV); }
432
        ;
433
 
434
exp     :       exp MOD exp
435
                        { write_exp_elt_opcode (BINOP_REM); }
436
        ;
437
 
438
exp     :       exp '+' exp
439
                        { write_exp_elt_opcode (BINOP_ADD); }
440
        ;
441
 
442
exp     :       exp '-' exp
443
                        { write_exp_elt_opcode (BINOP_SUB); }
444
        ;
445
 
446
exp     :       exp '=' exp
447
                        { write_exp_elt_opcode (BINOP_EQUAL); }
448
        ;
449
 
450
exp     :       exp NOTEQUAL exp
451
                        { write_exp_elt_opcode (BINOP_NOTEQUAL); }
452
        |       exp '#' exp
453
                        { write_exp_elt_opcode (BINOP_NOTEQUAL); }
454
        ;
455
 
456
exp     :       exp LEQ exp
457
                        { write_exp_elt_opcode (BINOP_LEQ); }
458
        ;
459
 
460
exp     :       exp GEQ exp
461
                        { write_exp_elt_opcode (BINOP_GEQ); }
462
        ;
463
 
464
exp     :       exp '<' exp
465
                        { write_exp_elt_opcode (BINOP_LESS); }
466
        ;
467
 
468
exp     :       exp '>' exp
469
                        { write_exp_elt_opcode (BINOP_GTR); }
470
        ;
471
 
472
exp     :       exp LOGICAL_AND exp
473
                        { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
474
        ;
475
 
476
exp     :       exp OROR exp
477
                        { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
478
        ;
479
 
480
exp     :       exp ASSIGN exp
481
                        { write_exp_elt_opcode (BINOP_ASSIGN); }
482
        ;
483
 
484
 
485
/* Constants */
486
 
487
exp     :       M2_TRUE
488
                        { write_exp_elt_opcode (OP_BOOL);
489
                          write_exp_elt_longcst ((LONGEST) $1);
490
                          write_exp_elt_opcode (OP_BOOL); }
491
        ;
492
 
493
exp     :       M2_FALSE
494
                        { write_exp_elt_opcode (OP_BOOL);
495
                          write_exp_elt_longcst ((LONGEST) $1);
496
                          write_exp_elt_opcode (OP_BOOL); }
497
        ;
498
 
499
exp     :       INT
500
                        { write_exp_elt_opcode (OP_LONG);
501
                          write_exp_elt_type (parse_m2_type->builtin_int);
502
                          write_exp_elt_longcst ((LONGEST) $1);
503
                          write_exp_elt_opcode (OP_LONG); }
504
        ;
505
 
506
exp     :       UINT
507
                        {
508
                          write_exp_elt_opcode (OP_LONG);
509
                          write_exp_elt_type (parse_m2_type->builtin_card);
510
                          write_exp_elt_longcst ((LONGEST) $1);
511
                          write_exp_elt_opcode (OP_LONG);
512
                        }
513
        ;
514
 
515
exp     :       CHAR
516
                        { write_exp_elt_opcode (OP_LONG);
517
                          write_exp_elt_type (parse_m2_type->builtin_char);
518
                          write_exp_elt_longcst ((LONGEST) $1);
519
                          write_exp_elt_opcode (OP_LONG); }
520
        ;
521
 
522
 
523
exp     :       FLOAT
524
                        { write_exp_elt_opcode (OP_DOUBLE);
525
                          write_exp_elt_type (parse_m2_type->builtin_real);
526
                          write_exp_elt_dblcst ($1);
527
                          write_exp_elt_opcode (OP_DOUBLE); }
528
        ;
529
 
530
exp     :       variable
531
        ;
532
 
533
exp     :       SIZE '(' type ')'       %prec UNARY
534
                        { write_exp_elt_opcode (OP_LONG);
535
                          write_exp_elt_type (parse_type->builtin_int);
536
                          write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
537
                          write_exp_elt_opcode (OP_LONG); }
538
        ;
539
 
540
exp     :       STRING
541
                        { write_exp_elt_opcode (OP_M2_STRING);
542
                          write_exp_string ($1);
543
                          write_exp_elt_opcode (OP_M2_STRING); }
544
        ;
545
 
546
/* This will be used for extensions later.  Like adding modules. */
547
block   :       fblock
548
                        { $$ = SYMBOL_BLOCK_VALUE($1); }
549
        ;
550
 
551
fblock  :       BLOCKNAME
552
                        { struct symbol *sym
553
                            = lookup_symbol (copy_name ($1), expression_context_block,
554
                                             VAR_DOMAIN, 0);
555
                          $$ = sym;}
556
        ;
557
 
558
 
559
/* GDB scope operator */
560
fblock  :       block COLONCOLON BLOCKNAME
561
                        { struct symbol *tem
562
                            = lookup_symbol (copy_name ($3), $1,
563
                                             VAR_DOMAIN, 0);
564
                          if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
565
                            error ("No function \"%s\" in specified context.",
566
                                   copy_name ($3));
567
                          $$ = tem;
568
                        }
569
        ;
570
 
571
/* Useful for assigning to PROCEDURE variables */
572
variable:       fblock
573
                        { write_exp_elt_opcode(OP_VAR_VALUE);
574
                          write_exp_elt_block (NULL);
575
                          write_exp_elt_sym ($1);
576
                          write_exp_elt_opcode (OP_VAR_VALUE); }
577
        ;
578
 
579
/* GDB internal ($foo) variable */
580
variable:       INTERNAL_VAR
581
        ;
582
 
583
/* GDB scope operator */
584
variable:       block COLONCOLON NAME
585
                        { struct symbol *sym;
586
                          sym = lookup_symbol (copy_name ($3), $1,
587
                                               VAR_DOMAIN, 0);
588
                          if (sym == 0)
589
                            error ("No symbol \"%s\" in specified context.",
590
                                   copy_name ($3));
591
 
592
                          write_exp_elt_opcode (OP_VAR_VALUE);
593
                          /* block_found is set by lookup_symbol.  */
594
                          write_exp_elt_block (block_found);
595
                          write_exp_elt_sym (sym);
596
                          write_exp_elt_opcode (OP_VAR_VALUE); }
597
        ;
598
 
599
/* Base case for variables. */
600
variable:       NAME
601
                        { struct symbol *sym;
602
                          int is_a_field_of_this;
603
 
604
                          sym = lookup_symbol (copy_name ($1),
605
                                               expression_context_block,
606
                                               VAR_DOMAIN,
607
                                               &is_a_field_of_this);
608
                          if (sym)
609
                            {
610
                              if (symbol_read_needs_frame (sym))
611
                                {
612
                                  if (innermost_block == 0 ||
613
                                      contained_in (block_found,
614
                                                    innermost_block))
615
                                    innermost_block = block_found;
616
                                }
617
 
618
                              write_exp_elt_opcode (OP_VAR_VALUE);
619
                              /* We want to use the selected frame, not
620
                                 another more inner frame which happens to
621
                                 be in the same block.  */
622
                              write_exp_elt_block (NULL);
623
                              write_exp_elt_sym (sym);
624
                              write_exp_elt_opcode (OP_VAR_VALUE);
625
                            }
626
                          else
627
                            {
628
                              struct minimal_symbol *msymbol;
629
                              char *arg = copy_name ($1);
630
 
631
                              msymbol =
632
                                lookup_minimal_symbol (arg, NULL, NULL);
633
                              if (msymbol != NULL)
634
                                write_exp_msymbol (msymbol);
635
                              else if (!have_full_symbols () && !have_partial_symbols ())
636
                                error ("No symbol table is loaded.  Use the \"symbol-file\" command.");
637
                              else
638
                                error ("No symbol \"%s\" in current context.",
639
                                       copy_name ($1));
640
                            }
641
                        }
642
        ;
643
 
644
type
645
        :       TYPENAME
646
                        { $$ = lookup_typename (parse_language, parse_gdbarch,
647
                                                copy_name ($1),
648
                                                expression_context_block, 0); }
649
 
650
        ;
651
 
652
%%
653
 
654
#if 0  /* FIXME! */
655
int
656
overflow(a,b)
657
   long a,b;
658
{
659
   return (MAX_OF_TYPE(parse_m2_type->builtin_int) - b) < a;
660
}
661
 
662
int
663
uoverflow(a,b)
664
   unsigned long a,b;
665
{
666
   return (MAX_OF_TYPE(parse_m2_type->builtin_card) - b) < a;
667
}
668
#endif /* FIXME */
669
 
670
/* Take care of parsing a number (anything that starts with a digit).
671
   Set yylval and return the token type; update lexptr.
672
   LEN is the number of characters in it.  */
673
 
674
/*** Needs some error checking for the float case ***/
675
 
676
static int
677
parse_number (olen)
678
     int olen;
679
{
680
  char *p = lexptr;
681
  LONGEST n = 0;
682
  LONGEST prevn = 0;
683
  int c,i,ischar=0;
684
  int base = input_radix;
685
  int len = olen;
686
  int unsigned_p = number_sign == 1 ? 1 : 0;
687
 
688
  if(p[len-1] == 'H')
689
  {
690
     base = 16;
691
     len--;
692
  }
693
  else if(p[len-1] == 'C' || p[len-1] == 'B')
694
  {
695
     base = 8;
696
     ischar = p[len-1] == 'C';
697
     len--;
698
  }
699
 
700
  /* Scan the number */
701
  for (c = 0; c < len; c++)
702
  {
703
    if (p[c] == '.' && base == 10)
704
      {
705
        /* It's a float since it contains a point.  */
706
        yylval.dval = atof (p);
707
        lexptr += len;
708
        return FLOAT;
709
      }
710
    if (p[c] == '.' && base != 10)
711
       error("Floating point numbers must be base 10.");
712
    if (base == 10 && (p[c] < '0' || p[c] > '9'))
713
       error("Invalid digit \'%c\' in number.",p[c]);
714
 }
715
 
716
  while (len-- > 0)
717
    {
718
      c = *p++;
719
      n *= base;
720
      if( base == 8 && (c == '8' || c == '9'))
721
         error("Invalid digit \'%c\' in octal number.",c);
722
      if (c >= '0' && c <= '9')
723
        i = c - '0';
724
      else
725
        {
726
          if (base == 16 && c >= 'A' && c <= 'F')
727
            i = c - 'A' + 10;
728
          else
729
             return ERROR;
730
        }
731
      n+=i;
732
      if(i >= base)
733
         return ERROR;
734
      if(!unsigned_p && number_sign == 1 && (prevn >= n))
735
         unsigned_p=1;          /* Try something unsigned */
736
      /* Don't do the range check if n==i and i==0, since that special
737
         case will give an overflow error. */
738
      if(RANGE_CHECK && n!=i && i)
739
      {
740
         if((unsigned_p && (unsigned)prevn >= (unsigned)n) ||
741
            ((!unsigned_p && number_sign==-1) && -prevn <= -n))
742
            range_error("Overflow on numeric constant.");
743
      }
744
         prevn=n;
745
    }
746
 
747
  lexptr = p;
748
  if(*p == 'B' || *p == 'C' || *p == 'H')
749
     lexptr++;                  /* Advance past B,C or H */
750
 
751
  if (ischar)
752
  {
753
     yylval.ulval = n;
754
     return CHAR;
755
  }
756
  else if ( unsigned_p && number_sign == 1)
757
  {
758
     yylval.ulval = n;
759
     return UINT;
760
  }
761
  else if((unsigned_p && (n<0))) {
762
     range_error("Overflow on numeric constant -- number too large.");
763
     /* But, this can return if range_check == range_warn.  */
764
  }
765
  yylval.lval = n;
766
  return INT;
767
}
768
 
769
 
770
/* Some tokens */
771
 
772
static struct
773
{
774
   char name[2];
775
   int token;
776
} tokentab2[] =
777
{
778
    { {'<', '>'},    NOTEQUAL         },
779
    { {':', '='},    ASSIGN     },
780
    { {'<', '='},    LEQ        },
781
    { {'>', '='},    GEQ        },
782
    { {':', ':'},    COLONCOLON },
783
 
784
};
785
 
786
/* Some specific keywords */
787
 
788
struct keyword {
789
   char keyw[10];
790
   int token;
791
};
792
 
793
static struct keyword keytab[] =
794
{
795
    {"OR" ,   OROR       },
796
    {"IN",    IN         },/* Note space after IN */
797
    {"AND",   LOGICAL_AND},
798
    {"ABS",   ABS        },
799
    {"CHR",   CHR        },
800
    {"DEC",   DEC        },
801
    {"NOT",   NOT        },
802
    {"DIV",   DIV        },
803
    {"INC",   INC        },
804
    {"MAX",   MAX_FUNC   },
805
    {"MIN",   MIN_FUNC   },
806
    {"MOD",   MOD        },
807
    {"ODD",   ODD        },
808
    {"CAP",   CAP        },
809
    {"ORD",   ORD        },
810
    {"VAL",   VAL        },
811
    {"EXCL",  EXCL       },
812
    {"HIGH",  HIGH       },
813
    {"INCL",  INCL       },
814
    {"SIZE",  SIZE       },
815
    {"FLOAT", FLOAT_FUNC },
816
    {"TRUNC", TRUNC      },
817
    {"TSIZE", SIZE       },
818
};
819
 
820
 
821
/* Read one token, getting characters through lexptr.  */
822
 
823
/* This is where we will check to make sure that the language and the operators used are
824
   compatible  */
825
 
826
static int
827
yylex ()
828
{
829
  int c;
830
  int namelen;
831
  int i;
832
  char *tokstart;
833
  char quote;
834
 
835
 retry:
836
 
837
  prev_lexptr = lexptr;
838
 
839
  tokstart = lexptr;
840
 
841
 
842
  /* See if it is a special token of length 2 */
843
  for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
844
     if (strncmp (tokentab2[i].name, tokstart, 2) == 0)
845
     {
846
        lexptr += 2;
847
        return tokentab2[i].token;
848
     }
849
 
850
  switch (c = *tokstart)
851
    {
852
    case 0:
853
      return 0;
854
 
855
    case ' ':
856
    case '\t':
857
    case '\n':
858
      lexptr++;
859
      goto retry;
860
 
861
    case '(':
862
      paren_depth++;
863
      lexptr++;
864
      return c;
865
 
866
    case ')':
867
      if (paren_depth == 0)
868
        return 0;
869
      paren_depth--;
870
      lexptr++;
871
      return c;
872
 
873
    case ',':
874
      if (comma_terminates && paren_depth == 0)
875
        return 0;
876
      lexptr++;
877
      return c;
878
 
879
    case '.':
880
      /* Might be a floating point number.  */
881
      if (lexptr[1] >= '0' && lexptr[1] <= '9')
882
        break;                  /* Falls into number code.  */
883
      else
884
      {
885
         lexptr++;
886
         return DOT;
887
      }
888
 
889
/* These are character tokens that appear as-is in the YACC grammar */
890
    case '+':
891
    case '-':
892
    case '*':
893
    case '/':
894
    case '^':
895
    case '<':
896
    case '>':
897
    case '[':
898
    case ']':
899
    case '=':
900
    case '{':
901
    case '}':
902
    case '#':
903
    case '@':
904
    case '~':
905
    case '&':
906
      lexptr++;
907
      return c;
908
 
909
    case '\'' :
910
    case '"':
911
      quote = c;
912
      for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
913
        if (c == '\\')
914
          {
915
            c = tokstart[++namelen];
916
            if (c >= '0' && c <= '9')
917
              {
918
                c = tokstart[++namelen];
919
                if (c >= '0' && c <= '9')
920
                  c = tokstart[++namelen];
921
              }
922
          }
923
      if(c != quote)
924
         error("Unterminated string or character constant.");
925
      yylval.sval.ptr = tokstart + 1;
926
      yylval.sval.length = namelen - 1;
927
      lexptr += namelen + 1;
928
 
929
      if(namelen == 2)          /* Single character */
930
      {
931
           yylval.ulval = tokstart[1];
932
           return CHAR;
933
      }
934
      else
935
         return STRING;
936
    }
937
 
938
  /* Is it a number?  */
939
  /* Note:  We have already dealt with the case of the token '.'.
940
     See case '.' above.  */
941
  if ((c >= '0' && c <= '9'))
942
    {
943
      /* It's a number.  */
944
      int got_dot = 0, got_e = 0;
945
      char *p = tokstart;
946
      int toktype;
947
 
948
      for (++p ;; ++p)
949
        {
950
          if (!got_e && (*p == 'e' || *p == 'E'))
951
            got_dot = got_e = 1;
952
          else if (!got_dot && *p == '.')
953
            got_dot = 1;
954
          else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
955
                   && (*p == '-' || *p == '+'))
956
            /* This is the sign of the exponent, not the end of the
957
               number.  */
958
            continue;
959
          else if ((*p < '0' || *p > '9') &&
960
                   (*p < 'A' || *p > 'F') &&
961
                   (*p != 'H'))  /* Modula-2 hexadecimal number */
962
            break;
963
        }
964
        toktype = parse_number (p - tokstart);
965
        if (toktype == ERROR)
966
          {
967
            char *err_copy = (char *) alloca (p - tokstart + 1);
968
 
969
            memcpy (err_copy, tokstart, p - tokstart);
970
            err_copy[p - tokstart] = 0;
971
            error ("Invalid number \"%s\".", err_copy);
972
          }
973
        lexptr = p;
974
        return toktype;
975
    }
976
 
977
  if (!(c == '_' || c == '$'
978
        || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
979
    /* We must have come across a bad character (e.g. ';').  */
980
    error ("Invalid character '%c' in expression.", c);
981
 
982
  /* It's a name.  See how long it is.  */
983
  namelen = 0;
984
  for (c = tokstart[namelen];
985
       (c == '_' || c == '$' || (c >= '0' && c <= '9')
986
        || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
987
       c = tokstart[++namelen])
988
    ;
989
 
990
  /* The token "if" terminates the expression and is NOT
991
     removed from the input stream.  */
992
  if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
993
    {
994
      return 0;
995
    }
996
 
997
  lexptr += namelen;
998
 
999
  /*  Lookup special keywords */
1000
  for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
1001
     if (namelen == strlen (keytab[i].keyw)
1002
         && strncmp (tokstart, keytab[i].keyw, namelen) == 0)
1003
           return keytab[i].token;
1004
 
1005
  yylval.sval.ptr = tokstart;
1006
  yylval.sval.length = namelen;
1007
 
1008
  if (*tokstart == '$')
1009
    {
1010
      write_dollar_variable (yylval.sval);
1011
      return INTERNAL_VAR;
1012
    }
1013
 
1014
  /* Use token-type BLOCKNAME for symbols that happen to be defined as
1015
     functions.  If this is not so, then ...
1016
     Use token-type TYPENAME for symbols that happen to be defined
1017
     currently as names of types; NAME for other symbols.
1018
     The caller is not constrained to care about the distinction.  */
1019
 {
1020
 
1021
 
1022
    char *tmp = copy_name (yylval.sval);
1023
    struct symbol *sym;
1024
 
1025
    if (lookup_partial_symtab (tmp))
1026
      return BLOCKNAME;
1027
    sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0);
1028
    if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1029
      return BLOCKNAME;
1030
    if (lookup_typename (parse_language, parse_gdbarch,
1031
                         copy_name (yylval.sval), expression_context_block, 1))
1032
      return TYPENAME;
1033
 
1034
    if(sym)
1035
    {
1036
      switch(SYMBOL_CLASS (sym))
1037
       {
1038
       case LOC_STATIC:
1039
       case LOC_REGISTER:
1040
       case LOC_ARG:
1041
       case LOC_REF_ARG:
1042
       case LOC_REGPARM_ADDR:
1043
       case LOC_LOCAL:
1044
       case LOC_CONST:
1045
       case LOC_CONST_BYTES:
1046
       case LOC_OPTIMIZED_OUT:
1047
       case LOC_COMPUTED:
1048
          return NAME;
1049
 
1050
       case LOC_TYPEDEF:
1051
          return TYPENAME;
1052
 
1053
       case LOC_BLOCK:
1054
          return BLOCKNAME;
1055
 
1056
       case LOC_UNDEF:
1057
          error("internal:  Undefined class in m2lex()");
1058
 
1059
       case LOC_LABEL:
1060
       case LOC_UNRESOLVED:
1061
          error("internal:  Unforseen case in m2lex()");
1062
 
1063
       default:
1064
          error ("unhandled token in m2lex()");
1065
          break;
1066
       }
1067
    }
1068
    else
1069
    {
1070
       /* Built-in BOOLEAN type.  This is sort of a hack. */
1071
       if (strncmp (tokstart, "TRUE", 4) == 0)
1072
       {
1073
          yylval.ulval = 1;
1074
          return M2_TRUE;
1075
       }
1076
       else if (strncmp (tokstart, "FALSE", 5) == 0)
1077
       {
1078
          yylval.ulval = 0;
1079
          return M2_FALSE;
1080
       }
1081
    }
1082
 
1083
    /* Must be another type of name... */
1084
    return NAME;
1085
 }
1086
}
1087
 
1088
#if 0           /* Unused */
1089
static char *
1090
make_qualname(mod,ident)
1091
   char *mod, *ident;
1092
{
1093
   char *new = malloc(strlen(mod)+strlen(ident)+2);
1094
 
1095
   strcpy(new,mod);
1096
   strcat(new,".");
1097
   strcat(new,ident);
1098
   return new;
1099
}
1100
#endif  /* 0 */
1101
 
1102
void
1103
yyerror (msg)
1104
     char *msg;
1105
{
1106
  if (prev_lexptr)
1107
    lexptr = prev_lexptr;
1108
 
1109
  error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1110
}

powered by: WebSVN 2.1.0

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