ruby-changes:49606
From: mame <ko1@a...>
Date: Tue, 9 Jan 2018 17:45:44 +0900 (JST)
Subject: [ruby-changes:49606] mame:r61721 (trunk): Rename code_range to code_location
mame 2018-01-09 17:45:35 +0900 (Tue, 09 Jan 2018) New Revision: 61721 https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=61721 Log: Rename code_range to code_location Because the name "code_range" is ambiguous with encoding's. Abbreviations ("crange", and "cr") are also renamed to "loc". The traditional "code_location" (a pair of lineno and column) is renamed to "code_position". Abbreviations are also renamed (first_loc to beg_pos, and last_loc to end_pos). Modified files: trunk/compile.c trunk/iseq.c trunk/iseq.h trunk/node.c trunk/node.h trunk/parse.y trunk/thread.c trunk/vm_core.h Index: parse.y =================================================================== --- parse.y (revision 61720) +++ parse.y (revision 61721) @@ -17,7 +17,7 @@ https://github.com/ruby/ruby/blob/trunk/parse.y#L17 #define YYDEBUG 1 #define YYERROR_VERBOSE 1 #define YYSTACK_USE_ALLOCA 0 -#define YYLTYPE rb_code_range_t +#define YYLTYPE rb_code_location_t #define YYLTYPE_IS_DECLARED 1 #include "ruby/ruby.h" @@ -44,27 +44,27 @@ https://github.com/ruby/ruby/blob/trunk/parse.y#L44 #define YYCALLOC(nelem, size) rb_parser_calloc(parser, (nelem), (size)) #define YYFREE(ptr) rb_parser_free(parser, (ptr)) #define YYFPRINTF rb_parser_printf -#define YY_LOCATION_PRINT(File, Loc) \ +#define YY_LOCATION_PRINT(File, loc) \ rb_parser_printf(parser, "%d.%d-%d.%d", \ - (Loc).first_loc.lineno, (Loc).first_loc.column,\ - (Loc).last_loc.lineno, (Loc).last_loc.column) + (loc).beg_pos.lineno, (loc).beg_pos.column,\ + (loc).end_pos.lineno, (loc).end_pos.column) #define YYLLOC_DEFAULT(Current, Rhs, N) \ do \ if (N) \ { \ - (Current).first_loc = YYRHSLOC(Rhs, 1).first_loc; \ - (Current).last_loc = YYRHSLOC(Rhs, N).last_loc; \ + (Current).beg_pos = YYRHSLOC(Rhs, 1).beg_pos; \ + (Current).end_pos = YYRHSLOC(Rhs, N).end_pos; \ } \ else \ RUBY_SET_YYLLOC_OF_NONE(Current); \ while (0) #define RUBY_SET_YYLLOC_FROM_STRTERM_HEREDOC(Current) \ - rb_parser_set_code_range_from_strterm_heredoc(parser, &lex_strterm->u.heredoc, &(Current)) + rb_parser_set_location_from_strterm_heredoc(parser, &lex_strterm->u.heredoc, &(Current)) #define RUBY_SET_YYLLOC_OF_NONE(Current) \ - rb_parser_set_code_range_of_none(parser, &(Current)) + rb_parser_set_location_of_none(parser, &(Current)) #define RUBY_SET_YYLLOC(Current) \ - rb_parser_set_code_range(parser, &(Current)) + rb_parser_set_location(parser, &(Current)) enum lex_state_bits { EXPR_BEG_bit, /* ignore newline, +/- is a sign. */ @@ -116,7 +116,7 @@ enum lex_state_e { https://github.com/ruby/ruby/blob/trunk/parse.y#L116 typedef VALUE stack_type; -static const rb_code_range_t NULL_LOC = { {0, -1}, {0, -1} }; +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 BITSTACK_PUSH(stack, n) (((stack) = ((stack)<<1)|((n)&1)), SHOW_BITSTACK(stack, #stack"(push)")) @@ -282,7 +282,7 @@ struct parser_params { https://github.com/ruby/ruby/blob/trunk/parse.y#L282 static int parser_yyerror(struct parser_params*, const YYLTYPE *yylloc, const char*); #define yyerror0(msg) parser_yyerror(parser, NULL, (msg)) -#define yyerror1(cr, msg) parser_yyerror(parser, (cr), (msg)) +#define yyerror1(loc, msg) parser_yyerror(parser, (loc), (msg)) #define yyerror(yylloc, parser, msg) parser_yyerror(parser, yylloc, msg) #define token_flush(p) ((p)->lex.ptok = (p)->lex.pcur) @@ -337,7 +337,7 @@ static int parser_yyerror(struct parser_ https://github.com/ruby/ruby/blob/trunk/parse.y#L337 #define CALL_Q_P(q) ((q) == TOKEN2VAL(tANDDOT)) #define NODE_CALL_Q(q) (CALL_Q_P(q) ? NODE_QCALL : NODE_CALL) -#define NEW_QCALL(q,r,m,a,cr) NEW_NODE(NODE_CALL_Q(q),r,m,a,cr) +#define NEW_QCALL(q,r,m,a,loc) NEW_NODE(NODE_CALL_Q(q),r,m,a,loc) #define lambda_beginning_p() (lpar_beg && lpar_beg == paren_nest) @@ -366,10 +366,10 @@ add_mark_object_gen(struct parser_params https://github.com/ruby/ruby/blob/trunk/parse.y#L366 } #define add_mark_object(obj) add_mark_object_gen(parser, (obj)) -static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE, const rb_code_range_t*); -#define rb_node_newnode(type, a1, a2, a3, cr) node_newnode(parser, (type), (a1), (a2), (a3), (cr)) +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)) -static NODE *nd_set_crange(NODE *nd, const YYLTYPE *cr); +static NODE *nd_set_loc(NODE *nd, const YYLTYPE *loc); #ifndef RIPPER static inline void @@ -386,17 +386,17 @@ set_line_body(NODE *body, int line) https://github.com/ruby/ruby/blob/trunk/parse.y#L386 #define yyparse ruby_yyparse static NODE *cond_gen(struct parser_params*,NODE*,int,const YYLTYPE*); -#define cond(node,cr) cond_gen(parser, (node), FALSE, cr) -#define method_cond(node,cr) cond_gen(parser, (node), TRUE, cr) -#define new_nil(cr) NEW_NIL(cr) +#define cond(node,loc) cond_gen(parser, (node), FALSE, loc) +#define method_cond(node,loc) cond_gen(parser, (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,cr) new_if_gen(parser, (cc), (left), (right), (cr)) +#define new_if(cc,left,right,loc) new_if_gen(parser, (cc), (left), (right), (loc)) static NODE *new_unless_gen(struct parser_params*,NODE*,NODE*,NODE*,const YYLTYPE*); -#define new_unless(cc,left,right,cr) new_unless_gen(parser, (cc), (left), (right), (cr)) +#define new_unless(cc,left,right,loc) new_unless_gen(parser, (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_cr,cr) \ +#define logop(id,node1,node2,op_loc,loc) \ logop_gen(parser, ((id)==idAND||(id)==idANDOP)?NODE_AND:NODE_OR, \ - (node1), (node2), (op_cr), (cr)) + (node1), (node2), (op_loc), (loc)) static NODE *newline_node(NODE*); static void fixpos(NODE*,NODE*); @@ -421,36 +421,36 @@ static NODE *list_append_gen(struct pars https://github.com/ruby/ruby/blob/trunk/parse.y#L421 #define list_append(l,i) list_append_gen(parser,(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,cr) arg_append_gen(parser,(h),(t),(cr)) +#define arg_append(h,t,loc) arg_append_gen(parser,(h),(t),(loc)) static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define arg_concat(h,t,cr) arg_concat_gen(parser,(h),(t),(cr)) +#define arg_concat(h,t,loc) arg_concat_gen(parser,(h),(t),(loc)) static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define literal_concat(h,t,cr) literal_concat_gen(parser,(h),(t),(cr)) +#define literal_concat(h,t,loc) literal_concat_gen(parser,(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, cr) new_evstr_gen(parser,(n),(cr)) +#define new_evstr(n, loc) new_evstr_gen(parser,(n),(loc)) static NODE *evstr2dstr_gen(struct parser_params*,NODE*); #define evstr2dstr(n) evstr2dstr_gen(parser,(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_cr,cr) call_bin_op_gen(parser, (recv),(id),(arg1),(op_cr),(cr)) +#define call_bin_op(recv,id,arg1,op_loc,loc) call_bin_op_gen(parser, (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_cr,cr) call_uni_op_gen(parser, (recv),(id),(op_cr),(cr)) -static NODE *new_qcall_gen(struct parser_params* parser, ID atype, NODE *recv, ID mid, NODE *args, const YYLTYPE *op_cr, const YYLTYPE *cr); -#define new_qcall(q,r,m,a,op_cr,cr) new_qcall_gen(parser,q,r,m,a,op_cr,cr) -#define new_command_qcall(q,r,m,a,op_cr,cr) new_qcall_gen(parser,q,r,m,a,op_cr,cr) +#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 *cr) {b->nd_iter = m; b->nd_crange = *cr; return b;} -#define method_add_block(m,b,cr) method_add_block_gen(parser, m, b, cr) +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) static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*,const YYLTYPE*); -#define new_args(f,o,r,p,t,cr) new_args_gen(parser, (f),(o),(r),(p),(t),(cr)) +#define new_args(f,o,r,p,t,loc) new_args_gen(parser, (f),(o),(r),(p),(t),(loc)) static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID,const YYLTYPE*); -#define new_args_tail(k,kr,b,cr) new_args_tail_gen(parser, (k),(kr),(b),(cr)) -static NODE *new_kw_arg_gen(struct parser_params *parser, NODE *k, const YYLTYPE *cr); -#define new_kw_arg(k,cr) new_kw_arg_gen(parser, k, cr) +#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) static VALUE negate_lit_gen(struct parser_params*, VALUE); #define negate_lit(lit) negate_lit_gen(parser, lit) @@ -458,65 +458,65 @@ static NODE *ret_args_gen(struct parser_ https://github.com/ruby/ruby/blob/trunk/parse.y#L458 #define ret_args(node) ret_args_gen(parser, (node)) static NODE *arg_blk_pass(NODE*,NODE*); static NODE *new_yield_gen(struct parser_params*,NODE*,const YYLTYPE*); -#define new_yield(node,cr) new_yield_gen(parser, (node), (cr)) +#define new_yield(node,loc) new_yield_gen(parser, (node), (loc)) static NODE *dsym_node_gen(struct parser_params*,NODE*,const YYLTYPE*); -#define dsym_node(node,cr) dsym_node_gen(parser, (node), (cr)) +#define dsym_node(node,loc) dsym_node_gen(parser, (node), (loc)) static NODE *gettable_gen(struct parser_params*,ID,const YYLTYPE*); -#define gettable(id,cr) gettable_gen(parser,(id),(cr)) +#define gettable(id,loc) gettable_gen(parser,(id),(loc)) static NODE *assignable_gen(struct parser_params*,ID,NODE*,const YYLTYPE*); -#define assignable(id,node,cr) assignable_gen(parser, (id), (node), (cr)) +#define assignable(id,node,loc) assignable_gen(parser, (id), (node), (loc)) static NODE *aryset_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define aryset(node1,node2,cr) aryset_gen(parser, (node1), (node2), (cr)) +#define aryset(node1,node2,loc) aryset_gen(parser, (node1), (node2), (loc)) static NODE *attrset_gen(struct parser_params*,NODE*,ID,ID,const YYLTYPE*); -#define attrset(node,q,id,cr) attrset_gen(parser, (node), (q), (id), (cr)) +#define attrset(node,q,id,loc) attrset_gen(parser, (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)) static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*); -#define node_assign(node1, node2, cr) node_assign_gen(parser, (node1), (node2), (cr)) +#define node_assign(node1, node2, loc) node_assign_gen(parser, (node1), (node2), (loc)) -static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *cr); -#define new_op_assign(lhs, op, rhs, cr) new_op_assign_gen(parser, (lhs), (op), (rhs), (cr)) -static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, const YYLTYPE *cr); -#define new_attr_op_assign(lhs, type, attr, op, rhs, cr) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs), (cr)) -static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, const YYLTYPE *cr); -#define new_const_op_assign(lhs, op, rhs, cr) new_const_op_assign_gen(parser, (lhs), (op), (rhs), (cr)) - -static NODE *const_path_field_gen(struct parser_params *parser, NODE *head, ID mid, const YYLTYPE *cr); -#define const_path_field(w, n, cr) const_path_field_gen(parser, w, n, cr) -#define top_const_field(n,cr) NEW_COLON3(n,cr) -static NODE *const_decl_gen(struct parser_params *parser, NODE* path, const YYLTYPE *cr); -#define const_decl(path, cr) const_decl_gen(parser, path, cr) +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 *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) +#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) #define var_field(n) (n) -#define backref_assign_error(n, a, cr) (rb_backref_error(n), NEW_BEGIN(0, cr)) +#define backref_assign_error(n, a, loc) (rb_backref_error(n), NEW_BEGIN(0, loc)) 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 *cr); -#define new_hash(hash, cr) new_hash_gen(parser, (hash), cr) +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_defined_gen(struct parser_params *parser, NODE *expr, const YYLTYPE *cr); -#define new_defined(expr, cr) new_defined_gen(parser, expr, cr) +static NODE *new_defined_gen(struct parser_params *parser, NODE *expr, const YYLTYPE *loc); +#define new_defined(expr, loc) new_defined_gen(parser, expr, loc) static NODE *new_regexp_gen(struct parser_params *, NODE *, int, const YYLTYPE *); -#define new_regexp(node, opt, cr) new_regexp_gen(parser, node, opt, cr) +#define new_regexp(node, opt, loc) new_regexp_gen(parser, node, opt, loc) -#define make_array(ary, cr) ((ary) ? (nd_set_crange(ary, cr), ary) : NEW_ZARRAY(cr)) +#define make_array(ary, loc) ((ary) ? (nd_set_loc(ary, loc), ary) : NEW_ZARRAY(loc)) -static NODE *new_xstring_gen(struct parser_params *, NODE *, const YYLTYPE *cr); -#define new_xstring(node, cr) new_xstring_gen(parser, node, cr) +static NODE *new_xstring_gen(struct parser_params *, NODE *, const YYLTYPE *loc); +#define new_xstring(node, loc) new_xstring_gen(parser, node, loc) #define new_string1(str) (str) -static NODE *new_body_gen(struct parser_params *parser, NODE *param, NODE *stmt, const YYLTYPE *cr); -#define new_brace_body(param, stmt, cr) new_body_gen(parser, param, stmt, cr) -#define new_do_body(param, stmt, cr) new_body_gen(parser, param, stmt, cr) +static NODE *new_body_gen(struct parser_params *parser, NODE *param, NODE *stmt, const YYLTYPE *loc); +#define new_brace_body(param, stmt, loc) new_body_gen(parser, param, stmt, loc) +#define new_do_body(param, stmt, loc) new_body_gen(parser, param, stmt, loc) static NODE *match_op_gen(struct parser_params*,NODE*,NODE*,const YYLTYPE*,const YYLTYPE*); -#define match_op(node1,node2,op_cr,cr) match_op_gen(parser, (node1), (node2), (op_cr), (cr)) +#define match_op(node1,node2,op_loc,loc) match_op_gen(parser, (node1), (node2), (op_loc), (loc)) static ID *local_tbl_gen(struct parser_params*); #define local_tbl() local_tbl_gen(parser) @@ -527,8 +527,8 @@ static void reg_fragment_setenc_gen(stru https://github.com/ruby/ruby/blob/trunk/parse.y#L527 #define reg_fragment_setenc(str,options) reg_fragment_setenc_gen(parser, (str), (options)) static int reg_fragment_check_gen(struct parser_params*, VALUE, int); #define reg_fragment_check(str,options) reg_fragment_check_gen(parser, (str), (options)) -static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, const YYLTYPE *cr); -#define reg_named_capture_assign(regexp,cr) reg_named_capture_assign_gen(parser,(regexp),cr) +static NODE *reg_named_capture_assign_gen(struct parser_params* parser, VALUE regexp, const YYLTYPE *loc); +#define reg_named_capture_assign(regexp,loc) reg_named_capture_assign_gen(parser,(regexp),loc) static NODE *parser_heredoc_dedent(struct parser_params*,NODE*); # define heredoc_dedent(str) parser_heredoc_dedent(parser, (str)) @@ -562,48 +562,48 @@ static ID ripper_get_id(VALUE); https://github.com/ruby/ruby/blob/trunk/parse.y#L562 static VALUE ripper_get_value(VALUE); #define get_value(val) ripper_get_value(val) static VALUE assignable_gen(struct parser_params*,VALUE); -#define assignable(lhs,node,cr) assignable_gen(parser, (lhs)) +#define assignable(lhs,node,loc) assignable_gen(parser, (lhs)) static int id_is_var_gen(struct parser_params *parser, ID id); #define id_is_var(id) id_is_var_gen(parser, (id)) -#define method_cond(node,cr) (node) -#define call_bin_op(recv,id,arg1,op_cr,cr) dispatch3(binary, (recv), STATIC_ID2SYM(id), (arg1)) -#define match_op(node1,node2,op_cr,cr) call_bin_op((node1), idEqTilde, (node2), op_cr, cr) -#define call_uni_op(recv,id,op_cr,cr) dispatch2(unary, STATIC_ID2SYM(id), (recv)) -#define logop(id,node1,node2,op_cr,cr) call_bin_op((node1), (id), (node2), op_cr, cr) -#define node_assign(node1, node2, cr) dispatch2(assign, (node1), (node2)) +#define method_cond(node,loc) (node) +#define call_bin_op(recv,id,arg1,op_loc,loc) dispatch3(binary, (recv), STATIC_ID2SYM(id), (arg1)) +#define match_op(node1,node2,op_loc,loc) call_bin_op((node1), idEqTilde, (node2), op_loc, loc) +#define call_uni_op(recv,id,op_loc,loc) dispatch2(unary, STATIC_ID2SYM(id), (recv)) +#define logop(id,node1,node2,op_loc,loc) call_bin_op((node1), (id), (node2), op_loc, loc) +#define node_assign(node1, node2, loc) dispatch2(assign, (node1), (node2)) static VALUE new_qcall_gen(struct parser_params *parser, VALUE q, VALUE r, VALUE m, VALUE a); -#define new_qcall(q,r,m,a,op_cr,cr) new_qcall_gen(parser, (r), (q), (m), (a)) -#define new_command_qcall(q,r,m,a,op_cr,cr) dispatch4(command_call, (r), (q), (m), (a)) +#define new_qcall(q,r,m,a,op_loc,loc) new_qcall_gen(parser, (r), (q), (m), (a)) +#define new_command_qcall(q,r,m,a,op_loc,loc) dispatch4(command_call, (r), (q), (m), (a)) #define new_command(m,a) dispatch2(command, (m), (a)); -#define new_nil(cr) Qnil +#define new_nil(loc) Qnil static VALUE new_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE op, VALUE rhs); -#define new_op_assign(lhs, op, rhs, cr) new_op_assign_gen(parser, (lhs), (op), (rhs)) +#define new_op_assign(lhs, op, rhs, loc) new_op_assign_gen(parser, (lhs), (op), (rhs)) static VALUE new_attr_op_assign_gen(struct parser_params *parser, VALUE lhs, VALUE type, VALUE attr, VALUE op, VALUE rhs); -#define new_attr_op_assign(lhs, type, attr, op, rhs, cr) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs)) -#define new_const_op_assign(lhs, op, rhs, cr) new_op_assign(lhs, op, rhs, cr) +#define new_attr_op_assign(lhs, type, attr, op, rhs, loc) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs)) +#define new_const_op_assign(lhs, op, rhs, loc) new_op_assign(lhs, op, rhs, loc) static VALUE new_regexp_gen(struct parse (... truncated) -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/