[前][次][番号順一覧][スレッド一覧]

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/

[前][次][番号順一覧][スレッド一覧]