From: "Pierre Muller" <pierre.muller@ics-cnrs.unistra.fr>
To: "'Sergio Durigan Junior'" <sergiodj@redhat.com>,
"'GDB Patches'" <gdb-patches@sourceware.org>
Cc: "'Tom Tromey'" <tromey@redhat.com>
Subject: RE: [PATCH 09/10] Pascal language
Date: Tue, 05 Jun 2012 07:39:00 -0000 [thread overview]
Message-ID: <004a01cd42ee$516d7530$f4485f90$@muller@ics-cnrs.unistra.fr> (raw)
In-Reply-To: <1338665528-5932-10-git-send-email-sergiodj@redhat.com>
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
next prev parent reply other threads:[~2012-06-05 7:39 UTC|newest]
Thread overview: 40+ messages / expand[flat|nested] mbox.gz Atom feed top
2012-06-02 19:33 [PATCH 00/10] Remove `expout*' globals from parser-defs.h Sergio Durigan Junior
2012-06-02 19:33 ` [PATCH 01/10] Language independent bits Sergio Durigan Junior
2012-06-04 20:20 ` Tom Tromey
2012-06-05 0:39 ` Sergio Durigan Junior
2012-06-02 19:33 ` [PATCH 02/10] SystemTap integration Sergio Durigan Junior
2012-06-04 20:23 ` Tom Tromey
2012-06-02 19:34 ` [PATCH 03/10] C language Sergio Durigan Junior
2012-06-04 4:25 ` Doug Evans
2012-06-04 4:32 ` Sergio Durigan Junior
2012-06-04 20:32 ` Tom Tromey
2012-06-04 20:39 ` Sergio Durigan Junior
2012-06-04 20:42 ` Mark Kettenis
2012-06-04 20:49 ` Sergio Durigan Junior
2012-06-04 21:19 ` Mark Kettenis
2012-06-06 19:17 ` Tom Tromey
2012-06-02 20:23 ` [PATCH 10/10] Go programming language Sergio Durigan Junior
2012-06-13 4:58 ` Sergio Durigan Junior
2012-06-13 17:02 ` Doug Evans
2012-06-02 20:23 ` [PATCH 04/10] Ada language Sergio Durigan Junior
2012-06-13 4:57 ` Sergio Durigan Junior
2012-06-13 14:50 ` Joel Brobecker
2012-06-02 20:24 ` [PATCH 05/10] Fortran language Sergio Durigan Junior
2012-06-13 4:59 ` Sergio Durigan Junior
2012-06-13 14:55 ` Joel Brobecker
2012-06-02 20:24 ` [PATCH 08/10] Objective-C language Sergio Durigan Junior
2012-06-13 4:59 ` Sergio Durigan Junior
2012-06-13 14:54 ` Joel Brobecker
2012-06-13 16:02 ` Tom Tromey
2012-06-02 20:33 ` [PATCH 07/10] Modula-2 language Sergio Durigan Junior
2012-06-13 4:59 ` Sergio Durigan Junior
2012-06-13 14:51 ` Joel Brobecker
2012-06-16 14:29 ` Gaius Mulley
2012-06-02 20:33 ` [PATCH 09/10] Pascal language Sergio Durigan Junior
2012-06-05 7:39 ` Pierre Muller [this message]
2012-06-02 20:34 ` [PATCH 06/10] Java language Sergio Durigan Junior
2012-06-04 20:27 ` Tom Tromey
2012-06-05 0:35 ` Sergio Durigan Junior
2012-06-06 20:02 ` Tom Tromey
2012-06-07 0:57 ` Joel Brobecker
2012-06-04 20:38 ` [PATCH 00/10] Remove `expout*' globals from parser-defs.h Tom Tromey
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to='004a01cd42ee$516d7530$f4485f90$@muller@ics-cnrs.unistra.fr' \
--to=pierre.muller@ics-cnrs.unistra.fr \
--cc=gdb-patches@sourceware.org \
--cc=sergiodj@redhat.com \
--cc=tromey@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox