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

ruby-changes:48466

From: yui-knk <ko1@a...>
Date: Mon, 30 Oct 2017 22:36:26 +0900 (JST)
Subject: [ruby-changes:48466] yui-knk:r60580 (trunk): Store lineno on RNode

yui-knk	2017-10-30 22:36:20 +0900 (Mon, 30 Oct 2017)

  New Revision: 60580

  https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=60580

  Log:
    Store lineno on RNode
    
    * node.c (A_NODE_HEADER): Print lineno.
    
    * node.h (nd_column, nd_set_column): Store column
      number with 16-bit.
    * node.h (nd_lineno, nd_set_lineno): Define
      getter/setter macros for lineno of RNode.
    
    * parse.y : Set first lineno of tokens.
    
    Thanks to takeshinoda for review.

  Modified files:
    trunk/node.c
    trunk/node.h
    trunk/parse.y
Index: parse.y
===================================================================
--- parse.y	(revision 60579)
+++ parse.y	(revision 60580)
@@ -45,6 +45,24 @@ https://github.com/ruby/ruby/blob/trunk/parse.y#L45
 #define YYCALLOC(nelem, size)	rb_parser_calloc(parser, (nelem), (size))
 #define YYFREE(ptr)		rb_parser_free(parser, (ptr))
 #define YYFPRINTF		rb_parser_printf
+#define YYLLOC_DEFAULT(Current, Rhs, N)					\
+    do									\
+      if (N)								\
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   = 		\
+		ruby_sourceline;					\
+	  (Current).first_column = (Current).last_column = 		\
+		(int)(parser->tokp - lex_pbeg);				\
+	}								\
+    while (0)
+
 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 # define YY_LOCATION_PRINT(File, Loc) \
      rb_parser_printf(parser, "%d.%d-%d.%d", \
@@ -375,18 +393,18 @@ set_line_body(NODE *body, int line) https://github.com/ruby/ruby/blob/trunk/parse.y#L393
 static NODE* node_newnode(struct parser_params *, enum node_type, VALUE, VALUE, VALUE);
 #define rb_node_newnode(type, a1, a2, a3) node_newnode(parser, (type), (a1), (a2), (a3))
 
-static NODE *cond_gen(struct parser_params*,NODE*,int,int);
-#define cond(node,column) cond_gen(parser, (node), FALSE, column)
-#define method_cond(node,column) cond_gen(parser, (node), TRUE, column)
+static NODE *cond_gen(struct parser_params*,NODE*,int,YYLTYPE*);
+#define cond(node,location) cond_gen(parser, (node), FALSE, location)
+#define method_cond(node,location) cond_gen(parser, (node), TRUE, location)
 #define new_nil() NEW_NIL()
-static NODE *new_if_gen(struct parser_params*,NODE*,NODE*,NODE*,int);
-#define new_if(cc,left,right,column) new_if_gen(parser, (cc), (left), (right), (column))
-static NODE *new_unless_gen(struct parser_params*,NODE*,NODE*,NODE*,int);
-#define new_unless(cc,left,right,column) new_unless_gen(parser, (cc), (left), (right), (column))
-static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*,int);
-#define logop(id,node1,node2,column) \
+static NODE *new_if_gen(struct parser_params*,NODE*,NODE*,NODE*,YYLTYPE*);
+#define new_if(cc,left,right,location) new_if_gen(parser, (cc), (left), (right), (location))
+static NODE *new_unless_gen(struct parser_params*,NODE*,NODE*,NODE*,YYLTYPE*);
+#define new_unless(cc,left,right,location) new_unless_gen(parser, (cc), (left), (right), (location))
+static NODE *logop_gen(struct parser_params*,enum node_type,NODE*,NODE*,YYLTYPE*);
+#define logop(id,node1,node2,location) \
     logop_gen(parser, ((id)==idAND||(id)==idANDOP)?NODE_AND:NODE_OR, \
-	      (node1), (node2), (column))
+	      (node1), (node2), (location))
 
 static NODE *newline_node(NODE*);
 static void fixpos(NODE*,NODE*);
@@ -405,31 +423,31 @@ static void reduce_nodes_gen(struct pars https://github.com/ruby/ruby/blob/trunk/parse.y#L423
 static void block_dup_check_gen(struct parser_params*,NODE*,NODE*);
 #define block_dup_check(n1,n2) block_dup_check_gen(parser,(n1),(n2))
 
-static NODE *block_append_gen(struct parser_params*,NODE*,NODE*,int);
-#define block_append(h,t,column) block_append_gen(parser,(h),(t),(column))
-static NODE *list_append_gen(struct parser_params*,NODE*,NODE*,int);
-#define list_append(l,i,column) list_append_gen(parser,(l),(i),(column))
+static NODE *block_append_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define block_append(h,t,location) block_append_gen(parser,(h),(t),(location))
+static NODE *list_append_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define list_append(l,i,location) list_append_gen(parser,(l),(i),(location))
 static NODE *list_concat(NODE*,NODE*);
-static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*,int);
-#define arg_append(h,t,column) arg_append_gen(parser,(h),(t),(column))
-static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*,int);
-#define arg_concat(h,t,column) arg_concat_gen(parser,(h),(t),(column))
-static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*,int);
-#define literal_concat(h,t,column) literal_concat_gen(parser,(h),(t),(column))
+static NODE *arg_append_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define arg_append(h,t,location) arg_append_gen(parser,(h),(t),(location))
+static NODE *arg_concat_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define arg_concat(h,t,location) arg_concat_gen(parser,(h),(t),(location))
+static NODE *literal_concat_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define literal_concat(h,t,location) literal_concat_gen(parser,(h),(t),(location))
 static int literal_concat0(struct parser_params *, VALUE, VALUE);
-static NODE *new_evstr_gen(struct parser_params*,NODE*,int);
-#define new_evstr(n, column) new_evstr_gen(parser,(n),(column))
-static NODE *evstr2dstr_gen(struct parser_params*,NODE*,int);
-#define evstr2dstr(n,column) evstr2dstr_gen(parser,(n),(column))
+static NODE *new_evstr_gen(struct parser_params*,NODE*,YYLTYPE*);
+#define new_evstr(n, location) new_evstr_gen(parser,(n),(location))
+static NODE *evstr2dstr_gen(struct parser_params*,NODE*,YYLTYPE*);
+#define evstr2dstr(n,location) evstr2dstr_gen(parser,(n),(location))
 static NODE *splat_array(NODE*);
 
-static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*,int);
-#define call_bin_op(recv,id,arg1,column) call_bin_op_gen(parser, (recv),(id),(arg1),(column))
-static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID,int);
-#define call_uni_op(recv,id,column) call_uni_op_gen(parser, (recv),(id),(column))
-static NODE *new_qcall_gen(struct parser_params* parser, ID atype, NODE *recv, ID mid, NODE *args, int column);
-#define new_qcall(q,r,m,a,column) new_qcall_gen(parser,q,r,m,a,column)
-#define new_command_qcall(q,r,m,a,column) new_qcall_gen(parser,q,r,m,a,column)
+static NODE *call_bin_op_gen(struct parser_params*,NODE*,ID,NODE*,YYLTYPE*);
+#define call_bin_op(recv,id,arg1,location) call_bin_op_gen(parser, (recv),(id),(arg1),(location))
+static NODE *call_uni_op_gen(struct parser_params*,NODE*,ID,YYLTYPE*);
+#define call_uni_op(recv,id,location) call_uni_op_gen(parser, (recv),(id),(location))
+static NODE *new_qcall_gen(struct parser_params* parser, ID atype, NODE *recv, ID mid, NODE *args, YYLTYPE *location);
+#define new_qcall(q,r,m,a,location) new_qcall_gen(parser,q,r,m,a,location)
+#define new_command_qcall(q,r,m,a,location) new_qcall_gen(parser,q,r,m,a,location)
 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) {b->nd_iter = m; return b;}
@@ -437,136 +455,136 @@ static NODE *method_add_block_gen(struct https://github.com/ruby/ruby/blob/trunk/parse.y#L455
 
 static NODE *new_args_gen(struct parser_params*,NODE*,NODE*,ID,NODE*,NODE*);
 #define new_args(f,o,r,p,t) new_args_gen(parser, (f),(o),(r),(p),(t))
-static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID,int);
-#define new_args_tail(k,kr,b,column) new_args_tail_gen(parser, (k),(kr),(b),(column))
-static NODE *new_kw_arg_gen(struct parser_params *parser, NODE *k, int column);
-#define new_kw_arg(k,column) new_kw_arg_gen(parser, k, column)
+static NODE *new_args_tail_gen(struct parser_params*,NODE*,ID,ID,YYLTYPE*);
+#define new_args_tail(k,kr,b,location) new_args_tail_gen(parser, (k),(kr),(b),(location))
+static NODE *new_kw_arg_gen(struct parser_params *parser, NODE *k, YYLTYPE *location);
+#define new_kw_arg(k,location) new_kw_arg_gen(parser, k, location)
 
 static VALUE negate_lit_gen(struct parser_params*, VALUE);
 #define negate_lit(lit) negate_lit_gen(parser, lit)
 static NODE *ret_args_gen(struct parser_params*,NODE*);
 #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*,int);
-#define new_yield(node,column) new_yield_gen(parser, (node), (column))
-static NODE *dsym_node_gen(struct parser_params*,NODE*,int);
-#define dsym_node(node,column) dsym_node_gen(parser, (node), (column))
-
-static NODE *gettable_gen(struct parser_params*,ID,int);
-#define gettable(id,column) gettable_gen(parser,(id),(column))
-static NODE *assignable_gen(struct parser_params*,ID,NODE*,int);
-#define assignable(id,node,column) assignable_gen(parser, (id), (node), (column))
-
-static NODE *aryset_gen(struct parser_params*,NODE*,NODE*,int);
-#define aryset(node1,node2,column) aryset_gen(parser, (node1), (node2), (column))
-static NODE *attrset_gen(struct parser_params*,NODE*,ID,ID,int);
-#define attrset(node,q,id,column) attrset_gen(parser, (node), (q), (id), (column))
+static NODE *new_yield_gen(struct parser_params*,NODE*,YYLTYPE*);
+#define new_yield(node,location) new_yield_gen(parser, (node), (location))
+static NODE *dsym_node_gen(struct parser_params*,NODE*,YYLTYPE*);
+#define dsym_node(node,location) dsym_node_gen(parser, (node), (location))
+
+static NODE *gettable_gen(struct parser_params*,ID,YYLTYPE*);
+#define gettable(id,location) gettable_gen(parser,(id),(location))
+static NODE *assignable_gen(struct parser_params*,ID,NODE*,YYLTYPE*);
+#define assignable(id,node,location) assignable_gen(parser, (id), (node), (location))
+
+static NODE *aryset_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define aryset(node1,node2,location) aryset_gen(parser, (node1), (node2), (location))
+static NODE *attrset_gen(struct parser_params*,NODE*,ID,ID,YYLTYPE*);
+#define attrset(node,q,id,location) attrset_gen(parser, (node), (q), (id), (location))
 
 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*,int);
-#define node_assign(node1, node2, column) node_assign_gen(parser, (node1), (node2), (column))
+static NODE *node_assign_gen(struct parser_params*,NODE*,NODE*,YYLTYPE*);
+#define node_assign(node1, node2, location) node_assign_gen(parser, (node1), (node2), (location))
 
-static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, int column);
-#define new_op_assign(lhs, op, rhs, column) new_op_assign_gen(parser, (lhs), (op), (rhs), (column))
-static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, int column);
-#define new_attr_op_assign(lhs, type, attr, op, rhs, column) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs), (column))
-static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, int column);
-#define new_const_op_assign(lhs, op, rhs, column) new_const_op_assign_gen(parser, (lhs), (op), (rhs), (column))
+static NODE *new_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, YYLTYPE *location);
+#define new_op_assign(lhs, op, rhs, location) new_op_assign_gen(parser, (lhs), (op), (rhs), (location))
+static NODE *new_attr_op_assign_gen(struct parser_params *parser, NODE *lhs, ID atype, ID attr, ID op, NODE *rhs, YYLTYPE *location);
+#define new_attr_op_assign(lhs, type, attr, op, rhs, location) new_attr_op_assign_gen(parser, (lhs), (type), (attr), (op), (rhs), (location))
+static NODE *new_const_op_assign_gen(struct parser_params *parser, NODE *lhs, ID op, NODE *rhs, YYLTYPE *location);
+#define new_const_op_assign(lhs, op, rhs, location) new_const_op_assign_gen(parser, (lhs), (op), (rhs), (location))
 
-static NODE *const_path_field_gen(struct parser_params *parser, NODE *head, ID mid, int column);
-#define const_path_field(w, n, column) const_path_field_gen(parser, w, n, column)
+static NODE *const_path_field_gen(struct parser_params *parser, NODE *head, ID mid, YYLTYPE *location);
+#define const_path_field(w, n, location) const_path_field_gen(parser, w, n, location)
 #define top_const_field(n) NEW_COLON3(n)
-static NODE *const_decl_gen(struct parser_params *parser, NODE* path, int column);
-#define const_decl(path, column) const_decl_gen(parser, path, column)
+static NODE *const_decl_gen(struct parser_params *parser, NODE* path, YYLTYPE *location);
+#define const_decl(path, location) const_decl_gen(parser, path, location)
 
 #define var_field(n) (n)
-#define backref_assign_error(n, a, column) (rb_backref_error(n), new_begin(0, column))
+#define backref_assign_error(n, a, location) (rb_backref_error(n), new_begin(0, location))
 
 static NODE *kwd_append(NODE*, NODE*);
 
-static NODE *new_hash_gen(struct parser_params *parser, NODE *hash, int column);
-#define new_hash(hash, column) new_hash_gen(parser, (hash), column)
+static NODE *new_hash_gen(struct parser_params *parser, NODE *hash, YYLTYPE *location);
+#define new_hash(hash, location) new_hash_gen(parser, (hash), location)
 
-static NODE *new_defined_gen(struct parser_params *parser, NODE *expr, int column);
-#define new_defined(expr, column) new_defined_gen(parser, expr, column)
+static NODE *new_defined_gen(struct parser_params *parser, NODE *expr, YYLTYPE *location);
+#define new_defined(expr, location) new_defined_gen(parser, expr, location)
 
-static NODE *new_regexp_gen(struct parser_params *, NODE *, int, int);
-#define new_regexp(node, opt, column) new_regexp_gen(parser, node, opt, column)
+static NODE *new_regexp_gen(struct parser_params *, NODE *, int, YYLTYPE *);
+#define new_regexp(node, opt, location) new_regexp_gen(parser, node, opt, location)
 
-static NODE *new_lit_gen(struct parser_params *parser, VALUE sym, int column);
-#define new_lit(sym, column) new_lit_gen(parser, sym, column)
+static NODE *new_lit_gen(struct parser_params *parser, VALUE sym, YYLTYPE *location);
+#define new_lit(sym, location) new_lit_gen(parser, sym, location)
 
-static NODE *new_list_gen(struct parser_params *parser, NODE *item, int column);
-#define new_list(item, column) new_list_gen(parser, item, column)
+static NODE *new_list_gen(struct parser_params *parser, NODE *item, YYLTYPE *location);
+#define new_list(item, location) new_list_gen(parser, item, location)
 
-static NODE *new_str_gen(struct parser_params *parser, VALUE str, int column);
-#define new_str(s,column) new_str_gen(parser, s, column)
+static NODE *new_str_gen(struct parser_params *parser, VALUE str, YYLTYPE *location);
+#define new_str(s,location) new_str_gen(parser, s, location)
 
-static NODE *new_dvar_gen(struct parser_params *parser, ID id, int column);
-#define new_dvar(id, column) new_dvar_gen(parser, id, column)
+static NODE *new_dvar_gen(struct parser_params *parser, ID id, YYLTYPE *location);
+#define new_dvar(id, location) new_dvar_gen(parser, id, location)
 
-static NODE *new_resbody_gen(struct parser_params *parser, NODE *exc_list, NODE *stmt, NODE *rescue, int column);
-#define new_resbody(e,s,r,column) new_resbody_gen(parser, (e),(s),(r),(column))
+static NODE *new_resbody_gen(struct parser_params *parser, NODE *exc_list, NODE *stmt, NODE *rescue, YYLTYPE *location);
+#define new_resbody(e,s,r,location) new_resbody_gen(parser, (e),(s),(r),(location))
 
-static NODE *new_errinfo_gen(struct parser_params *parser, int column);
-#define new_errinfo(column) new_errinfo_gen(parser, column)
+static NODE *new_errinfo_gen(struct parser_params *parser, YYLTYPE *location);
+#define new_errinfo(location) new_errinfo_gen(parser, location)
 
-static NODE *new_call_gen(struct parser_params *parser, NODE *recv, ID mid, NODE *args, int column);
-#define new_call(recv,mid,args,column) new_call_gen(parser, recv,mid,args,column)
+static NODE *new_call_gen(struct parser_params *parser, NODE *recv, ID mid, NODE *args, YYLTYPE *location);
+#define new_call(recv,mid,args,location) new_call_gen(parser, recv,mid,args,location)
 
-static NODE *new_fcall_gen(struct parser_params *parser, ID mid, NODE *args, int column);
-#define new_fcall(mid,args,column) new_fcall_gen(parser, mid, args, column)
+static NODE *new_fcall_gen(struct parser_params *parser, ID mid, NODE *args, YYLTYPE *location);
+#define new_fcall(mid,args,location) new_fcall_gen(parser, mid, args, location)
 
-static NODE *new_for_gen(struct parser_params *parser, NODE *var, NODE *iter, NODE *body, int column);
-#define new_for(var,iter,body,column) new_for_gen(parser, var, iter, body, column)
+static NODE *new_for_gen(struct parser_params *parser, NODE *var, NODE *iter, NODE *body, YYLTYPE *location);
+#define new_for(var,iter,body,location) new_for_gen(parser, var, iter, body, location)
 
-static NODE *new_gvar_gen(struct parser_params *parser, ID id, int column);
-#define new_gvar(id, column) new_gvar_gen(parser, id, column)
+static NODE *new_gvar_gen(struct parser_params *parser, ID id, YYLTYPE *location);
+#define new_gvar(id, location) new_gvar_gen(parser, id, location)
 
-static NODE *new_lvar_gen(struct parser_params *parser, ID id, int column);
-#define new_lvar(id, column) new_lvar_gen(parser, id, column)
+static NODE *new_lvar_gen(struct parser_params *parser, ID id, YYLTYPE *location);
+#define new_lvar(id, location) new_lvar_gen(parser, id, location)
 
-static NODE *new_dstr_gen(struct parser_params *parser, VALUE str, int column);
-#define new_dstr(s, column) new_dstr_gen(parser, s, column)
+static NODE *new_dstr_gen(struct parser_params *parser, VALUE str, YYLTYPE *location);
+#define new_dstr(s, location) new_dstr_gen(parser, s, location)
 
-static NODE *new_rescue_gen(struct parser_params *parser, NODE *b, NODE *res, NODE *e, int column);
-#define new_rescue(b,res,e,column) new_rescue_gen(parser,b,res,e,column)
+static NODE *new_rescue_gen(struct parser_params *parser, NODE *b, NODE *res, NODE *e, YYLTYPE *location);
+#define new_rescue(b,res,e,location) new_rescue_gen(parser,b,res,e,location)
 
-static NODE *new_undef_gen(struct parser_params *parser, NODE *i, int column);
-#define new_undef(i, column) new_undef_gen(parser, i, column)
+static NODE *new_undef_gen(struct parser_params *parser, NODE *i, YYLTYPE *location);
+#define new_undef(i, location) new_undef_gen(parser, i, location)
 
-static NODE *new_zarray_gen(struct parser_params *parser, int column);
-#define new_zarray(column) new_zarray_gen(parser, column)
+static NODE *new_zarray_gen(struct parser_params *parser, YYLTYPE *location);
+#define new_zarray(location) new_zarray_gen(parser, location)
 
-static NODE *new_ivar_gen(struct parser_params *parser, ID id, int column);
-#define new_ivar(id, column) new_ivar_gen(parser,id,column)
+static NODE *new_ivar_gen(struct parser_params *parser, ID id, YYLTYPE *location);
+#define new_ivar(id, location) new_ivar_gen(parser,id,location)
 
-static NODE *new_postarg_gen(struct parser_params *parser, NODE *i, NODE *v, int column);
-#define new_postarg(i,v,column) new_postarg_gen(parser,i,v,column)
+static NODE *new_postarg_gen(struct parser_params *parser, NODE *i, NODE *v, YYLTYPE *location);
+#define new_postarg(i,v,location) new_postarg_gen(parser,i,v,location)
 
-static NODE *new_cdecl_gen(struct parser_params *parser, ID v, NODE *val, NODE *path, int column);
-#define new_cdecl(v,val,path,column) new_cdecl_gen(parser,v,val,path,column)
+static NODE *new_cdecl_gen(struct parser_params *parser, ID v, NODE *val, NODE *path, YYLTYPE *location);
+#define new_cdecl(v,val,path,location) new_cdecl_gen(parser,v,val,path,location)
 
-static NODE *new_scope_gen(struct parser_params *parser, NODE *a, NODE *b, int column);
-#define new_scope(a,b,column) new_scope_gen(parser,a,b,column)
+static NODE *new_scope_gen(struct parser_params *parser, NODE *a, NODE *b, YYLTYPE *location);
+#define new_scope(a,b,location) new_scope_gen(parser,a,b,location)
 
-static NODE *new_begin_gen(struct parser_params *parser, NODE *b, int column);
-#define new_begin(b,column) new_begin_gen(parser,b,column)
+static NODE *new_begin_gen(struct parser_params *parser, NODE *b, YYLTYPE *location);
 (... truncated)

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/

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