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.
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 2 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, write to the Free Software
22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
25 /* This was blantantly ripped off the C expression parser, please
26 be aware of that as you look at its basic structure -FMB */
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.
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. */
48 #include "gdb_string.h"
49 #include "expression.h"
51 #include "parser-defs.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 */
60 #define parse_type builtin_type (parse_gdbarch)
61 #define parse_f_type builtin_f_type (parse_gdbarch)
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. */
70 #define yymaxdepth f_maxdepth
71 #define yyparse f_parse
73 #define yyerror f_error
76 #define yydebug f_debug
85 #define yyerrflag f_errflag
86 #define yynerrs f_nerrs
91 #define yystate f_state
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
112 #define YYDEBUG 1 /* Default to yydebug support */
115 #define YYFPRINTF parser_fprintf
119 static int yylex (void);
121 void yyerror (char *);
123 static void growbuf_by_size (int);
125 static int match_string_literal (void);
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. */
145 struct symtoken ssym;
148 enum exp_opcode opcode;
149 struct internalvar *ivar;
156 /* YYSTYPE gets defined by %union */
157 static int parse_number (char *, int, int, YYSTYPE *);
160 %type <voidval> exp type_exp start variable
161 %type <tval> type typebase
162 %type <tvec> nonempty_typelist
163 /* %type <bval> block */
165 /* Fancy type parsing. */
166 %type <voidval> func_mod direct_abs_decl abs_decl
169 %token <typed_val> INT
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. */
180 %token <sval> STRING_LITERAL
181 %token <lval> BOOLEAN_LITERAL
183 %token <tsym> TYPENAME
185 %type <ssym> name_not_typename
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. */
192 %token <ssym> NAME_OR_INT
197 /* Special type cases, put in to allow the parser to distinguish different
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
205 %token <voidval> VARIABLE
207 %token <opcode> ASSIGN_MODIFY
211 %right '=' ASSIGN_MODIFY
220 %left LESSTHAN GREATERTHAN LEQ GEQ
238 { write_exp_elt_opcode(OP_TYPE);
239 write_exp_elt_type($1);
240 write_exp_elt_opcode(OP_TYPE); }
247 /* Expressions, not including the comma operator. */
248 exp : '*' exp %prec UNARY
249 { write_exp_elt_opcode (UNOP_IND); }
252 exp : '&' exp %prec UNARY
253 { write_exp_elt_opcode (UNOP_ADDR); }
256 exp : '-' exp %prec UNARY
257 { write_exp_elt_opcode (UNOP_NEG); }
260 exp : BOOL_NOT exp %prec UNARY
261 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
264 exp : '~' exp %prec UNARY
265 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
268 exp : SIZEOF exp %prec UNARY
269 { write_exp_elt_opcode (UNOP_SIZEOF); }
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
278 { start_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); }
296 arglist : arglist ',' exp %prec ABOVE_COMMA
300 /* There are four sorts of subrange types in F90. */
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); }
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); }
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); }
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); }
326 complexnum: exp ',' exp
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); }
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); }
343 { write_exp_elt_opcode (STRUCTOP_STRUCT);
344 write_exp_string ($3);
345 write_exp_elt_opcode (STRUCTOP_STRUCT); }
348 /* Binary operators in order of decreasing precedence. */
351 { write_exp_elt_opcode (BINOP_REPEAT); }
354 exp : exp STARSTAR exp
355 { write_exp_elt_opcode (BINOP_EXP); }
359 { write_exp_elt_opcode (BINOP_MUL); }
363 { write_exp_elt_opcode (BINOP_DIV); }
367 { write_exp_elt_opcode (BINOP_ADD); }
371 { write_exp_elt_opcode (BINOP_SUB); }
375 { write_exp_elt_opcode (BINOP_LSH); }
379 { write_exp_elt_opcode (BINOP_RSH); }
383 { write_exp_elt_opcode (BINOP_EQUAL); }
386 exp : exp NOTEQUAL exp
387 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
391 { write_exp_elt_opcode (BINOP_LEQ); }
395 { write_exp_elt_opcode (BINOP_GEQ); }
398 exp : exp LESSTHAN exp
399 { write_exp_elt_opcode (BINOP_LESS); }
402 exp : exp GREATERTHAN exp
403 { write_exp_elt_opcode (BINOP_GTR); }
407 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
411 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
415 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
418 exp : exp BOOL_AND exp
419 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
423 exp : exp BOOL_OR exp
424 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
428 { write_exp_elt_opcode (BINOP_ASSIGN); }
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); }
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); }
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); }
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); }
466 exp : SIZEOF '(' type ')' %prec UNARY
467 { write_exp_elt_opcode (OP_LONG);
468 write_exp_elt_type (parse_f_type->builtin_integer);
470 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
471 write_exp_elt_opcode (OP_LONG); }
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);
483 write_exp_elt_opcode (OP_STRING);
484 write_exp_string ($1);
485 write_exp_elt_opcode (OP_STRING);
489 variable: name_not_typename
490 { struct symbol *sym = $1.sym;
494 if (symbol_read_needs_frame (sym))
496 if (innermost_block == 0 ||
497 contained_in (block_found,
499 innermost_block = block_found;
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);
512 struct minimal_symbol *msymbol;
513 char *arg = copy_name ($1.stoken);
516 lookup_minimal_symbol (arg, NULL, 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.");
522 error ("No symbol \"%s\" in current context.",
523 copy_name ($1.stoken));
535 /* This is where the interesting stuff happens. */
538 struct type *follow_type = $1;
539 struct type *range_type;
548 follow_type = lookup_pointer_type (follow_type);
551 follow_type = lookup_reference_type (follow_type);
554 array_size = pop_type_int ();
555 if (array_size != -1)
558 create_range_type ((struct type *) NULL,
559 parse_f_type->builtin_integer,
562 create_array_type ((struct type *) NULL,
563 follow_type, range_type);
566 follow_type = lookup_pointer_type (follow_type);
569 follow_type = lookup_function_type (follow_type);
577 { push_type (tp_pointer); $$ = 0; }
579 { push_type (tp_pointer); $$ = $2; }
581 { push_type (tp_reference); $$ = 0; }
583 { push_type (tp_reference); $$ = $2; }
587 direct_abs_decl: '(' abs_decl ')'
589 | direct_abs_decl func_mod
590 { push_type (tp_function); }
592 { push_type (tp_function); }
597 | '(' nonempty_typelist ')'
598 { free ($2); $$ = 0; }
601 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
605 { $$ = parse_f_type->builtin_integer; }
607 { $$ = parse_f_type->builtin_integer_s2; }
609 { $$ = parse_f_type->builtin_character; }
611 { $$ = parse_f_type->builtin_logical; }
613 { $$ = parse_f_type->builtin_logical_s2; }
615 { $$ = parse_f_type->builtin_logical_s1; }
617 { $$ = parse_f_type->builtin_real; }
619 { $$ = parse_f_type->builtin_real_s8; }
621 { $$ = parse_f_type->builtin_real_s16; }
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; }
632 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
633 $<ivec>$[0] = 1; /* Number of types in vector */
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;
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.
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. */
663 /*** Needs some error checking for the float case ***/
666 parse_number (p, len, parsed_float, putithere)
675 int base = input_radix;
679 struct type *signed_type;
680 struct type *unsigned_type;
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'. */
689 for (tmp2 = tmp; *tmp2; ++tmp2)
690 if (*tmp2 == 'd' || *tmp2 == 'D')
692 putithere->dval = atof (tmp);
697 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
733 if (len == 0 && c == 'l')
735 else if (len == 0 && c == 'u')
740 if (c >= '0' && c <= '9')
742 else if (c >= 'a' && c <= 'f')
745 return ERROR; /* Char not a digit */
747 return ERROR; /* Invalid digit in this base */
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)
758 if ((unsigned_p && (unsigned)prevn >= (unsigned)n))
759 range_error("Overflow on numeric constant.");
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.
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. */
776 if ((gdbarch_int_bit (parse_gdbarch) != gdbarch_long_bit (parse_gdbarch)
778 >> (gdbarch_int_bit (parse_gdbarch)-2))) /* Avoid shift warning */
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;
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;
792 putithere->typed_val.val = n;
794 /* If the high bit of the worked out type is set then this number
795 has to be unsigned. */
797 if (unsigned_p || (n & high_bit))
798 putithere->typed_val.type = unsigned_type;
800 putithere->typed_val.type = signed_type;
809 enum exp_opcode opcode;
812 static const struct token dot_ops[] =
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 },
839 struct f77_boolean_val
845 static const struct f77_boolean_val boolean_values[] =
854 static const struct token f77_keywords[] =
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 },
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 */
877 static char *tempbuf; /* Current buffer contents */
878 static int tempbufsize; /* Size of allocated buffer */
879 static int tempbufindex; /* Current index into buffer */
881 #define GROWBY_MIN_SIZE 64 /* Minimum amount to grow buffer by */
883 #define CHECKBUF(size) \
885 if (tempbufindex + (size) >= tempbufsize) \
887 growbuf_by_size (size); \
892 /* Grow the static temp buffer if necessary, including allocating the first one
896 growbuf_by_size (count)
901 growby = max (count, GROWBY_MIN_SIZE);
902 tempbufsize += growby;
904 tempbuf = (char *) malloc (tempbufsize);
906 tempbuf = (char *) realloc (tempbuf, tempbufsize);
909 /* Blatantly ripped off from ch-exp.y. This routine recognizes F77
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') */
919 match_string_literal ()
921 char *tokptr = lexptr;
923 for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)
926 if (*tokptr == *lexptr)
928 if (*(tokptr + 1) == *lexptr)
933 tempbuf[tempbufindex++] = *tokptr;
935 if (*tokptr == '\0' /* no terminator */
936 || tempbufindex == 0) /* no string */
940 tempbuf[tempbufindex] = '\0';
941 yylval.sval.ptr = tempbuf;
942 yylval.sval.length = tempbufindex;
944 return STRING_LITERAL;
948 /* Read one token, getting characters through lexptr. */
955 unsigned int i,token;
960 prev_lexptr = lexptr;
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. */
969 for (i = 0; boolean_values[i].name != NULL; i++)
971 if (strncmp (tokstart, boolean_values[i].name,
972 strlen (boolean_values[i].name)) == 0)
974 lexptr += strlen (boolean_values[i].name);
975 yylval.lval = boolean_values[i].value;
976 return BOOLEAN_LITERAL;
981 /* See if it is a special .foo. operator. */
983 for (i = 0; dot_ops[i].operator != NULL; i++)
984 if (strncmp (tokstart, dot_ops[i].operator, strlen (dot_ops[i].operator)) == 0)
986 lexptr += strlen (dot_ops[i].operator);
987 yylval.opcode = dot_ops[i].opcode;
988 return dot_ops[i].token;
991 /* See if it is an exponentiation operator. */
993 if (strncmp (tokstart, "**", 2) == 0)
996 yylval.opcode = BINOP_EXP;
1000 switch (c = *tokstart)
1012 token = match_string_literal ();
1023 if (paren_depth == 0)
1030 if (comma_terminates && paren_depth == 0)
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. */
1052 /* It's a number. */
1053 int got_dot = 0, got_e = 0, got_d = 0, toktype;
1055 int hex = input_radix > 10;
1057 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1062 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
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 == '.')
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
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')))
1089 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e|got_d,
1091 if (toktype == ERROR)
1093 char *err_copy = (char *) alloca (p - tokstart + 1);
1095 memcpy (err_copy, tokstart, p - tokstart);
1096 err_copy[p - tokstart] = 0;
1097 error ("Invalid number \"%s\".", err_copy);
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);
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]);
1139 /* The token "if" terminates the expression and is NOT
1140 removed from the input stream. */
1142 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1147 /* Catch specific keywords. */
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)
1153 /* lexptr += strlen(f77_keywords[i].operator); */
1154 yylval.opcode = f77_keywords[i].opcode;
1155 return f77_keywords[i].token;
1158 yylval.sval.ptr = tokstart;
1159 yylval.sval.length = namelen;
1161 if (*tokstart == '$')
1163 write_dollar_variable (yylval.sval);
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. */
1171 char *tmp = copy_name (yylval.sval);
1173 int is_a_field_of_this = 0;
1176 sym = lookup_symbol (tmp, expression_context_block,
1178 parse_language->la_language == language_cplus
1179 ? &is_a_field_of_this : NULL);
1180 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1182 yylval.tsym.type = SYMBOL_TYPE (sym);
1186 = language_lookup_primitive_type_by_name (parse_language,
1187 parse_gdbarch, tmp);
1188 if (yylval.tsym.type != NULL)
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. */
1195 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1196 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1198 YYSTYPE newlval; /* Its value is ignored. */
1199 hextype = parse_number (tokstart, namelen, 0, &newlval);
1202 yylval.ssym.sym = sym;
1203 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1208 /* Any other kind of symbol */
1209 yylval.ssym.sym = sym;
1210 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1220 lexptr = prev_lexptr;
1222 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);