1 /* YACC grammar for Modula-2 expressions, for GDB.
2 Copyright (C) 1986-2014 Free Software Foundation, Inc.
3 Generated from expread.y (now c-exp.y) and contributed by the Department
4 of Computer Science at the State University of New York at Buffalo, 1991.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Parse a Modula-2 expression from text in a string,
22 and return the result as a struct expression pointer.
23 That structure contains arithmetic operations in reverse polish,
24 with constants represented by operations that are followed by special data.
25 See expression.h for the details of the format.
26 What is important here is that it can be built up sequentially
27 during the process of parsing; the lower levels of the tree always
28 come first in the result.
30 Note that malloc's and realloc's in this file are transformed to
31 xmalloc and xrealloc respectively by the same sed command in the
32 makefile that remaps any other malloc/realloc inserted by the parser
33 generator. Doing this with #defines and trying to control the interaction
34 with include files (<malloc.h> and <stdlib.h> for example) just became
35 too messy, particularly when such includes can be inserted at random
36 times by the parser generator. */
42 #include "expression.h"
45 #include "parser-defs.h"
47 #include "bfd.h" /* Required by objfiles.h. */
48 #include "symfile.h" /* Required by objfiles.h. */
49 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
52 #define parse_type(ps) builtin_type (parse_gdbarch (ps))
53 #define parse_m2_type(ps) builtin_m2_type (parse_gdbarch (ps))
55 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc),
56 as well as gratuitiously global symbol names, so we can have multiple
57 yacc generated parsers in gdb. Note that these are only the variables
58 produced by yacc. If other parser generators (bison, byacc, etc) produce
59 additional global names that conflict at link time, then those parser
60 generators need to be fixed instead of adding those names to this list. */
62 #define yymaxdepth m2_maxdepth
63 #define yyparse m2_parse_internal
65 #define yyerror m2_error
66 #define yylval m2_lval
67 #define yychar m2_char
68 #define yydebug m2_debug
69 #define yypact m2_pact
76 #define yyexca m2_exca
77 #define yyerrflag m2_errflag
78 #define yynerrs m2_nerrs
83 #define yystate m2_state
88 #define yylloc m2_lloc
89 #define yyreds m2_reds /* With YYDEBUG defined */
90 #define yytoks m2_toks /* With YYDEBUG defined */
91 #define yyname m2_name /* With YYDEBUG defined */
92 #define yyrule m2_rule /* With YYDEBUG defined */
93 #define yylhs m2_yylhs
94 #define yylen m2_yylen
95 #define yydefred m2_yydefred
96 #define yydgoto m2_yydgoto
97 #define yysindex m2_yysindex
98 #define yyrindex m2_yyrindex
99 #define yygindex m2_yygindex
100 #define yytable m2_yytable
101 #define yycheck m2_yycheck
103 #define yysslim m2_yysslim
104 #define yyssp m2_yyssp
105 #define yystacksize m2_yystacksize
107 #define yyvsp m2_yyvsp
110 #define YYDEBUG 1 /* Default to yydebug support */
113 #define YYFPRINTF parser_fprintf
115 /* The state of the parser, used internally when we are parsing the
118 static struct parser_state *pstate = NULL;
122 static int yylex (void);
124 void yyerror (char *);
126 static int parse_number (int);
128 /* The sign of the number being parsed. */
129 static int number_sign = 1;
133 /* Although the yacc "value" of an expression is not used,
134 since the result is stored in the structure being created,
135 other node types do have values. */
146 const struct block *bval;
147 enum exp_opcode opcode;
148 struct internalvar *ivar;
154 %type <voidval> exp type_exp start set
155 %type <voidval> variable
160 %token <lval> INT HEX ERROR
161 %token <ulval> UINT M2_TRUE M2_FALSE CHAR
164 /* Both NAME and TYPENAME tokens represent symbols in the input,
165 and both convey their data as strings.
166 But a TYPENAME is a string that happens to be defined as a typedef
167 or builtin type name (such as int or char)
168 and a NAME is any other symbol.
170 Contexts where this distinction is not important can use the
171 nonterminal "name", which matches either NAME or TYPENAME. */
174 %token <sval> NAME BLOCKNAME IDENT VARNAME
175 %token <sval> TYPENAME
177 %token SIZE CAP ORD HIGH ABS MIN_FUNC MAX_FUNC FLOAT_FUNC VAL CHR ODD TRUNC
179 %token INC DEC INCL EXCL
181 /* The GDB scope operator */
184 %token <voidval> INTERNAL_VAR
190 %left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
192 %left LOGICAL_AND '&'
195 %left '*' '/' DIV MOD
197 %right '^' DOT '[' '('
200 /* This is not an actual token ; it is used for precedence.
212 { write_exp_elt_opcode (pstate, OP_TYPE);
213 write_exp_elt_type (pstate, $1);
214 write_exp_elt_opcode (pstate, OP_TYPE);
220 exp : exp '^' %prec UNARY
221 { write_exp_elt_opcode (pstate, UNOP_IND); }
225 { number_sign = -1; }
228 write_exp_elt_opcode (pstate, UNOP_NEG); }
231 exp : '+' exp %prec UNARY
232 { write_exp_elt_opcode (pstate, UNOP_PLUS); }
235 exp : not_exp exp %prec UNARY
236 { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
243 exp : CAP '(' exp ')'
244 { write_exp_elt_opcode (pstate, UNOP_CAP); }
247 exp : ORD '(' exp ')'
248 { write_exp_elt_opcode (pstate, UNOP_ORD); }
251 exp : ABS '(' exp ')'
252 { write_exp_elt_opcode (pstate, UNOP_ABS); }
255 exp : HIGH '(' exp ')'
256 { write_exp_elt_opcode (pstate, UNOP_HIGH); }
259 exp : MIN_FUNC '(' type ')'
260 { write_exp_elt_opcode (pstate, UNOP_MIN);
261 write_exp_elt_type (pstate, $3);
262 write_exp_elt_opcode (pstate, UNOP_MIN); }
265 exp : MAX_FUNC '(' type ')'
266 { write_exp_elt_opcode (pstate, UNOP_MAX);
267 write_exp_elt_type (pstate, $3);
268 write_exp_elt_opcode (pstate, UNOP_MAX); }
271 exp : FLOAT_FUNC '(' exp ')'
272 { write_exp_elt_opcode (pstate, UNOP_FLOAT); }
275 exp : VAL '(' type ',' exp ')'
276 { write_exp_elt_opcode (pstate, BINOP_VAL);
277 write_exp_elt_type (pstate, $3);
278 write_exp_elt_opcode (pstate, BINOP_VAL); }
281 exp : CHR '(' exp ')'
282 { write_exp_elt_opcode (pstate, UNOP_CHR); }
285 exp : ODD '(' exp ')'
286 { write_exp_elt_opcode (pstate, UNOP_ODD); }
289 exp : TRUNC '(' exp ')'
290 { write_exp_elt_opcode (pstate, UNOP_TRUNC); }
293 exp : TSIZE '(' exp ')'
294 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
297 exp : SIZE exp %prec UNARY
298 { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
302 exp : INC '(' exp ')'
303 { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); }
306 exp : INC '(' exp ',' exp ')'
307 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
308 write_exp_elt_opcode (pstate, BINOP_ADD);
309 write_exp_elt_opcode (pstate,
310 BINOP_ASSIGN_MODIFY); }
313 exp : DEC '(' exp ')'
314 { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT);}
317 exp : DEC '(' exp ',' exp ')'
318 { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
319 write_exp_elt_opcode (pstate, BINOP_SUB);
320 write_exp_elt_opcode (pstate,
321 BINOP_ASSIGN_MODIFY); }
325 { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
326 write_exp_string (pstate, $3);
327 write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
334 { error (_("Sets are not implemented."));}
337 exp : INCL '(' exp ',' exp ')'
338 { error (_("Sets are not implemented."));}
341 exp : EXCL '(' exp ',' exp ')'
342 { error (_("Sets are not implemented."));}
345 set : '{' arglist '}'
346 { error (_("Sets are not implemented."));}
347 | type '{' arglist '}'
348 { error (_("Sets are not implemented."));}
352 /* Modula-2 array subscript notation [a,b,c...] */
354 /* This function just saves the number of arguments
355 that follow in the list. It is *not* specific to
358 non_empty_arglist ']' %prec DOT
359 { write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT);
360 write_exp_elt_longcst (pstate,
361 (LONGEST) end_arglist());
362 write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT); }
365 exp : exp '[' exp ']'
366 { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); }
370 /* This is to save the value of arglist_len
371 being accumulated by an outer function call. */
372 { start_arglist (); }
373 arglist ')' %prec DOT
374 { write_exp_elt_opcode (pstate, OP_FUNCALL);
375 write_exp_elt_longcst (pstate,
376 (LONGEST) end_arglist ());
377 write_exp_elt_opcode (pstate, OP_FUNCALL); }
387 arglist : arglist ',' exp %prec ABOVE_COMMA
397 : non_empty_arglist ',' exp %prec ABOVE_COMMA
402 exp : '{' type '}' exp %prec UNARY
403 { write_exp_elt_opcode (pstate, UNOP_MEMVAL);
404 write_exp_elt_type (pstate, $2);
405 write_exp_elt_opcode (pstate, UNOP_MEMVAL); }
408 exp : type '(' exp ')' %prec UNARY
409 { write_exp_elt_opcode (pstate, UNOP_CAST);
410 write_exp_elt_type (pstate, $1);
411 write_exp_elt_opcode (pstate, UNOP_CAST); }
418 /* Binary operators in order of decreasing precedence. Note that some
419 of these operators are overloaded! (ie. sets) */
423 { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
427 { write_exp_elt_opcode (pstate, BINOP_MUL); }
431 { write_exp_elt_opcode (pstate, BINOP_DIV); }
435 { write_exp_elt_opcode (pstate, BINOP_INTDIV); }
439 { write_exp_elt_opcode (pstate, BINOP_REM); }
443 { write_exp_elt_opcode (pstate, BINOP_ADD); }
447 { write_exp_elt_opcode (pstate, BINOP_SUB); }
451 { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
454 exp : exp NOTEQUAL exp
455 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
457 { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
461 { write_exp_elt_opcode (pstate, BINOP_LEQ); }
465 { write_exp_elt_opcode (pstate, BINOP_GEQ); }
469 { write_exp_elt_opcode (pstate, BINOP_LESS); }
473 { write_exp_elt_opcode (pstate, BINOP_GTR); }
476 exp : exp LOGICAL_AND exp
477 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
481 { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
485 { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
492 { write_exp_elt_opcode (pstate, OP_BOOL);
493 write_exp_elt_longcst (pstate, (LONGEST) $1);
494 write_exp_elt_opcode (pstate, OP_BOOL); }
498 { write_exp_elt_opcode (pstate, OP_BOOL);
499 write_exp_elt_longcst (pstate, (LONGEST) $1);
500 write_exp_elt_opcode (pstate, OP_BOOL); }
504 { write_exp_elt_opcode (pstate, OP_LONG);
505 write_exp_elt_type (pstate,
506 parse_m2_type (pstate)->builtin_int);
507 write_exp_elt_longcst (pstate, (LONGEST) $1);
508 write_exp_elt_opcode (pstate, OP_LONG); }
513 write_exp_elt_opcode (pstate, OP_LONG);
514 write_exp_elt_type (pstate,
515 parse_m2_type (pstate)
517 write_exp_elt_longcst (pstate, (LONGEST) $1);
518 write_exp_elt_opcode (pstate, OP_LONG);
523 { write_exp_elt_opcode (pstate, OP_LONG);
524 write_exp_elt_type (pstate,
525 parse_m2_type (pstate)
527 write_exp_elt_longcst (pstate, (LONGEST) $1);
528 write_exp_elt_opcode (pstate, OP_LONG); }
533 { write_exp_elt_opcode (pstate, OP_DOUBLE);
534 write_exp_elt_type (pstate,
535 parse_m2_type (pstate)
537 write_exp_elt_dblcst (pstate, $1);
538 write_exp_elt_opcode (pstate, OP_DOUBLE); }
544 exp : SIZE '(' type ')' %prec UNARY
545 { write_exp_elt_opcode (pstate, OP_LONG);
546 write_exp_elt_type (pstate,
547 parse_type (pstate)->builtin_int);
548 write_exp_elt_longcst (pstate,
549 (LONGEST) TYPE_LENGTH ($3));
550 write_exp_elt_opcode (pstate, OP_LONG); }
554 { write_exp_elt_opcode (pstate, OP_M2_STRING);
555 write_exp_string (pstate, $1);
556 write_exp_elt_opcode (pstate, OP_M2_STRING); }
559 /* This will be used for extensions later. Like adding modules. */
561 { $$ = SYMBOL_BLOCK_VALUE($1); }
566 = lookup_symbol (copy_name ($1),
567 expression_context_block,
573 /* GDB scope operator */
574 fblock : block COLONCOLON BLOCKNAME
576 = lookup_symbol (copy_name ($3), $1,
578 if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK)
579 error (_("No function \"%s\" in specified context."),
585 /* Useful for assigning to PROCEDURE variables */
587 { write_exp_elt_opcode (pstate, OP_VAR_VALUE);
588 write_exp_elt_block (pstate, NULL);
589 write_exp_elt_sym (pstate, $1);
590 write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
593 /* GDB internal ($foo) variable */
594 variable: INTERNAL_VAR
597 /* GDB scope operator */
598 variable: block COLONCOLON NAME
599 { struct symbol *sym;
600 sym = lookup_symbol (copy_name ($3), $1,
603 error (_("No symbol \"%s\" in specified context."),
605 if (symbol_read_needs_frame (sym))
607 if (innermost_block == 0
608 || contained_in (block_found,
610 innermost_block = block_found;
613 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
614 /* block_found is set by lookup_symbol. */
615 write_exp_elt_block (pstate, block_found);
616 write_exp_elt_sym (pstate, sym);
617 write_exp_elt_opcode (pstate, OP_VAR_VALUE); }
620 /* Base case for variables. */
622 { struct symbol *sym;
623 struct field_of_this_result is_a_field_of_this;
625 sym = lookup_symbol (copy_name ($1),
626 expression_context_block,
628 &is_a_field_of_this);
631 if (symbol_read_needs_frame (sym))
633 if (innermost_block == 0 ||
634 contained_in (block_found,
636 innermost_block = block_found;
639 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
640 /* We want to use the selected frame, not
641 another more inner frame which happens to
642 be in the same block. */
643 write_exp_elt_block (pstate, NULL);
644 write_exp_elt_sym (pstate, sym);
645 write_exp_elt_opcode (pstate, OP_VAR_VALUE);
649 struct bound_minimal_symbol msymbol;
650 char *arg = copy_name ($1);
653 lookup_bound_minimal_symbol (arg);
654 if (msymbol.minsym != NULL)
655 write_exp_msymbol (pstate, msymbol);
656 else if (!have_full_symbols () && !have_partial_symbols ())
657 error (_("No symbol table is loaded. Use the \"symbol-file\" command."));
659 error (_("No symbol \"%s\" in current context."),
667 { $$ = lookup_typename (parse_language (pstate),
668 parse_gdbarch (pstate),
670 expression_context_block, 0); }
676 /* Take care of parsing a number (anything that starts with a digit).
677 Set yylval and return the token type; update lexptr.
678 LEN is the number of characters in it. */
680 /*** Needs some error checking for the float case ***/
683 parse_number (int olen)
685 const char *p = lexptr;
689 int base = input_radix;
691 int unsigned_p = number_sign == 1 ? 1 : 0;
698 else if(p[len-1] == 'C' || p[len-1] == 'B')
701 ischar = p[len-1] == 'C';
705 /* Scan the number */
706 for (c = 0; c < len; c++)
708 if (p[c] == '.' && base == 10)
710 /* It's a float since it contains a point. */
711 yylval.dval = atof (p);
715 if (p[c] == '.' && base != 10)
716 error (_("Floating point numbers must be base 10."));
717 if (base == 10 && (p[c] < '0' || p[c] > '9'))
718 error (_("Invalid digit \'%c\' in number."),p[c]);
725 if( base == 8 && (c == '8' || c == '9'))
726 error (_("Invalid digit \'%c\' in octal number."),c);
727 if (c >= '0' && c <= '9')
731 if (base == 16 && c >= 'A' && c <= 'F')
739 if(!unsigned_p && number_sign == 1 && (prevn >= n))
740 unsigned_p=1; /* Try something unsigned */
741 /* Don't do the range check if n==i and i==0, since that special
742 case will give an overflow error. */
743 if(RANGE_CHECK && n!=i && i)
745 if((unsigned_p && (unsigned)prevn >= (unsigned)n) ||
746 ((!unsigned_p && number_sign==-1) && -prevn <= -n))
747 range_error (_("Overflow on numeric constant."));
753 if(*p == 'B' || *p == 'C' || *p == 'H')
754 lexptr++; /* Advance past B,C or H */
761 else if ( unsigned_p && number_sign == 1)
766 else if((unsigned_p && (n<0))) {
767 range_error (_("Overflow on numeric constant -- number too large."));
768 /* But, this can return if range_check == range_warn. */
783 { {'<', '>'}, NOTEQUAL },
784 { {':', '='}, ASSIGN },
787 { {':', ':'}, COLONCOLON },
791 /* Some specific keywords */
798 static struct keyword keytab[] =
801 {"IN", IN },/* Note space after IN */
802 {"AND", LOGICAL_AND},
820 {"FLOAT", FLOAT_FUNC },
826 /* Read one token, getting characters through lexptr. */
828 /* This is where we will check to make sure that the language and the
829 operators used are compatible */
837 const char *tokstart;
842 prev_lexptr = lexptr;
847 /* See if it is a special token of length 2 */
848 for( i = 0 ; i < (int) (sizeof tokentab2 / sizeof tokentab2[0]) ; i++)
849 if (strncmp (tokentab2[i].name, tokstart, 2) == 0)
852 return tokentab2[i].token;
855 switch (c = *tokstart)
872 if (paren_depth == 0)
879 if (comma_terminates && paren_depth == 0)
885 /* Might be a floating point number. */
886 if (lexptr[1] >= '0' && lexptr[1] <= '9')
887 break; /* Falls into number code. */
894 /* These are character tokens that appear as-is in the YACC grammar */
917 for (namelen = 1; (c = tokstart[namelen]) != quote && c != '\0'; namelen++)
920 c = tokstart[++namelen];
921 if (c >= '0' && c <= '9')
923 c = tokstart[++namelen];
924 if (c >= '0' && c <= '9')
925 c = tokstart[++namelen];
929 error (_("Unterminated string or character constant."));
930 yylval.sval.ptr = tokstart + 1;
931 yylval.sval.length = namelen - 1;
932 lexptr += namelen + 1;
934 if(namelen == 2) /* Single character */
936 yylval.ulval = tokstart[1];
943 /* Is it a number? */
944 /* Note: We have already dealt with the case of the token '.'.
945 See case '.' above. */
946 if ((c >= '0' && c <= '9'))
949 int got_dot = 0, got_e = 0;
950 const char *p = tokstart;
955 if (!got_e && (*p == 'e' || *p == 'E'))
957 else if (!got_dot && *p == '.')
959 else if (got_e && (p[-1] == 'e' || p[-1] == 'E')
960 && (*p == '-' || *p == '+'))
961 /* This is the sign of the exponent, not the end of the
964 else if ((*p < '0' || *p > '9') &&
965 (*p < 'A' || *p > 'F') &&
966 (*p != 'H')) /* Modula-2 hexadecimal number */
969 toktype = parse_number (p - tokstart);
970 if (toktype == ERROR)
972 char *err_copy = (char *) alloca (p - tokstart + 1);
974 memcpy (err_copy, tokstart, p - tokstart);
975 err_copy[p - tokstart] = 0;
976 error (_("Invalid number \"%s\"."), err_copy);
982 if (!(c == '_' || c == '$'
983 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')))
984 /* We must have come across a bad character (e.g. ';'). */
985 error (_("Invalid character '%c' in expression."), c);
987 /* It's a name. See how long it is. */
989 for (c = tokstart[namelen];
990 (c == '_' || c == '$' || (c >= '0' && c <= '9')
991 || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'));
992 c = tokstart[++namelen])
995 /* The token "if" terminates the expression and is NOT
996 removed from the input stream. */
997 if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
1004 /* Lookup special keywords */
1005 for(i = 0 ; i < (int) (sizeof(keytab) / sizeof(keytab[0])) ; i++)
1006 if (namelen == strlen (keytab[i].keyw)
1007 && strncmp (tokstart, keytab[i].keyw, namelen) == 0)
1008 return keytab[i].token;
1010 yylval.sval.ptr = tokstart;
1011 yylval.sval.length = namelen;
1013 if (*tokstart == '$')
1015 write_dollar_variable (pstate, yylval.sval);
1016 return INTERNAL_VAR;
1019 /* Use token-type BLOCKNAME for symbols that happen to be defined as
1020 functions. If this is not so, then ...
1021 Use token-type TYPENAME for symbols that happen to be defined
1022 currently as names of types; NAME for other symbols.
1023 The caller is not constrained to care about the distinction. */
1027 char *tmp = copy_name (yylval.sval);
1030 if (lookup_symtab (tmp))
1032 sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0);
1033 if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
1035 if (lookup_typename (parse_language (pstate), parse_gdbarch (pstate),
1036 copy_name (yylval.sval),
1037 expression_context_block, 1))
1042 switch(SYMBOL_CLASS (sym))
1048 case LOC_REGPARM_ADDR:
1051 case LOC_CONST_BYTES:
1052 case LOC_OPTIMIZED_OUT:
1063 error (_("internal: Undefined class in m2lex()"));
1066 case LOC_UNRESOLVED:
1067 error (_("internal: Unforseen case in m2lex()"));
1070 error (_("unhandled token in m2lex()"));
1076 /* Built-in BOOLEAN type. This is sort of a hack. */
1077 if (strncmp (tokstart, "TRUE", 4) == 0)
1082 else if (strncmp (tokstart, "FALSE", 5) == 0)
1089 /* Must be another type of name... */
1095 m2_parse (struct parser_state *par_state)
1098 struct cleanup *c = make_cleanup_clear_parser_state (&pstate);
1100 /* Setting up the parser state. */
1101 gdb_assert (par_state != NULL);
1104 result = yyparse ();
1114 lexptr = prev_lexptr;
1116 error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr);