* Add coverage measurement constant COVERAGE__. This constant is not

  for casual use.  Usage: (1) assign {} to COVERAGE__, (2) require or
  load Ruby source file, and (3) COVERAGE__["sourcefilepath"] will
  return an array whose elements represent number of executions per
  line of source code.

* vm_core.h: add field of coverage array to iseq.

* iseq.c (prepare_iseq_build): ditto.

* insns.def (trace): update coverage array.

* parse.y (coverage): create and initialize coverage array.

* compile.h (ADD_TRACE): add trace instruction to update covearge
  array.

* thread.c (clear_coverage): delete coverage array when forking.
  Otherwise, double count of coverage may occur.

* lib/coverage.rb: sample coverage measurement tool.

* error.c: distinguish explicitly between parse_in_eval and
  mild_compile_error.

* load.c: ditto.

* vm_eval.c: ditto.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17781 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

11 files changed, 200 insertions, 18 deletions

diff --git a/ChangeLog b/ChangeLog
index 3234836be3..2011d0c059 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,34 @@
+Wed Jul  2 01:53:40 2008  Yusuke Endoh  <mame@tsg.ne.jp>
+
+	* Add coverage measurement constant COVERAGE__.  This constant is not
+	  for casual use.  Usage: (1) assign {} to COVERAGE__, (2) require or
+	  load Ruby source file, and (3) COVERAGE__["sourcefilepath"] will
+	  return an array whose elements represent number of executions per
+	  line of source code.
+
+	* vm_core.h: add field of coverage array to iseq.
+
+	* iseq.c (prepare_iseq_build): ditto.
+
+	* insns.def (trace): update coverage array.
+
+	* parse.y (coverage): create and initialize coverage array.
+
+	* compile.h (ADD_TRACE): add trace instruction to update covearge
+	  array.
+
+	* thread.c (clear_coverage): delete coverage array when forking.
+	  Otherwise, double count of coverage may occur.
+
+	* lib/coverage.rb: sample coverage measurement tool.
+
+	* error.c: distinguish explicitly between parse_in_eval and
+	  mild_compile_error.
+
+	* load.c: ditto.
+
+	* vm_eval.c: ditto.
+
 Tue Jul  1 21:32:43 2008  Yusuke Endoh  <mame@tsg.ne.jp>
 
 	* lib/test/unit/ui/console/testrunner.rb: prevent destructive
diff --git a/compile.h b/compile.h
index c7688949e5..73a2567468 100644
--- a/compile.h
+++ b/compile.h
@@ -163,9 +163,16 @@ PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
                          (VALUE)id, (VALUE)argc, (VALUE)block, (VALUE)flag))
 
 #define ADD_TRACE(seq, line, event) \
-  if (iseq->compile_data->option->trace_instruction) { \
-      ADD_INSN1(seq, line, trace, INT2FIX(event)); \
-  }
+  do { \
+      VALUE coverage = Qfalse; \
+      if ((event) == RUBY_EVENT_LINE && iseq->coverage && RARRAY_PTR(iseq->coverage)[(line) - 1] == Qnil) { \
+          RARRAY_PTR(iseq->coverage)[(line) - 1] = INT2FIX(0); \
+          coverage = iseq->coverage; \
+      } \
+      if (iseq->compile_data->option->trace_instruction || coverage) { \
+          ADD_INSN2(seq, line, trace, INT2FIX(event), coverage); \
+      } \
+  }while(0);
 
 /* add label */
 #define ADD_LABEL(seq, label) \
diff --git a/error.c b/error.c
index 2210a705af..9bf5c27fbd 100644
--- a/error.c
+++ b/error.c
@@ -1546,7 +1546,7 @@ err_append(const char *s)
     rb_thread_t *th = GET_THREAD();
     VALUE err = th->errinfo;
 
-    if (th->parse_in_eval) {
+    if (th->mild_compile_error) {
 	if (!RTEST(err)) {
 	    err = rb_exc_new2(rb_eSyntaxError, s);
 	    th->errinfo = err;
diff --git a/insns.def b/insns.def
index 161dc38e2e..96023a4adf 100644
--- a/insns.def
+++ b/insns.def
@@ -847,11 +847,21 @@ defined
  */
 DEFINE_INSN
 trace
-(rb_num_t nf)
+(rb_num_t nf, VALUE coverage)
 ()
 ()
 {
     rb_event_flag_t flag = nf;
+    if (coverage) {
+	long line = rb_sourceline() - 1;
+	if (RARRAY_PTR(coverage)[line] == Qnil) {
+	    rb_bug("bug");
+	}
+	long count = FIX2LONG(RARRAY_PTR(coverage)[line]) + 1;
+	if (POSFIXABLE(count)) {
+	    RARRAY_PTR(coverage)[line] = LONG2FIX(count);
+	}
+    }
     EXEC_EVENT_HOOK(th, flag, GET_SELF(), 0, 0 /* TODO: id, klass */);
 }
 
diff --git a/iseq.c b/iseq.c
index b2a3237f0b..8339073eb9 100644
--- a/iseq.c
+++ b/iseq.c
@@ -81,6 +81,7 @@ iseq_mark(void *ptr)
 	RUBY_MARK_UNLESS_NULL(iseq->filename);
 	RUBY_MARK_UNLESS_NULL((VALUE)iseq->cref_stack);
 	RUBY_MARK_UNLESS_NULL(iseq->klass);
+	RUBY_MARK_UNLESS_NULL(iseq->coverage);
 /* 	RUBY_MARK_UNLESS_NULL((VALUE)iseq->node); */
 /*	RUBY_MARK_UNLESS_NULL(iseq->cached_special_block); */
 
@@ -191,6 +192,17 @@ prepare_iseq_build(rb_iseq_t *iseq,
 
     set_relation(iseq, parent);
 
+    iseq->coverage = Qfalse;
+    if (!GET_THREAD()->parse_in_eval) {
+	if (rb_const_defined_at(rb_cObject, rb_intern("COVERAGE__"))) {
+	    VALUE hash = rb_const_get_at(rb_cObject, rb_intern("COVERAGE__"));
+	    if (TYPE(hash) == T_HASH) {
+		iseq->coverage = rb_hash_aref(hash, filename);
+		if (NIL_P(iseq->coverage)) iseq->coverage = Qfalse;
+	    }
+	}
+    }
+
     return Qtrue;
 }
 
diff --git a/lib/coverage.rb b/lib/coverage.rb
new file mode 100644
index 0000000000..f72473ece3
--- /dev/null
+++ b/lib/coverage.rb
@@ -0,0 +1,57 @@
+COVERAGE__ ||= {}
+ext = ENV["COVERUBY_EXT"] || ".cov"
+accum = ENV["COVERUBY_ACCUM"]
+accum = !accum || accum == "" || !(%w(f n 0).include?(accum[0]))
+pwd = Dir.pwd
+
+at_exit do
+  Dir.chdir(pwd) do
+    COVERAGE__.each do |sfile, covs|
+      cfile = sfile + ext
+
+      writable = proc do |f|
+        File.writable?(f) || File.writable?(File.dirname(f))
+      end
+      unless writable[cfile]
+        cfile = cfile.gsub(File.PATH_SEPARATOR, "#")
+        next unless writable[cfile]
+      end
+
+      readlines = proc do |f|
+        File.read(f).force_encoding("ASCII-8BIT").lines.to_a
+      end
+
+      sources = (readlines[sfile] rescue [])
+
+      pcovs = []
+      if accum
+        pcovs = (readlines[cfile] rescue []).map.with_index do |line, idx|
+          if line[/^\s*(?:(#####)|(\d+)|-):\s*\d+:(.*)$/n]
+            cov, line = $1 ? 0 : ($2 ? $2.to_i : nil), $3
+            if !sources[idx] || sources[idx].chomp != line.chomp
+              warn("source file changed, ignoring: `#{ cfile }'")
+              break []
+            end
+            cov
+          else
+	    p line
+            warn("coverage file corrupted, ignoring: #{ cfile }")
+            break []
+          end
+        end
+        unless pcovs.empty? || pcovs.size == covs.size
+          warn("coverage file changed, ignoring: `#{ cfile }'")
+          pcovs = []
+        end
+      end
+
+      open(cfile, "w") do |out|
+        covs.zip(sources, pcovs).each_with_index do |(cov, line, pcov), idx|
+          cov += pcov || 0 if cov
+          cov = (cov ? (cov == 0 ? "#####" : cov.to_s) : "-").rjust(9)
+          out.puts("%s:% 5d:%s" % [cov, idx + 1, line])
+        end
+      end
+    end
+  end
+end
diff --git a/load.c b/load.c
index 88db04bdfd..b9c8a3743d 100644
--- a/load.c
+++ b/load.c
@@ -240,8 +240,8 @@ rb_load(VALUE fname, int wrap)
     rb_thread_t *th = GET_THREAD();
     volatile VALUE wrapper = th->top_wrapper;
     volatile VALUE self = th->top_self;
-    volatile int parse_in_eval;
     volatile int loaded = Qfalse;
+    volatile int mild_compile_error;
 #ifndef __GNUC__
     rb_thread_t *volatile th0 = th;
 #endif
@@ -267,19 +267,19 @@ rb_load(VALUE fname, int wrap)
 	rb_extend_object(th->top_self, th->top_wrapper);
     }
 
-    parse_in_eval = th->parse_in_eval;
+    mild_compile_error = th->mild_compile_error;
     PUSH_TAG();
     state = EXEC_TAG();
     if (state == 0) {
 	NODE *node;
 	VALUE iseq;
 
-	th->parse_in_eval++;
+	th->mild_compile_error++;
 	node = (NODE *)rb_load_file(RSTRING_PTR(fname));
-	th->parse_in_eval--;
 	loaded = Qtrue;
 	iseq = rb_iseq_new(node, rb_str_new2("<top (required)>"),
 			   fname, Qfalse, ISEQ_TYPE_TOP);
+	th->mild_compile_error--;
 	rb_iseq_eval(iseq);
     }
     POP_TAG();
@@ -288,7 +288,7 @@ rb_load(VALUE fname, int wrap)
     th = th0;
     fname = RB_GC_GUARD(fname);
 #endif
-    th->parse_in_eval = parse_in_eval;
+    th->mild_compile_error = mild_compile_error;
     th->top_self = self;
     th->top_wrapper = wrapper;
 
diff --git a/parse.y b/parse.y
index 4b42870a0c..54d728a1d0 100644
--- a/parse.y
+++ b/parse.y
@@ -249,6 +249,7 @@ struct parser_params {
     NODE *parser_eval_tree_begin;
     NODE *parser_eval_tree;
     VALUE debug_lines;
+    VALUE coverage;
     int nerr;
 #else
     /* Ripper only */
@@ -322,6 +323,7 @@ static int parser_yyerror(struct parser_params*, const char*);
 #define ruby_eval_tree		(parser->parser_eval_tree)
 #define ruby_eval_tree_begin	(parser->parser_eval_tree_begin)
 #define ruby_debug_lines	(parser->debug_lines)
+#define ruby_coverage		(parser->coverage)
 #endif
 
 static int yylex(void*, void*);
@@ -4668,6 +4670,32 @@ debug_lines(const char *f)
 }
 
 static VALUE
+coverage(const char *f, int n)
+{
+    if (rb_const_defined_at(rb_cObject, rb_intern("COVERAGE__"))) {
+	VALUE hash = rb_const_get_at(rb_cObject, rb_intern("COVERAGE__"));
+	if (TYPE(hash) == T_HASH) {
+	    VALUE fname = rb_str_new2(f);
+	    VALUE lines = rb_ary_new2(n);
+	    int i;
+	    for (i = 0; i < n; i++) RARRAY_PTR(lines)[i] = Qnil;
+	    RARRAY(lines)->len = n;
+	    rb_hash_aset(hash, fname, lines);
+	    return lines;
+	}
+    }
+    return 0;
+}
+
+static int
+e_option_supplied(struct parser_params *parser)
+{
+    if (strcmp(ruby_sourcefile, "-e") == 0)
+	return Qtrue;
+    return Qfalse;
+}
+
+static VALUE
 yycompile0(VALUE arg, int tracing)
 {
     int n;
@@ -4683,11 +4711,19 @@ yycompile0(VALUE arg, int tracing)
 		rb_ary_push(ruby_debug_lines, str);
 	    } while (--n);
 	}
+
+	if (!e_option_supplied(parser)) {
+	    ruby_coverage = coverage(ruby_sourcefile, ruby_sourceline);
+	}
     }
 
     parser_prepare(parser);
     n = yyparse((void*)parser);
+    if (ruby_coverage) {
+	rb_ary_freeze(ruby_coverage);
+    }
     ruby_debug_lines = 0;
+    ruby_coverage = 0;
     compile_for_eval = 0;
 
     lex_strterm = 0;
@@ -4750,6 +4786,9 @@ lex_getline(struct parser_params *parser)
     if (ruby_debug_lines && !NIL_P(line)) {
 	rb_ary_push(ruby_debug_lines, line);
     }
+    if (ruby_coverage && !NIL_P(line)) {
+	rb_ary_push(ruby_coverage, Qnil);
+    }
 #endif
     return line;
 }
@@ -8126,14 +8165,6 @@ assign_in_cond(struct parser_params *parser, NODE *node)
     return 1;
 }
 
-static int
-e_option_supplied(struct parser_params *parser)
-{
-    if (strcmp(ruby_sourcefile, "-e") == 0)
-	return Qtrue;
-    return Qfalse;
-}
-
 static void
 warn_unless_e_option(struct parser_params *parser, NODE *node, const char *str)
 {
diff --git a/thread.c b/thread.c
index 10c4e3ea73..bac4715ca2 100644
--- a/thread.c
+++ b/thread.c
@@ -2100,6 +2100,31 @@ rb_thread_start_timer_thread(void)
 }
 
 static int
+clear_coverage_i(st_data_t key, st_data_t val, st_data_t dummy)
+{
+    int i;
+    VALUE lines = (VALUE)val;
+
+    for (i = 0; i < RARRAY_LEN(lines); i++) {
+	if (RARRAY_PTR(lines)[i] != Qnil) {
+	    RARRAY_PTR(lines)[i] = INT2FIX(0);
+	}
+    }
+    return ST_CONTINUE;
+}
+
+static void
+clear_coverage(void)
+{
+    if (rb_const_defined_at(rb_cObject, rb_intern("COVERAGE__"))) {
+	VALUE hash = rb_const_get_at(rb_cObject, rb_intern("COVERAGE__"));
+	if (TYPE(hash) == T_HASH) {
+	    st_foreach(RHASH_TBL(hash), clear_coverage_i, 0);
+	}
+    }
+}
+
+static int
 terminate_atfork_i(st_data_t key, st_data_t val, rb_thread_t *current_th)
 {
     VALUE thval = key;
@@ -2124,6 +2149,7 @@ rb_thread_atfork(void)
     st_clear(vm->living_threads);
     st_insert(vm->living_threads, thval, (st_data_t) th->thread_id);
     vm->sleeper = 0;
+    clear_coverage();
     rb_reset_random_seed();
 }
 
@@ -2152,6 +2178,7 @@ rb_thread_atfork_before_exec(void)
     st_clear(vm->living_threads);
     st_insert(vm->living_threads, thval, (st_data_t) th->thread_id);
     vm->sleeper = 0;
+    clear_coverage();
 }
 
 struct thgroup {
diff --git a/vm_core.h b/vm_core.h
index 0614e660dc..700c33f224 100644
--- a/vm_core.h
+++ b/vm_core.h
@@ -201,6 +201,7 @@ struct rb_iseq_struct {
     VALUE *iseq_encoded; /* encoded iseq */
     unsigned long iseq_size;
     VALUE mark_ary;	/* Array: includes operands which should be GC marked */
+    VALUE coverage;     /* coverage array */
 
     /* insn info, must be freed */
     struct iseq_insn_info_entry *insn_info_table;
@@ -448,6 +449,7 @@ struct rb_thread_struct
     struct rb_vm_trap_tag *trap_tag;
 
     int parse_in_eval;
+    int mild_compile_error;
 
     /* storage */
     st_table *local_storage;
diff --git a/vm_eval.c b/vm_eval.c
index ef84121ef3..d89f7e972a 100644
--- a/vm_eval.c
+++ b/vm_eval.c
@@ -667,6 +667,7 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char
     rb_env_t *env = NULL;
     rb_block_t block;
     volatile int parse_in_eval;
+    volatile int mild_compile_error;
 
     if (file == 0) {
 	file = rb_sourcefile();
@@ -674,6 +675,7 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char
     }
 
     parse_in_eval = th->parse_in_eval;
+    mild_compile_error = th->mild_compile_error;
     PUSH_TAG();
     if ((state = EXEC_TAG()) == 0) {
 	rb_iseq_t *iseq;
@@ -708,7 +710,9 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char
 
 	/* make eval iseq */
 	th->parse_in_eval++;
+	th->mild_compile_error++;
 	iseqval = rb_iseq_compile(src, rb_str_new2(file), INT2FIX(line));
+	th->mild_compile_error--;
 	th->parse_in_eval--;
 
 	vm_set_eval_stack(th, iseqval, cref);
@@ -730,6 +734,7 @@ eval_string_with_cref(VALUE self, VALUE src, VALUE scope, NODE *cref, const char
 	result = vm_eval_body(th);
     }
     POP_TAG();
+    th->mild_compile_error = mild_compile_error;
     th->parse_in_eval = parse_in_eval;
 
     if (state) {