X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fp-exp.y;h=5d5c22b6be9e7d33348d41aae280954305c33851;hb=8b558f797a3a63aaa8de119ddf53c8afdd1dc6eb;hp=c034fbbdd4db97278b34c65a458973590d906a96;hpb=f870a310ee7fbfd6ccaea95d632063cbdbd2b9c9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/p-exp.y b/gdb/p-exp.y index c034fbbdd4..5d5c22b6be 100644 --- a/gdb/p-exp.y +++ b/gdb/p-exp.y @@ -1,6 +1,5 @@ /* YACC parser for Pascal expressions, for GDB. - Copyright (C) 2000, 2006, 2007, 2008, 2009, 2010 - Free Software Foundation, Inc. + Copyright (C) 2000-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -41,11 +40,10 @@ - there are some problems with boolean types. - Pascal type hexadecimal constants are not supported because they conflict with the internal variables format. - Probably also lots of other problems, less well defined PM */ + Probably also lots of other problems, less well defined PM. */ %{ #include "defs.h" -#include "gdb_string.h" #include #include "expression.h" #include "value.h" @@ -54,31 +52,32 @@ #include "p-lang.h" #include "bfd.h" /* Required by objfiles.h. */ #include "symfile.h" /* Required by objfiles.h. */ -#include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ +#include "objfiles.h" /* For have_full_symbols and have_partial_symbols. */ #include "block.h" +#include "completer.h" -#define parse_type builtin_type (parse_gdbarch) +#define parse_type(ps) builtin_type (parse_gdbarch (ps)) /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), as well as gratuitiously global symbol names, so we can have multiple yacc generated parsers in gdb. Note that these are only the variables produced by yacc. If other parser generators (bison, byacc, etc) produce additional global names that conflict at link time, then those parser - generators need to be fixed instead of adding those names to this list. */ + generators need to be fixed instead of adding those names to this list. */ #define yymaxdepth pascal_maxdepth -#define yyparse pascal_parse +#define yyparse pascal_parse_internal #define yylex pascal_lex #define yyerror pascal_error #define yylval pascal_lval #define yychar pascal_char #define yydebug pascal_debug -#define yypact pascal_pact -#define yyr1 pascal_r1 -#define yyr2 pascal_r2 -#define yydef pascal_def -#define yychk pascal_chk -#define yypgo pascal_pgo +#define yypact pascal_pact +#define yyr1 pascal_r1 +#define yyr2 pascal_r2 +#define yydef pascal_def +#define yychk pascal_chk +#define yypgo pascal_pgo #define yyact pascal_act #define yyexca pascal_exca #define yyerrflag pascal_errflag @@ -106,6 +105,12 @@ #define yygindex pascal_yygindex #define yytable pascal_yytable #define yycheck pascal_yycheck +#define yyss pascal_yyss +#define yysslim pascal_yysslim +#define yyssp pascal_yyssp +#define yystacksize pascal_yystacksize +#define yyvs pascal_yyvs +#define yyvsp pascal_yyvsp #ifndef YYDEBUG #define YYDEBUG 1 /* Default to yydebug support */ @@ -113,14 +118,18 @@ #define YYFPRINTF parser_fprintf +/* The state of the parser, used internally when we are parsing the + expression. */ + +static struct parser_state *pstate = NULL; + int yyparse (void); static int yylex (void); -void -yyerror (char *); +void yyerror (char *); -static char * uptok (char *, int); +static char *uptok (const char *, int); %} /* Although the yacc "value" of an expression is not used, @@ -144,7 +153,7 @@ static char * uptok (char *, int); struct ttype tsym; struct symtoken ssym; int voidval; - struct block *bval; + const struct block *bval; enum exp_opcode opcode; struct internalvar *ivar; @@ -154,10 +163,11 @@ static char * uptok (char *, int); %{ /* YYSTYPE gets defined by %union */ -static int -parse_number (char *, int, int, YYSTYPE *); +static int parse_number (struct parser_state *, + const char *, int, int, YYSTYPE *); static struct type *current_type; +static struct internalvar *intvar; static int leftdiv_is_integer; static void push_current_type (void); static void pop_current_type (void); @@ -182,9 +192,10 @@ static int search_field; Contexts where this distinction is not important can use the nonterminal "name", which matches either NAME or TYPENAME. */ -%token STRING +%token STRING %token FIELDNAME -%token NAME /* BLOCKNAME defined below to give it higher precedence. */ +%token COMPLETE +%token NAME /* BLOCKNAME defined below to give it higher precedence. */ %token TYPENAME %type name %type name_not_typename @@ -233,6 +244,7 @@ static int search_field; %% start : { current_type = NULL; + intvar = NULL; search_field = 0; leftdiv_is_integer = 0; } @@ -245,82 +257,127 @@ normal_start : ; type_exp: type - { write_exp_elt_opcode(OP_TYPE); - write_exp_elt_type($1); - write_exp_elt_opcode(OP_TYPE); + { write_exp_elt_opcode (pstate, OP_TYPE); + write_exp_elt_type (pstate, $1); + write_exp_elt_opcode (pstate, OP_TYPE); current_type = $1; } ; /* Expressions, including the comma operator. */ exp1 : exp | exp1 ',' exp - { write_exp_elt_opcode (BINOP_COMMA); } + { write_exp_elt_opcode (pstate, BINOP_COMMA); } ; /* Expressions, not including the comma operator. */ exp : exp '^' %prec UNARY - { write_exp_elt_opcode (UNOP_IND); - if (current_type) + { write_exp_elt_opcode (pstate, UNOP_IND); + if (current_type) current_type = TYPE_TARGET_TYPE (current_type); } ; exp : '@' exp %prec UNARY - { write_exp_elt_opcode (UNOP_ADDR); + { write_exp_elt_opcode (pstate, UNOP_ADDR); if (current_type) current_type = TYPE_POINTER_TYPE (current_type); } ; exp : '-' exp %prec UNARY - { write_exp_elt_opcode (UNOP_NEG); } + { write_exp_elt_opcode (pstate, UNOP_NEG); } ; exp : NOT exp %prec UNARY - { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } + { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } ; exp : INCREMENT '(' exp ')' %prec UNARY - { write_exp_elt_opcode (UNOP_PREINCREMENT); } + { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); } ; exp : DECREMENT '(' exp ')' %prec UNARY - { write_exp_elt_opcode (UNOP_PREDECREMENT); } + { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT); } + ; + + +field_exp : exp '.' %prec UNARY + { search_field = 1; } ; -exp : exp '.' { search_field = 1; } - FIELDNAME - /* name */ - { write_exp_elt_opcode (STRUCTOP_STRUCT); - write_exp_string ($4); - write_exp_elt_opcode (STRUCTOP_STRUCT); - search_field = 0; +exp : field_exp FIELDNAME + { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + write_exp_string (pstate, $2); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + search_field = 0; if (current_type) - { while (TYPE_CODE (current_type) == TYPE_CODE_PTR) - current_type = TYPE_TARGET_TYPE (current_type); + { + while (TYPE_CODE (current_type) + == TYPE_CODE_PTR) + current_type = + TYPE_TARGET_TYPE (current_type); current_type = lookup_struct_elt_type ( - current_type, $4.ptr, 0); }; - } ; + current_type, $2.ptr, 0); + } + } + ; + + +exp : field_exp name + { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + write_exp_string (pstate, $2); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + search_field = 0; + if (current_type) + { + while (TYPE_CODE (current_type) + == TYPE_CODE_PTR) + current_type = + TYPE_TARGET_TYPE (current_type); + current_type = lookup_struct_elt_type ( + current_type, $2.ptr, 0); + } + } + ; +exp : field_exp name COMPLETE + { mark_struct_expression (pstate); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + write_exp_string (pstate, $2); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } + ; +exp : field_exp COMPLETE + { struct stoken s; + mark_struct_expression (pstate); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + s.ptr = ""; + s.length = 0; + write_exp_string (pstate, s); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } + ; + exp : exp '[' - /* We need to save the current_type value */ - { char *arrayname; + /* We need to save the current_type value. */ + { const char *arrayname; int arrayfieldindex; arrayfieldindex = is_pascal_string_type ( current_type, NULL, NULL, - NULL, NULL, &arrayname); - if (arrayfieldindex) + NULL, NULL, &arrayname); + if (arrayfieldindex) { struct stoken stringsval; - stringsval.ptr = alloca (strlen (arrayname) + 1); + char *buf; + + buf = alloca (strlen (arrayname) + 1); + stringsval.ptr = buf; stringsval.length = strlen (arrayname); - strcpy (stringsval.ptr, arrayname); + strcpy (buf, arrayname); current_type = TYPE_FIELD_TYPE (current_type, - arrayfieldindex - 1); - write_exp_elt_opcode (STRUCTOP_STRUCT); - write_exp_string (stringsval); - write_exp_elt_opcode (STRUCTOP_STRUCT); + arrayfieldindex - 1); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); + write_exp_string (pstate, stringsval); + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } push_current_type (); } exp1 ']' { pop_current_type (); - write_exp_elt_opcode (BINOP_SUBSCRIPT); + write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); if (current_type) current_type = TYPE_TARGET_TYPE (current_type); } ; @@ -331,9 +388,10 @@ exp : exp '(' { push_current_type (); start_arglist (); } arglist ')' %prec ARROW - { write_exp_elt_opcode (OP_FUNCALL); - write_exp_elt_longcst ((LONGEST) end_arglist ()); - write_exp_elt_opcode (OP_FUNCALL); + { write_exp_elt_opcode (pstate, OP_FUNCALL); + write_exp_elt_longcst (pstate, + (LONGEST) end_arglist ()); + write_exp_elt_opcode (pstate, OP_FUNCALL); pop_current_type (); if (current_type) current_type = TYPE_TARGET_TYPE (current_type); @@ -352,13 +410,13 @@ exp : type '(' exp ')' %prec UNARY { /* Allow automatic dereference of classes. */ if ((TYPE_CODE (current_type) == TYPE_CODE_PTR) - && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_CLASS) - && (TYPE_CODE ($1) == TYPE_CODE_CLASS)) - write_exp_elt_opcode (UNOP_IND); + && (TYPE_CODE (TYPE_TARGET_TYPE (current_type)) == TYPE_CODE_STRUCT) + && (TYPE_CODE ($1) == TYPE_CODE_STRUCT)) + write_exp_elt_opcode (pstate, UNOP_IND); } - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type ($1); - write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_opcode (pstate, UNOP_CAST); + write_exp_elt_type (pstate, $1); + write_exp_elt_opcode (pstate, UNOP_CAST); current_type = $1; } ; @@ -369,195 +427,226 @@ exp : '(' exp1 ')' /* Binary operators in order of decreasing precedence. */ exp : exp '*' exp - { write_exp_elt_opcode (BINOP_MUL); } + { write_exp_elt_opcode (pstate, BINOP_MUL); } ; exp : exp '/' { if (current_type && is_integral_type (current_type)) leftdiv_is_integer = 1; - } + } exp - { + { if (leftdiv_is_integer && current_type && is_integral_type (current_type)) { - write_exp_elt_opcode (UNOP_CAST); - write_exp_elt_type (parse_type->builtin_long_double); - current_type = parse_type->builtin_long_double; - write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_opcode (pstate, UNOP_CAST); + write_exp_elt_type (pstate, + parse_type (pstate) + ->builtin_long_double); + current_type + = parse_type (pstate)->builtin_long_double; + write_exp_elt_opcode (pstate, UNOP_CAST); leftdiv_is_integer = 0; } - write_exp_elt_opcode (BINOP_DIV); + write_exp_elt_opcode (pstate, BINOP_DIV); } ; exp : exp DIV exp - { write_exp_elt_opcode (BINOP_INTDIV); } + { write_exp_elt_opcode (pstate, BINOP_INTDIV); } ; exp : exp MOD exp - { write_exp_elt_opcode (BINOP_REM); } + { write_exp_elt_opcode (pstate, BINOP_REM); } ; exp : exp '+' exp - { write_exp_elt_opcode (BINOP_ADD); } + { write_exp_elt_opcode (pstate, BINOP_ADD); } ; exp : exp '-' exp - { write_exp_elt_opcode (BINOP_SUB); } + { write_exp_elt_opcode (pstate, BINOP_SUB); } ; exp : exp LSH exp - { write_exp_elt_opcode (BINOP_LSH); } + { write_exp_elt_opcode (pstate, BINOP_LSH); } ; exp : exp RSH exp - { write_exp_elt_opcode (BINOP_RSH); } + { write_exp_elt_opcode (pstate, BINOP_RSH); } ; exp : exp '=' exp - { write_exp_elt_opcode (BINOP_EQUAL); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (pstate, BINOP_EQUAL); + current_type = parse_type (pstate)->builtin_bool; } ; exp : exp NOTEQUAL exp - { write_exp_elt_opcode (BINOP_NOTEQUAL); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); + current_type = parse_type (pstate)->builtin_bool; } ; exp : exp LEQ exp - { write_exp_elt_opcode (BINOP_LEQ); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (pstate, BINOP_LEQ); + current_type = parse_type (pstate)->builtin_bool; } ; exp : exp GEQ exp - { write_exp_elt_opcode (BINOP_GEQ); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (pstate, BINOP_GEQ); + current_type = parse_type (pstate)->builtin_bool; } ; exp : exp '<' exp - { write_exp_elt_opcode (BINOP_LESS); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (pstate, BINOP_LESS); + current_type = parse_type (pstate)->builtin_bool; } ; exp : exp '>' exp - { write_exp_elt_opcode (BINOP_GTR); - current_type = parse_type->builtin_bool; + { write_exp_elt_opcode (pstate, BINOP_GTR); + current_type = parse_type (pstate)->builtin_bool; } ; exp : exp ANDAND exp - { write_exp_elt_opcode (BINOP_BITWISE_AND); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); } ; exp : exp XOR exp - { write_exp_elt_opcode (BINOP_BITWISE_XOR); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); } ; exp : exp OR exp - { write_exp_elt_opcode (BINOP_BITWISE_IOR); } + { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); } ; exp : exp ASSIGN exp - { write_exp_elt_opcode (BINOP_ASSIGN); } + { write_exp_elt_opcode (pstate, BINOP_ASSIGN); } ; exp : TRUEKEYWORD - { write_exp_elt_opcode (OP_BOOL); - write_exp_elt_longcst ((LONGEST) $1); - current_type = parse_type->builtin_bool; - write_exp_elt_opcode (OP_BOOL); } + { write_exp_elt_opcode (pstate, OP_BOOL); + write_exp_elt_longcst (pstate, (LONGEST) $1); + current_type = parse_type (pstate)->builtin_bool; + write_exp_elt_opcode (pstate, OP_BOOL); } ; exp : FALSEKEYWORD - { write_exp_elt_opcode (OP_BOOL); - write_exp_elt_longcst ((LONGEST) $1); - current_type = parse_type->builtin_bool; - write_exp_elt_opcode (OP_BOOL); } + { write_exp_elt_opcode (pstate, OP_BOOL); + write_exp_elt_longcst (pstate, (LONGEST) $1); + current_type = parse_type (pstate)->builtin_bool; + write_exp_elt_opcode (pstate, OP_BOOL); } ; exp : INT - { write_exp_elt_opcode (OP_LONG); - write_exp_elt_type ($1.type); + { write_exp_elt_opcode (pstate, OP_LONG); + write_exp_elt_type (pstate, $1.type); current_type = $1.type; - write_exp_elt_longcst ((LONGEST)($1.val)); - write_exp_elt_opcode (OP_LONG); } + write_exp_elt_longcst (pstate, (LONGEST)($1.val)); + write_exp_elt_opcode (pstate, OP_LONG); } ; exp : NAME_OR_INT { YYSTYPE val; - parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val); - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (val.typed_val_int.type); + parse_number (pstate, $1.stoken.ptr, + $1.stoken.length, 0, &val); + write_exp_elt_opcode (pstate, OP_LONG); + write_exp_elt_type (pstate, val.typed_val_int.type); current_type = val.typed_val_int.type; - write_exp_elt_longcst ((LONGEST)val.typed_val_int.val); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_longcst (pstate, (LONGEST) + val.typed_val_int.val); + write_exp_elt_opcode (pstate, OP_LONG); } ; exp : FLOAT - { write_exp_elt_opcode (OP_DOUBLE); - write_exp_elt_type ($1.type); + { write_exp_elt_opcode (pstate, OP_DOUBLE); + write_exp_elt_type (pstate, $1.type); current_type = $1.type; - write_exp_elt_dblcst ($1.dval); - write_exp_elt_opcode (OP_DOUBLE); } + write_exp_elt_dblcst (pstate, $1.dval); + write_exp_elt_opcode (pstate, OP_DOUBLE); } ; exp : variable ; exp : VARIABLE - /* Already written by write_dollar_variable. */ - ; + /* Already written by write_dollar_variable. + Handle current_type. */ + { if (intvar) { + struct value * val, * mark; + + mark = value_mark (); + val = value_of_internalvar (parse_gdbarch (pstate), + intvar); + current_type = value_type (val); + value_release_to_mark (mark); + } + } + ; exp : SIZEOF '(' type ')' %prec UNARY - { write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (parse_type->builtin_int); - CHECK_TYPEDEF ($3); - write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); - write_exp_elt_opcode (OP_LONG); } + { write_exp_elt_opcode (pstate, OP_LONG); + write_exp_elt_type (pstate, + parse_type (pstate)->builtin_int); + current_type = parse_type (pstate)->builtin_int; + $3 = check_typedef ($3); + write_exp_elt_longcst (pstate, + (LONGEST) TYPE_LENGTH ($3)); + write_exp_elt_opcode (pstate, OP_LONG); } ; +exp : SIZEOF '(' exp ')' %prec UNARY + { write_exp_elt_opcode (pstate, UNOP_SIZEOF); + current_type = parse_type (pstate)->builtin_int; } + exp : STRING { /* C strings are converted into array constants with an explicit null byte added at the end. Thus the array upper bound is the string length. There is no such thing in C as a completely empty - string. */ - char *sp = $1.ptr; int count = $1.length; + string. */ + const char *sp = $1.ptr; int count = $1.length; + while (count-- > 0) { - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (parse_type->builtin_char); - write_exp_elt_longcst ((LONGEST)(*sp++)); - write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (pstate, OP_LONG); + write_exp_elt_type (pstate, + parse_type (pstate) + ->builtin_char); + write_exp_elt_longcst (pstate, + (LONGEST) (*sp++)); + write_exp_elt_opcode (pstate, OP_LONG); } - write_exp_elt_opcode (OP_LONG); - write_exp_elt_type (parse_type->builtin_char); - write_exp_elt_longcst ((LONGEST)'\0'); - write_exp_elt_opcode (OP_LONG); - write_exp_elt_opcode (OP_ARRAY); - write_exp_elt_longcst ((LONGEST) 0); - write_exp_elt_longcst ((LONGEST) ($1.length)); - write_exp_elt_opcode (OP_ARRAY); } + write_exp_elt_opcode (pstate, OP_LONG); + write_exp_elt_type (pstate, + parse_type (pstate) + ->builtin_char); + write_exp_elt_longcst (pstate, (LONGEST)'\0'); + write_exp_elt_opcode (pstate, OP_LONG); + write_exp_elt_opcode (pstate, OP_ARRAY); + write_exp_elt_longcst (pstate, (LONGEST) 0); + write_exp_elt_longcst (pstate, + (LONGEST) ($1.length)); + write_exp_elt_opcode (pstate, OP_ARRAY); } ; /* Object pascal */ exp : THIS - { + { struct value * this_val; struct type * this_type; - write_exp_elt_opcode (OP_THIS); - write_exp_elt_opcode (OP_THIS); - /* we need type of this */ - this_val = value_of_this (0); + write_exp_elt_opcode (pstate, OP_THIS); + write_exp_elt_opcode (pstate, OP_THIS); + /* We need type of this. */ + this_val + = value_of_this_silent (parse_language (pstate)); if (this_val) this_type = value_type (this_val); else @@ -567,10 +656,10 @@ exp : THIS if (TYPE_CODE (this_type) == TYPE_CODE_PTR) { this_type = TYPE_TARGET_TYPE (this_type); - write_exp_elt_opcode (UNOP_IND); + write_exp_elt_opcode (pstate, UNOP_IND); } } - + current_type = this_type; } ; @@ -586,9 +675,10 @@ block : BLOCKNAME struct symtab *tem = lookup_symtab (copy_name ($1.stoken)); if (tem) - $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), STATIC_BLOCK); + $$ = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (tem), + STATIC_BLOCK); else - error ("No file or function \"%s\".", + error (_("No file or function \"%s\"."), copy_name ($1.stoken)); } } @@ -597,9 +687,9 @@ block : BLOCKNAME block : block COLONCOLON name { struct symbol *tem = lookup_symbol (copy_name ($3), $1, - VAR_DOMAIN, (int *) NULL); + VAR_DOMAIN, NULL); if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) - error ("No function \"%s\" in specified context.", + error (_("No function \"%s\" in specified context."), copy_name ($3)); $$ = SYMBOL_BLOCK_VALUE (tem); } ; @@ -607,16 +697,16 @@ block : block COLONCOLON name variable: block COLONCOLON name { struct symbol *sym; sym = lookup_symbol (copy_name ($3), $1, - VAR_DOMAIN, (int *) NULL); + VAR_DOMAIN, NULL); if (sym == 0) - error ("No symbol \"%s\" in specified context.", + error (_("No symbol \"%s\" in specified context."), copy_name ($3)); - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (pstate, OP_VAR_VALUE); /* block_found is set by lookup_symbol. */ - write_exp_elt_block (block_found); - write_exp_elt_sym (sym); - write_exp_elt_opcode (OP_VAR_VALUE); } + write_exp_elt_block (pstate, block_found); + write_exp_elt_sym (pstate, sym); + write_exp_elt_opcode (pstate, OP_VAR_VALUE); } ; qualified_name: typebase COLONCOLON name @@ -624,13 +714,13 @@ qualified_name: typebase COLONCOLON name struct type *type = $1; if (TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) - error ("`%s' is not defined as an aggregate type.", + error (_("`%s' is not defined as an aggregate type."), TYPE_NAME (type)); - write_exp_elt_opcode (OP_SCOPE); - write_exp_elt_type (type); - write_exp_string ($3); - write_exp_elt_opcode (OP_SCOPE); + write_exp_elt_opcode (pstate, OP_SCOPE); + write_exp_elt_type (pstate, type); + write_exp_string (pstate, $3); + write_exp_elt_opcode (pstate, OP_SCOPE); } ; @@ -639,27 +729,30 @@ variable: qualified_name { char *name = copy_name ($2); struct symbol *sym; - struct minimal_symbol *msymbol; + struct bound_minimal_symbol msymbol; sym = lookup_symbol (name, (const struct block *) NULL, - VAR_DOMAIN, (int *) NULL); + VAR_DOMAIN, NULL); if (sym) { - write_exp_elt_opcode (OP_VAR_VALUE); - write_exp_elt_block (NULL); - write_exp_elt_sym (sym); - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (pstate, OP_VAR_VALUE); + write_exp_elt_block (pstate, NULL); + write_exp_elt_sym (pstate, sym); + write_exp_elt_opcode (pstate, OP_VAR_VALUE); break; } - msymbol = lookup_minimal_symbol (name, NULL, NULL); - if (msymbol != NULL) - write_exp_msymbol (msymbol); - else if (!have_full_symbols () && !have_partial_symbols ()) - error ("No symbol table is loaded. Use the \"file\" command."); + msymbol = lookup_bound_minimal_symbol (name); + if (msymbol.minsym != NULL) + write_exp_msymbol (pstate, msymbol); + else if (!have_full_symbols () + && !have_partial_symbols ()) + error (_("No symbol table is loaded. " + "Use the \"file\" command.")); else - error ("No symbol \"%s\" in current context.", name); + error (_("No symbol \"%s\" in current context."), + name); } ; @@ -676,13 +769,13 @@ variable: name_not_typename innermost_block = block_found; } - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_opcode (pstate, OP_VAR_VALUE); /* We want to use the selected frame, not another more inner frame which happens to be in the same block. */ - write_exp_elt_block (NULL); - write_exp_elt_sym (sym); - write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_block (pstate, NULL); + write_exp_elt_sym (pstate, sym); + write_exp_elt_opcode (pstate, OP_VAR_VALUE); current_type = sym->type; } else if ($1.is_a_field_of_this) { @@ -695,13 +788,14 @@ variable: name_not_typename || contained_in (block_found, innermost_block)) innermost_block = block_found; - write_exp_elt_opcode (OP_THIS); - write_exp_elt_opcode (OP_THIS); - write_exp_elt_opcode (STRUCTOP_PTR); - write_exp_string ($1.stoken); - write_exp_elt_opcode (STRUCTOP_PTR); - /* we need type of this */ - this_val = value_of_this (0); + write_exp_elt_opcode (pstate, OP_THIS); + write_exp_elt_opcode (pstate, OP_THIS); + write_exp_elt_opcode (pstate, STRUCTOP_PTR); + write_exp_string (pstate, $1.stoken); + write_exp_elt_opcode (pstate, STRUCTOP_PTR); + /* We need type of this. */ + this_val + = value_of_this_silent (parse_language (pstate)); if (this_val) this_type = value_type (this_val); else @@ -711,21 +805,23 @@ variable: name_not_typename this_type, copy_name ($1.stoken), 0); else - current_type = NULL; + current_type = NULL; } else { - struct minimal_symbol *msymbol; + struct bound_minimal_symbol msymbol; char *arg = copy_name ($1.stoken); msymbol = - lookup_minimal_symbol (arg, NULL, NULL); - if (msymbol != NULL) - write_exp_msymbol (msymbol); - else if (!have_full_symbols () && !have_partial_symbols ()) - error ("No symbol table is loaded. Use the \"file\" command."); + lookup_bound_minimal_symbol (arg); + if (msymbol.minsym != NULL) + write_exp_msymbol (pstate, msymbol); + else if (!have_full_symbols () + && !have_partial_symbols ()) + error (_("No symbol table is loaded. " + "Use the \"file\" command.")); else - error ("No symbol \"%s\" in current context.", + error (_("No symbol \"%s\" in current context."), copy_name ($1.stoken)); } } @@ -788,11 +884,8 @@ name_not_typename : NAME /*** Needs some error checking for the float case ***/ static int -parse_number (p, len, parsed_float, putithere) - char *p; - int len; - int parsed_float; - YYSTYPE *putithere; +parse_number (struct parser_state *par_state, + const char *p, int len, int parsed_float, YYSTYPE *putithere) { /* FIXME: Shouldn't these be unsigned? We don't deal with negative values here, and we do kind of silly things like cast to unsigned. */ @@ -817,34 +910,14 @@ parse_number (p, len, parsed_float, putithere) if (parsed_float) { - /* It's a float since it contains a point or an exponent. */ - char c; - int num = 0; /* number of tokens scanned by scanf */ - char saved_char = p[len]; - - p[len] = 0; /* null-terminate the token */ - num = sscanf (p, "%" DOUBLEST_SCAN_FORMAT "%c", - &putithere->typed_val_float.dval, &c); - p[len] = saved_char; /* restore the input stream */ - if (num != 1) /* check scanf found ONLY a float ... */ - return ERROR; - /* See if it has `f' or `l' suffix (float or long double). */ - - c = tolower (p[len - 1]); - - if (c == 'f') - putithere->typed_val_float.type = parse_type->builtin_float; - else if (c == 'l') - putithere->typed_val_float.type = parse_type->builtin_long_double; - else if (isdigit (c) || c == '.') - putithere->typed_val_float.type = parse_type->builtin_double; - else + if (! parse_c_float (parse_gdbarch (par_state), p, len, + &putithere->typed_val_float.dval, + &putithere->typed_val_float.type)) return ERROR; - return FLOAT; } - /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ + /* Handle base-switching prefixes 0x, 0t, 0d, 0. */ if (p[0] == '0') switch (p[1]) { @@ -910,21 +983,21 @@ parse_number (p, len, parsed_float, putithere) return ERROR; /* Char not a digit */ } if (i >= base) - return ERROR; /* Invalid digit in this base */ + return ERROR; /* Invalid digit in this base. */ /* Portably test for overflow (only works for nonzero values, so make a second check for zero). FIXME: Can't we just make n and prevn unsigned and avoid this? */ if (c != 'l' && c != 'u' && (prevn >= n) && n != 0) - unsigned_p = 1; /* Try something unsigned */ + unsigned_p = 1; /* Try something unsigned. */ /* Portably test for unsigned overflow. FIXME: This check is wrong; for example it doesn't find overflow on 0x123456789 when LONGEST is 32 bits. */ if (c != 'l' && c != 'u' && n != 0) - { + { if ((unsigned_p && (ULONGEST) prevn >= (ULONGEST) n)) - error ("Numeric constant too large."); + error (_("Numeric constant too large.")); } prevn = n; } @@ -943,9 +1016,10 @@ parse_number (p, len, parsed_float, putithere) un = (ULONGEST)n >> 2; if (long_p == 0 - && (un >> (gdbarch_int_bit (parse_gdbarch) - 2)) == 0) + && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0) { - high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch) - 1); + high_bit + = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1); /* A large decimal (not hex or octal) constant (between INT_MAX and UINT_MAX) is a long or unsigned long, according to ANSI, @@ -953,34 +1027,35 @@ parse_number (p, len, parsed_float, putithere) int. This probably should be fixed. GCC gives a warning on such constants. */ - unsigned_type = parse_type->builtin_unsigned_int; - signed_type = parse_type->builtin_int; + unsigned_type = parse_type (par_state)->builtin_unsigned_int; + signed_type = parse_type (par_state)->builtin_int; } else if (long_p <= 1 - && (un >> (gdbarch_long_bit (parse_gdbarch) - 2)) == 0) + && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0) { - high_bit = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch) - 1); - unsigned_type = parse_type->builtin_unsigned_long; - signed_type = parse_type->builtin_long; + high_bit + = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1); + unsigned_type = parse_type (par_state)->builtin_unsigned_long; + signed_type = parse_type (par_state)->builtin_long; } else { int shift; if (sizeof (ULONGEST) * HOST_CHAR_BIT - < gdbarch_long_long_bit (parse_gdbarch)) + < gdbarch_long_long_bit (parse_gdbarch (par_state))) /* A long long does not fit in a LONGEST. */ shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1); else - shift = (gdbarch_long_long_bit (parse_gdbarch) - 1); + shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1); high_bit = (ULONGEST) 1 << shift; - unsigned_type = parse_type->builtin_unsigned_long_long; - signed_type = parse_type->builtin_long_long; + unsigned_type = parse_type (par_state)->builtin_unsigned_long_long; + signed_type = parse_type (par_state)->builtin_long_long; } putithere->typed_val_int.val = n; /* If the high bit of the worked out type is set then this number - has to be unsigned. */ + has to be unsigned. */ if (unsigned_p || (n & high_bit)) { @@ -1011,7 +1086,7 @@ push_current_type (void) tpnew->next = tp_top; tpnew->stored = current_type; current_type = NULL; - tp_top = tpnew; + tp_top = tpnew; } static void @@ -1028,7 +1103,7 @@ pop_current_type (void) struct token { - char *operator; + char *oper; int token; enum exp_opcode opcode; }; @@ -1055,11 +1130,10 @@ static const struct token tokentab2[] = {":=", ASSIGN, BINOP_END}, {"::", COLONCOLON, BINOP_END} }; -/* Allocate uppercased var */ -/* make an uppercased copy of tokstart */ -static char * uptok (tokstart, namelen) - char *tokstart; - int namelen; +/* Allocate uppercased var: */ +/* make an uppercased copy of tokstart. */ +static char * +uptok (const char *tokstart, int namelen) { int i; char *uptokstart = (char *)malloc(namelen+1); @@ -1073,19 +1147,18 @@ static char * uptok (tokstart, namelen) uptokstart[namelen]='\0'; return uptokstart; } -/* Read one token, getting characters through lexptr. */ +/* Read one token, getting characters through lexptr. */ static int -yylex () +yylex (void) { int c; int namelen; unsigned int i; - char *tokstart; + const char *tokstart; char *uptokstart; - char *tokptr; - char *p; + const char *tokptr; int explen, tempbufindex; static char *tempbuf; static int tempbufsize; @@ -1096,12 +1169,14 @@ yylex () tokstart = lexptr; explen = strlen (lexptr); + /* See if it is a special token of length 3. */ if (explen > 2) for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++) - if (strncasecmp (tokstart, tokentab3[i].operator, 3) == 0 - && (!isalpha (tokentab3[i].operator[0]) || explen == 3 - || (!isalpha (tokstart[3]) && !isdigit (tokstart[3]) && tokstart[3] != '_'))) + if (strncasecmp (tokstart, tokentab3[i].oper, 3) == 0 + && (!isalpha (tokentab3[i].oper[0]) || explen == 3 + || (!isalpha (tokstart[3]) + && !isdigit (tokstart[3]) && tokstart[3] != '_'))) { lexptr += 3; yylval.opcode = tokentab3[i].opcode; @@ -1111,9 +1186,10 @@ yylex () /* See if it is a special token of length 2. */ if (explen > 1) for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++) - if (strncasecmp (tokstart, tokentab2[i].operator, 2) == 0 - && (!isalpha (tokentab2[i].operator[0]) || explen == 2 - || (!isalpha (tokstart[2]) && !isdigit (tokstart[2]) && tokstart[2] != '_'))) + if (strncasecmp (tokstart, tokentab2[i].oper, 2) == 0 + && (!isalpha (tokentab2[i].oper[0]) || explen == 2 + || (!isalpha (tokstart[2]) + && !isdigit (tokstart[2]) && tokstart[2] != '_'))) { lexptr += 2; yylval.opcode = tokentab2[i].opcode; @@ -1123,7 +1199,10 @@ yylex () switch (c = *tokstart) { case 0: - return 0; + if (search_field && parse_completion) + return COMPLETE; + else + return 0; case ' ': case '\t': @@ -1134,16 +1213,16 @@ yylex () case '\'': /* We either have a character constant ('0' or '\177' for example) or we have a quoted symbol reference ('foo(int,int)' in object pascal - for example). */ + for example). */ lexptr++; c = *lexptr++; if (c == '\\') - c = parse_escape (parse_gdbarch, &lexptr); + c = parse_escape (parse_gdbarch (pstate), &lexptr); else if (c == '\'') - error ("Empty character constant."); + error (_("Empty character constant.")); yylval.typed_val_int.val = c; - yylval.typed_val_int.type = parse_type->builtin_char; + yylval.typed_val_int.type = parse_type (pstate)->builtin_char; c = *lexptr++; if (c != '\'') @@ -1153,13 +1232,13 @@ yylex () { lexptr = tokstart + namelen; if (lexptr[-1] != '\'') - error ("Unmatched single quote."); + error (_("Unmatched single quote.")); namelen -= 2; tokstart++; uptokstart = uptok(tokstart,namelen); goto tryname; } - error ("Invalid character constant."); + error (_("Invalid character constant.")); } return INT; @@ -1184,7 +1263,10 @@ yylex () case '.': /* Might be a floating point number. */ if (lexptr[1] < '0' || lexptr[1] > '9') - goto symbol; /* Nope, must be a symbol. */ + { + goto symbol; /* Nope, must be a symbol. */ + } + /* FALL THRU into number case. */ case '0': @@ -1200,7 +1282,7 @@ yylex () { /* It's a number. */ int got_dot = 0, got_e = 0, toktype; - char *p = tokstart; + const char *p = tokstart; int hex = input_radix > 10; if (c == '0' && (p[1] == 'x' || p[1] == 'X')) @@ -1208,7 +1290,8 @@ yylex () p += 2; hex = 1; } - else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) + else if (c == '0' && (p[1]=='t' || p[1]=='T' + || p[1]=='d' || p[1]=='D')) { p += 2; hex = 0; @@ -1237,14 +1320,15 @@ yylex () && (*p < 'A' || *p > 'Z'))) break; } - toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); + toktype = parse_number (pstate, tokstart, + p - tokstart, got_dot | got_e, &yylval); if (toktype == ERROR) { char *err_copy = (char *) alloca (p - tokstart + 1); memcpy (err_copy, tokstart, p - tokstart); err_copy[p - tokstart] = 0; - error ("Invalid number \"%s\".", err_copy); + error (_("Invalid number \"%s\"."), err_copy); } lexptr = p; return toktype; @@ -1282,14 +1366,14 @@ yylex () the buffer contains no embedded nulls. Gdb does not depend upon the buffer being null byte terminated, it uses the length string instead. This allows gdb to handle C strings (as well - as strings in other languages) with embedded null bytes */ + as strings in other languages) with embedded null bytes. */ tokptr = ++tokstart; tempbufindex = 0; do { /* Grow the static temp buffer if necessary, including allocating - the first one on demand. */ + the first one on demand. */ if (tempbufindex + 1 >= tempbufsize) { tempbuf = (char *) realloc (tempbuf, tempbufsize += 64); @@ -1299,11 +1383,11 @@ yylex () { case '\0': case '"': - /* Do nothing, loop will terminate. */ + /* Do nothing, loop will terminate. */ break; case '\\': - tokptr++; - c = parse_escape (parse_gdbarch, &tokptr); + ++tokptr; + c = parse_escape (parse_gdbarch (pstate), &tokptr); if (c == -1) { continue; @@ -1317,9 +1401,9 @@ yylex () } while ((*tokptr != '"') && (*tokptr != '\0')); if (*tokptr++ != '"') { - error ("Unterminated string in expression."); + error (_("Unterminated string in expression.")); } - tempbuf[tempbufindex] = '\0'; /* See note above */ + tempbuf[tempbufindex] = '\0'; /* See note above. */ yylval.sval.ptr = tempbuf; yylval.sval.length = tempbufindex; lexptr = tokptr; @@ -1329,7 +1413,7 @@ yylex () if (!(c == '_' || c == '$' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) /* We must have come across a bad character (e.g. ';'). */ - error ("Invalid character '%c' in expression.", c); + error (_("Invalid character '%c' in expression."), c); /* It's a name. See how long it is. */ namelen = 0; @@ -1359,7 +1443,7 @@ yylex () break; } - /* do NOT uppercase internals because of registers !!! */ + /* do NOT uppercase internals because of registers !!! */ c = tokstart[++namelen]; } @@ -1419,12 +1503,12 @@ yylex () } if (strcmp (uptokstart, "SELF") == 0) { - /* here we search for 'this' like - inserted in FPC stabs debug info */ + /* Here we search for 'this' like + inserted in FPC stabs debug info. */ static const char this_name[] = "this"; if (lookup_symbol (this_name, expression_context_block, - VAR_DOMAIN, (int *) NULL)) + VAR_DOMAIN, NULL)) { free (uptokstart); return THIS; @@ -1440,11 +1524,17 @@ yylex () if (*tokstart == '$') { + char *tmp; + /* $ is the normal prefix for pascal hexadecimal values but this conflicts with the GDB use for debugger variables so in expression to enter hexadecimal values we still need to use C syntax with 0xff */ - write_dollar_variable (yylval.sval); + write_dollar_variable (pstate, yylval.sval); + tmp = alloca (namelen + 1); + memcpy (tmp, tokstart, namelen); + tmp[namelen] = '\0'; + intvar = lookup_only_internalvar (tmp + 1); free (uptokstart); return VARIABLE; } @@ -1457,20 +1547,20 @@ yylex () { char *tmp = copy_name (yylval.sval); struct symbol *sym; - int is_a_field_of_this = 0; + struct field_of_this_result is_a_field_of_this; int is_a_field = 0; int hextype; - + is_a_field_of_this.type = NULL; if (search_field && current_type) - is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); + is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); if (is_a_field) sym = NULL; else sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, &is_a_field_of_this); /* second chance uppercased (as Free Pascal does). */ - if (!sym && !is_a_field_of_this && !is_a_field) + if (!sym && is_a_field_of_this.type == NULL && !is_a_field) { for (i = 0; i <= namelen; i++) { @@ -1478,21 +1568,15 @@ yylex () tmp[i] -= ('a'-'A'); } if (search_field && current_type) - is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); + is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); if (is_a_field) sym = NULL; else sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, &is_a_field_of_this); - if (sym || is_a_field_of_this || is_a_field) - for (i = 0; i <= namelen; i++) - { - if ((tokstart[i] >= 'a' && tokstart[i] <= 'z')) - tokstart[i] -= ('a'-'A'); - } } /* Third chance Capitalized (as GPC does). */ - if (!sym && !is_a_field_of_this && !is_a_field) + if (!sym && is_a_field_of_this.type == NULL && !is_a_field) { for (i = 0; i <= namelen; i++) { @@ -1506,35 +1590,29 @@ yylex () tmp[i] -= ('A'-'a'); } if (search_field && current_type) - is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); + is_a_field = (lookup_struct_elt_type (current_type, tmp, 1) != NULL); if (is_a_field) sym = NULL; else sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, &is_a_field_of_this); - if (sym || is_a_field_of_this || is_a_field) - for (i = 0; i <= namelen; i++) - { - if (i == 0) - { - if ((tokstart[i] >= 'a' && tokstart[i] <= 'z')) - tokstart[i] -= ('a'-'A'); - } - else - if ((tokstart[i] >= 'A' && tokstart[i] <= 'Z')) - tokstart[i] -= ('A'-'a'); - } } - if (is_a_field) + if (is_a_field || (is_a_field_of_this.type != NULL)) { tempbuf = (char *) realloc (tempbuf, namelen + 1); - strncpy (tempbuf, tokstart, namelen); tempbuf [namelen] = 0; + strncpy (tempbuf, tmp, namelen); + tempbuf [namelen] = 0; yylval.sval.ptr = tempbuf; - yylval.sval.length = namelen; + yylval.sval.length = namelen; + yylval.ssym.sym = NULL; free (uptokstart); - return FIELDNAME; - } + yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; + if (is_a_field) + return FIELDNAME; + else + return NAME; + } /* Call lookup_symtab, not lookup_partial_symtab, in case there are no psymtabs (coff, xcoff, or some future change to blow away the psymtabs once once symbols are read). */ @@ -1542,7 +1620,7 @@ yylex () || lookup_symtab (tmp)) { yylval.ssym.sym = sym; - yylval.ssym.is_a_field_of_this = is_a_field_of_this; + yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; free (uptokstart); return BLOCKNAME; } @@ -1558,8 +1636,8 @@ yylex () distinction) named x, then this code incorrectly thinks we are dealing with nested types rather than a member function. */ - char *p; - char *namestart; + const char *p; + const char *namestart; struct symbol *best_sym; /* Look ahead to detect nested types. This probably should be @@ -1608,7 +1686,7 @@ yylex () memcpy (tmp1, namestart, p - namestart); tmp1[p - namestart] = '\0'; cur_sym = lookup_symbol (ncopy, expression_context_block, - VAR_DOMAIN, (int *) NULL); + VAR_DOMAIN, NULL); if (cur_sym) { if (SYMBOL_CLASS (cur_sym) == LOC_TYPEDEF) @@ -1637,8 +1715,8 @@ yylex () return TYPENAME; } yylval.tsym.type - = language_lookup_primitive_type_by_name (parse_language, - parse_gdbarch, tmp); + = language_lookup_primitive_type (parse_language (pstate), + parse_gdbarch (pstate), tmp); if (yylval.tsym.type != NULL) { free (uptokstart); @@ -1653,30 +1731,43 @@ yylex () || (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) { YYSTYPE newlval; /* Its value is ignored. */ - hextype = parse_number (tokstart, namelen, 0, &newlval); + hextype = parse_number (pstate, tokstart, namelen, 0, &newlval); if (hextype == INT) { yylval.ssym.sym = sym; - yylval.ssym.is_a_field_of_this = is_a_field_of_this; + yylval.ssym.is_a_field_of_this = is_a_field_of_this.type != NULL; free (uptokstart); return NAME_OR_INT; } } free(uptokstart); - /* Any other kind of symbol */ + /* Any other kind of symbol. */ yylval.ssym.sym = sym; - yylval.ssym.is_a_field_of_this = is_a_field_of_this; return NAME; } } +int +pascal_parse (struct parser_state *par_state) +{ + int result; + struct cleanup *c = make_cleanup_clear_parser_state (&pstate); + + /* Setting up the parser state. */ + gdb_assert (par_state != NULL); + pstate = par_state; + + result = yyparse (); + do_cleanups (c); + return result; +} + void -yyerror (msg) - char *msg; +yyerror (char *msg) { if (prev_lexptr) lexptr = prev_lexptr; - error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr); + error (_("A %s in expression, near `%s'."), (msg ? msg : "error"), lexptr); }