* eval.c (call_trace_func): should not call trace function while

nobu · nobu · commit 742283385fc8 · 2002-09-22T12:52:18.000Z
compilation.

* eval.c (rb_call0): also inside c-func.

* parse.y (yycompile): ditto.

* ruby.c (require_libraries): preserve source file/line for each
  require.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2880 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
diff --git a/ChangeLog b/ChangeLog
@@ -1,3 +1,15 @@
+Sun Sep 22 21:49:42 2002  Nobuyoshi Nakada  <nobu.nokada@softhome.net>
+
+	* eval.c (call_trace_func): should not call trace function while
+	  compilation.
+
+	* eval.c (rb_call0): also inside c-func.
+
+	* parse.y (yycompile): ditto.
+
+	* ruby.c (require_libraries): preserve source file/line for each
+	  require.
+
 Sat Sep 21 22:23:41 2002  Nobuyoshi Nakada  <nobu.nokada@softhome.net>
 
 	* eval.c (rb_thread_raise): no need to save dead thread context.
diff --git a/eval.c b/eval.c
@@ -895,8 +895,7 @@ void
 ruby_set_current_source()
 {
     if (ruby_current_node) {
-	ruby_sourcefile = ruby_current_node->nd_file;
-	ruby_sourceline = nd_line(ruby_current_node);
+	SET_CURRENT_SOURCE();
     }
 }
 
@@ -2061,6 +2060,7 @@ call_trace_func(event, node, self, id, klass)
 
     if (!trace_func) return;
     if (tracing) return;
+    if (ruby_in_compile) return;
 
     node_save[0] = ruby_last_node;
     if (!(node_save[1] = ruby_current_node)) {
@@ -4501,17 +4501,21 @@ rb_call0(klass, recv, id, oid, argc, argv, body, nosuper)
 	    }
 	    if (trace_func) {
 		int state;
+		NODE *volatile node = ruby_current_node;
 
 		call_trace_func("c-call", ruby_current_node, recv, id, klass);
+		ruby_current_node = 0;
 		PUSH_TAG(PROT_FUNC);
 		if ((state = EXEC_TAG()) == 0) {
 		    result = call_cfunc(body->nd_cfnc, recv, len, argc, argv);
 		}
 		POP_TAG();
+		ruby_current_node = node;
 		call_trace_func("c-return", ruby_current_node, recv, id, klass);
 		if (state) JUMP_TAG(state);
 	    }
 	    else {
+		ruby_current_node = 0;
 		result = call_cfunc(body->nd_cfnc, recv, len, argc, argv);
 	    }
 	}
diff --git a/parse.y b/parse.y
@@ -2335,6 +2335,7 @@ yycompile(f, line)
     NODE *node = 0;
     struct RVarmap *vp, *vars = ruby_dyna_vars;
 
+    ruby_in_compile = 1;
     if (!compile_for_eval && rb_safe_level() == 0 &&
 	rb_const_defined(rb_cObject, rb_intern("SCRIPT_LINES__"))) {
 	VALUE hash, fname;
@@ -2365,7 +2366,6 @@ yycompile(f, line)
     quoted_term = -1;
     ruby_current_node = 0;
     ruby_sourcefile = rb_source_filename(f);
-    ruby_in_compile = 1;
     n = yyparse();
     ruby_debug_lines = 0;
     compile_for_eval = 0;
diff --git a/ruby.c b/ruby.c
@@ -321,19 +321,20 @@ require_libraries()
     ruby_eval_tree = ruby_eval_tree_begin = 0;
     req_list_last = 0;
     while (list) {
+	ruby_current_node = 0;
 	rb_require(list->name);
 	tmp = list->next;
 	free(list->name);
 	free(list);
 	list = tmp;
+	ruby_current_node = save[2];
+	ruby_set_current_source();
     }
     req_list_head.next = 0;
     ruby_eval_tree = save[0];
     ruby_eval_tree_begin = save[1];
-    ruby_current_node = save[2];
-    ruby_set_current_source();
-    ruby_current_node = 0;
     rb_gc_force_recycle((VALUE)save[2]);
+    ruby_current_node = 0;
 }
 
 static void

Original file line number	Diff line number	Diff line change
`@@ -895,8 +895,7 @@ void`
`895`	`895`	`ruby_set_current_source()`
`896`	`896`	`{`
`897`	`897`	`if (ruby_current_node) {`
`898`		`- ruby_sourcefile = ruby_current_node->nd_file;`
`899`		`- ruby_sourceline = nd_line(ruby_current_node);`
	`898`	`+ SET_CURRENT_SOURCE();`
`900`	`899`	`}`
`901`	`900`	`}`
`902`	`901`
`@@ -2061,6 +2060,7 @@ call_trace_func(event, node, self, id, klass)`
`2061`	`2060`
`2062`	`2061`	`if (!trace_func) return;`
`2063`	`2062`	`if (tracing) return;`
	`2063`	`+ if (ruby_in_compile) return;`
`2064`	`2064`
`2065`	`2065`	`node_save[0] = ruby_last_node;`
`2066`	`2066`	`if (!(node_save[1] = ruby_current_node)) {`
`@@ -4501,17 +4501,21 @@ rb_call0(klass, recv, id, oid, argc, argv, body, nosuper)`
`4501`	`4501`	`}`
`4502`	`4502`	`if (trace_func) {`
`4503`	`4503`	`int state;`
	`4504`	`+ NODE *volatile node = ruby_current_node;`
`4504`	`4505`
`4505`	`4506`	`call_trace_func("c-call", ruby_current_node, recv, id, klass);`
	`4507`	`+ ruby_current_node = 0;`
`4506`	`4508`	`PUSH_TAG(PROT_FUNC);`
`4507`	`4509`	`if ((state = EXEC_TAG()) == 0) {`
`4508`	`4510`	`result = call_cfunc(body->nd_cfnc, recv, len, argc, argv);`
`4509`	`4511`	`}`
`4510`	`4512`	`POP_TAG();`
	`4513`	`+ ruby_current_node = node;`
`4511`	`4514`	`call_trace_func("c-return", ruby_current_node, recv, id, klass);`
`4512`	`4515`	`if (state) JUMP_TAG(state);`
`4513`	`4516`	`}`
`4514`	`4517`	`else {`
	`4518`	`+ ruby_current_node = 0;`
`4515`	`4519`	`result = call_cfunc(body->nd_cfnc, recv, len, argc, argv);`
`4516`	`4520`	`}`
`4517`	`4521`	`}`