ruby-changes:49699
From: mame <ko1@a...>
Date: Sun, 14 Jan 2018 22:51:44 +0900 (JST)
Subject: [ruby-changes:49699] mame:r61816 (trunk): parse.y: Use "p" for the variable of struct parser_params consistently
mame 2018-01-14 22:51:38 +0900 (Sun, 14 Jan 2018) New Revision: 61816 https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=61816 Log: parse.y: Use "p" for the variable of struct parser_params consistently Modified files: trunk/parse.y trunk/tool/ytab.sed Index: parse.y =================================================================== --- parse.y (revision 61815) +++ parse.y (revision 61816) @@ -39,13 +39,13 @@ https://github.com/ruby/ruby/blob/trunk/parse.y#L39 #define TAB_WIDTH 8 -#define YYMALLOC(size) rb_parser_malloc(parser, (size)) -#define YYREALLOC(ptr, size) rb_parser_realloc(parser, (ptr), (size)) -#define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size)) -#define YYFREE(ptr) rb_parser_free(parser, (ptr)) +#define YYMALLOC(size) rb_parser_malloc(p, (size)) +#define YYREALLOC(ptr, size) rb_parser_realloc(p, (ptr), (size)) +#define YYCALLOC(nelem, size) rb_parser_calloc(p, (nelem), (size)) +#define YYFREE(ptr) rb_parser_free(p, (ptr)) #define YYFPRINTF rb_parser_printf #define YY_LOCATION_PRINT(File, loc) \ - rb_parser_printf(parser, "%d.%d-%d.%d", \ + rb_parser_printf(p, "%d.%d-%d.%d", \ (loc).beg_pos.lineno, (loc).beg_pos.column,\ (loc).end_pos.lineno, (loc).end_pos.column) #define YYLLOC_DEFAULT(Current, Rhs, N) \ @@ -60,11 +60,11 @@ https://github.com/ruby/ruby/blob/trunk/parse.y#L60 while (0) #define RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(Current) \ - rb_parser_set_location_from_strterm_heredoc(parser, &lex_strterm->u.heredoc, &(Current)) + rb_parser_set_location_from_strterm_heredoc(p, &lex_strterm->u.heredoc, &(Current)) #define RUBY_SET_YYLLOC_OF_NONE(Current) \ - rb_parser_set_location_of_none(parser, &(Current)) + rb_parser_set_location_of_none(p, &(Current)) #define RUBY_SET_YYLLOC(Current) \ - rb_parser_set_location(parser, &(Current)) + rb_parser_set_location(p, &(Current)) enum lex_state_bits { EXPR_BEG_bit, /* ignore newline, +/- is a sign. */ @@ -111,14 +111,14 @@ enum lex_state_e { https://github.com/ruby/ruby/blob/trunk/parse.y#L111 # define SET_LEX_STATE(ls) \ (lex_state = \ (yydebug ? \ - rb_parser_trace_lex_state(parser, lex_state, (ls), __LINE__) : \ + rb_parser_trace_lex_state(p, lex_state, (ls), __LINE__) : \ (enum lex_state_e)(ls))) typedef VALUE stack_type; static const rb_code_location_t NULL_LOC = { {0, -1}, {0, -1} }; -# define SHOW_BITSTACK(stack, name) (yydebug ? rb_parser_show_bitstack(parser, stack, name, __LINE__) : (void)0) +# define SHOW_BITSTACK(stack, name) (yydebug ? rb_parser_show_bitstack(p, stack, name, __LINE__) : (void)0) # define BITSTACK_PUSH(stack, n) (((stack) = ((stack)<<1)|((n)&1)), SHOW_BITSTACK(stack, #stack"(push)")) # define BITSTACK_POP(stack) (((stack) = (stack) >> 1), SHOW_BITSTACK(stack, #stack"(pop)")) # define BITSTACK_SET_P(stack) (SHOW_BITSTACK(stack, #stack), (stack)&1) @@ -284,59 +284,59 @@ struct parser_params { https://github.com/ruby/ruby/blob/trunk/parse.y#L284 #define TOK_INTERN() intern_cstr(tok(), toklen(), current_enc) static int parser_yyerror(struct parser_params*, const YYLTYPE *yylloc, const char*); -#define yyerror0(msg) parser_yyerror(parser, NULL, (msg)) -#define yyerror1(loc, msg) parser_yyerror(parser, (loc), (msg)) -#define yyerror(yylloc, parser, msg) parser_yyerror(parser, yylloc, msg) +#define yyerror0(msg) parser_yyerror(p, NULL, (msg)) +#define yyerror1(loc, msg) parser_yyerror(p, (loc), (msg)) +#define yyerror(yylloc, p, msg) parser_yyerror(p, yylloc, msg) #define token_flush(ptr) ((ptr)->lex.ptok = (ptr)->lex.pcur) -#define lex_strterm (parser->lex.strterm) -#define lex_state (parser->lex.state) -#define cond_stack (parser->cond_stack) -#define cmdarg_stack (parser->cmdarg_stack) -#define paren_nest (parser->lex.paren_nest) -#define lpar_beg (parser->lex.lpar_beg) -#define brace_nest (parser->lex.brace_nest) -#define in_def (parser->in_def) -#define in_class (parser->in_class) -#define in_main (parser->in_main) -#define in_defined (parser->in_defined) -#define tokenbuf (parser->tokenbuf) -#define tokidx (parser->tokidx) -#define toksiz (parser->toksiz) -#define tokline (parser->tokline) -#define lex_input (parser->lex.input) -#define lex_prevline (parser->lex.prevline) -#define lex_lastline (parser->lex.lastline) -#define lex_nextline (parser->lex.nextline) -#define lex_pbeg (parser->lex.pbeg) -#define lex_p (parser->lex.pcur) -#define lex_pend (parser->lex.pend) -#define heredoc_end (parser->heredoc_end) -#define heredoc_indent (parser->heredoc_indent) -#define heredoc_line_indent (parser->heredoc_line_indent) -#define command_start (parser->command_start) -#define lex_gets_ptr (parser->lex.gets_ptr) -#define lex_gets (parser->lex.gets) -#define lvtbl (parser->lvtbl) -#define ruby__end__seen (parser->ruby__end__seen) -#define ruby_sourceline (parser->ruby_sourceline) -#define ruby_sourcefile (parser->ruby_sourcefile) -#define ruby_sourcefile_string (parser->ruby_sourcefile_string) -#define current_enc (parser->enc) -#define current_arg (parser->cur_arg) -#define yydebug (parser->yydebug) +#define lex_strterm (p->lex.strterm) +#define lex_state (p->lex.state) +#define cond_stack (p->cond_stack) +#define cmdarg_stack (p->cmdarg_stack) +#define paren_nest (p->lex.paren_nest) +#define lpar_beg (p->lex.lpar_beg) +#define brace_nest (p->lex.brace_nest) +#define in_def (p->in_def) +#define in_class (p->in_class) +#define in_main (p->in_main) +#define in_defined (p->in_defined) +#define tokenbuf (p->tokenbuf) +#define tokidx (p->tokidx) +#define toksiz (p->toksiz) +#define tokline (p->tokline) +#define lex_input (p->lex.input) +#define lex_prevline (p->lex.prevline) +#define lex_lastline (p->lex.lastline) +#define lex_nextline (p->lex.nextline) +#define lex_pbeg (p->lex.pbeg) +#define lex_p (p->lex.pcur) +#define lex_pend (p->lex.pend) +#define heredoc_end (p->heredoc_end) +#define heredoc_indent (p->heredoc_indent) +#define heredoc_line_indent (p->heredoc_line_indent) +#define command_start (p->command_start) +#define lex_gets_ptr (p->lex.gets_ptr) +#define lex_gets (p->lex.gets) +#define lvtbl (p->lvtbl) +#define ruby__end__seen (p->ruby__end__seen) +#define ruby_sourceline (p->ruby_sourceline) +#define ruby_sourcefile (p->ruby_sourcefile) +#define ruby_sourcefile_string (p->ruby_sourcefile_string) +#define current_enc (p->enc) +#define current_arg (p->cur_arg) +#define yydebug (p->yydebug) #ifdef RIPPER #define compile_for_eval (0) #else -#define compile_for_eval (parser->base_block != 0 && !in_main) -#define ruby_eval_tree (parser->eval_tree) -#define ruby_eval_tree_begin (parser->eval_tree_begin) -#define ruby_debug_lines (parser->debug_lines) -#define ruby_coverage (parser->coverage) +#define compile_for_eval (p->base_block != 0 && !in_main) +#define ruby_eval_tree (p->eval_tree) +#define ruby_eval_tree_begin (p->eval_tree_begin) +#define ruby_debug_lines (p->debug_lines) +#define ruby_coverage (p->coverage) #endif #define tokp lex.ptok -#define token_column ((int)(parser->tokp - lex_pbeg)) +#define token_column ((int)(p->tokp - lex_pbeg)) #define CALL_Q_P(q) ((q) == TOKEN2VAL(tANDDOT)) #define NODE_CALL_Q(q) (CALL_Q_P(q) ? NODE_QCALL : NODE_CALL) @@ -348,29 +348,29 @@ static enum yytokentype yylex(YYSTYPE*, https://github.com/ruby/ruby/blob/trunk/parse.y#L348 #ifndef RIPPER static inline void -rb_discard_node_gen(struct parser_params *parser, NODE *n) +rb_discard_node_gen(struct parser_params *p, NODE *n) { - rb_ast_delete_node(parser->ast, n); + rb_ast_delete_node(p->ast, n); } -#define rb_discard_node(n) rb_discard_node_gen(parser, (n)) +#define rb_discard_node(n) rb_discard_node_gen(p, (n)) #endif static inline VALUE -add_mark_object_gen(struct parser_params *parser, VALUE obj) +add_mark_object_gen(struct parser_params *p, VALUE obj) { if (!SPECIAL_CONST_P(obj) #ifdef RIPPER && !RB_TYPE_P(obj, T_NODE) /* Ripper jumbles NODE objects and other objects... */ #endif ) { - rb_ast_add_mark_object(parser->ast, obj); + rb_ast_add_mark_object(p->ast, obj); } return obj; } -#define add_mark_object(obj) add_mark_object_gen(parser, (obj)) +#define add_mark_object(obj) add_mark_object_gen(p, (obj)) static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE, const rb_code_location_t*); -#define rb_node_newnode(type, a1, a2, a3, loc) node_newnode(parser, (type), (a1), (a2), (a3), (loc)) +#define rb_node_newnode(type, a1, a2, a3, loc) node_newnode(p, (type), (a1), (a2), (a3), (loc)) static NODE *nd_set_loc(NODE *nd, const YYLTYPE *loc); @@ -389,16 +389,16 @@ set_line_body(NODE *body, int line) https://github.com/ruby/ruby/blob/trunk/parse.y#L389 #define yyparse ruby_yyparse static NODE *cond_gen(struct parser_params*,NODE*,int,const YYLTYPE*); -#define cond(node,loc) cond_gen(parser, (node), FALSE, loc) -#define method_cond(node,loc) cond_gen(parser, (node), TRUE, loc) +#define cond(node,loc) cond_gen(p, (node), FALSE, loc) +#define method_cond(node,loc) cond_gen(p, (node), TRUE, loc) #define new_nil(loc) NEW_NIL(loc) static NODE *new_if_gen(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*); -#define new_if(cc,left,right,loc) new_if_gen(parser, (cc), (left), (right), (loc)) +#define new_if(cc,left,right,loc) new_if_gen(p, (cc), (left), (right), (loc)) static NODE *new_unless_gen(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*); -#define new_unless(cc,left,right,loc) new_unless_gen(parser, (cc), (left), (right), (loc)) +#define new_unless(cc,left,right,loc) new_unless_gen(p, (cc), (left), (right), (loc)) static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*); #define logop(id,node1,node2,op_loc,loc) \ - logop_gen(parser, ((id)==idAND||(id)==idANDOP)?NODE_AND:NODE_OR, \ + logop_gen(p, ((id)==idAND||(id)==idANDOP)?NODE_AND:NODE_OR, \ (node1), (node2), (op_loc), (loc)) static NODE *newline_node(NODE*); @@ -408,90 +408,90 @@ static int value_expr_gen(struct parser_ https://github.com/ruby/ruby/blob/trunk/parse.y#L408 static void void_expr_gen(struct parser_params*,NODE*); static NODE *remove_begin(NODE*); static NODE *remove_begin_all(NODE*); -#define value_expr(node) value_expr_gen(parser, (node) = remove_begin(node)) -#define void_expr0(node) void_expr_gen(parser, (node)) +#define value_expr(node) value_expr_gen(p, (node) = remove_begin(node)) +#define void_expr0(node) void_expr_gen(p, (node)) #define void_expr(node) void_expr0((node) = remove_begin(node)) static void void_stmts_gen(struct parser_params*,NODE*); -#define void_stmts(node) void_stmts_gen(parser, (node)) +#define void_stmts(node) void_stmts_gen(p, (node)) static void reduce_nodes_gen(struct parser_params*,NODE**); -#define reduce_nodes(n) reduce_nodes_gen(parser,(n)) +#define reduce_nodes(n) reduce_nodes_gen(p,(n)) static void block_dup_check_gen(struct parser_params*,NODE*,NODE*); -#define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2)) +#define block_dup_check(n1,n2) block_dup_check_gen(p,(n1),(n2)) static NODE *block_append_gen(struct parser_params*,NODE*,NODE*); -#define block_append(h,t) block_append_gen(parser,(h),(t)) +#define block_append(h,t) block_append_gen(p,(h),(t)) static NODE *list_append_gen(struct parser_params*,NODE*,NODE*); -#define list_append(l,i) list_append_gen(parser,(l),(i)) +#define list_append(l,i) list_append_gen(p,(l),(i)) static NODE *list_concat(NODE*,NODE*); static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define arg_append(h,t,loc) arg_append_gen(parser,(h),(t),(loc)) +#define arg_append(h,t,loc) arg_append_gen(p,(h),(t),(loc)) static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define arg_concat(h,t,loc) arg_concat_gen(parser,(h),(t),(loc)) +#define arg_concat(h,t,loc) arg_concat_gen(p,(h),(t),(loc)) static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define literal_concat(h,t,loc) literal_concat_gen(parser,(h),(t),(loc)) +#define literal_concat(h,t,loc) literal_concat_gen(p,(h),(t),(loc)) static int literal_concat0(struct parser_params *, VALUE, VALUE); static NODE *new_evstr_gen(struct parser_params*,NODE*,const YYLTYPE*); -#define new_evstr(n, loc) new_evstr_gen(parser,(n),(loc)) +#define new_evstr(n, loc) new_evstr_gen(p,(n),(loc)) static NODE *evstr2dstr_gen(struct parser_params*,NODE*); -#define evstr2dstr(n) evstr2dstr_gen(parser,(n)) +#define evstr2dstr(n) evstr2dstr_gen(p,(n)) static NODE *splat_array(NODE*); static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*,const YYLTYPE*,const YYLTYPE*); -#define call_bin_op(recv,id,arg1,op_loc,loc) call_bin_op_gen(parser, (recv),(id),(arg1),(op_loc),(loc)) +#define call_bin_op(recv,id,arg1,op_loc,loc) call_bin_op_gen(p, (recv),(id),(arg1),(op_loc),(loc)) static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID,const YYLTYPE*,const YYLTYPE*); -#define call_uni_op(recv,id,op_loc,loc) call_uni_op_gen(parser, (recv),(id),(op_loc),(loc)) -static NODE *new_qcall_gen(struct parser_params* parser, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc); -#define new_qcall(q,r,m,a,op_loc,loc) new_qcall_gen(parser,q,r,m,a,op_loc,loc) -#define new_command_qcall(q,r,m,a,op_loc,loc) new_qcall_gen(parser,q,r,m,a,op_loc,loc) -static NODE *new_command_gen(struct parser_params*parser, NODE *m, NODE *a) {m->nd_args = a; return m;} -#define new_command(m,a) new_command_gen(parser, m, a) -static NODE *method_add_block_gen(struct parser_params*parser, NODE *m, NODE *b, const YYLTYPE *loc) {b->nd_iter = m; b->nd_loc = *loc; return b;} -#define method_add_block(m,b,loc) method_add_block_gen(parser, m, b, loc) +#define call_uni_op(recv,id,op_loc,loc) call_uni_op_gen(p, (recv),(id),(op_loc),(loc)) +static NODE *new_qcall_gen(struct parser_params* p, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_loc, const YYLTYPE *loc); +#define new_qcall(q,r,m,a,op_loc,loc) new_qcall_gen(p,q,r,m,a,op_loc,loc) +#define new_command_qcall(q,r,m,a,op_loc,loc) new_qcall_gen(p,q,r,m,a,op_loc,loc) +static NODE *new_command_gen(struct parser_params*p, NODE *m, NODE *a) {m->nd_args = a; return m;} +#define new_command(m,a) new_command_gen(p, m, a) +static NODE *method_add_block_gen(struct parser_params*p, NODE *m, NODE *b, const YYLTYPE *loc) {b->nd_iter = m; b->nd_loc = *loc; return b;} +#define method_add_block(m,b,loc) method_add_block_gen(p, m, b, loc) static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*,const YYLTYPE*); -#define new_args(pre,opt,rest,post,tail,loc) new_args_gen(parser, (pre),(opt),(rest),(post),(tail),(loc)) +#define new_args(pre,opt,rest,post,tail,loc) new_args_gen(p, (pre),(opt),(rest),(post),(tail),(loc)) static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID,const YYLTYPE*); -#define new_args_tail(k,kr,b,loc) new_args_tail_gen(parser, (k),(kr),(b),(loc)) -static NODE *new_kw_arg_gen(struct parser_params *parser, NODE *k, const YYLTYPE *loc); -#define new_kw_arg(k,loc) new_kw_arg_gen(parser, k, loc) +#define new_args_tail(k,kr,b,loc) new_args_tail_gen(p, (k),(kr),(b),(loc)) +static NODE *new_kw_arg_gen(struct parser_params *p, NODE *k, const YYLTYPE *loc); +#define new_kw_arg(k,loc) new_kw_arg_gen(p, k, loc) static VALUE negate_lit_gen(struct parser_params*, VALUE); -#define negate_lit(lit) negate_lit_gen(parser, lit) +#define negate_lit(lit) negate_lit_gen(p, lit) static NODE *ret_args_gen(struct parser_params*,NODE*); -#define ret_args(node) ret_args_gen(parser, (node)) +#define ret_args(node) ret_args_gen(p, (node)) static NODE *arg_blk_pass(NODE*,NODE*); static NODE *new_yield_gen(struct parser_params*,NODE*,const YYLTYPE*); -#define new_yield(node,loc) new_yield_gen(parser, (node), (loc)) +#define new_yield(node,loc) new_yield_gen(p, (node), (loc)) static NODE *dsym_node_gen(struct parser_params*,NODE*,const YYLTYPE*); -#define dsym_node(node,loc) dsym_node_gen(parser, (node), (loc)) +#define dsym_node(node,loc) dsym_node_gen(p, (node), (loc)) static NODE *gettable_gen(struct parser_params*,ID,const YYLTYPE*); -#define gettable(id,loc) gettable_gen(parser,(id),(loc)) +#define gettable(id,loc) gettable_gen(p,(id),(loc)) static NODE *assignable_gen(struct parser_params*,ID,NODE*,const YYLTYPE*); -#define assignable(id,node,loc) assignable_gen(parser, (id), (node), (loc)) +#define assignable(id,node,loc) assignable_gen(p, (id), (node), (loc)) static NODE *aryset_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define aryset(node1,node2,loc) aryset_gen(parser, (node1), (node2), (loc)) +#define aryset(node1,node2,loc) aryset_gen(p, (node1), (node2), (loc)) static NODE *attrset_gen(struct parser_params*,NODE*,ID,ID,const YYLTYPE*); -#define attrset(node,q,id,loc) attrset_gen(parser, (node), (q), (id), (loc)) +#define attrset(node,q,id,loc) attrset_gen(p, (node), (q), (id), (loc)) static void rb_backref_error_gen(struct parser_params*,NODE*); -#define rb_backref_error(n) rb_backref_error_gen(parser,(n)) +#define rb_backref_error(n) rb_backref_error_gen(p,(n)) static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define node_assign(node1, node2, loc) node_assign_gen(parser, (node1), (node2), (loc)) +#define node_assign(node1, node2, loc) node_assign_gen(p, (node1), (node2), (loc)) -static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc); -#define new_op_assign(lhs, op, rhs, loc) new_op_assign_gen(parser, (lhs), (op), (rhs), (loc)) -static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc); -#define new_attr_op_assign(lhs, type, attr, op, rhs, loc) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs), (loc)) -static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc); -#define new_const_op_assign(lhs, op, rhs, loc) new_const_op_assign_gen(parser, (lhs), (op), (rhs), (loc)) +static NODE *new_op_assign_gen(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc); +#define new_op_assign(lhs, op, rhs, loc) new_op_assign_gen(p, (lhs), (op), (rhs), (loc)) +static NODE *new_attr_op_assign_gen(struct parser_params *p, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *loc); +#define new_attr_op_assign(lhs, type, attr, op, rhs, loc) new_attr_op_assign_gen(p, (lhs), (type), (attr), (op), (rhs), (loc)) +static NODE *new_const_op_assign_gen(struct parser_params *p, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *loc); +#define new_const_op_assign(lhs, op, rhs, loc) new_const_op_assign_gen(p, (lhs), (op), (rhs), (loc)) -static NODE *const_path_field_gen(struct parser_params *parser, NODE *head, ID mid, const YYLTYPE *loc); -#define const_path_field(w, n, loc) const_path_field_gen(parser, w, n, loc) +static NODE *const_path_field_gen(struct parser_params *p, NODE *head, ID mid, const YYLTYPE *loc); +#define const_path_field(w, n, loc) const_path_field_gen(p, w, n, loc) #define top_const_field(n,loc) NEW_COLON3(n,loc) -static NODE *const_decl_gen(struct parser_params *parser, NODE* path, const YYLTYPE *loc); -#define const_decl(path, loc) const_decl_gen(parser, path, loc) +static NODE *const_decl_gen(struct parser_params *p, NODE* path, const YYLTYPE *loc); +#define const_decl(path, loc) const_decl_gen(p, path, loc) #define var_field(n) (n) #define backref_assign_error(n, a, loc) (rb_backref_error(n), NEW_BEGIN(0, loc)) @@ -499,42 +499,42 @@ static NODE *const_decl_gen(struct parse https://github.com/ruby/ruby/blob/trunk/parse.y#L499 static NODE *opt_arg_append(NODE*, NODE*); static NODE *kwd_append(NODE*, NODE*); -static NODE *new_hash_gen(struct parser_params *parser, NODE *hash, const YYLTYPE *loc); -#define new_hash(hash, loc) new_hash_gen(parser, (hash), loc) +static NODE *new_hash_gen(struct parser_params *p, NODE *hash, const YYLTYPE *loc); +#define new_hash(hash, loc) new_hash_gen(p, (hash), loc) -static NODE *new_defined_gen(struct parser_params *parse (... truncated) -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/