From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 30592 invoked by alias); 13 Jun 2012 04:58:22 -0000 Received: (qmail 30532 invoked by uid 22791); 13 Jun 2012 04:58:14 -0000 X-SWARE-Spam-Status: No, hits=-6.2 required=5.0 tests=AWL,BAYES_00,KHOP_RCVD_UNTRUST,RCVD_IN_DNSWL_HI,RCVD_IN_HOSTKARMA_W,SPF_HELO_PASS,TW_YY,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org 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:57:43 +0000 Received: from int-mx02.intmail.prod.int.phx2.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id q5D4vgMd022708 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Wed, 13 Jun 2012 00:57:42 -0400 Received: from psique (ovpn-113-39.phx2.redhat.com [10.3.113.39]) by int-mx02.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id q5D4vdQl016099; Wed, 13 Jun 2012 00:57:40 -0400 From: Sergio Durigan Junior To: GDB Patches Cc: Tom Tromey , Doug Evans Subject: Re: [PATCH 10/10] Go programming language References: <1338665528-5932-1-git-send-email-sergiodj@redhat.com> <1338665528-5932-11-git-send-email-sergiodj@redhat.com> X-URL: http://www.redhat.com Date: Wed, 13 Jun 2012 04:58:00 -0000 In-Reply-To: <1338665528-5932-11-git-send-email-sergiodj@redhat.com> (Sergio Durigan Junior's message of "Sat, 2 Jun 2012 16:32:08 -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/msg00380.txt.bz2 On Saturday, June 02 2012, I wrote: > Patch for the Go programming language. Similar to the C language one. Ping. Doug, since you have put this code in, would you like to take a look just to be safe? Thanks, > > --- > gdb/go-exp.y | 268 +++++++++++++++++++++++++++++++-------------------------- > gdb/go-lang.h | 4 +- > 2 files changed, 148 insertions(+), 124 deletions(-) > > diff --git a/gdb/go-exp.y b/gdb/go-exp.y > index c3171c3..7e02283 100644 > --- a/gdb/go-exp.y > +++ b/gdb/go-exp.y > @@ -66,7 +66,7 @@ > #include "charset.h" > #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 > @@ -76,7 +76,7 @@ > generators need to be fixed instead of adding those names to this list. */ > > #define yymaxdepth go_maxdepth > -#define yyparse go_parse_internal > +#define yyparse _go_parse > #define yylex go_lex > #define yyerror go_error > #define yylval go_lval > @@ -122,6 +122,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 @@ void yyerror (char *); > > %{ > /* 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 int parse_go_float (struct gdbarch *gdbarch, const char *p, int len, > DOUBLEST *d, struct type **t); > %} > @@ -239,77 +244,77 @@ start : exp1 > ; > > 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); } > ; > > /* 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); } > ; > > 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 : '+' exp %prec UNARY > - { write_exp_elt_opcode (UNOP_PLUS); } > + { write_exp_elt_opcode (pstate, UNOP_PLUS); } > ; > > exp : '!' 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 : exp INCREMENT %prec UNARY > - { write_exp_elt_opcode (UNOP_POSTINCREMENT); } > + { write_exp_elt_opcode (pstate, UNOP_POSTINCREMENT); } > ; > > exp : exp DECREMENT %prec UNARY > - { write_exp_elt_opcode (UNOP_POSTDECREMENT); } > + { write_exp_elt_opcode (pstate, UNOP_POSTDECREMENT); } > ; > > /* foo->bar is not in Go. May want as a gdb extension. Later. */ > > exp : exp '.' name_not_typename > - { write_exp_elt_opcode (STRUCTOP_STRUCT); > - write_exp_string ($3.stoken); > - write_exp_elt_opcode (STRUCTOP_STRUCT); } > + { write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); > + write_exp_string (pstate, $3.stoken); > + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } > ; > > exp : exp '.' name_not_typename COMPLETE > - { mark_struct_expression (); > - write_exp_elt_opcode (STRUCTOP_STRUCT); > - write_exp_string ($3.stoken); > - write_exp_elt_opcode (STRUCTOP_STRUCT); } > + { mark_struct_expression (pstate); > + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); > + write_exp_string (pstate, $3.stoken); > + write_exp_elt_opcode (pstate, STRUCTOP_STRUCT); } > ; > > exp : 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 '[' exp1 ']' > - { write_exp_elt_opcode (BINOP_SUBSCRIPT); } > + { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); } > ; > > exp : exp '(' > @@ -317,9 +322,10 @@ exp : exp '(' > being accumulated by an outer function call. */ > { start_arglist (); } > arglist ')' %prec LEFT_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); } > ; > > lcurly : '{' > @@ -342,15 +348,15 @@ rcurly : '}' > ; > > exp : lcurly type rcurly exp %prec UNARY > - { write_exp_elt_opcode (UNOP_MEMVAL); > - write_exp_elt_type ($2); > - write_exp_elt_opcode (UNOP_MEMVAL); } > + { write_exp_elt_opcode (pstate, UNOP_MEMVAL); > + write_exp_elt_type (pstate, $2); > + write_exp_elt_opcode (pstate, UNOP_MEMVAL); } > ; > > exp : type '(' exp ')' %prec UNARY > - { 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); } > ; > > exp : '(' exp1 ')' > @@ -360,100 +366,100 @@ exp : '(' exp1 ')' > /* 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 '*' 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_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 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 '<' exp > - { write_exp_elt_opcode (BINOP_LESS); } > + { write_exp_elt_opcode (pstate, BINOP_LESS); } > ; > > exp : exp '>' 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 ANDAND exp > - { write_exp_elt_opcode (BINOP_LOGICAL_AND); } > + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_AND); } > ; > > exp : exp OROR exp > - { write_exp_elt_opcode (BINOP_LOGICAL_OR); } > + { write_exp_elt_opcode (pstate, BINOP_LOGICAL_OR); } > ; > > exp : exp '?' exp ':' exp %prec '?' > - { write_exp_elt_opcode (TERNOP_COND); } > + { write_exp_elt_opcode (pstate, TERNOP_COND); } > ; > > 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 : CHAR > @@ -461,28 +467,28 @@ exp : CHAR > struct stoken_vector vec; > vec.len = 1; > vec.tokens = &$1; > - write_exp_string_vector ($1.type, &vec); > + write_exp_string_vector (pstate, $1.type, &vec); > } > ; > > exp : NAME_OR_INT > { YYSTYPE val; > - parse_number ($1.stoken.ptr, $1.stoken.length, > - 0, &val); > - write_exp_elt_opcode (OP_LONG); > - write_exp_elt_type (val.typed_val_int.type); > - write_exp_elt_longcst ((LONGEST) > + parse_number (pstate, $1.stoken.ptr, > + $1.stoken.length, 0, &val); > + write_exp_elt_opcode (pstate, OP_LONG); > + write_exp_elt_type (pstate, val.typed_val_int.type); > + 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_dblcst ($1.dval); > - write_exp_elt_opcode (OP_DOUBLE); } > + { write_exp_elt_opcode (pstate, OP_DOUBLE); > + write_exp_elt_type (pstate, $1.type); > + write_exp_elt_dblcst (pstate, $1.dval); > + write_exp_elt_opcode (pstate, OP_DOUBLE); } > ; > > exp : variable > @@ -490,26 +496,29 @@ exp : variable > > exp : DOLLAR_VARIABLE > { > - write_dollar_variable ($1); > + write_dollar_variable (pstate, $1); > } > ; > > exp : SIZEOF_KEYWORD '(' type ')' %prec UNARY > { > /* TODO(dje): Go objects in structs. */ > - write_exp_elt_opcode (OP_LONG); > + write_exp_elt_opcode (pstate, OP_LONG); > /* TODO(dje): What's the right type here? */ > - write_exp_elt_type (parse_type->builtin_unsigned_int); > + write_exp_elt_type > + (pstate, > + parse_type (pstate)->builtin_unsigned_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_KEYWORD '(' exp ')' %prec UNARY > { > /* TODO(dje): Go objects in structs. */ > - write_exp_elt_opcode (UNOP_SIZEOF); > + write_exp_elt_opcode (pstate, UNOP_SIZEOF); > } > > string_exp: > @@ -552,7 +561,8 @@ exp : string_exp %prec ABOVE_COMMA > { > int i; > > - write_exp_string_vector (0 /*always utf8*/, &$1); > + write_exp_string_vector (pstate, 0 /*always utf8*/, > + &$1); > for (i = 0; i < $1.len; ++i) > free ($1.tokens[i].ptr); > free ($1.tokens); > @@ -560,15 +570,15 @@ exp : string_exp %prec ABOVE_COMMA > ; > > exp : TRUE_KEYWORD > - { 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 : FALSE_KEYWORD > - { 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); } > ; > > variable: name_not_typename ENTRY > @@ -581,9 +591,9 @@ variable: name_not_typename ENTRY > "parameters, not for \"%s\""), > copy_name ($1.stoken)); > > - write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); > - write_exp_elt_sym (sym); > - write_exp_elt_opcode (OP_VAR_ENTRY_VALUE); > + write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE); > + write_exp_elt_sym (pstate, sym); > + write_exp_elt_opcode (pstate, OP_VAR_ENTRY_VALUE); > } > ; > > @@ -600,13 +610,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); > } > else if ($1.is_a_field_of_this) > { > @@ -622,7 +632,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. " > @@ -652,7 +662,7 @@ type /* Implements (approximately): [*] type-specifier */ > expression_context_block); } > */ > | BYTE_KEYWORD > - { $$ = builtin_go_type (parse_gdbarch) > + { $$ = builtin_go_type (parse_gdbarch (pstate)) > ->builtin_uint8; } > ; > > @@ -704,7 +714,8 @@ parse_go_float (struct gdbarch *gdbarch, const char *p, int len, > as our YYSTYPE is different than c-exp.y's */ > > 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. */ > @@ -729,7 +740,7 @@ parse_number (char *p, int len, int parsed_float, YYSTYPE *putithere) > > if (parsed_float) > { > - if (! parse_go_float (parse_gdbarch, p, len, > + if (! parse_go_float (parse_gdbarch (par_state), p, len, > &putithere->typed_val_float.dval, > &putithere->typed_val_float.type)) > return ERROR; > @@ -845,9 +856,10 @@ 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, > @@ -855,28 +867,29 @@ 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; > @@ -1044,7 +1057,7 @@ static int last_was_structop; > /* Read one token, getting characters through lexptr. */ > > static int > -lex_one_token (void) > +lex_one_token (struct parser_state *par_state) > { > int c; > int namelen; > @@ -1175,7 +1188,8 @@ lex_one_token (void) > && (*p < 'A' || *p > 'Z'))) > break; > } > - toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); > + toktype = parse_number (par_state, tokstart, p - tokstart, > + got_dot|got_e, &yylval); > if (toktype == ERROR) > { > char *err_copy = (char *) alloca (p - tokstart + 1); > @@ -1430,7 +1444,7 @@ classify_packaged_name (struct block *block) > The result is one of NAME, NAME_OR_INT, or TYPENAME. */ > > static int > -classify_name (struct block *block) > +classify_name (struct parser_state *par_state, struct block *block) > { > struct type *type; > struct symbol *sym; > @@ -1440,8 +1454,9 @@ classify_name (struct block *block) > copy = copy_name (yylval.sval); > > /* Try primitive types first so they win over bad/weird debug info. */ > - type = language_lookup_primitive_type_by_name (parse_language, > - parse_gdbarch, copy); > + type = language_lookup_primitive_type_by_name (parse_language (par_state), > + parse_gdbarch (par_state), > + copy); > if (type != NULL) > { > /* NOTE: We take advantage of the fact that yylval coming in was a > @@ -1497,7 +1512,8 @@ classify_name (struct block *block) > || (copy[0] >= 'A' && copy[0] < 'A' + input_radix - 10)) > { > YYSTYPE newlval; /* Its value is ignored. */ > - int hextype = parse_number (copy, yylval.sval.length, 0, &newlval); > + int hextype = parse_number (par_state, copy, yylval.sval.length, > + 0, &newlval); > if (hextype == INT) > { > yylval.ssym.sym = NULL; > @@ -1530,7 +1546,7 @@ yylex (void) > } > popping = 0; > > - current.token = lex_one_token (); > + current.token = lex_one_token (pstate); > > /* TODO: Need a way to force specifying name1 as a package. > .name1.name2 ? */ > @@ -1541,14 +1557,14 @@ yylex (void) > /* See if we have "name1 . name2". */ > > current.value = yylval; > - next.token = lex_one_token (); > + next.token = lex_one_token (pstate); > next.value = yylval; > > if (next.token == '.') > { > token_and_value name2; > > - name2.token = lex_one_token (); > + name2.token = lex_one_token (pstate); > name2.value = yylval; > > if (name2.token == NAME) > @@ -1587,14 +1603,20 @@ yylex (void) > > popping = 1; > yylval = current.value; > - return classify_name (expression_context_block); > + return classify_name (pstate, expression_context_block); > } > > int > -go_parse (void) > +go_parse (struct parser_state *par_state) > { > int result; > - struct cleanup *back_to = make_cleanup (null_cleanup, NULL); > + struct cleanup *back_to; > + > + /* Setting up the parser state. */ > + gdb_assert (par_state != NULL); > + pstate = par_state; > + > + back_to = make_cleanup (null_cleanup, NULL); > > make_cleanup_restore_integer (&yydebug); > yydebug = parser_debug; > diff --git a/gdb/go-lang.h b/gdb/go-lang.h > index 67b5d93..2be37b2 100644 > --- a/gdb/go-lang.h > +++ b/gdb/go-lang.h > @@ -24,6 +24,8 @@ > #include "symtab.h" > #include "value.h" > > +struct parser_state; > + > struct builtin_go_type > { > struct type *builtin_void; > @@ -54,7 +56,7 @@ enum go_type > > /* Defined in go-exp.y. */ > > -extern int go_parse (void); > +extern int go_parse (struct parser_state *); > > extern void go_error (char *); > > -- > 1.7.7.6 -- Sergio