1 /* YACC parser for Fortran expressions, for GDB.
2 Copyright (C) 1986, 1989-1991, 1993-1996, 2000-2012 Free Software
5 Contributed by Motorola. Adapted from the C parser by Farooq Butt
6 (fmbutt@engage.sps.mot.com).
8 This file is part of GDB.
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 3 of the License, or
13 (at your option) any later version.
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.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* This was blantantly ripped off the C expression parser, please
24 be aware of that as you look at its basic structure -FMB */
26 /* Parse a F77 expression from text in a string,
27 and return the result as a struct expression pointer.
28 That structure contains arithmetic operations in reverse polish,
29 with constants represented by operations that are followed by special data.
30 See expression.h for the details of the format.
31 What is important here is that it can be built up sequentially
32 during the process of parsing; the lower levels of the tree always
33 come first in the result.
35 Note that malloc's and realloc's in this file are transformed to
36 xmalloc and xrealloc respectively by the same sed command in the
37 makefile that remaps any other malloc/realloc inserted by the parser
38 generator. Doing this with #defines and trying to control the interaction
39 with include files (<malloc.h> and <stdlib.h> for example) just became
40 too messy, particularly when such includes can be inserted at random
41 times by the parser generator. */
46 #include "gdb_string.h"
47 #include "expression.h"
49 #include "parser-defs.h"
52 #include "bfd.h" /* Required by objfiles.h. */
53 #include "symfile.h" /* Required by objfiles.h. */
54 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
58 #define parse_type builtin_type (parse_gdbarch)
59 #define parse_f_type builtin_f_type (parse_gdbarch)
61 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
62 as well as gratuitiously global symbol names, so we can have multiple
63 yacc generated parsers in gdb. Note that these are only the variables
64 produced by yacc. If other parser generators (bison, byacc, etc) produce
65 additional global names that conflict at link time, then those parser
66 generators need to be fixed instead of adding those names to this list. */
68 #define yymaxdepth f_maxdepth
69 #define yyparse f_parse
71 #define yyerror f_error
74 #define yydebug f_debug
83 #define yyerrflag f_errflag
84 #define yynerrs f_nerrs
89 #define yystate f_state
95 #define yyreds f_reds /* With YYDEBUG defined */
96 #define yytoks f_toks /* With YYDEBUG defined */
97 #define yyname f_name /* With YYDEBUG defined */
98 #define yyrule f_rule /* With YYDEBUG defined */
100 #define yylen f_yylen
101 #define yydefred f_yydefred
102 #define yydgoto f_yydgoto
103 #define yysindex f_yysindex
104 #define yyrindex f_yyrindex
105 #define yygindex f_yygindex
106 #define yytable f_yytable
107 #define yycheck f_yycheck
110 #define YYDEBUG 1 /* Default to yydebug support */
113 #define YYFPRINTF parser_fprintf
117 static int yylex (void);
119 void yyerror (char *);
121 static void growbuf_by_size (int);
123 static int match_string_literal (void);
127 /* Although the yacc "value" of an expression is not used,
128 since the result is stored in the structure being created,
129 other node types do have values. */
143 struct symtoken ssym;
146 enum exp_opcode opcode;
147 struct internalvar *ivar;
154 /* YYSTYPE gets defined by %union */
155 static int parse_number (char *, int, int, YYSTYPE *);
158 %type <voidval> exp type_exp start variable
159 %type <tval> type typebase
160 %type <tvec> nonempty_typelist
161 /* %type <bval> block */
163 /* Fancy type parsing. */
164 %type <voidval> func_mod direct_abs_decl abs_decl
167 %token <typed_val> INT
170 /* Both NAME and TYPENAME tokens represent symbols in the input,
171 and both convey their data as strings.
172 But a TYPENAME is a string that happens to be defined as a typedef
173 or builtin type name (such as int or char)
174 and a NAME is any other symbol.
175 Contexts where this distinction is not important can use the
176 nonterminal "name", which matches either NAME or TYPENAME. */
178 %token <sval> STRING_LITERAL
179 %token <lval> BOOLEAN_LITERAL
181 %token <tsym> TYPENAME
183 %type <ssym> name_not_typename
185 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
186 but which would parse as a valid number in the current input radix.
187 E.g. "c" when input_radix==16. Depending on the parse, it will be
188 turned into a name or into a number. */
190 %token <ssym> NAME_OR_INT
195 /* Special type cases, put in to allow the parser to distinguish different
197 %token INT_KEYWORD INT_S2_KEYWORD LOGICAL_S1_KEYWORD LOGICAL_S2_KEYWORD
198 %token LOGICAL_S8_KEYWORD
199 %token LOGICAL_KEYWORD REAL_KEYWORD REAL_S8_KEYWORD REAL_S16_KEYWORD
200 %token COMPLEX_S8_KEYWORD COMPLEX_S16_KEYWORD COMPLEX_S32_KEYWORD
201 %token BOOL_AND BOOL_OR BOOL_NOT
202 %token <lval> CHARACTER
204 %token <voidval> VARIABLE
206 %token <opcode> ASSIGN_MODIFY
210 %right '=' ASSIGN_MODIFY
219 %left LESSTHAN GREATERTHAN LEQ GEQ
237 { write_exp_elt_opcode(OP_TYPE);
238 write_exp_elt_type($1);
239 write_exp_elt_opcode(OP_TYPE); }
246 /* Expressions, not including the comma operator. */
247 exp : '*' exp %prec UNARY
248 { write_exp_elt_opcode (UNOP_IND); }
251 exp : '&' exp %prec UNARY
252 { write_exp_elt_opcode (UNOP_ADDR); }
255 exp : '-' exp %prec UNARY
256 { write_exp_elt_opcode (UNOP_NEG); }
259 exp : BOOL_NOT exp %prec UNARY
260 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
263 exp : '~' exp %prec UNARY
264 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
267 exp : SIZEOF exp %prec UNARY
268 { write_exp_elt_opcode (UNOP_SIZEOF); }
271 /* No more explicit array operators, we treat everything in F77 as
272 a function call. The disambiguation as to whether we are
273 doing a subscript operation or a function call is done
277 { start_arglist (); }
279 { write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);
280 write_exp_elt_longcst ((LONGEST) end_arglist ());
281 write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST); }
295 arglist : arglist ',' exp %prec ABOVE_COMMA
299 /* There are four sorts of subrange types in F90. */
301 subrange: exp ':' exp %prec ABOVE_COMMA
302 { write_exp_elt_opcode (OP_F90_RANGE);
303 write_exp_elt_longcst (NONE_BOUND_DEFAULT);
304 write_exp_elt_opcode (OP_F90_RANGE); }
307 subrange: exp ':' %prec ABOVE_COMMA
308 { write_exp_elt_opcode (OP_F90_RANGE);
309 write_exp_elt_longcst (HIGH_BOUND_DEFAULT);
310 write_exp_elt_opcode (OP_F90_RANGE); }
313 subrange: ':' exp %prec ABOVE_COMMA
314 { write_exp_elt_opcode (OP_F90_RANGE);
315 write_exp_elt_longcst (LOW_BOUND_DEFAULT);
316 write_exp_elt_opcode (OP_F90_RANGE); }
319 subrange: ':' %prec ABOVE_COMMA
320 { write_exp_elt_opcode (OP_F90_RANGE);
321 write_exp_elt_longcst (BOTH_BOUND_DEFAULT);
322 write_exp_elt_opcode (OP_F90_RANGE); }
325 complexnum: exp ',' exp
329 exp : '(' complexnum ')'
330 { write_exp_elt_opcode(OP_COMPLEX);
331 write_exp_elt_type (parse_f_type->builtin_complex_s16);
332 write_exp_elt_opcode(OP_COMPLEX); }
335 exp : '(' type ')' exp %prec UNARY
336 { write_exp_elt_opcode (UNOP_CAST);
337 write_exp_elt_type ($2);
338 write_exp_elt_opcode (UNOP_CAST); }
342 { write_exp_elt_opcode (STRUCTOP_STRUCT);
343 write_exp_string ($3);
344 write_exp_elt_opcode (STRUCTOP_STRUCT); }
347 /* Binary operators in order of decreasing precedence. */
350 { write_exp_elt_opcode (BINOP_REPEAT); }
353 exp : exp STARSTAR exp
354 { write_exp_elt_opcode (BINOP_EXP); }
358 { write_exp_elt_opcode (BINOP_MUL); }
362 { write_exp_elt_opcode (BINOP_DIV); }
366 { write_exp_elt_opcode (BINOP_ADD); }
370 { write_exp_elt_opcode (BINOP_SUB); }
374 { write_exp_elt_opcode (BINOP_LSH); }
378 { write_exp_elt_opcode (BINOP_RSH); }
382 { write_exp_elt_opcode (BINOP_EQUAL); }
385 exp : exp NOTEQUAL exp
386 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
390 { write_exp_elt_opcode (BINOP_LEQ); }
394 { write_exp_elt_opcode (BINOP_GEQ); }
397 exp : exp LESSTHAN exp
398 { write_exp_elt_opcode (BINOP_LESS); }
401 exp : exp GREATERTHAN exp
402 { write_exp_elt_opcode (BINOP_GTR); }
406 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
410 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
414 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
417 exp : exp BOOL_AND exp
418 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
422 exp : exp BOOL_OR exp
423 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
427 { write_exp_elt_opcode (BINOP_ASSIGN); }
430 exp : exp ASSIGN_MODIFY exp
431 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
432 write_exp_elt_opcode ($2);
433 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
437 { write_exp_elt_opcode (OP_LONG);
438 write_exp_elt_type ($1.type);
439 write_exp_elt_longcst ((LONGEST)($1.val));
440 write_exp_elt_opcode (OP_LONG); }
445 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
446 write_exp_elt_opcode (OP_LONG);
447 write_exp_elt_type (val.typed_val.type);
448 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
449 write_exp_elt_opcode (OP_LONG); }
453 { write_exp_elt_opcode (OP_DOUBLE);
454 write_exp_elt_type (parse_f_type->builtin_real_s8);
455 write_exp_elt_dblcst ($1);
456 write_exp_elt_opcode (OP_DOUBLE); }
465 exp : SIZEOF '(' type ')' %prec UNARY
466 { write_exp_elt_opcode (OP_LONG);
467 write_exp_elt_type (parse_f_type->builtin_integer);
469 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
470 write_exp_elt_opcode (OP_LONG); }
473 exp : BOOLEAN_LITERAL
474 { write_exp_elt_opcode (OP_BOOL);
475 write_exp_elt_longcst ((LONGEST) $1);
476 write_exp_elt_opcode (OP_BOOL);
482 write_exp_elt_opcode (OP_STRING);
483 write_exp_string ($1);
484 write_exp_elt_opcode (OP_STRING);
488 variable: name_not_typename
489 { struct symbol *sym = $1.sym;
493 if (symbol_read_needs_frame (sym))
495 if (innermost_block == 0
496 || contained_in (block_found,
498 innermost_block = block_found;
500 write_exp_elt_opcode (OP_VAR_VALUE);
501 /* We want to use the selected frame, not
502 another more inner frame which happens to
503 be in the same block. */
504 write_exp_elt_block (NULL);
505 write_exp_elt_sym (sym);
506 write_exp_elt_opcode (OP_VAR_VALUE);
511 struct minimal_symbol *msymbol;
512 char *arg = copy_name ($1.stoken);
515 lookup_minimal_symbol (arg, NULL, NULL);
517 write_exp_msymbol (msymbol);
518 else if (!have_full_symbols () && !have_partial_symbols ())
519 error (_("No symbol table is loaded. Use the \"file\" command."));
521 error (_("No symbol \"%s\" in current context."),
522 copy_name ($1.stoken));
534 /* This is where the interesting stuff happens. */
537 struct type *follow_type = $1;
538 struct type *range_type;
547 follow_type = lookup_pointer_type (follow_type);
550 follow_type = lookup_reference_type (follow_type);
553 array_size = pop_type_int ();
554 if (array_size != -1)
557 create_range_type ((struct type *) NULL,
558 parse_f_type->builtin_integer,
561 create_array_type ((struct type *) NULL,
562 follow_type, range_type);
565 follow_type = lookup_pointer_type (follow_type);
568 follow_type = lookup_function_type (follow_type);
576 { push_type (tp_pointer); $$ = 0; }
578 { push_type (tp_pointer); $$ = $2; }
580 { push_type (tp_reference); $$ = 0; }
582 { push_type (tp_reference); $$ = $2; }
586 direct_abs_decl: '(' abs_decl ')'
588 | direct_abs_decl func_mod
589 { push_type (tp_function); }
591 { push_type (tp_function); }
596 | '(' nonempty_typelist ')'
597 { free ($2); $$ = 0; }
600 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
604 { $$ = parse_f_type->builtin_integer; }
606 { $$ = parse_f_type->builtin_integer_s2; }
608 { $$ = parse_f_type->builtin_character; }
610 { $$ = parse_f_type->builtin_logical_s8; }
612 { $$ = parse_f_type->builtin_logical; }
614 { $$ = parse_f_type->builtin_logical_s2; }
616 { $$ = parse_f_type->builtin_logical_s1; }
618 { $$ = parse_f_type->builtin_real; }
620 { $$ = parse_f_type->builtin_real_s8; }
622 { $$ = parse_f_type->builtin_real_s16; }
624 { $$ = parse_f_type->builtin_complex_s8; }
625 | COMPLEX_S16_KEYWORD
626 { $$ = parse_f_type->builtin_complex_s16; }
627 | COMPLEX_S32_KEYWORD
628 { $$ = parse_f_type->builtin_complex_s32; }
633 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
634 $<ivec>$[0] = 1; /* Number of types in vector */
637 | nonempty_typelist ',' type
638 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
639 $$ = (struct type **) realloc ((char *) $1, len);
640 $$[$<ivec>$[0]] = $3;
648 name_not_typename : NAME
649 /* These would be useful if name_not_typename was useful, but it is just
650 a fake for "variable", so these cause reduce/reduce conflicts because
651 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
652 =exp) or just an exp. If name_not_typename was ever used in an lvalue
653 context where only a name could occur, this might be useful.
660 /* Take care of parsing a number (anything that starts with a digit).
661 Set yylval and return the token type; update lexptr.
662 LEN is the number of characters in it. */
664 /*** Needs some error checking for the float case ***/
667 parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
672 int base = input_radix;
676 struct type *signed_type;
677 struct type *unsigned_type;
681 /* It's a float since it contains a point or an exponent. */
682 /* [dD] is not understood as an exponent by atof, change it to 'e'. */
686 for (tmp2 = tmp; *tmp2; ++tmp2)
687 if (*tmp2 == 'd' || *tmp2 == 'D')
689 putithere->dval = atof (tmp);
694 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
730 if (len == 0 && c == 'l')
732 else if (len == 0 && c == 'u')
737 if (c >= '0' && c <= '9')
739 else if (c >= 'a' && c <= 'f')
742 return ERROR; /* Char not a digit */
744 return ERROR; /* Invalid digit in this base */
748 /* Portably test for overflow (only works for nonzero values, so make
749 a second check for zero). */
750 if ((prevn >= n) && n != 0)
751 unsigned_p=1; /* Try something unsigned */
752 /* If range checking enabled, portably test for unsigned overflow. */
753 if (RANGE_CHECK && n != 0)
755 if ((unsigned_p && (unsigned)prevn >= (unsigned)n))
756 range_error (_("Overflow on numeric constant."));
761 /* If the number is too big to be an int, or it's got an l suffix
762 then it's a long. Work out if this has to be a long by
763 shifting right and seeing if anything remains, and the
764 target int size is different to the target long size.
766 In the expression below, we could have tested
767 (n >> gdbarch_int_bit (parse_gdbarch))
768 to see if it was zero,
769 but too many compilers warn about that, when ints and longs
770 are the same size. So we shift it twice, with fewer bits
771 each time, for the same result. */
773 if ((gdbarch_int_bit (parse_gdbarch) != gdbarch_long_bit (parse_gdbarch)
775 >> (gdbarch_int_bit (parse_gdbarch)-2))) /* Avoid shift warning */
778 high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch)-1);
779 unsigned_type = parse_type->builtin_unsigned_long;
780 signed_type = parse_type->builtin_long;
784 high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch)-1);
785 unsigned_type = parse_type->builtin_unsigned_int;
786 signed_type = parse_type->builtin_int;
789 putithere->typed_val.val = n;
791 /* If the high bit of the worked out type is set then this number
792 has to be unsigned. */
794 if (unsigned_p || (n & high_bit))
795 putithere->typed_val.type = unsigned_type;
797 putithere->typed_val.type = signed_type;
806 enum exp_opcode opcode;
809 static const struct token dot_ops[] =
811 { ".and.", BOOL_AND, BINOP_END },
812 { ".AND.", BOOL_AND, BINOP_END },
813 { ".or.", BOOL_OR, BINOP_END },
814 { ".OR.", BOOL_OR, BINOP_END },
815 { ".not.", BOOL_NOT, BINOP_END },
816 { ".NOT.", BOOL_NOT, BINOP_END },
817 { ".eq.", EQUAL, BINOP_END },
818 { ".EQ.", EQUAL, BINOP_END },
819 { ".eqv.", EQUAL, BINOP_END },
820 { ".NEQV.", NOTEQUAL, BINOP_END },
821 { ".neqv.", NOTEQUAL, BINOP_END },
822 { ".EQV.", EQUAL, BINOP_END },
823 { ".ne.", NOTEQUAL, BINOP_END },
824 { ".NE.", NOTEQUAL, BINOP_END },
825 { ".le.", LEQ, BINOP_END },
826 { ".LE.", LEQ, BINOP_END },
827 { ".ge.", GEQ, BINOP_END },
828 { ".GE.", GEQ, BINOP_END },
829 { ".gt.", GREATERTHAN, BINOP_END },
830 { ".GT.", GREATERTHAN, BINOP_END },
831 { ".lt.", LESSTHAN, BINOP_END },
832 { ".LT.", LESSTHAN, BINOP_END },
836 struct f77_boolean_val
842 static const struct f77_boolean_val boolean_values[] =
851 static const struct token f77_keywords[] =
853 { "complex_16", COMPLEX_S16_KEYWORD, BINOP_END },
854 { "complex_32", COMPLEX_S32_KEYWORD, BINOP_END },
855 { "character", CHARACTER, BINOP_END },
856 { "integer_2", INT_S2_KEYWORD, BINOP_END },
857 { "logical_1", LOGICAL_S1_KEYWORD, BINOP_END },
858 { "logical_2", LOGICAL_S2_KEYWORD, BINOP_END },
859 { "logical_8", LOGICAL_S8_KEYWORD, BINOP_END },
860 { "complex_8", COMPLEX_S8_KEYWORD, BINOP_END },
861 { "integer", INT_KEYWORD, BINOP_END },
862 { "logical", LOGICAL_KEYWORD, BINOP_END },
863 { "real_16", REAL_S16_KEYWORD, BINOP_END },
864 { "complex", COMPLEX_S8_KEYWORD, BINOP_END },
865 { "sizeof", SIZEOF, BINOP_END },
866 { "real_8", REAL_S8_KEYWORD, BINOP_END },
867 { "real", REAL_KEYWORD, BINOP_END },
871 /* Implementation of a dynamically expandable buffer for processing input
872 characters acquired through lexptr and building a value to return in
873 yylval. Ripped off from ch-exp.y */
875 static char *tempbuf; /* Current buffer contents */
876 static int tempbufsize; /* Size of allocated buffer */
877 static int tempbufindex; /* Current index into buffer */
879 #define GROWBY_MIN_SIZE 64 /* Minimum amount to grow buffer by */
881 #define CHECKBUF(size) \
883 if (tempbufindex + (size) >= tempbufsize) \
885 growbuf_by_size (size); \
890 /* Grow the static temp buffer if necessary, including allocating the
891 first one on demand. */
894 growbuf_by_size (int count)
898 growby = max (count, GROWBY_MIN_SIZE);
899 tempbufsize += growby;
901 tempbuf = (char *) malloc (tempbufsize);
903 tempbuf = (char *) realloc (tempbuf, tempbufsize);
906 /* Blatantly ripped off from ch-exp.y. This routine recognizes F77
909 Recognize a string literal. A string literal is a nonzero sequence
910 of characters enclosed in matching single quotes, except that
911 a single character inside single quotes is a character literal, which
912 we reject as a string literal. To embed the terminator character inside
913 a string, it is simply doubled (I.E. 'this''is''one''string') */
916 match_string_literal (void)
918 char *tokptr = lexptr;
920 for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)
923 if (*tokptr == *lexptr)
925 if (*(tokptr + 1) == *lexptr)
930 tempbuf[tempbufindex++] = *tokptr;
932 if (*tokptr == '\0' /* no terminator */
933 || tempbufindex == 0) /* no string */
937 tempbuf[tempbufindex] = '\0';
938 yylval.sval.ptr = tempbuf;
939 yylval.sval.length = tempbufindex;
941 return STRING_LITERAL;
945 /* Read one token, getting characters through lexptr. */
952 unsigned int i,token;
957 prev_lexptr = lexptr;
961 /* First of all, let us make sure we are not dealing with the
962 special tokens .true. and .false. which evaluate to 1 and 0. */
966 for (i = 0; boolean_values[i].name != NULL; i++)
968 if (strncmp (tokstart, boolean_values[i].name,
969 strlen (boolean_values[i].name)) == 0)
971 lexptr += strlen (boolean_values[i].name);
972 yylval.lval = boolean_values[i].value;
973 return BOOLEAN_LITERAL;
978 /* See if it is a special .foo. operator. */
980 for (i = 0; dot_ops[i].operator != NULL; i++)
981 if (strncmp (tokstart, dot_ops[i].operator,
982 strlen (dot_ops[i].operator)) == 0)
984 lexptr += strlen (dot_ops[i].operator);
985 yylval.opcode = dot_ops[i].opcode;
986 return dot_ops[i].token;
989 /* See if it is an exponentiation operator. */
991 if (strncmp (tokstart, "**", 2) == 0)
994 yylval.opcode = BINOP_EXP;
998 switch (c = *tokstart)
1010 token = match_string_literal ();
1021 if (paren_depth == 0)
1028 if (comma_terminates && paren_depth == 0)
1034 /* Might be a floating point number. */
1035 if (lexptr[1] < '0' || lexptr[1] > '9')
1036 goto symbol; /* Nope, must be a symbol. */
1037 /* FALL THRU into number case. */
1050 /* It's a number. */
1051 int got_dot = 0, got_e = 0, got_d = 0, toktype;
1053 int hex = input_radix > 10;
1055 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1060 else if (c == '0' && (p[1]=='t' || p[1]=='T'
1061 || p[1]=='d' || p[1]=='D'))
1069 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1070 got_dot = got_e = 1;
1071 else if (!hex && !got_d && (*p == 'd' || *p == 'D'))
1072 got_dot = got_d = 1;
1073 else if (!hex && !got_dot && *p == '.')
1075 else if (((got_e && (p[-1] == 'e' || p[-1] == 'E'))
1076 || (got_d && (p[-1] == 'd' || p[-1] == 'D')))
1077 && (*p == '-' || *p == '+'))
1078 /* This is the sign of the exponent, not the end of the
1081 /* We will take any letters or digits. parse_number will
1082 complain if past the radix, or if L or U are not final. */
1083 else if ((*p < '0' || *p > '9')
1084 && ((*p < 'a' || *p > 'z')
1085 && (*p < 'A' || *p > 'Z')))
1088 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e|got_d,
1090 if (toktype == ERROR)
1092 char *err_copy = (char *) alloca (p - tokstart + 1);
1094 memcpy (err_copy, tokstart, p - tokstart);
1095 err_copy[p - tokstart] = 0;
1096 error (_("Invalid number \"%s\"."), err_copy);
1127 if (!(c == '_' || c == '$' || c ==':'
1128 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1129 /* We must have come across a bad character (e.g. ';'). */
1130 error (_("Invalid character '%c' in expression."), c);
1133 for (c = tokstart[namelen];
1134 (c == '_' || c == '$' || c == ':' || (c >= '0' && c <= '9')
1135 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1136 c = tokstart[++namelen]);
1138 /* The token "if" terminates the expression and is NOT
1139 removed from the input stream. */
1141 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1146 /* Catch specific keywords. */
1148 for (i = 0; f77_keywords[i].operator != NULL; i++)
1149 if (strlen (f77_keywords[i].operator) == namelen
1150 && strncmp (tokstart, f77_keywords[i].operator, namelen) == 0)
1152 /* lexptr += strlen(f77_keywords[i].operator); */
1153 yylval.opcode = f77_keywords[i].opcode;
1154 return f77_keywords[i].token;
1157 yylval.sval.ptr = tokstart;
1158 yylval.sval.length = namelen;
1160 if (*tokstart == '$')
1162 write_dollar_variable (yylval.sval);
1166 /* Use token-type TYPENAME for symbols that happen to be defined
1167 currently as names of types; NAME for other symbols.
1168 The caller is not constrained to care about the distinction. */
1170 char *tmp = copy_name (yylval.sval);
1172 int is_a_field_of_this = 0;
1175 sym = lookup_symbol (tmp, expression_context_block,
1177 parse_language->la_language == language_cplus
1178 ? &is_a_field_of_this : NULL);
1179 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1181 yylval.tsym.type = SYMBOL_TYPE (sym);
1185 = language_lookup_primitive_type_by_name (parse_language,
1186 parse_gdbarch, tmp);
1187 if (yylval.tsym.type != NULL)
1190 /* Input names that aren't symbols but ARE valid hex numbers,
1191 when the input radix permits them, can be names or numbers
1192 depending on the parse. Note we support radixes > 16 here. */
1194 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1195 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1197 YYSTYPE newlval; /* Its value is ignored. */
1198 hextype = parse_number (tokstart, namelen, 0, &newlval);
1201 yylval.ssym.sym = sym;
1202 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1207 /* Any other kind of symbol */
1208 yylval.ssym.sym = sym;
1209 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1218 lexptr = prev_lexptr;
1220 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);