* expression.h (enum exp_opcode): Document OP_COMPLEX to take
[platform/upstream/binutils.git] / gdb / f-exp.y
1 /* YACC parser for Fortran expressions, for GDB.
2    Copyright (C) 1986, 1989, 1990, 1991, 1993, 1994, 1995, 1996, 2000, 2001,
3    2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4
5    Contributed by Motorola.  Adapted from the C parser by Farooq Butt
6    (fmbutt@engage.sps.mot.com).
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA.  */
24
25 /* This was blantantly ripped off the C expression parser, please 
26    be aware of that as you look at its basic structure -FMB */ 
27
28 /* Parse a F77 expression from text in a string,
29    and return the result as a  struct expression  pointer.
30    That structure contains arithmetic operations in reverse polish,
31    with constants represented by operations that are followed by special data.
32    See expression.h for the details of the format.
33    What is important here is that it can be built up sequentially
34    during the process of parsing; the lower levels of the tree always
35    come first in the result.
36
37    Note that malloc's and realloc's in this file are transformed to
38    xmalloc and xrealloc respectively by the same sed command in the
39    makefile that remaps any other malloc/realloc inserted by the parser
40    generator.  Doing this with #defines and trying to control the interaction
41    with include files (<malloc.h> and <stdlib.h> for example) just became
42    too messy, particularly when such includes can be inserted at random
43    times by the parser generator.  */
44    
45 %{
46
47 #include "defs.h"
48 #include "gdb_string.h"
49 #include "expression.h"
50 #include "value.h"
51 #include "parser-defs.h"
52 #include "language.h"
53 #include "f-lang.h"
54 #include "bfd.h" /* Required by objfiles.h.  */
55 #include "symfile.h" /* Required by objfiles.h.  */
56 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
57 #include "block.h"
58 #include <ctype.h>
59
60 #define parse_type builtin_type (parse_gdbarch)
61 #define parse_f_type builtin_f_type (parse_gdbarch)
62
63 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
64    as well as gratuitiously global symbol names, so we can have multiple
65    yacc generated parsers in gdb.  Note that these are only the variables
66    produced by yacc.  If other parser generators (bison, byacc, etc) produce
67    additional global names that conflict at link time, then those parser
68    generators need to be fixed instead of adding those names to this list. */
69
70 #define yymaxdepth f_maxdepth
71 #define yyparse f_parse
72 #define yylex   f_lex
73 #define yyerror f_error
74 #define yylval  f_lval
75 #define yychar  f_char
76 #define yydebug f_debug
77 #define yypact  f_pact  
78 #define yyr1    f_r1                    
79 #define yyr2    f_r2                    
80 #define yydef   f_def           
81 #define yychk   f_chk           
82 #define yypgo   f_pgo           
83 #define yyact   f_act           
84 #define yyexca  f_exca
85 #define yyerrflag f_errflag
86 #define yynerrs f_nerrs
87 #define yyps    f_ps
88 #define yypv    f_pv
89 #define yys     f_s
90 #define yy_yys  f_yys
91 #define yystate f_state
92 #define yytmp   f_tmp
93 #define yyv     f_v
94 #define yy_yyv  f_yyv
95 #define yyval   f_val
96 #define yylloc  f_lloc
97 #define yyreds  f_reds          /* With YYDEBUG defined */
98 #define yytoks  f_toks          /* With YYDEBUG defined */
99 #define yyname  f_name          /* With YYDEBUG defined */
100 #define yyrule  f_rule          /* With YYDEBUG defined */
101 #define yylhs   f_yylhs
102 #define yylen   f_yylen
103 #define yydefred f_yydefred
104 #define yydgoto f_yydgoto
105 #define yysindex f_yysindex
106 #define yyrindex f_yyrindex
107 #define yygindex f_yygindex
108 #define yytable  f_yytable
109 #define yycheck  f_yycheck
110
111 #ifndef YYDEBUG
112 #define YYDEBUG 1               /* Default to yydebug support */
113 #endif
114
115 #define YYFPRINTF parser_fprintf
116
117 int yyparse (void);
118
119 static int yylex (void);
120
121 void yyerror (char *);
122
123 static void growbuf_by_size (int);
124
125 static int match_string_literal (void);
126
127 %}
128
129 /* Although the yacc "value" of an expression is not used,
130    since the result is stored in the structure being created,
131    other node types do have values.  */
132
133 %union
134   {
135     LONGEST lval;
136     struct {
137       LONGEST val;
138       struct type *type;
139     } typed_val;
140     DOUBLEST dval;
141     struct symbol *sym;
142     struct type *tval;
143     struct stoken sval;
144     struct ttype tsym;
145     struct symtoken ssym;
146     int voidval;
147     struct block *bval;
148     enum exp_opcode opcode;
149     struct internalvar *ivar;
150
151     struct type **tvec;
152     int *ivec;
153   }
154
155 %{
156 /* YYSTYPE gets defined by %union */
157 static int parse_number (char *, int, int, YYSTYPE *);
158 %}
159
160 %type <voidval> exp  type_exp start variable 
161 %type <tval> type typebase
162 %type <tvec> nonempty_typelist
163 /* %type <bval> block */
164
165 /* Fancy type parsing.  */
166 %type <voidval> func_mod direct_abs_decl abs_decl
167 %type <tval> ptype
168
169 %token <typed_val> INT
170 %token <dval> FLOAT
171
172 /* Both NAME and TYPENAME tokens represent symbols in the input,
173    and both convey their data as strings.
174    But a TYPENAME is a string that happens to be defined as a typedef
175    or builtin type name (such as int or char)
176    and a NAME is any other symbol.
177    Contexts where this distinction is not important can use the
178    nonterminal "name", which matches either NAME or TYPENAME.  */
179
180 %token <sval> STRING_LITERAL
181 %token <lval> BOOLEAN_LITERAL
182 %token <ssym> NAME 
183 %token <tsym> TYPENAME
184 %type <sval> name
185 %type <ssym> name_not_typename
186
187 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
188    but which would parse as a valid number in the current input radix.
189    E.g. "c" when input_radix==16.  Depending on the parse, it will be
190    turned into a name or into a number.  */
191
192 %token <ssym> NAME_OR_INT 
193
194 %token  SIZEOF 
195 %token ERROR
196
197 /* Special type cases, put in to allow the parser to distinguish different
198    legal basetypes.  */
199 %token INT_KEYWORD INT_S2_KEYWORD LOGICAL_S1_KEYWORD LOGICAL_S2_KEYWORD 
200 %token LOGICAL_KEYWORD REAL_KEYWORD REAL_S8_KEYWORD REAL_S16_KEYWORD 
201 %token COMPLEX_S8_KEYWORD COMPLEX_S16_KEYWORD COMPLEX_S32_KEYWORD 
202 %token BOOL_AND BOOL_OR BOOL_NOT   
203 %token <lval> CHARACTER 
204
205 %token <voidval> VARIABLE
206
207 %token <opcode> ASSIGN_MODIFY
208
209 %left ','
210 %left ABOVE_COMMA
211 %right '=' ASSIGN_MODIFY
212 %right '?'
213 %left BOOL_OR
214 %right BOOL_NOT
215 %left BOOL_AND
216 %left '|'
217 %left '^'
218 %left '&'
219 %left EQUAL NOTEQUAL
220 %left LESSTHAN GREATERTHAN LEQ GEQ
221 %left LSH RSH
222 %left '@'
223 %left '+' '-'
224 %left '*' '/'
225 %right STARSTAR
226 %right '%'
227 %right UNARY 
228 %right '('
229
230 \f
231 %%
232
233 start   :       exp
234         |       type_exp
235         ;
236
237 type_exp:       type
238                         { write_exp_elt_opcode(OP_TYPE);
239                           write_exp_elt_type($1);
240                           write_exp_elt_opcode(OP_TYPE); }
241         ;
242
243 exp     :       '(' exp ')'
244                         { }
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     :       BOOL_NOT 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     :       SIZEOF exp       %prec UNARY
269                         { write_exp_elt_opcode (UNOP_SIZEOF); }
270         ;
271
272 /* No more explicit array operators, we treat everything in F77 as 
273    a function call.  The disambiguation as to whether we are 
274    doing a subscript operation or a function call is done 
275    later in eval.c.  */
276
277 exp     :       exp '(' 
278                         { start_arglist (); }
279                 arglist ')'     
280                         { write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);
281                           write_exp_elt_longcst ((LONGEST) end_arglist ());
282                           write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST); }
283         ;
284
285 arglist :
286         ;
287
288 arglist :       exp
289                         { arglist_len = 1; }
290         ;
291
292 arglist :       subrange
293                         { arglist_len = 1; }
294         ;
295    
296 arglist :       arglist ',' exp   %prec ABOVE_COMMA
297                         { arglist_len++; }
298         ;
299
300 /* There are four sorts of subrange types in F90.  */
301
302 subrange:       exp ':' exp     %prec ABOVE_COMMA
303                         { write_exp_elt_opcode (OP_F90_RANGE); 
304                           write_exp_elt_longcst (NONE_BOUND_DEFAULT);
305                           write_exp_elt_opcode (OP_F90_RANGE); }
306         ;
307
308 subrange:       exp ':' %prec ABOVE_COMMA
309                         { write_exp_elt_opcode (OP_F90_RANGE);
310                           write_exp_elt_longcst (HIGH_BOUND_DEFAULT);
311                           write_exp_elt_opcode (OP_F90_RANGE); }
312         ;
313
314 subrange:       ':' exp %prec ABOVE_COMMA
315                         { write_exp_elt_opcode (OP_F90_RANGE);
316                           write_exp_elt_longcst (LOW_BOUND_DEFAULT);
317                           write_exp_elt_opcode (OP_F90_RANGE); }
318         ;
319
320 subrange:       ':'     %prec ABOVE_COMMA
321                         { write_exp_elt_opcode (OP_F90_RANGE);
322                           write_exp_elt_longcst (BOTH_BOUND_DEFAULT);
323                           write_exp_elt_opcode (OP_F90_RANGE); }
324         ;
325
326 complexnum:     exp ',' exp 
327                         { }                          
328         ;
329
330 exp     :       '(' complexnum ')'
331                         { write_exp_elt_opcode(OP_COMPLEX);
332                           write_exp_elt_type (parse_f_type->builtin_complex_s16);
333                           write_exp_elt_opcode(OP_COMPLEX); }
334         ;
335
336 exp     :       '(' type ')' exp  %prec UNARY
337                         { write_exp_elt_opcode (UNOP_CAST);
338                           write_exp_elt_type ($2);
339                           write_exp_elt_opcode (UNOP_CAST); }
340         ;
341
342 exp     :       exp '%' name
343                         { write_exp_elt_opcode (STRUCTOP_STRUCT);
344                           write_exp_string ($3);
345                           write_exp_elt_opcode (STRUCTOP_STRUCT); }
346         ;
347
348 /* Binary operators in order of decreasing precedence.  */
349
350 exp     :       exp '@' exp
351                         { write_exp_elt_opcode (BINOP_REPEAT); }
352         ;
353
354 exp     :       exp STARSTAR exp
355                         { write_exp_elt_opcode (BINOP_EXP); }
356         ;
357
358 exp     :       exp '*' exp
359                         { write_exp_elt_opcode (BINOP_MUL); }
360         ;
361
362 exp     :       exp '/' exp
363                         { write_exp_elt_opcode (BINOP_DIV); }
364         ;
365
366 exp     :       exp '+' exp
367                         { write_exp_elt_opcode (BINOP_ADD); }
368         ;
369
370 exp     :       exp '-' exp
371                         { write_exp_elt_opcode (BINOP_SUB); }
372         ;
373
374 exp     :       exp LSH exp
375                         { write_exp_elt_opcode (BINOP_LSH); }
376         ;
377
378 exp     :       exp RSH exp
379                         { write_exp_elt_opcode (BINOP_RSH); }
380         ;
381
382 exp     :       exp EQUAL exp
383                         { write_exp_elt_opcode (BINOP_EQUAL); }
384         ;
385
386 exp     :       exp NOTEQUAL exp
387                         { write_exp_elt_opcode (BINOP_NOTEQUAL); }
388         ;
389
390 exp     :       exp LEQ exp
391                         { write_exp_elt_opcode (BINOP_LEQ); }
392         ;
393
394 exp     :       exp GEQ exp
395                         { write_exp_elt_opcode (BINOP_GEQ); }
396         ;
397
398 exp     :       exp LESSTHAN exp
399                         { write_exp_elt_opcode (BINOP_LESS); }
400         ;
401
402 exp     :       exp GREATERTHAN exp
403                         { write_exp_elt_opcode (BINOP_GTR); }
404         ;
405
406 exp     :       exp '&' exp
407                         { write_exp_elt_opcode (BINOP_BITWISE_AND); }
408         ;
409
410 exp     :       exp '^' exp
411                         { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
412         ;
413
414 exp     :       exp '|' exp
415                         { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
416         ;
417
418 exp     :       exp BOOL_AND exp
419                         { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
420         ;
421
422
423 exp     :       exp BOOL_OR exp
424                         { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
425         ;
426
427 exp     :       exp '=' exp
428                         { write_exp_elt_opcode (BINOP_ASSIGN); }
429         ;
430
431 exp     :       exp ASSIGN_MODIFY exp
432                         { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
433                           write_exp_elt_opcode ($2);
434                           write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
435         ;
436
437 exp     :       INT
438                         { write_exp_elt_opcode (OP_LONG);
439                           write_exp_elt_type ($1.type);
440                           write_exp_elt_longcst ((LONGEST)($1.val));
441                           write_exp_elt_opcode (OP_LONG); }
442         ;
443
444 exp     :       NAME_OR_INT
445                         { YYSTYPE val;
446                           parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
447                           write_exp_elt_opcode (OP_LONG);
448                           write_exp_elt_type (val.typed_val.type);
449                           write_exp_elt_longcst ((LONGEST)val.typed_val.val);
450                           write_exp_elt_opcode (OP_LONG); }
451         ;
452
453 exp     :       FLOAT
454                         { write_exp_elt_opcode (OP_DOUBLE);
455                           write_exp_elt_type (parse_f_type->builtin_real_s8);
456                           write_exp_elt_dblcst ($1);
457                           write_exp_elt_opcode (OP_DOUBLE); }
458         ;
459
460 exp     :       variable
461         ;
462
463 exp     :       VARIABLE
464         ;
465
466 exp     :       SIZEOF '(' type ')'     %prec UNARY
467                         { write_exp_elt_opcode (OP_LONG);
468                           write_exp_elt_type (parse_f_type->builtin_integer);
469                           CHECK_TYPEDEF ($3);
470                           write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
471                           write_exp_elt_opcode (OP_LONG); }
472         ;
473
474 exp     :       BOOLEAN_LITERAL
475                         { write_exp_elt_opcode (OP_BOOL);
476                           write_exp_elt_longcst ((LONGEST) $1);
477                           write_exp_elt_opcode (OP_BOOL);
478                         }
479         ;
480
481 exp     :       STRING_LITERAL
482                         {
483                           write_exp_elt_opcode (OP_STRING);
484                           write_exp_string ($1);
485                           write_exp_elt_opcode (OP_STRING);
486                         }
487         ;
488
489 variable:       name_not_typename
490                         { struct symbol *sym = $1.sym;
491
492                           if (sym)
493                             {
494                               if (symbol_read_needs_frame (sym))
495                                 {
496                                   if (innermost_block == 0 ||
497                                       contained_in (block_found, 
498                                                     innermost_block))
499                                     innermost_block = block_found;
500                                 }
501                               write_exp_elt_opcode (OP_VAR_VALUE);
502                               /* We want to use the selected frame, not
503                                  another more inner frame which happens to
504                                  be in the same block.  */
505                               write_exp_elt_block (NULL);
506                               write_exp_elt_sym (sym);
507                               write_exp_elt_opcode (OP_VAR_VALUE);
508                               break;
509                             }
510                           else
511                             {
512                               struct minimal_symbol *msymbol;
513                               char *arg = copy_name ($1.stoken);
514
515                               msymbol =
516                                 lookup_minimal_symbol (arg, NULL, NULL);
517                               if (msymbol != NULL)
518                                 write_exp_msymbol (msymbol);
519                               else if (!have_full_symbols () && !have_partial_symbols ())
520                                 error ("No symbol table is loaded.  Use the \"file\" command.");
521                               else
522                                 error ("No symbol \"%s\" in current context.",
523                                        copy_name ($1.stoken));
524                             }
525                         }
526         ;
527
528
529 type    :       ptype
530         ;
531
532 ptype   :       typebase
533         |       typebase abs_decl
534                 {
535                   /* This is where the interesting stuff happens.  */
536                   int done = 0;
537                   int array_size;
538                   struct type *follow_type = $1;
539                   struct type *range_type;
540                   
541                   while (!done)
542                     switch (pop_type ())
543                       {
544                       case tp_end:
545                         done = 1;
546                         break;
547                       case tp_pointer:
548                         follow_type = lookup_pointer_type (follow_type);
549                         break;
550                       case tp_reference:
551                         follow_type = lookup_reference_type (follow_type);
552                         break;
553                       case tp_array:
554                         array_size = pop_type_int ();
555                         if (array_size != -1)
556                           {
557                             range_type =
558                               create_range_type ((struct type *) NULL,
559                                                  parse_f_type->builtin_integer,
560                                                  0, array_size - 1);
561                             follow_type =
562                               create_array_type ((struct type *) NULL,
563                                                  follow_type, range_type);
564                           }
565                         else
566                           follow_type = lookup_pointer_type (follow_type);
567                         break;
568                       case tp_function:
569                         follow_type = lookup_function_type (follow_type);
570                         break;
571                       }
572                   $$ = follow_type;
573                 }
574         ;
575
576 abs_decl:       '*'
577                         { push_type (tp_pointer); $$ = 0; }
578         |       '*' abs_decl
579                         { push_type (tp_pointer); $$ = $2; }
580         |       '&'
581                         { push_type (tp_reference); $$ = 0; }
582         |       '&' abs_decl
583                         { push_type (tp_reference); $$ = $2; }
584         |       direct_abs_decl
585         ;
586
587 direct_abs_decl: '(' abs_decl ')'
588                         { $$ = $2; }
589         |       direct_abs_decl func_mod
590                         { push_type (tp_function); }
591         |       func_mod
592                         { push_type (tp_function); }
593         ;
594
595 func_mod:       '(' ')'
596                         { $$ = 0; }
597         |       '(' nonempty_typelist ')'
598                         { free ($2); $$ = 0; }
599         ;
600
601 typebase  /* Implements (approximately): (type-qualifier)* type-specifier */
602         :       TYPENAME
603                         { $$ = $1.type; }
604         |       INT_KEYWORD
605                         { $$ = parse_f_type->builtin_integer; }
606         |       INT_S2_KEYWORD 
607                         { $$ = parse_f_type->builtin_integer_s2; }
608         |       CHARACTER 
609                         { $$ = parse_f_type->builtin_character; }
610         |       LOGICAL_KEYWORD 
611                         { $$ = parse_f_type->builtin_logical; }
612         |       LOGICAL_S2_KEYWORD
613                         { $$ = parse_f_type->builtin_logical_s2; }
614         |       LOGICAL_S1_KEYWORD 
615                         { $$ = parse_f_type->builtin_logical_s1; }
616         |       REAL_KEYWORD 
617                         { $$ = parse_f_type->builtin_real; }
618         |       REAL_S8_KEYWORD
619                         { $$ = parse_f_type->builtin_real_s8; }
620         |       REAL_S16_KEYWORD
621                         { $$ = parse_f_type->builtin_real_s16; }
622         |       COMPLEX_S8_KEYWORD
623                         { $$ = parse_f_type->builtin_complex_s8; }
624         |       COMPLEX_S16_KEYWORD 
625                         { $$ = parse_f_type->builtin_complex_s16; }
626         |       COMPLEX_S32_KEYWORD 
627                         { $$ = parse_f_type->builtin_complex_s32; }
628         ;
629
630 nonempty_typelist
631         :       type
632                 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
633                   $<ivec>$[0] = 1;      /* Number of types in vector */
634                   $$[1] = $1;
635                 }
636         |       nonempty_typelist ',' type
637                 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
638                   $$ = (struct type **) realloc ((char *) $1, len);
639                   $$[$<ivec>$[0]] = $3;
640                 }
641         ;
642
643 name    :       NAME
644                 {  $$ = $1.stoken; }
645         ;
646
647 name_not_typename :     NAME
648 /* These would be useful if name_not_typename was useful, but it is just
649    a fake for "variable", so these cause reduce/reduce conflicts because
650    the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
651    =exp) or just an exp.  If name_not_typename was ever used in an lvalue
652    context where only a name could occur, this might be useful.
653         |       NAME_OR_INT
654    */
655         ;
656
657 %%
658
659 /* Take care of parsing a number (anything that starts with a digit).
660    Set yylval and return the token type; update lexptr.
661    LEN is the number of characters in it.  */
662
663 /*** Needs some error checking for the float case ***/
664
665 static int
666 parse_number (p, len, parsed_float, putithere)
667      char *p;
668      int len;
669      int parsed_float;
670      YYSTYPE *putithere;
671 {
672   LONGEST n = 0;
673   LONGEST prevn = 0;
674   int c;
675   int base = input_radix;
676   int unsigned_p = 0;
677   int long_p = 0;
678   ULONGEST high_bit;
679   struct type *signed_type;
680   struct type *unsigned_type;
681
682   if (parsed_float)
683     {
684       /* It's a float since it contains a point or an exponent.  */
685       /* [dD] is not understood as an exponent by atof, change it to 'e'.  */
686       char *tmp, *tmp2;
687
688       tmp = xstrdup (p);
689       for (tmp2 = tmp; *tmp2; ++tmp2)
690         if (*tmp2 == 'd' || *tmp2 == 'D')
691           *tmp2 = 'e';
692       putithere->dval = atof (tmp);
693       free (tmp);
694       return FLOAT;
695     }
696
697   /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
698   if (p[0] == '0')
699     switch (p[1])
700       {
701       case 'x':
702       case 'X':
703         if (len >= 3)
704           {
705             p += 2;
706             base = 16;
707             len -= 2;
708           }
709         break;
710         
711       case 't':
712       case 'T':
713       case 'd':
714       case 'D':
715         if (len >= 3)
716           {
717             p += 2;
718             base = 10;
719             len -= 2;
720           }
721         break;
722         
723       default:
724         base = 8;
725         break;
726       }
727   
728   while (len-- > 0)
729     {
730       c = *p++;
731       if (isupper (c))
732         c = tolower (c);
733       if (len == 0 && c == 'l')
734         long_p = 1;
735       else if (len == 0 && c == 'u')
736         unsigned_p = 1;
737       else
738         {
739           int i;
740           if (c >= '0' && c <= '9')
741             i = c - '0';
742           else if (c >= 'a' && c <= 'f')
743             i = c - 'a' + 10;
744           else
745             return ERROR;       /* Char not a digit */
746           if (i >= base)
747             return ERROR;               /* Invalid digit in this base */
748           n *= base;
749           n += i;
750         }
751       /* Portably test for overflow (only works for nonzero values, so make
752          a second check for zero).  */
753       if ((prevn >= n) && n != 0)
754         unsigned_p=1;           /* Try something unsigned */
755       /* If range checking enabled, portably test for unsigned overflow.  */
756       if (RANGE_CHECK && n != 0)
757         {
758           if ((unsigned_p && (unsigned)prevn >= (unsigned)n))
759             range_error("Overflow on numeric constant.");        
760         }
761       prevn = n;
762     }
763   
764   /* If the number is too big to be an int, or it's got an l suffix
765      then it's a long.  Work out if this has to be a long by
766      shifting right and and seeing if anything remains, and the
767      target int size is different to the target long size.
768      
769      In the expression below, we could have tested
770      (n >> gdbarch_int_bit (parse_gdbarch))
771      to see if it was zero,
772      but too many compilers warn about that, when ints and longs
773      are the same size.  So we shift it twice, with fewer bits
774      each time, for the same result.  */
775   
776   if ((gdbarch_int_bit (parse_gdbarch) != gdbarch_long_bit (parse_gdbarch)
777        && ((n >> 2)
778            >> (gdbarch_int_bit (parse_gdbarch)-2))) /* Avoid shift warning */
779       || long_p)
780     {
781       high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch)-1);
782       unsigned_type = parse_type->builtin_unsigned_long;
783       signed_type = parse_type->builtin_long;
784     }
785   else 
786     {
787       high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch)-1);
788       unsigned_type = parse_type->builtin_unsigned_int;
789       signed_type = parse_type->builtin_int;
790     }    
791   
792   putithere->typed_val.val = n;
793   
794   /* If the high bit of the worked out type is set then this number
795      has to be unsigned. */
796   
797   if (unsigned_p || (n & high_bit)) 
798     putithere->typed_val.type = unsigned_type;
799   else 
800     putithere->typed_val.type = signed_type;
801   
802   return INT;
803 }
804
805 struct token
806 {
807   char *operator;
808   int token;
809   enum exp_opcode opcode;
810 };
811
812 static const struct token dot_ops[] =
813 {
814   { ".and.", BOOL_AND, BINOP_END },
815   { ".AND.", BOOL_AND, BINOP_END },
816   { ".or.", BOOL_OR, BINOP_END },
817   { ".OR.", BOOL_OR, BINOP_END },
818   { ".not.", BOOL_NOT, BINOP_END },
819   { ".NOT.", BOOL_NOT, BINOP_END },
820   { ".eq.", EQUAL, BINOP_END },
821   { ".EQ.", EQUAL, BINOP_END },
822   { ".eqv.", EQUAL, BINOP_END },
823   { ".NEQV.", NOTEQUAL, BINOP_END },
824   { ".neqv.", NOTEQUAL, BINOP_END },
825   { ".EQV.", EQUAL, BINOP_END },
826   { ".ne.", NOTEQUAL, BINOP_END },
827   { ".NE.", NOTEQUAL, BINOP_END },
828   { ".le.", LEQ, BINOP_END },
829   { ".LE.", LEQ, BINOP_END },
830   { ".ge.", GEQ, BINOP_END },
831   { ".GE.", GEQ, BINOP_END },
832   { ".gt.", GREATERTHAN, BINOP_END },
833   { ".GT.", GREATERTHAN, BINOP_END },
834   { ".lt.", LESSTHAN, BINOP_END },
835   { ".LT.", LESSTHAN, BINOP_END },
836   { NULL, 0, 0 }
837 };
838
839 struct f77_boolean_val 
840 {
841   char *name;
842   int value;
843 }; 
844
845 static const struct f77_boolean_val boolean_values[]  = 
846 {
847   { ".true.", 1 },
848   { ".TRUE.", 1 },
849   { ".false.", 0 },
850   { ".FALSE.", 0 },
851   { NULL, 0 }
852 };
853
854 static const struct token f77_keywords[] = 
855 {
856   { "complex_16", COMPLEX_S16_KEYWORD, BINOP_END },
857   { "complex_32", COMPLEX_S32_KEYWORD, BINOP_END },
858   { "character", CHARACTER, BINOP_END },
859   { "integer_2", INT_S2_KEYWORD, BINOP_END },
860   { "logical_1", LOGICAL_S1_KEYWORD, BINOP_END },
861   { "logical_2", LOGICAL_S2_KEYWORD, BINOP_END },
862   { "complex_8", COMPLEX_S8_KEYWORD, BINOP_END },
863   { "integer", INT_KEYWORD, BINOP_END },
864   { "logical", LOGICAL_KEYWORD, BINOP_END },
865   { "real_16", REAL_S16_KEYWORD, BINOP_END },
866   { "complex", COMPLEX_S8_KEYWORD, BINOP_END },
867   { "sizeof", SIZEOF, BINOP_END },
868   { "real_8", REAL_S8_KEYWORD, BINOP_END },
869   { "real", REAL_KEYWORD, BINOP_END },
870   { NULL, 0, 0 }
871 }; 
872
873 /* Implementation of a dynamically expandable buffer for processing input
874    characters acquired through lexptr and building a value to return in
875    yylval. Ripped off from ch-exp.y */ 
876
877 static char *tempbuf;           /* Current buffer contents */
878 static int tempbufsize;         /* Size of allocated buffer */
879 static int tempbufindex;        /* Current index into buffer */
880
881 #define GROWBY_MIN_SIZE 64      /* Minimum amount to grow buffer by */
882
883 #define CHECKBUF(size) \
884   do { \
885     if (tempbufindex + (size) >= tempbufsize) \
886       { \
887         growbuf_by_size (size); \
888       } \
889   } while (0);
890
891
892 /* Grow the static temp buffer if necessary, including allocating the first one
893    on demand. */
894
895 static void
896 growbuf_by_size (count)
897      int count;
898 {
899   int growby;
900
901   growby = max (count, GROWBY_MIN_SIZE);
902   tempbufsize += growby;
903   if (tempbuf == NULL)
904     tempbuf = (char *) malloc (tempbufsize);
905   else
906     tempbuf = (char *) realloc (tempbuf, tempbufsize);
907 }
908
909 /* Blatantly ripped off from ch-exp.y. This routine recognizes F77 
910    string-literals. 
911    
912    Recognize a string literal.  A string literal is a nonzero sequence
913    of characters enclosed in matching single quotes, except that
914    a single character inside single quotes is a character literal, which
915    we reject as a string literal.  To embed the terminator character inside
916    a string, it is simply doubled (I.E. 'this''is''one''string') */
917
918 static int
919 match_string_literal ()
920 {
921   char *tokptr = lexptr;
922
923   for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)
924     {
925       CHECKBUF (1);
926       if (*tokptr == *lexptr)
927         {
928           if (*(tokptr + 1) == *lexptr)
929             tokptr++;
930           else
931             break;
932         }
933       tempbuf[tempbufindex++] = *tokptr;
934     }
935   if (*tokptr == '\0'                                   /* no terminator */
936       || tempbufindex == 0)                             /* no string */
937     return 0;
938   else
939     {
940       tempbuf[tempbufindex] = '\0';
941       yylval.sval.ptr = tempbuf;
942       yylval.sval.length = tempbufindex;
943       lexptr = ++tokptr;
944       return STRING_LITERAL;
945     }
946 }
947
948 /* Read one token, getting characters through lexptr.  */
949
950 static int
951 yylex ()
952 {
953   int c;
954   int namelen;
955   unsigned int i,token;
956   char *tokstart;
957   
958  retry:
959  
960   prev_lexptr = lexptr;
961  
962   tokstart = lexptr;
963   
964   /* First of all, let us make sure we are not dealing with the 
965      special tokens .true. and .false. which evaluate to 1 and 0.  */
966   
967   if (*lexptr == '.')
968     { 
969       for (i = 0; boolean_values[i].name != NULL; i++)
970         {
971           if (strncmp (tokstart, boolean_values[i].name,
972                        strlen (boolean_values[i].name)) == 0)
973             {
974               lexptr += strlen (boolean_values[i].name); 
975               yylval.lval = boolean_values[i].value; 
976               return BOOLEAN_LITERAL;
977             }
978         }
979     }
980   
981   /* See if it is a special .foo. operator.  */
982   
983   for (i = 0; dot_ops[i].operator != NULL; i++)
984     if (strncmp (tokstart, dot_ops[i].operator, strlen (dot_ops[i].operator)) == 0)
985       {
986         lexptr += strlen (dot_ops[i].operator);
987         yylval.opcode = dot_ops[i].opcode;
988         return dot_ops[i].token;
989       }
990   
991   /* See if it is an exponentiation operator.  */
992
993   if (strncmp (tokstart, "**", 2) == 0)
994     {
995       lexptr += 2;
996       yylval.opcode = BINOP_EXP;
997       return STARSTAR;
998     }
999
1000   switch (c = *tokstart)
1001     {
1002     case 0:
1003       return 0;
1004       
1005     case ' ':
1006     case '\t':
1007     case '\n':
1008       lexptr++;
1009       goto retry;
1010       
1011     case '\'':
1012       token = match_string_literal ();
1013       if (token != 0)
1014         return (token);
1015       break;
1016       
1017     case '(':
1018       paren_depth++;
1019       lexptr++;
1020       return c;
1021       
1022     case ')':
1023       if (paren_depth == 0)
1024         return 0;
1025       paren_depth--;
1026       lexptr++;
1027       return c;
1028       
1029     case ',':
1030       if (comma_terminates && paren_depth == 0)
1031         return 0;
1032       lexptr++;
1033       return c;
1034       
1035     case '.':
1036       /* Might be a floating point number.  */
1037       if (lexptr[1] < '0' || lexptr[1] > '9')
1038         goto symbol;            /* Nope, must be a symbol. */
1039       /* FALL THRU into number case.  */
1040       
1041     case '0':
1042     case '1':
1043     case '2':
1044     case '3':
1045     case '4':
1046     case '5':
1047     case '6':
1048     case '7':
1049     case '8':
1050     case '9':
1051       {
1052         /* It's a number.  */
1053         int got_dot = 0, got_e = 0, got_d = 0, toktype;
1054         char *p = tokstart;
1055         int hex = input_radix > 10;
1056         
1057         if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1058           {
1059             p += 2;
1060             hex = 1;
1061           }
1062         else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1063           {
1064             p += 2;
1065             hex = 0;
1066           }
1067         
1068         for (;; ++p)
1069           {
1070             if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1071               got_dot = got_e = 1;
1072             else if (!hex && !got_d && (*p == 'd' || *p == 'D'))
1073               got_dot = got_d = 1;
1074             else if (!hex && !got_dot && *p == '.')
1075               got_dot = 1;
1076             else if (((got_e && (p[-1] == 'e' || p[-1] == 'E'))
1077                      || (got_d && (p[-1] == 'd' || p[-1] == 'D')))
1078                      && (*p == '-' || *p == '+'))
1079               /* This is the sign of the exponent, not the end of the
1080                  number.  */
1081               continue;
1082             /* We will take any letters or digits.  parse_number will
1083                complain if past the radix, or if L or U are not final.  */
1084             else if ((*p < '0' || *p > '9')
1085                      && ((*p < 'a' || *p > 'z')
1086                          && (*p < 'A' || *p > 'Z')))
1087               break;
1088           }
1089         toktype = parse_number (tokstart, p - tokstart, got_dot|got_e|got_d,
1090                                 &yylval);
1091         if (toktype == ERROR)
1092           {
1093             char *err_copy = (char *) alloca (p - tokstart + 1);
1094             
1095             memcpy (err_copy, tokstart, p - tokstart);
1096             err_copy[p - tokstart] = 0;
1097             error ("Invalid number \"%s\".", err_copy);
1098           }
1099         lexptr = p;
1100         return toktype;
1101       }
1102       
1103     case '+':
1104     case '-':
1105     case '*':
1106     case '/':
1107     case '%':
1108     case '|':
1109     case '&':
1110     case '^':
1111     case '~':
1112     case '!':
1113     case '@':
1114     case '<':
1115     case '>':
1116     case '[':
1117     case ']':
1118     case '?':
1119     case ':':
1120     case '=':
1121     case '{':
1122     case '}':
1123     symbol:
1124       lexptr++;
1125       return c;
1126     }
1127   
1128   if (!(c == '_' || c == '$'
1129         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1130     /* We must have come across a bad character (e.g. ';').  */
1131     error ("Invalid character '%c' in expression.", c);
1132   
1133   namelen = 0;
1134   for (c = tokstart[namelen];
1135        (c == '_' || c == '$' || (c >= '0' && c <= '9') 
1136         || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); 
1137        c = tokstart[++namelen]);
1138   
1139   /* The token "if" terminates the expression and is NOT 
1140      removed from the input stream.  */
1141   
1142   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1143     return 0;
1144   
1145   lexptr += namelen;
1146   
1147   /* Catch specific keywords.  */
1148   
1149   for (i = 0; f77_keywords[i].operator != NULL; i++)
1150     if (strncmp (tokstart, f77_keywords[i].operator,
1151                  strlen(f77_keywords[i].operator)) == 0)
1152       {
1153         /*      lexptr += strlen(f77_keywords[i].operator); */ 
1154         yylval.opcode = f77_keywords[i].opcode;
1155         return f77_keywords[i].token;
1156       }
1157   
1158   yylval.sval.ptr = tokstart;
1159   yylval.sval.length = namelen;
1160   
1161   if (*tokstart == '$')
1162     {
1163       write_dollar_variable (yylval.sval);
1164       return VARIABLE;
1165     }
1166   
1167   /* Use token-type TYPENAME for symbols that happen to be defined
1168      currently as names of types; NAME for other symbols.
1169      The caller is not constrained to care about the distinction.  */
1170   {
1171     char *tmp = copy_name (yylval.sval);
1172     struct symbol *sym;
1173     int is_a_field_of_this = 0;
1174     int hextype;
1175     
1176     sym = lookup_symbol (tmp, expression_context_block,
1177                          VAR_DOMAIN,
1178                          parse_language->la_language == language_cplus
1179                          ? &is_a_field_of_this : NULL);
1180     if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1181       {
1182         yylval.tsym.type = SYMBOL_TYPE (sym);
1183         return TYPENAME;
1184       }
1185     yylval.tsym.type
1186       = language_lookup_primitive_type_by_name (parse_language,
1187                                                 parse_gdbarch, tmp);
1188     if (yylval.tsym.type != NULL)
1189       return TYPENAME;
1190     
1191     /* Input names that aren't symbols but ARE valid hex numbers,
1192        when the input radix permits them, can be names or numbers
1193        depending on the parse.  Note we support radixes > 16 here.  */
1194     if (!sym
1195         && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1196             || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1197       {
1198         YYSTYPE newlval;        /* Its value is ignored.  */
1199         hextype = parse_number (tokstart, namelen, 0, &newlval);
1200         if (hextype == INT)
1201           {
1202             yylval.ssym.sym = sym;
1203             yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1204             return NAME_OR_INT;
1205           }
1206       }
1207     
1208     /* Any other kind of symbol */
1209     yylval.ssym.sym = sym;
1210     yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1211     return NAME;
1212   }
1213 }
1214
1215 void
1216 yyerror (msg)
1217      char *msg;
1218 {
1219   if (prev_lexptr)
1220     lexptr = prev_lexptr;
1221
1222   error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
1223 }