From: Sergio Durigan Junior <sergiodj@redhat.com>
To: GDB Patches <gdb-patches@sourceware.org>
Cc: Tom Tromey <tromey@redhat.com>
Subject: Re: [PATCH 05/10] Fortran language
Date: Wed, 13 Jun 2012 04:59:00 -0000 [thread overview]
Message-ID: <m3zk87st71.fsf@redhat.com> (raw)
In-Reply-To: <1338665528-5932-6-git-send-email-sergiodj@redhat.com> (Sergio Durigan Junior's message of "Sat, 2 Jun 2012 16:32:03 -0300")
On Saturday, June 02 2012, I wrote:
> Patch for the Fortran language. This patch is similiar to the C
> language one.
Ping.
> ---
> gdb/f-exp.y | 261 ++++++++++++++++++++++++++++++++--------------------------
> gdb/f-lang.h | 6 +-
> 2 files changed, 148 insertions(+), 119 deletions(-)
>
> diff --git a/gdb/f-exp.y b/gdb/f-exp.y
> index 33c7418..832b0b8 100644
> --- a/gdb/f-exp.y
> +++ b/gdb/f-exp.y
> @@ -55,8 +55,8 @@
> #include "block.h"
> #include <ctype.h>
>
> -#define parse_type builtin_type (parse_gdbarch)
> -#define parse_f_type builtin_f_type (parse_gdbarch)
> +#define parse_type(ps) builtin_type (parse_gdbarch (ps))
> +#define parse_f_type(ps) builtin_f_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 f_maxdepth
> -#define yyparse f_parse
> +#define yyparse _f_parse
> #define yylex f_lex
> #define yyerror f_error
> #define yylval f_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 int match_string_literal (void);
>
> %{
> /* YYSTYPE gets defined by %union */
> -static int parse_number (char *, int, int, YYSTYPE *);
> +static int parse_number (struct parser_state *, char *, int, int, YYSTYPE *);
> %}
>
> %type <voidval> exp type_exp start variable
> @@ -240,9 +245,9 @@ start : exp
> ;
>
> 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); }
> ;
>
> exp : '(' exp ')'
> @@ -251,27 +256,27 @@ exp : '(' exp ')'
>
> /* Expressions, not including the comma operator. */
> exp : '*' exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_IND); }
> + { write_exp_elt_opcode (pstate, UNOP_IND); }
> ;
>
> exp : '&' exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_ADDR); }
> + { write_exp_elt_opcode (pstate, UNOP_ADDR); }
> ;
>
> exp : '-' exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_NEG); }
> + { write_exp_elt_opcode (pstate, UNOP_NEG); }
> ;
>
> exp : BOOL_NOT exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
> + { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); }
> ;
>
> exp : '~' exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_COMPLEMENT); }
> + { write_exp_elt_opcode (pstate, UNOP_COMPLEMENT); }
> ;
>
> exp : SIZEOF exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_SIZEOF); }
> + { write_exp_elt_opcode (pstate, UNOP_SIZEOF); }
> ;
>
> /* No more explicit array operators, we treat everything in F77 as
> @@ -282,9 +287,9 @@ exp : SIZEOF exp %prec UNARY
> exp : exp '('
> { start_arglist (); }
> arglist ')'
> - { write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST);
> - write_exp_elt_longcst ((LONGEST) end_arglist ());
> - write_exp_elt_opcode (OP_F77_UNDETERMINED_ARGLIST); }
> + { write_exp_elt_opcode (pstate, OP_F77_UNDETERMINED_ARGLIST);
> + write_exp_elt_longcst (pstate, (LONGEST) end_arglist ());
> + write_exp_elt_opcode (pstate, OP_F77_UNDETERMINED_ARGLIST); }
> ;
>
> arglist :
> @@ -305,27 +310,27 @@ arglist : arglist ',' exp %prec ABOVE_COMMA
> /* There are four sorts of subrange types in F90. */
>
> subrange: exp ':' exp %prec ABOVE_COMMA
> - { write_exp_elt_opcode (OP_F90_RANGE);
> - write_exp_elt_longcst (NONE_BOUND_DEFAULT);
> - write_exp_elt_opcode (OP_F90_RANGE); }
> + { write_exp_elt_opcode (pstate, OP_F90_RANGE);
> + write_exp_elt_longcst (pstate, NONE_BOUND_DEFAULT);
> + write_exp_elt_opcode (pstate, OP_F90_RANGE); }
> ;
>
> subrange: exp ':' %prec ABOVE_COMMA
> - { write_exp_elt_opcode (OP_F90_RANGE);
> - write_exp_elt_longcst (HIGH_BOUND_DEFAULT);
> - write_exp_elt_opcode (OP_F90_RANGE); }
> + { write_exp_elt_opcode (pstate, OP_F90_RANGE);
> + write_exp_elt_longcst (pstate, HIGH_BOUND_DEFAULT);
> + write_exp_elt_opcode (pstate, OP_F90_RANGE); }
> ;
>
> subrange: ':' exp %prec ABOVE_COMMA
> - { write_exp_elt_opcode (OP_F90_RANGE);
> - write_exp_elt_longcst (LOW_BOUND_DEFAULT);
> - write_exp_elt_opcode (OP_F90_RANGE); }
> + { write_exp_elt_opcode (pstate, OP_F90_RANGE);
> + write_exp_elt_longcst (pstate, LOW_BOUND_DEFAULT);
> + write_exp_elt_opcode (pstate, OP_F90_RANGE); }
> ;
>
> subrange: ':' %prec ABOVE_COMMA
> - { write_exp_elt_opcode (OP_F90_RANGE);
> - write_exp_elt_longcst (BOTH_BOUND_DEFAULT);
> - write_exp_elt_opcode (OP_F90_RANGE); }
> + { write_exp_elt_opcode (pstate, OP_F90_RANGE);
> + write_exp_elt_longcst (pstate, BOTH_BOUND_DEFAULT);
> + write_exp_elt_opcode (pstate, OP_F90_RANGE); }
> ;
>
> complexnum: exp ',' exp
> @@ -333,133 +338,138 @@ complexnum: exp ',' exp
> ;
>
> exp : '(' complexnum ')'
> - { write_exp_elt_opcode(OP_COMPLEX);
> - write_exp_elt_type (parse_f_type->builtin_complex_s16);
> - write_exp_elt_opcode(OP_COMPLEX); }
> + { write_exp_elt_opcode (pstate, OP_COMPLEX);
> + write_exp_elt_type (pstate,
> + parse_f_type (pstate)
> + ->builtin_complex_s16);
> + write_exp_elt_opcode (pstate, OP_COMPLEX); }
> ;
>
> exp : '(' type ')' exp %prec UNARY
> - { write_exp_elt_opcode (UNOP_CAST);
> - write_exp_elt_type ($2);
> - write_exp_elt_opcode (UNOP_CAST); }
> + { write_exp_elt_opcode (pstate, UNOP_CAST);
> + write_exp_elt_type (pstate, $2);
> + write_exp_elt_opcode (pstate, UNOP_CAST); }
> ;
>
> exp : exp '%' name
> - { write_exp_elt_opcode (STRUCTOP_STRUCT);
> - write_exp_string ($3);
> - write_exp_elt_opcode (STRUCTOP_STRUCT); }
> + { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT);
> + write_exp_string (pstate, $3);
> + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); }
> ;
>
> /* Binary operators in order of decreasing precedence. */
>
> exp : exp '@' exp
> - { write_exp_elt_opcode (BINOP_REPEAT); }
> + { write_exp_elt_opcode (pstate, BINOP_REPEAT); }
> ;
>
> exp : exp STARSTAR exp
> - { write_exp_elt_opcode (BINOP_EXP); }
> + { write_exp_elt_opcode (pstate, BINOP_EXP); }
> ;
>
> exp : exp '*' exp
> - { write_exp_elt_opcode (BINOP_MUL); }
> + { write_exp_elt_opcode (pstate, BINOP_MUL); }
> ;
>
> exp : exp '/' exp
> - { write_exp_elt_opcode (BINOP_DIV); }
> + { write_exp_elt_opcode (pstate, BINOP_DIV); }
> ;
>
> 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 EQUAL exp
> - { write_exp_elt_opcode (BINOP_EQUAL); }
> + { write_exp_elt_opcode (pstate, BINOP_EQUAL); }
> ;
>
> exp : exp NOTEQUAL exp
> - { write_exp_elt_opcode (BINOP_NOTEQUAL); }
> + { write_exp_elt_opcode (pstate, BINOP_NOTEQUAL); }
> ;
>
> exp : exp LEQ exp
> - { write_exp_elt_opcode (BINOP_LEQ); }
> + { write_exp_elt_opcode (pstate, BINOP_LEQ); }
> ;
>
> exp : exp GEQ exp
> - { write_exp_elt_opcode (BINOP_GEQ); }
> + { write_exp_elt_opcode (pstate, BINOP_GEQ); }
> ;
>
> exp : exp LESSTHAN exp
> - { write_exp_elt_opcode (BINOP_LESS); }
> + { write_exp_elt_opcode (pstate, BINOP_LESS); }
> ;
>
> exp : exp GREATERTHAN exp
> - { write_exp_elt_opcode (BINOP_GTR); }
> + { write_exp_elt_opcode (pstate, BINOP_GTR); }
> ;
>
> exp : exp '&' exp
> - { write_exp_elt_opcode (BINOP_BITWISE_AND); }
> + { write_exp_elt_opcode (pstate, BINOP_BITWISE_AND); }
> ;
>
> exp : exp '^' exp
> - { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
> + { write_exp_elt_opcode (pstate, BINOP_BITWISE_XOR); }
> ;
>
> exp : exp '|' exp
> - { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
> + { write_exp_elt_opcode (pstate, BINOP_BITWISE_IOR); }
> ;
>
> exp : exp BOOL_AND exp
> - { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
> + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); }
> ;
>
>
> exp : exp BOOL_OR exp
> - { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
> + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); }
> ;
>
> exp : exp '=' exp
> - { write_exp_elt_opcode (BINOP_ASSIGN); }
> + { write_exp_elt_opcode (pstate, BINOP_ASSIGN); }
> ;
>
> exp : exp ASSIGN_MODIFY exp
> - { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY);
> - write_exp_elt_opcode ($2);
> - write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); }
> + { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY);
> + write_exp_elt_opcode (pstate, $2);
> + write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); }
> ;
>
> exp : INT
> - { write_exp_elt_opcode (OP_LONG);
> - write_exp_elt_type ($1.type);
> - write_exp_elt_longcst ((LONGEST)($1.val));
> - write_exp_elt_opcode (OP_LONG); }
> + { write_exp_elt_opcode (pstate, OP_LONG);
> + write_exp_elt_type (pstate, $1.type);
> + 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.type);
> - write_exp_elt_longcst ((LONGEST)val.typed_val.val);
> - write_exp_elt_opcode (OP_LONG); }
> + 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.type);
> + write_exp_elt_longcst (pstate, (LONGEST)val.typed_val.val);
> + write_exp_elt_opcode (pstate, OP_LONG); }
> ;
>
> exp : FLOAT
> - { write_exp_elt_opcode (OP_DOUBLE);
> - write_exp_elt_type (parse_f_type->builtin_real_s8);
> - write_exp_elt_dblcst ($1);
> - write_exp_elt_opcode (OP_DOUBLE); }
> + { write_exp_elt_opcode (pstate, OP_DOUBLE);
> + write_exp_elt_type (pstate,
> + parse_f_type (pstate)
> + ->builtin_real_s8);
> + write_exp_elt_dblcst (pstate, $1);
> + write_exp_elt_opcode (pstate, OP_DOUBLE); }
> ;
>
> exp : variable
> @@ -469,25 +479,27 @@ exp : VARIABLE
> ;
>
> exp : SIZEOF '(' type ')' %prec UNARY
> - { write_exp_elt_opcode (OP_LONG);
> - write_exp_elt_type (parse_f_type->builtin_integer);
> + { write_exp_elt_opcode (pstate, OP_LONG);
> + write_exp_elt_type (pstate,
> + parse_f_type (pstate)
> + ->builtin_integer);
> 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 : BOOLEAN_LITERAL
> - { write_exp_elt_opcode (OP_BOOL);
> - write_exp_elt_longcst ((LONGEST) $1);
> - write_exp_elt_opcode (OP_BOOL);
> + { write_exp_elt_opcode (pstate, OP_BOOL);
> + write_exp_elt_longcst (pstate, (LONGEST) $1);
> + write_exp_elt_opcode (pstate, OP_BOOL);
> }
> ;
>
> exp : STRING_LITERAL
> {
> - write_exp_elt_opcode (OP_STRING);
> - write_exp_string ($1);
> - write_exp_elt_opcode (OP_STRING);
> + write_exp_elt_opcode (pstate, OP_STRING);
> + write_exp_string (pstate, $1);
> + write_exp_elt_opcode (pstate, OP_STRING);
> }
> ;
>
> @@ -503,13 +515,13 @@ variable: name_not_typename
> innermost_block))
> 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);
> break;
> }
> else
> @@ -520,7 +532,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. Use the \"file\" command."));
> else
> @@ -561,7 +573,8 @@ ptype : typebase
> {
> range_type =
> create_range_type ((struct type *) NULL,
> - parse_f_type->builtin_integer,
> + parse_f_type (pstate)
> + ->builtin_integer,
> 0, array_size - 1);
> follow_type =
> create_array_type ((struct type *) NULL,
> @@ -607,31 +620,31 @@ typebase /* Implements (approximately): (type-qualifier)* type-specifier */
> : TYPENAME
> { $$ = $1.type; }
> | INT_KEYWORD
> - { $$ = parse_f_type->builtin_integer; }
> + { $$ = parse_f_type (pstate)->builtin_integer; }
> | INT_S2_KEYWORD
> - { $$ = parse_f_type->builtin_integer_s2; }
> + { $$ = parse_f_type (pstate)->builtin_integer_s2; }
> | CHARACTER
> - { $$ = parse_f_type->builtin_character; }
> + { $$ = parse_f_type (pstate)->builtin_character; }
> | LOGICAL_S8_KEYWORD
> - { $$ = parse_f_type->builtin_logical_s8; }
> + { $$ = parse_f_type (pstate)->builtin_logical_s8; }
> | LOGICAL_KEYWORD
> - { $$ = parse_f_type->builtin_logical; }
> + { $$ = parse_f_type (pstate)->builtin_logical; }
> | LOGICAL_S2_KEYWORD
> - { $$ = parse_f_type->builtin_logical_s2; }
> + { $$ = parse_f_type (pstate)->builtin_logical_s2; }
> | LOGICAL_S1_KEYWORD
> - { $$ = parse_f_type->builtin_logical_s1; }
> + { $$ = parse_f_type (pstate)->builtin_logical_s1; }
> | REAL_KEYWORD
> - { $$ = parse_f_type->builtin_real; }
> + { $$ = parse_f_type (pstate)->builtin_real; }
> | REAL_S8_KEYWORD
> - { $$ = parse_f_type->builtin_real_s8; }
> + { $$ = parse_f_type (pstate)->builtin_real_s8; }
> | REAL_S16_KEYWORD
> - { $$ = parse_f_type->builtin_real_s16; }
> + { $$ = parse_f_type (pstate)->builtin_real_s16; }
> | COMPLEX_S8_KEYWORD
> - { $$ = parse_f_type->builtin_complex_s8; }
> + { $$ = parse_f_type (pstate)->builtin_complex_s8; }
> | COMPLEX_S16_KEYWORD
> - { $$ = parse_f_type->builtin_complex_s16; }
> + { $$ = parse_f_type (pstate)->builtin_complex_s16; }
> | COMPLEX_S32_KEYWORD
> - { $$ = parse_f_type->builtin_complex_s32; }
> + { $$ = parse_f_type (pstate)->builtin_complex_s32; }
> ;
>
> nonempty_typelist
> @@ -670,7 +683,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)
> {
> LONGEST n = 0;
> LONGEST prevn = 0;
> @@ -776,20 +790,22 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere)
> are the same size. So we shift it twice, with fewer bits
> each time, for the same result. */
>
> - if ((gdbarch_int_bit (parse_gdbarch) != gdbarch_long_bit (parse_gdbarch)
> + if ((gdbarch_int_bit (parse_gdbarch (par_state))
> + != gdbarch_long_bit (parse_gdbarch (par_state))
> && ((n >> 2)
> - >> (gdbarch_int_bit (parse_gdbarch)-2))) /* Avoid shift warning */
> + >> (gdbarch_int_bit (parse_gdbarch (par_state))-2))) /* Avoid
> + shift warning */
> || long_p)
> {
> - 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
> {
> - high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch)-1);
> - unsigned_type = parse_type->builtin_unsigned_int;
> - signed_type = parse_type->builtin_int;
> + high_bit = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state))-1);
> + unsigned_type = parse_type (par_state)->builtin_unsigned_int;
> + signed_type = parse_type (par_state)->builtin_int;
> }
>
> putithere->typed_val.val = n;
> @@ -1091,7 +1107,8 @@ yylex (void)
> && (*p < 'A' || *p > 'Z')))
> break;
> }
> - toktype = parse_number (tokstart, p - tokstart, got_dot|got_e|got_d,
> + toktype = parse_number (pstate, tokstart, p - tokstart,
> + got_dot|got_e|got_d,
> &yylval);
> if (toktype == ERROR)
> {
> @@ -1165,7 +1182,7 @@ yylex (void)
>
> if (*tokstart == '$')
> {
> - write_dollar_variable (yylval.sval);
> + write_dollar_variable (pstate, yylval.sval);
> return VARIABLE;
> }
>
> @@ -1180,7 +1197,7 @@ yylex (void)
>
> sym = lookup_symbol (tmp, expression_context_block,
> VAR_DOMAIN,
> - parse_language->la_language == language_cplus
> + parse_language (pstate)->la_language == language_cplus
> ? &is_a_field_of_this : NULL);
> if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
> {
> @@ -1188,8 +1205,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)
> return TYPENAME;
>
> @@ -1201,7 +1218,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;
> @@ -1217,6 +1234,16 @@ yylex (void)
> }
> }
>
> +int
> +f_parse (struct parser_state *par_state)
> +{
> + /* Setting up the parser state. */
> + gdb_assert (par_state != NULL);
> + pstate = par_state;
> +
> + return _f_parse ();
> +}
> +
> void
> yyerror (char *msg)
> {
> diff --git a/gdb/f-lang.h b/gdb/f-lang.h
> index 4aae3c5..1392345 100644
> --- a/gdb/f-lang.h
> +++ b/gdb/f-lang.h
> @@ -21,9 +21,11 @@
> You should have received a copy of the GNU General Public License
> along with this program. If not, see <http://www.gnu.org/licenses/>. */
>
> -extern int f_parse (void);
> +struct parser_state;
>
> -extern void f_error (char *); /* Defined in f-exp.y */
> +extern int f_parse (struct parser_state *);
> +
> +extern void f_error (char *); /* Defined in f-exp.y */
>
> extern void f_print_type (struct type *, const char *, struct ui_file *, int,
> int);
> --
> 1.7.7.6
--
Sergio
next prev parent reply other threads:[~2012-06-13 4:59 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 02/10] SystemTap integration Sergio Durigan Junior
2012-06-04 20:23 ` Tom Tromey
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: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 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: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: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:24 ` [PATCH 05/10] Fortran language Sergio Durigan Junior
2012-06-13 4:59 ` Sergio Durigan Junior [this message]
2012-06-13 14:55 ` Joel Brobecker
2012-06-02 20:33 ` [PATCH 09/10] Pascal language Sergio Durigan Junior
2012-06-05 7:39 ` Pierre Muller
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: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=m3zk87st71.fsf@redhat.com \
--to=sergiodj@redhat.com \
--cc=gdb-patches@sourceware.org \
--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