From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 10243 invoked by alias); 22 Mar 2014 19:59:55 -0000 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 Received: (qmail 10233 invoked by uid 89); 22 Mar 2014 19:59:54 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.9 required=5.0 tests=AWL,BAYES_00,KAM_STOCKGEN,SPF_HELO_PASS,SPF_PASS,UNWANTED_LANGUAGE_BODY autolearn=no version=3.3.2 X-HELO: postbox.isd.glam.ac.uk Received: from postbox.isd.glam.ac.uk (HELO postbox.isd.glam.ac.uk) (81.87.34.17) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 22 Mar 2014 19:59:51 +0000 Received: from j228-gm.comp.glam.ac.uk ([193.63.148.84]) by postbox.isd.glam.ac.uk with esmtp (Exim 4.71) (envelope-from ) id 1WRS56-0008Kz-B0; Sat, 22 Mar 2014 19:59:48 +0000 Received: from gaius by j228-gm.comp.glam.ac.uk with local (Exim 4.80) (envelope-from ) id 1WRRu1-0001Pq-Rd; Sat, 22 Mar 2014 19:48:21 +0000 From: Gaius Mulley To: Sergio Durigan Junior Cc: GDB Patches , Tom Tromey Subject: Re: [PATCH v4 07/10] Modula-2 language References: <1395463432-29750-1-git-send-email-sergiodj@redhat.com> <1395463432-29750-8-git-send-email-sergiodj@redhat.com> Date: Sat, 22 Mar 2014 19:59:00 -0000 In-Reply-To: <1395463432-29750-8-git-send-email-sergiodj@redhat.com> (Sergio Durigan Junior's message of "Sat, 22 Mar 2014 01:43:49 -0300") Message-ID: <87ppleui9m.fsf@j228-gm.comp.glam.ac.uk> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/23.4 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-IsSubscribed: yes X-SW-Source: 2014-03/txt/msg00560.txt.bz2 Sergio Durigan Junior writes: > Patch for the Modula-2 language. Similar to the C language one. > > 2014-03-22 Sergio Durigan Junior > > * m2-exp.y (parse_type, parse_m2_type): Rewrite macros to use > parser state. > (yyparse): Redefine macro to m2_parse_internal. > (pstate): New variable. > (type_exp, exp, fblock, variable, type): Update calls to > write_exp* and similars to use parser state. > (yylex): Likewise. > (m2_parse): New function. > * m2-lang.h: Forward declare "struct parser_state". > (m2_parse): Add "struct parser_state" argument. > --- > gdb/m2-exp.y | 275 +++++++++++++++++++++++++++++++++------------------------- > gdb/m2-lang.h | 3 +- > 2 files changed, 158 insertions(+), 120 deletions(-) > > diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y > index 07aa986..917a028 100644 > --- a/gdb/m2-exp.y > +++ b/gdb/m2-exp.y > @@ -49,8 +49,8 @@ > #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */ > #include "block.h" > > -#define parse_type builtin_type (parse_gdbarch) > -#define parse_m2_type builtin_m2_type (parse_gdbarch) > +#define parse_type(ps) builtin_type (parse_gdbarch (ps)) > +#define parse_m2_type(ps) builtin_m2_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 > @@ -60,7 +60,7 @@ > generators need to be fixed instead of adding those names to this list. */ > > #define yymaxdepth m2_maxdepth > -#define yyparse m2_parse > +#define yyparse m2_parse_internal > #define yylex m2_lex > #define yyerror m2_error > #define yylval m2_lval > @@ -112,6 +112,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); > @@ -204,31 +209,31 @@ 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); > } > ; > > /* Expressions */ > > exp : exp '^' %prec UNARY > - { write_exp_elt_opcode (UNOP_IND); } > + { write_exp_elt_opcode (pstate, UNOP_IND); } > ; > > exp : '-' > { number_sign = -1; } > exp %prec UNARY > { number_sign = 1; > - 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 : not_exp exp %prec UNARY > - { write_exp_elt_opcode (UNOP_LOGICAL_NOT); } > + { write_exp_elt_opcode (pstate, UNOP_LOGICAL_NOT); } > ; > > not_exp : NOT > @@ -236,88 +241,90 @@ not_exp : NOT > ; > > exp : CAP '(' exp ')' > - { write_exp_elt_opcode (UNOP_CAP); } > + { write_exp_elt_opcode (pstate, UNOP_CAP); } > ; > > exp : ORD '(' exp ')' > - { write_exp_elt_opcode (UNOP_ORD); } > + { write_exp_elt_opcode (pstate, UNOP_ORD); } > ; > > exp : ABS '(' exp ')' > - { write_exp_elt_opcode (UNOP_ABS); } > + { write_exp_elt_opcode (pstate, UNOP_ABS); } > ; > > exp : HIGH '(' exp ')' > - { write_exp_elt_opcode (UNOP_HIGH); } > + { write_exp_elt_opcode (pstate, UNOP_HIGH); } > ; > > exp : MIN_FUNC '(' type ')' > - { write_exp_elt_opcode (UNOP_MIN); > - write_exp_elt_type ($3); > - write_exp_elt_opcode (UNOP_MIN); } > + { write_exp_elt_opcode (pstate, UNOP_MIN); > + write_exp_elt_type (pstate, $3); > + write_exp_elt_opcode (pstate, UNOP_MIN); } > ; > > exp : MAX_FUNC '(' type ')' > - { write_exp_elt_opcode (UNOP_MAX); > - write_exp_elt_type ($3); > - write_exp_elt_opcode (UNOP_MAX); } > + { write_exp_elt_opcode (pstate, UNOP_MAX); > + write_exp_elt_type (pstate, $3); > + write_exp_elt_opcode (pstate, UNOP_MAX); } > ; > > exp : FLOAT_FUNC '(' exp ')' > - { write_exp_elt_opcode (UNOP_FLOAT); } > + { write_exp_elt_opcode (pstate, UNOP_FLOAT); } > ; > > exp : VAL '(' type ',' exp ')' > - { write_exp_elt_opcode (BINOP_VAL); > - write_exp_elt_type ($3); > - write_exp_elt_opcode (BINOP_VAL); } > + { write_exp_elt_opcode (pstate, BINOP_VAL); > + write_exp_elt_type (pstate, $3); > + write_exp_elt_opcode (pstate, BINOP_VAL); } > ; > > exp : CHR '(' exp ')' > - { write_exp_elt_opcode (UNOP_CHR); } > + { write_exp_elt_opcode (pstate, UNOP_CHR); } > ; > > exp : ODD '(' exp ')' > - { write_exp_elt_opcode (UNOP_ODD); } > + { write_exp_elt_opcode (pstate, UNOP_ODD); } > ; > > exp : TRUNC '(' exp ')' > - { write_exp_elt_opcode (UNOP_TRUNC); } > + { write_exp_elt_opcode (pstate, UNOP_TRUNC); } > ; > > exp : TSIZE '(' exp ')' > - { write_exp_elt_opcode (UNOP_SIZEOF); } > + { write_exp_elt_opcode (pstate, UNOP_SIZEOF); } > ; > > exp : SIZE exp %prec UNARY > - { write_exp_elt_opcode (UNOP_SIZEOF); } > + { write_exp_elt_opcode (pstate, UNOP_SIZEOF); } > ; > > > exp : INC '(' exp ')' > - { write_exp_elt_opcode(UNOP_PREINCREMENT); } > + { write_exp_elt_opcode (pstate, UNOP_PREINCREMENT); } > ; > > exp : INC '(' exp ',' exp ')' > - { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); > - write_exp_elt_opcode(BINOP_ADD); > - write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); } > + { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); > + write_exp_elt_opcode (pstate, BINOP_ADD); > + write_exp_elt_opcode (pstate, > + BINOP_ASSIGN_MODIFY); } > ; > > exp : DEC '(' exp ')' > - { write_exp_elt_opcode(UNOP_PREDECREMENT);} > + { write_exp_elt_opcode (pstate, UNOP_PREDECREMENT);} > ; > > exp : DEC '(' exp ',' exp ')' > - { write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); > - write_exp_elt_opcode(BINOP_SUB); > - write_exp_elt_opcode(BINOP_ASSIGN_MODIFY); } > + { write_exp_elt_opcode (pstate, BINOP_ASSIGN_MODIFY); > + write_exp_elt_opcode (pstate, BINOP_SUB); > + write_exp_elt_opcode (pstate, > + BINOP_ASSIGN_MODIFY); } > ; > > exp : exp DOT 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); } > ; > > exp : set > @@ -349,13 +356,14 @@ exp : exp '[' > function types */ > { start_arglist(); } > non_empty_arglist ']' %prec DOT > - { write_exp_elt_opcode (MULTI_SUBSCRIPT); > - write_exp_elt_longcst ((LONGEST) end_arglist()); > - write_exp_elt_opcode (MULTI_SUBSCRIPT); } > + { write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT); > + write_exp_elt_longcst (pstate, > + (LONGEST) end_arglist()); > + write_exp_elt_opcode (pstate, MULTI_SUBSCRIPT); } > ; > > exp : exp '[' exp ']' > - { write_exp_elt_opcode (BINOP_SUBSCRIPT); } > + { write_exp_elt_opcode (pstate, BINOP_SUBSCRIPT); } > ; > > exp : exp '(' > @@ -363,9 +371,10 @@ exp : exp '(' > being accumulated by an outer function call. */ > { start_arglist (); } > arglist ')' %prec DOT > - { 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); } > ; > > arglist : > @@ -391,15 +400,15 @@ non_empty_arglist > > /* GDB construct */ > exp : '{' type '}' 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 : '(' exp ')' > @@ -411,131 +420,140 @@ exp : '(' exp ')' > > /* GDB construct */ > 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 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 '=' 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 > - { 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 LOGICAL_AND 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 ASSIGN exp > - { write_exp_elt_opcode (BINOP_ASSIGN); } > + { write_exp_elt_opcode (pstate, BINOP_ASSIGN); } > ; > > > /* Constants */ > > exp : M2_TRUE > - { 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 : M2_FALSE > - { 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 : INT > - { write_exp_elt_opcode (OP_LONG); > - write_exp_elt_type (parse_m2_type->builtin_int); > - write_exp_elt_longcst ((LONGEST) $1); > - write_exp_elt_opcode (OP_LONG); } > + { write_exp_elt_opcode (pstate, OP_LONG); > + write_exp_elt_type (pstate, > + parse_m2_type (pstate)->builtin_int); > + write_exp_elt_longcst (pstate, (LONGEST) $1); > + write_exp_elt_opcode (pstate, OP_LONG); } > ; > > exp : UINT > { > - write_exp_elt_opcode (OP_LONG); > - write_exp_elt_type (parse_m2_type->builtin_card); > - write_exp_elt_longcst ((LONGEST) $1); > - write_exp_elt_opcode (OP_LONG); > + write_exp_elt_opcode (pstate, OP_LONG); > + write_exp_elt_type (pstate, > + parse_m2_type (pstate) > + ->builtin_card); > + write_exp_elt_longcst (pstate, (LONGEST) $1); > + write_exp_elt_opcode (pstate, OP_LONG); > } > ; > > exp : CHAR > - { write_exp_elt_opcode (OP_LONG); > - write_exp_elt_type (parse_m2_type->builtin_char); > - write_exp_elt_longcst ((LONGEST) $1); > - write_exp_elt_opcode (OP_LONG); } > + { write_exp_elt_opcode (pstate, OP_LONG); > + write_exp_elt_type (pstate, > + parse_m2_type (pstate) > + ->builtin_char); > + write_exp_elt_longcst (pstate, (LONGEST) $1); > + write_exp_elt_opcode (pstate, OP_LONG); } > ; > > > exp : FLOAT > - { write_exp_elt_opcode (OP_DOUBLE); > - write_exp_elt_type (parse_m2_type->builtin_real); > - write_exp_elt_dblcst ($1); > - write_exp_elt_opcode (OP_DOUBLE); } > + { write_exp_elt_opcode (pstate, OP_DOUBLE); > + write_exp_elt_type (pstate, > + parse_m2_type (pstate) > + ->builtin_real); > + write_exp_elt_dblcst (pstate, $1); > + write_exp_elt_opcode (pstate, OP_DOUBLE); } > ; > > exp : variable > ; > > exp : SIZE '(' type ')' %prec UNARY > - { write_exp_elt_opcode (OP_LONG); > - write_exp_elt_type (parse_type->builtin_int); > - write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); > - write_exp_elt_opcode (OP_LONG); } > + { write_exp_elt_opcode (pstate, OP_LONG); > + write_exp_elt_type (pstate, > + parse_type (pstate)->builtin_int); > + write_exp_elt_longcst (pstate, > + (LONGEST) TYPE_LENGTH ($3)); > + write_exp_elt_opcode (pstate, OP_LONG); } > ; > > exp : STRING > - { write_exp_elt_opcode (OP_M2_STRING); > - write_exp_string ($1); > - write_exp_elt_opcode (OP_M2_STRING); } > + { write_exp_elt_opcode (pstate, OP_M2_STRING); > + write_exp_string (pstate, $1); > + write_exp_elt_opcode (pstate, OP_M2_STRING); } > ; > > /* This will be used for extensions later. Like adding modules. */ > @@ -545,7 +563,8 @@ block : fblock > > fblock : BLOCKNAME > { struct symbol *sym > - = lookup_symbol (copy_name ($1), expression_context_block, > + = lookup_symbol (copy_name ($1), > + expression_context_block, > VAR_DOMAIN, 0); > $$ = sym;} > ; > @@ -565,10 +584,10 @@ fblock : block COLONCOLON BLOCKNAME > > /* Useful for assigning to PROCEDURE variables */ > variable: fblock > - { write_exp_elt_opcode(OP_VAR_VALUE); > - write_exp_elt_block (NULL); > - write_exp_elt_sym ($1); > - 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, $1); > + write_exp_elt_opcode (pstate, OP_VAR_VALUE); } > ; > > /* GDB internal ($foo) variable */ > @@ -591,11 +610,11 @@ variable: block COLONCOLON NAME > innermost_block = block_found; > } > > - 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); } > ; > > /* Base case for variables. */ > @@ -617,13 +636,13 @@ variable: NAME > 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 > { > @@ -633,7 +652,7 @@ variable: NAME > msymbol = > lookup_bound_minimal_symbol (arg); > if (msymbol.minsym != 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 \"symbol-file\" command.")); > else > @@ -645,7 +664,8 @@ variable: NAME > > type > : TYPENAME > - { $$ = lookup_typename (parse_language, parse_gdbarch, > + { $$ = lookup_typename (parse_language (pstate), > + parse_gdbarch (pstate), > copy_name ($1), > expression_context_block, 0); } > > @@ -805,8 +825,8 @@ static struct keyword keytab[] = > > /* Read one token, getting characters through lexptr. */ > > -/* This is where we will check to make sure that the language and the operators used are > - compatible */ > +/* This is where we will check to make sure that the language and the > + operators used are compatible */ > > static int > yylex (void) > @@ -992,7 +1012,7 @@ yylex (void) > > if (*tokstart == '$') > { > - write_dollar_variable (yylval.sval); > + write_dollar_variable (pstate, yylval.sval); > return INTERNAL_VAR; > } > > @@ -1012,8 +1032,9 @@ yylex (void) > sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0); > if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK) > return BLOCKNAME; > - if (lookup_typename (parse_language, parse_gdbarch, > - copy_name (yylval.sval), expression_context_block, 1)) > + if (lookup_typename (parse_language (pstate), parse_gdbarch (pstate), > + copy_name (yylval.sval), > + expression_context_block, 1)) > return TYPENAME; > > if(sym) > @@ -1070,6 +1091,22 @@ yylex (void) > } > } > > +int > +m2_parse (struct parser_state *par_state) > +{ > + int result; > + struct cleanup *c = make_cleanup_clear_parser_state (&pstate); > + > + /* Setting up the parser state. */ > + gdb_assert (par_state != NULL); > + pstate = par_state; > + > + result = yyparse (); > + do_cleanups (c); > + > + return result; > +} > + > void > yyerror (char *msg) > { > diff --git a/gdb/m2-lang.h b/gdb/m2-lang.h > index 772221f..d363975 100644 > --- a/gdb/m2-lang.h > +++ b/gdb/m2-lang.h > @@ -18,8 +18,9 @@ > along with this program. If not, see . */ > > struct type_print_options; > +struct parser_state; > > -extern int m2_parse (void); /* Defined in m2-exp.y */ > +extern int m2_parse (struct parser_state *); /* Defined in m2-exp.y */ > > extern void m2_error (char *); /* Defined in m2-exp.y */ Hi, all looks good and clean - thanks, regards, Gaius