This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
RE: [PATCH 09/10] Pascal language
As pascal language maintainer,
I looked at your patch.
It seems that this patch is pretty mechanical
given the changes to the parameter list of the used functions.
Thus you can consider this patch approved
with similar changes to the C counterpart.
Pierre Muller
GDB pascal language maintainer
> -----Message d'origine-----
> De?: gdb-patches-owner@sourceware.org [mailto:gdb-patches-
> owner@sourceware.org] De la part de Sergio Durigan Junior
> Envoyé?: samedi 2 juin 2012 21:32
> À?: GDB Patches
> Cc?: Tom Tromey; Sergio Durigan Junior
> Objet?: [PATCH 09/10] Pascal language
>
> Patch for the Pascal language. Similar to the C language one.
>
> ---
> gdb/p-exp.y | 327
+++++++++++++++++++++++++++++++------------------------
> ---
> gdb/p-lang.h | 5 +-
> 2 files changed, 178 insertions(+), 154 deletions(-)
>
> diff --git a/gdb/p-exp.y b/gdb/p-exp.y
> index 5d344a4..43c4f30 100644
> --- a/gdb/p-exp.y
> +++ b/gdb/p-exp.y
> @@ -56,7 +56,7 @@
> #include "objfiles.h" /* For have_full_symbols and have_partial_symbols.
> */
> #include "block.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
> @@ -66,7 +66,7 @@
> 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
> #define yylex pascal_lex
> #define yyerror pascal_error
> #define yylval pascal_lval
> @@ -118,6 +118,11 @@
>
> #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);
> @@ -158,7 +163,7 @@ 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 *, char *, int, int, YYSTYPE
> *);
>
> static struct type *current_type;
> static struct internalvar *intvar;
> @@ -251,44 +256,44 @@ 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);
> + { 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);
}
> ;
>
>
> @@ -297,9 +302,9 @@ field_exp : exp '.' %prec UNARY
> ;
>
> exp : field_exp FIELDNAME
> - { write_exp_elt_opcode (STRUCTOP_STRUCT);
> - write_exp_string ($2);
> - write_exp_elt_opcode (STRUCTOP_STRUCT);
> + { 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)
> {
> @@ -315,10 +320,10 @@ exp : field_exp FIELDNAME
>
>
> exp : field_exp name
> - { mark_struct_expression ();
> - write_exp_elt_opcode (STRUCTOP_STRUCT);
> - write_exp_string ($2);
> - write_exp_elt_opcode (STRUCTOP_STRUCT);
> + { mark_struct_expression (pstate);
> + 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)
> {
> @@ -334,12 +339,12 @@ exp : field_exp name
>
> exp : field_exp COMPLETE
> { struct stoken s;
> - mark_struct_expression ();
> - write_exp_elt_opcode (STRUCTOP_STRUCT);
> + mark_struct_expression (pstate);
> + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
> s.ptr = "";
> s.length = 0;
> - write_exp_string (s);
> - write_exp_elt_opcode (STRUCTOP_STRUCT); }
> + write_exp_string (pstate, s);
> + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
> ;
>
> exp : exp '['
> @@ -357,14 +362,14 @@ exp : exp '['
> strcpy (stringsval.ptr, 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);
> + 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);
}
> ;
> @@ -375,9 +380,9 @@ 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);
> @@ -398,11 +403,11 @@ exp : type '(' exp ')' %prec UNARY
> 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);
> + 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; }
> ;
>
> @@ -413,7 +418,7 @@ 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 '/' {
> @@ -425,135 +430,137 @@ exp : 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,
> + parse_number (pstate, $1.stoken.ptr,
> $1.stoken.length, 0, &val);
> - write_exp_elt_opcode (OP_LONG);
> - write_exp_elt_type (val.typed_val_int.type);
> + 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)
> + write_exp_elt_longcst (pstate, (LONGEST)
> val.typed_val_int.val);
> - write_exp_elt_opcode (OP_LONG);
> + 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
> @@ -566,7 +573,7 @@ exp : VARIABLE
> struct value * val, * mark;
>
> mark = value_mark ();
> - val = value_of_internalvar (parse_gdbarch,
> + val = value_of_internalvar (parse_gdbarch
(pstate),
> intvar);
> current_type = value_type (val);
> value_release_to_mark (mark);
> @@ -575,15 +582,16 @@ exp : VARIABLE
> ;
>
> exp : SIZEOF '(' type ')' %prec UNARY
> - { write_exp_elt_opcode (OP_LONG);
> - write_exp_elt_type (parse_type->builtin_int);
> + { write_exp_elt_opcode (pstate, OP_LONG);
> + write_exp_elt_type (pstate, parse_type (pstate)-
> >builtin_int);
> CHECK_TYPEDEF ($3);
> - write_exp_elt_longcst ((LONGEST) TYPE_LENGTH
($3));
> - write_exp_elt_opcode (OP_LONG); }
> + 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 (UNOP_SIZEOF); }
> + { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
>
> exp : STRING
> { /* C strings are converted into array constants
with
> @@ -594,19 +602,23 @@ exp : STRING
> 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 */
> @@ -614,10 +626,10 @@ exp : THIS
> {
> struct value * this_val;
> struct type * this_type;
> - write_exp_elt_opcode (OP_THIS);
> - write_exp_elt_opcode (OP_THIS);
> + 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);
> + this_val = value_of_this_silent (parse_language
> (pstate));
> if (this_val)
> this_type = value_type (this_val);
> else
> @@ -627,7 +639,7 @@ 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);
> }
> }
>
> @@ -673,11 +685,11 @@ variable: block COLONCOLON name
> 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
> @@ -688,10 +700,10 @@ qualified_name: typebase COLONCOLON name
> 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);
> }
> ;
>
> @@ -707,16 +719,16 @@ variable: qualified_name
> VAR_DOMAIN, (int *) 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);
> + write_exp_msymbol (pstate, msymbol);
> else if (!have_full_symbols ()
> && !have_partial_symbols ())
> error (_("No symbol table is loaded. "
> @@ -740,13 +752,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)
> {
> @@ -759,13 +771,13 @@ 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);
> + 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);
> + this_val = value_of_this_silent
(parse_language
> (pstate));
> if (this_val)
> this_type = value_type (this_val);
> else
> @@ -785,7 +797,7 @@ variable: name_not_typename
> msymbol =
> lookup_minimal_symbol (arg, NULL, NULL);
> if (msymbol != NULL)
> - write_exp_msymbol (msymbol);
> + write_exp_msymbol (pstate, msymbol);
> else if (!have_full_symbols ()
> && !have_partial_symbols ())
> error (_("No symbol table is loaded. "
> @@ -854,7 +866,8 @@ name_not_typename : NAME
> /*** Needs some error checking for the float case ***/
>
> static int
> -parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
> +parse_number (struct parser_state *par_state, 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. */
> @@ -879,7 +892,7 @@ parse_number (char *p, int len, int parsed_float,
> YYSTYPE *putithere)
>
> if (parsed_float)
> {
> - if (! parse_c_float (parse_gdbarch, p, len,
> + if (! parse_c_float (parse_gdbarch (par_state), p, len,
> &putithere->typed_val_float.dval,
> &putithere->typed_val_float.type))
> return ERROR;
> @@ -985,9 +998,9 @@ parse_number (char *p, int len, int parsed_float,
> YYSTYPE *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,
> @@ -995,28 +1008,28 @@ parse_number (char *p, int len, int parsed_float,
> YYSTYPE *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;
> @@ -1190,12 +1203,12 @@ yylex (void)
> 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."));
>
> 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 != '\'')
> @@ -1295,7 +1308,7 @@ yylex (void)
> && (*p < 'A' || *p > 'Z')))
> break;
> }
> - toktype = parse_number (tokstart,
> + toktype = parse_number (pstate, tokstart,
> p - tokstart, got_dot | got_e, &yylval);
> if (toktype == ERROR)
> {
> @@ -1362,7 +1375,7 @@ yylex (void)
> break;
> case '\\':
> tokptr++;
> - c = parse_escape (parse_gdbarch, &tokptr);
> + c = parse_escape (parse_gdbarch (pstate), &tokptr);
> if (c == -1)
> {
> continue;
> @@ -1504,7 +1517,7 @@ yylex (void)
> 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);
> c = tokstart[namelen];
> tokstart[namelen] = 0;
> intvar = lookup_only_internalvar (++tokstart);
> @@ -1702,8 +1715,8 @@ yylex (void)
> return TYPENAME;
> }
> yylval.tsym.type
> - = language_lookup_primitive_type_by_name (parse_language,
> - parse_gdbarch, tmp);
> + = language_lookup_primitive_type_by_name (parse_language (pstate),
> + parse_gdbarch (pstate),
tmp);
> if (yylval.tsym.type != NULL)
> {
> free (uptokstart);
> @@ -1718,7 +1731,7 @@ yylex (void)
> || (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;
> @@ -1736,6 +1749,16 @@ yylex (void)
> }
> }
>
> +int
> +pascal_parse (struct parser_state *par_state)
> +{
> + /* Setting up the parser state. */
> + gdb_assert (par_state != NULL);
> + pstate = par_state;
> +
> + return _pascal_parse ();
> +}
> +
> void
> yyerror (char *msg)
> {
> diff --git a/gdb/p-lang.h b/gdb/p-lang.h
> index b1e218c..a5168f8 100644
> --- a/gdb/p-lang.h
> +++ b/gdb/p-lang.h
> @@ -20,13 +20,14 @@
> /* This file is derived from c-lang.h */
>
> struct value;
> +struct parser_state;
>
> /* Defined in p-lang.c */
> extern const char *pascal_main_name (void);
>
> -extern int pascal_parse (void); /* Defined in p-exp.y */
> +extern int pascal_parse (struct parser_state *); /* Defined in p-exp.y */
>
> -extern void pascal_error (char *); /* Defined in p-exp.y */
> +extern void pascal_error (char *); /* Defined in p-exp.y */
>
> /* Defined in p-typeprint.c */
> extern void pascal_print_type (struct type *, const char *, struct
ui_file
> *,
> --
> 1.7.7.6