1 /* YACC parser for Fortran expressions, for GDB.
2 Copyright 1986, 1989, 1990, 1991, 1993, 1994, 1995, 1996, 2000, 2001,
3 2002, 2003, 2004, 2005 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 /* This was blantantly ripped off the C expression parser, please
25 be aware of that as you look at its basic structure -FMB */
27 /* Parse a F77 expression from text in a string,
28 and return the result as a struct expression pointer.
29 That structure contains arithmetic operations in reverse polish,
30 with constants represented by operations that are followed by special data.
31 See expression.h for the details of the format.
32 What is important here is that it can be built up sequentially
33 during the process of parsing; the lower levels of the tree always
34 come first in the result.
36 Note that malloc's and realloc's in this file are transformed to
37 xmalloc and xrealloc respectively by the same sed command in the
38 makefile that remaps any other malloc/realloc inserted by the parser
39 generator. Doing this with #defines and trying to control the interaction
40 with include files (<malloc.h> and <stdlib.h> for example) just became
41 too messy, particularly when such includes can be inserted at random
42 times by the parser generator. */
47 #include "gdb_string.h"
48 #include "expression.h"
50 #include "parser-defs.h"
53 #include "bfd.h" /* Required by objfiles.h. */
54 #include "symfile.h" /* Required by objfiles.h. */
55 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
59 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
60 as well as gratuitiously global symbol names, so we can have multiple
61 yacc generated parsers in gdb. Note that these are only the variables
62 produced by yacc. If other parser generators (bison, byacc, etc) produce
63 additional global names that conflict at link time, then those parser
64 generators need to be fixed instead of adding those names to this list. */
66 #define yymaxdepth f_maxdepth
67 #define yyparse f_parse
69 #define yyerror f_error
72 #define yydebug f_debug
81 #define yyerrflag f_errflag
82 #define yynerrs f_nerrs
87 #define yystate f_state
93 #define yyreds f_reds /* With YYDEBUG defined */
94 #define yytoks f_toks /* With YYDEBUG defined */
95 #define yyname f_name /* With YYDEBUG defined */
96 #define yyrule f_rule /* With YYDEBUG defined */
99 #define yydefred f_yydefred
100 #define yydgoto f_yydgoto
101 #define yysindex f_yysindex
102 #define yyrindex f_yyrindex
103 #define yygindex f_yygindex
104 #define yytable f_yytable
105 #define yycheck f_yycheck
108 #define YYDEBUG 1 /* Default to yydebug support */
111 #define YYFPRINTF parser_fprintf
115 static int yylex (void);
117 void yyerror (char *);
119 static void growbuf_by_size (int);
121 static int match_string_literal (void);
125 /* Although the yacc "value" of an expression is not used,
126 since the result is stored in the structure being created,
127 other node types do have values. */
141 struct symtoken ssym;
144 enum exp_opcode opcode;
145 struct internalvar *ivar;
152 /* YYSTYPE gets defined by %union */
153 static int parse_number (char *, int, int, YYSTYPE *);
156 %type <voidval> exp type_exp start variable
157 %type <tval> type typebase
158 %type <tvec> nonempty_typelist
159 /* %type <bval> block */
161 /* Fancy type parsing. */
162 %type <voidval> func_mod direct_abs_decl abs_decl
165 %token <typed_val> INT
168 /* Both NAME and TYPENAME tokens represent symbols in the input,
169 and both convey their data as strings.
170 But a TYPENAME is a string that happens to be defined as a typedef
171 or builtin type name (such as int or char)
172 and a NAME is any other symbol.
173 Contexts where this distinction is not important can use the
174 nonterminal "name", which matches either NAME or TYPENAME. */
176 %token <sval> STRING_LITERAL
177 %token <lval> BOOLEAN_LITERAL
179 %token <tsym> TYPENAME
180 %type <ssym> name_not_typename
182 /* A NAME_OR_INT is a symbol which is not known in the symbol table,
183 but which would parse as a valid number in the current input radix.
184 E.g. "c" when input_radix==16. Depending on the parse, it will be
185 turned into a name or into a number. */
187 %token <ssym> NAME_OR_INT
192 /* Special type cases, put in to allow the parser to distinguish different
194 %token INT_KEYWORD INT_S2_KEYWORD LOGICAL_S1_KEYWORD LOGICAL_S2_KEYWORD
195 %token LOGICAL_KEYWORD REAL_KEYWORD REAL_S8_KEYWORD REAL_S16_KEYWORD
196 %token COMPLEX_S8_KEYWORD COMPLEX_S16_KEYWORD COMPLEX_S32_KEYWORD
197 %token BOOL_AND BOOL_OR BOOL_NOT
198 %token <lval> CHARACTER
200 %token <voidval> VARIABLE
202 %token <opcode> ASSIGN_MODIFY
206 %right '=' ASSIGN_MODIFY
215 %left LESSTHAN GREATERTHAN LEQ GEQ
232 { write_exp_elt_opcode(OP_TYPE);
233 write_exp_elt_type($1);
234 write_exp_elt_opcode(OP_TYPE); }
241 /* Expressions, not including the comma operator. */
242 exp : '*' exp %prec UNARY
243 { write_exp_elt_opcode (UNOP_IND); }
246 exp : '&' exp %prec UNARY
247 { write_exp_elt_opcode (UNOP_ADDR); }
250 exp : '-' exp %prec UNARY
251 { write_exp_elt_opcode (UNOP_NEG); }
254 exp : BOOL_NOT exp %prec UNARY
255 { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
258 exp : '~' exp %prec UNARY
259 { write_exp_elt_opcode (UNOP_COMPLEMENT); }
262 exp : SIZEOF exp %prec UNARY
263 { write_exp_elt_opcode (UNOP_SIZEOF); }
266 /* No more explicit array operators, we treat everything in F77 as
267 a function call. The disambiguation as to whether we are
268 doing a subscript operation or a function call is done
272 { start_arglist (); }
274 { write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);
275 write_exp_elt_longcst ((LONGEST) end_arglist ());
276 write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST); }
290 arglist : arglist ',' exp %prec ABOVE_COMMA
294 substring: exp ':' exp %prec ABOVE_COMMA
299 complexnum: exp ',' exp
303 exp : '(' complexnum ')'
304 { write_exp_elt_opcode(OP_COMPLEX); }
307 exp : '(' type ')' exp %prec UNARY
308 { write_exp_elt_opcode (UNOP_CAST);
309 write_exp_elt_type ($2);
310 write_exp_elt_opcode (UNOP_CAST); }
313 /* Binary operators in order of decreasing precedence. */
316 { write_exp_elt_opcode (BINOP_REPEAT); }
319 exp : exp STARSTAR exp
320 { write_exp_elt_opcode (BINOP_EXP); }
324 { write_exp_elt_opcode (BINOP_MUL); }
328 { write_exp_elt_opcode (BINOP_DIV); }
332 { write_exp_elt_opcode (BINOP_REM); }
336 { write_exp_elt_opcode (BINOP_ADD); }
340 { write_exp_elt_opcode (BINOP_SUB); }
344 { write_exp_elt_opcode (BINOP_LSH); }
348 { write_exp_elt_opcode (BINOP_RSH); }
352 { write_exp_elt_opcode (BINOP_EQUAL); }
355 exp : exp NOTEQUAL exp
356 { write_exp_elt_opcode (BINOP_NOTEQUAL); }
360 { write_exp_elt_opcode (BINOP_LEQ); }
364 { write_exp_elt_opcode (BINOP_GEQ); }
367 exp : exp LESSTHAN exp
368 { write_exp_elt_opcode (BINOP_LESS); }
371 exp : exp GREATERTHAN exp
372 { write_exp_elt_opcode (BINOP_GTR); }
376 { write_exp_elt_opcode (BINOP_BITWISE_AND); }
380 { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
384 { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
387 exp : exp BOOL_AND exp
388 { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
392 exp : exp BOOL_OR exp
393 { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
397 { write_exp_elt_opcode (BINOP_ASSIGN); }
400 exp : exp ASSIGN_MODIFY exp
401 { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
402 write_exp_elt_opcode ($2);
403 write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
407 { write_exp_elt_opcode (OP_LONG);
408 write_exp_elt_type ($1.type);
409 write_exp_elt_longcst ((LONGEST)($1.val));
410 write_exp_elt_opcode (OP_LONG); }
415 parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val);
416 write_exp_elt_opcode (OP_LONG);
417 write_exp_elt_type (val.typed_val.type);
418 write_exp_elt_longcst ((LONGEST)val.typed_val.val);
419 write_exp_elt_opcode (OP_LONG); }
423 { write_exp_elt_opcode (OP_DOUBLE);
424 write_exp_elt_type (builtin_type_f_real_s8);
425 write_exp_elt_dblcst ($1);
426 write_exp_elt_opcode (OP_DOUBLE); }
435 exp : SIZEOF '(' type ')' %prec UNARY
436 { write_exp_elt_opcode (OP_LONG);
437 write_exp_elt_type (builtin_type_f_integer);
439 write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
440 write_exp_elt_opcode (OP_LONG); }
443 exp : BOOLEAN_LITERAL
444 { write_exp_elt_opcode (OP_BOOL);
445 write_exp_elt_longcst ((LONGEST) $1);
446 write_exp_elt_opcode (OP_BOOL);
452 write_exp_elt_opcode (OP_STRING);
453 write_exp_string ($1);
454 write_exp_elt_opcode (OP_STRING);
458 variable: name_not_typename
459 { struct symbol *sym = $1.sym;
463 if (symbol_read_needs_frame (sym))
465 if (innermost_block == 0 ||
466 contained_in (block_found,
468 innermost_block = block_found;
470 write_exp_elt_opcode (OP_VAR_VALUE);
471 /* We want to use the selected frame, not
472 another more inner frame which happens to
473 be in the same block. */
474 write_exp_elt_block (NULL);
475 write_exp_elt_sym (sym);
476 write_exp_elt_opcode (OP_VAR_VALUE);
481 struct minimal_symbol *msymbol;
482 char *arg = copy_name ($1.stoken);
485 lookup_minimal_symbol (arg, NULL, NULL);
488 write_exp_msymbol (msymbol,
489 lookup_function_type (builtin_type_int),
492 else if (!have_full_symbols () && !have_partial_symbols ())
493 error ("No symbol table is loaded. Use the \"file\" command.");
495 error ("No symbol \"%s\" in current context.",
496 copy_name ($1.stoken));
508 /* This is where the interesting stuff happens. */
511 struct type *follow_type = $1;
512 struct type *range_type;
521 follow_type = lookup_pointer_type (follow_type);
524 follow_type = lookup_reference_type (follow_type);
527 array_size = pop_type_int ();
528 if (array_size != -1)
531 create_range_type ((struct type *) NULL,
532 builtin_type_f_integer, 0,
535 create_array_type ((struct type *) NULL,
536 follow_type, range_type);
539 follow_type = lookup_pointer_type (follow_type);
542 follow_type = lookup_function_type (follow_type);
550 { push_type (tp_pointer); $$ = 0; }
552 { push_type (tp_pointer); $$ = $2; }
554 { push_type (tp_reference); $$ = 0; }
556 { push_type (tp_reference); $$ = $2; }
560 direct_abs_decl: '(' abs_decl ')'
562 | direct_abs_decl func_mod
563 { push_type (tp_function); }
565 { push_type (tp_function); }
570 | '(' nonempty_typelist ')'
571 { free ($2); $$ = 0; }
574 typebase /* Implements (approximately): (type-qualifier)* type-specifier */
578 { $$ = builtin_type_f_integer; }
580 { $$ = builtin_type_f_integer_s2; }
582 { $$ = builtin_type_f_character; }
584 { $$ = builtin_type_f_logical;}
586 { $$ = builtin_type_f_logical_s2;}
588 { $$ = builtin_type_f_logical_s1;}
590 { $$ = builtin_type_f_real;}
592 { $$ = builtin_type_f_real_s8;}
594 { $$ = builtin_type_f_real_s16;}
596 { $$ = builtin_type_f_complex_s8;}
597 | COMPLEX_S16_KEYWORD
598 { $$ = builtin_type_f_complex_s16;}
599 | COMPLEX_S32_KEYWORD
600 { $$ = builtin_type_f_complex_s32;}
605 { $$ = (struct type **) malloc (sizeof (struct type *) * 2);
606 $<ivec>$[0] = 1; /* Number of types in vector */
609 | nonempty_typelist ',' type
610 { int len = sizeof (struct type *) * (++($<ivec>1[0]) + 1);
611 $$ = (struct type **) realloc ((char *) $1, len);
612 $$[$<ivec>$[0]] = $3;
616 name_not_typename : NAME
617 /* These would be useful if name_not_typename was useful, but it is just
618 a fake for "variable", so these cause reduce/reduce conflicts because
619 the parser can't tell whether NAME_OR_INT is a name_not_typename (=variable,
620 =exp) or just an exp. If name_not_typename was ever used in an lvalue
621 context where only a name could occur, this might be useful.
628 /* Take care of parsing a number (anything that starts with a digit).
629 Set yylval and return the token type; update lexptr.
630 LEN is the number of characters in it. */
632 /*** Needs some error checking for the float case ***/
635 parse_number (p, len, parsed_float, putithere)
644 int base = input_radix;
648 struct type *signed_type;
649 struct type *unsigned_type;
653 /* It's a float since it contains a point or an exponent. */
654 /* [dD] is not understood as an exponent by atof, change it to 'e'. */
658 for (tmp2 = tmp; *tmp2; ++tmp2)
659 if (*tmp2 == 'd' || *tmp2 == 'D')
661 putithere->dval = atof (tmp);
666 /* Handle base-switching prefixes 0x, 0t, 0d, 0 */
702 if (len == 0 && c == 'l')
704 else if (len == 0 && c == 'u')
709 if (c >= '0' && c <= '9')
711 else if (c >= 'a' && c <= 'f')
714 return ERROR; /* Char not a digit */
716 return ERROR; /* Invalid digit in this base */
720 /* Portably test for overflow (only works for nonzero values, so make
721 a second check for zero). */
722 if ((prevn >= n) && n != 0)
723 unsigned_p=1; /* Try something unsigned */
724 /* If range checking enabled, portably test for unsigned overflow. */
725 if (RANGE_CHECK && n != 0)
727 if ((unsigned_p && (unsigned)prevn >= (unsigned)n))
728 range_error("Overflow on numeric constant.");
733 /* If the number is too big to be an int, or it's got an l suffix
734 then it's a long. Work out if this has to be a long by
735 shifting right and and seeing if anything remains, and the
736 target int size is different to the target long size.
738 In the expression below, we could have tested
739 (n >> TARGET_INT_BIT)
740 to see if it was zero,
741 but too many compilers warn about that, when ints and longs
742 are the same size. So we shift it twice, with fewer bits
743 each time, for the same result. */
745 if ((TARGET_INT_BIT != TARGET_LONG_BIT
746 && ((n >> 2) >> (TARGET_INT_BIT-2))) /* Avoid shift warning */
749 high_bit = ((ULONGEST)1) << (TARGET_LONG_BIT-1);
750 unsigned_type = builtin_type_unsigned_long;
751 signed_type = builtin_type_long;
755 high_bit = ((ULONGEST)1) << (TARGET_INT_BIT-1);
756 unsigned_type = builtin_type_unsigned_int;
757 signed_type = builtin_type_int;
760 putithere->typed_val.val = n;
762 /* If the high bit of the worked out type is set then this number
763 has to be unsigned. */
765 if (unsigned_p || (n & high_bit))
766 putithere->typed_val.type = unsigned_type;
768 putithere->typed_val.type = signed_type;
777 enum exp_opcode opcode;
780 static const struct token dot_ops[] =
782 { ".and.", BOOL_AND, BINOP_END },
783 { ".AND.", BOOL_AND, BINOP_END },
784 { ".or.", BOOL_OR, BINOP_END },
785 { ".OR.", BOOL_OR, BINOP_END },
786 { ".not.", BOOL_NOT, BINOP_END },
787 { ".NOT.", BOOL_NOT, BINOP_END },
788 { ".eq.", EQUAL, BINOP_END },
789 { ".EQ.", EQUAL, BINOP_END },
790 { ".eqv.", EQUAL, BINOP_END },
791 { ".NEQV.", NOTEQUAL, BINOP_END },
792 { ".neqv.", NOTEQUAL, BINOP_END },
793 { ".EQV.", EQUAL, BINOP_END },
794 { ".ne.", NOTEQUAL, BINOP_END },
795 { ".NE.", NOTEQUAL, BINOP_END },
796 { ".le.", LEQ, BINOP_END },
797 { ".LE.", LEQ, BINOP_END },
798 { ".ge.", GEQ, BINOP_END },
799 { ".GE.", GEQ, BINOP_END },
800 { ".gt.", GREATERTHAN, BINOP_END },
801 { ".GT.", GREATERTHAN, BINOP_END },
802 { ".lt.", LESSTHAN, BINOP_END },
803 { ".LT.", LESSTHAN, BINOP_END },
807 struct f77_boolean_val
813 static const struct f77_boolean_val boolean_values[] =
822 static const struct token f77_keywords[] =
824 { "complex_16", COMPLEX_S16_KEYWORD, BINOP_END },
825 { "complex_32", COMPLEX_S32_KEYWORD, BINOP_END },
826 { "character", CHARACTER, BINOP_END },
827 { "integer_2", INT_S2_KEYWORD, BINOP_END },
828 { "logical_1", LOGICAL_S1_KEYWORD, BINOP_END },
829 { "logical_2", LOGICAL_S2_KEYWORD, BINOP_END },
830 { "complex_8", COMPLEX_S8_KEYWORD, BINOP_END },
831 { "integer", INT_KEYWORD, BINOP_END },
832 { "logical", LOGICAL_KEYWORD, BINOP_END },
833 { "real_16", REAL_S16_KEYWORD, BINOP_END },
834 { "complex", COMPLEX_S8_KEYWORD, BINOP_END },
835 { "sizeof", SIZEOF, BINOP_END },
836 { "real_8", REAL_S8_KEYWORD, BINOP_END },
837 { "real", REAL_KEYWORD, BINOP_END },
841 /* Implementation of a dynamically expandable buffer for processing input
842 characters acquired through lexptr and building a value to return in
843 yylval. Ripped off from ch-exp.y */
845 static char *tempbuf; /* Current buffer contents */
846 static int tempbufsize; /* Size of allocated buffer */
847 static int tempbufindex; /* Current index into buffer */
849 #define GROWBY_MIN_SIZE 64 /* Minimum amount to grow buffer by */
851 #define CHECKBUF(size) \
853 if (tempbufindex + (size) >= tempbufsize) \
855 growbuf_by_size (size); \
860 /* Grow the static temp buffer if necessary, including allocating the first one
864 growbuf_by_size (count)
869 growby = max (count, GROWBY_MIN_SIZE);
870 tempbufsize += growby;
872 tempbuf = (char *) malloc (tempbufsize);
874 tempbuf = (char *) realloc (tempbuf, tempbufsize);
877 /* Blatantly ripped off from ch-exp.y. This routine recognizes F77
880 Recognize a string literal. A string literal is a nonzero sequence
881 of characters enclosed in matching single quotes, except that
882 a single character inside single quotes is a character literal, which
883 we reject as a string literal. To embed the terminator character inside
884 a string, it is simply doubled (I.E. 'this''is''one''string') */
887 match_string_literal ()
889 char *tokptr = lexptr;
891 for (tempbufindex = 0, tokptr++; *tokptr != '\0'; tokptr++)
894 if (*tokptr == *lexptr)
896 if (*(tokptr + 1) == *lexptr)
901 tempbuf[tempbufindex++] = *tokptr;
903 if (*tokptr == '\0' /* no terminator */
904 || tempbufindex == 0) /* no string */
908 tempbuf[tempbufindex] = '\0';
909 yylval.sval.ptr = tempbuf;
910 yylval.sval.length = tempbufindex;
912 return STRING_LITERAL;
916 /* Read one token, getting characters through lexptr. */
923 unsigned int i,token;
928 prev_lexptr = lexptr;
932 /* First of all, let us make sure we are not dealing with the
933 special tokens .true. and .false. which evaluate to 1 and 0. */
937 for (i = 0; boolean_values[i].name != NULL; i++)
939 if (strncmp (tokstart, boolean_values[i].name,
940 strlen (boolean_values[i].name)) == 0)
942 lexptr += strlen (boolean_values[i].name);
943 yylval.lval = boolean_values[i].value;
944 return BOOLEAN_LITERAL;
949 /* See if it is a special .foo. operator. */
951 for (i = 0; dot_ops[i].operator != NULL; i++)
952 if (strncmp (tokstart, dot_ops[i].operator, strlen (dot_ops[i].operator)) == 0)
954 lexptr += strlen (dot_ops[i].operator);
955 yylval.opcode = dot_ops[i].opcode;
956 return dot_ops[i].token;
959 /* See if it is an exponentiation operator. */
961 if (strncmp (tokstart, "**", 2) == 0)
964 yylval.opcode = BINOP_EXP;
968 switch (c = *tokstart)
980 token = match_string_literal ();
991 if (paren_depth == 0)
998 if (comma_terminates && paren_depth == 0)
1004 /* Might be a floating point number. */
1005 if (lexptr[1] < '0' || lexptr[1] > '9')
1006 goto symbol; /* Nope, must be a symbol. */
1007 /* FALL THRU into number case. */
1020 /* It's a number. */
1021 int got_dot = 0, got_e = 0, got_d = 0, toktype;
1023 int hex = input_radix > 10;
1025 if (c == '0' && (p[1] == 'x' || p[1] == 'X'))
1030 else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D'))
1038 if (!hex && !got_e && (*p == 'e' || *p == 'E'))
1039 got_dot = got_e = 1;
1040 else if (!hex && !got_d && (*p == 'd' || *p == 'D'))
1041 got_dot = got_d = 1;
1042 else if (!hex && !got_dot && *p == '.')
1044 else if (((got_e && (p[-1] == 'e' || p[-1] == 'E'))
1045 || (got_d && (p[-1] == 'd' || p[-1] == 'D')))
1046 && (*p == '-' || *p == '+'))
1047 /* This is the sign of the exponent, not the end of the
1050 /* We will take any letters or digits. parse_number will
1051 complain if past the radix, or if L or U are not final. */
1052 else if ((*p < '0' || *p > '9')
1053 && ((*p < 'a' || *p > 'z')
1054 && (*p < 'A' || *p > 'Z')))
1057 toktype = parse_number (tokstart, p - tokstart, got_dot|got_e|got_d,
1059 if (toktype == ERROR)
1061 char *err_copy = (char *) alloca (p - tokstart + 1);
1063 memcpy (err_copy, tokstart, p - tokstart);
1064 err_copy[p - tokstart] = 0;
1065 error ("Invalid number \"%s\".", err_copy);
1096 if (!(c == '_' || c == '$'
1097 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
1098 /* We must have come across a bad character (e.g. ';'). */
1099 error ("Invalid character '%c' in expression.", c);
1102 for (c = tokstart[namelen];
1103 (c == '_' || c == '$' || (c >= '0' && c <= '9')
1104 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
1105 c = tokstart[++namelen]);
1107 /* The token "if" terminates the expression and is NOT
1108 removed from the input stream. */
1110 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1115 /* Catch specific keywords. */
1117 for (i = 0; f77_keywords[i].operator != NULL; i++)
1118 if (strncmp (tokstart, f77_keywords[i].operator,
1119 strlen(f77_keywords[i].operator)) == 0)
1121 /* lexptr += strlen(f77_keywords[i].operator); */
1122 yylval.opcode = f77_keywords[i].opcode;
1123 return f77_keywords[i].token;
1126 yylval.sval.ptr = tokstart;
1127 yylval.sval.length = namelen;
1129 if (*tokstart == '$')
1131 write_dollar_variable (yylval.sval);
1135 /* Use token-type TYPENAME for symbols that happen to be defined
1136 currently as names of types; NAME for other symbols.
1137 The caller is not constrained to care about the distinction. */
1139 char *tmp = copy_name (yylval.sval);
1141 int is_a_field_of_this = 0;
1144 sym = lookup_symbol (tmp, expression_context_block,
1146 current_language->la_language == language_cplus
1147 ? &is_a_field_of_this : NULL,
1149 if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
1151 yylval.tsym.type = SYMBOL_TYPE (sym);
1155 = language_lookup_primitive_type_by_name (current_language,
1156 current_gdbarch, tmp);
1157 if (yylval.tsym.type != NULL)
1160 /* Input names that aren't symbols but ARE valid hex numbers,
1161 when the input radix permits them, can be names or numbers
1162 depending on the parse. Note we support radixes > 16 here. */
1164 && ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10)
1165 || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10)))
1167 YYSTYPE newlval; /* Its value is ignored. */
1168 hextype = parse_number (tokstart, namelen, 0, &newlval);
1171 yylval.ssym.sym = sym;
1172 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1177 /* Any other kind of symbol */
1178 yylval.ssym.sym = sym;
1179 yylval.ssym.is_a_field_of_this = is_a_field_of_this;
1189 lexptr = prev_lexptr;
1191 error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);