From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 32029 invoked by alias); 13 Jun 2012 04:59:50 -0000 Received: (qmail 32001 invoked by uid 22791); 13 Jun 2012 04:59:47 -0000 X-SWARE-Spam-Status: No, hits= required= tests= Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 13 Jun 2012 04:59:33 +0000 Received: from int-mx09.intmail.prod.int.phx2.redhat.com (int-mx09.intmail.prod.int.phx2.redhat.com [10.5.11.22]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q5D4xXhp019551 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Wed, 13 Jun 2012 00:59:33 -0400 Received: from psique (ovpn-113-39.phx2.redhat.com [10.3.113.39]) by int-mx09.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id q5D4xUDr009110; Wed, 13 Jun 2012 00:59:31 -0400 From: Sergio Durigan Junior To: GDB Patches Cc: Tom Tromey Subject: Re: [PATCH 05/10] Fortran language References: <1338665528-5932-1-git-send-email-sergiodj@redhat.com> <1338665528-5932-6-git-send-email-sergiodj@redhat.com> X-URL: http://www.redhat.com Date: Wed, 13 Jun 2012 04:59:00 -0000 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") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-06/txt/msg00383.txt.bz2 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 > > -#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 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 . */ > > -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