mack 0.8.1 → 0.8.2

data/lib/gems/rcov-0.8.1.2.0/lib/rcov/lowlevel.rb

@@ -0,0 +1,147 @@
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+#
+# See LEGAL and LICENSE for licensing information.
+
+require 'rcov/version'
+
+module Rcov
+
+  # RCOV__ performs the low-level tracing of the execution, gathering code
+  # coverage information in the process. The C core made available through the
+  # rcovrt extension will be used if possible. Otherwise the functionality
+  # will be emulated using set_trace_func, but this is very expensive and
+  # will fail if other libraries (e.g. breakpoint) change the trace_func.
+  #
+  # Do not use this module; it is very low-level and subject to frequent
+  # changes. Rcov::CodeCoverageAnalyzer offers a much more convenient and
+  # stable interface.
+module RCOV__
+  COVER = {}
+  CALLSITES = {}
+  DEFSITES = {}
+  pure_ruby_impl_needed = true
+  unless defined? $rcov_do_not_use_rcovrt 
+    begin
+      require 'rcovrt'
+      abi = [0,0,0]
+      begin
+        abi = RCOV__.ABI
+        raise if abi[0] != RCOVRT_ABI[0] || abi[1] < RCOVRT_ABI[1]
+        pure_ruby_impl_needed = false
+      rescue
+        $stderr.puts <<-EOF
+The rcovrt extension I found was built for a different version of rcov.
+The required ABI is:              #{RCOVRT_ABI.join(".")}
+Your current rcovrt extension is: #{abi.join(".")}
+
+Please delete rcovrt.{so,bundle,dll,...} and install the required one.
+        EOF
+        raise LoadError
+      end
+    rescue LoadError
+      $stderr.puts <<-EOF
+
+Since the rcovrt extension couldn't be loaded, rcov will run in pure-Ruby
+mode, which is about two orders of magnitude slower.
+
+If you're on win32, you can find a pre-built extension (usable with recent
+One Click Installer and mswin32 builds) at http://eigenclass.org/hiki.rb?rcov .
+
+      EOF
+    end
+  end
+
+  if pure_ruby_impl_needed
+    methods = %w[install_coverage_hook remove_coverage_hook reset_coverage 
+                 install_callsite_hook remove_callsite_hook reset_callsite 
+                 generate_coverage_info generate_callsite_info]
+    sklass = class << self; self end
+    (methods & sklass.instance_methods).each do |meth|
+      sklass.class_eval{ remove_method meth }
+    end
+    
+    @coverage_hook_activated = @callsite_hook_activated = false
+
+    def self.install_coverage_hook # :nodoc:
+      install_common_hook
+      @coverage_hook_activated = true
+    end
+    
+    def self.install_callsite_hook # :nodoc:
+      install_common_hook
+      @callsite_hook_activated = true
+    end
+    
+    def self.install_common_hook # :nodoc:
+      set_trace_func lambda {|event, file, line, id, binding, klass|
+        next unless SCRIPT_LINES__.has_key? file
+        case event
+        when 'call'
+          if @callsite_hook_activated
+            receiver = eval("self", binding)
+            klass = class << klass; self end unless klass === receiver
+            begin
+              DEFSITES[[klass.to_s, id.to_s]] = [file, line]
+            rescue Exception
+            end
+            caller_arr = self.format_backtrace_array(caller[1,1])
+            begin
+              hash = CALLSITES[[klass.to_s, id.to_s]] ||= {}
+              hash[caller_arr] ||= 0
+              hash[caller_arr] += 1
+              #puts "#{event} #{file} #{line} #{klass.inspect} " +
+              #     "#{klass.object_id} #{id} #{eval('self', binding)}"
+            rescue Exception
+            end
+          end
+        when 'c-call', 'c-return', 'class'
+          return
+        end
+        if @coverage_hook_activated
+          COVER[file] ||= Array.new(SCRIPT_LINES__[file].size, 0)
+          COVER[file][line - 1] ||= 0
+          COVER[file][line - 1] += 1
+        end
+      }
+    end
+
+    def self.remove_coverage_hook # :nodoc:
+      @coverage_hook_activated = false
+      set_trace_func(nil) if !@callsite_hook_activated
+    end
+    
+    def self.remove_callsite_hook # :nodoc:
+      @callsite_hook_activated = false
+      set_trace_func(nil) if !@coverage_hook_activated
+    end
+
+    def self.reset_coverage # :nodoc:
+      COVER.replace({})
+    end
+
+    def self.reset_callsite # :nodoc:
+      CALLSITES.replace({})
+      DEFSITES.replace({})
+    end
+
+    def self.generate_coverage_info # :nodoc:
+      Marshal.load(Marshal.dump(COVER))
+    end
+
+    def self.generate_callsite_info # :nodoc:
+      [CALLSITES, DEFSITES]
+    end
+
+    def self.format_backtrace_array(backtrace)
+      backtrace.map do |line|
+        md = /^([^:]*)(?::(\d+)(?::in `(.*)'))?/.match(line)
+        raise "Bad backtrace format" unless md
+        [nil, md[3] ? md[3].to_sym : nil, md[1], (md[2] || '').to_i]
+      end
+    end
+  end
+end # RCOV__
+
+end # Rcov
+
+# vi: set sw=2:

data/lib/gems/rcov-0.8.1.2.0/lib/rcov/rant.rb

@@ -0,0 +1,87 @@
+
+require 'rant/rantlib'
+
+module Rant          # :nodoc:
+  module Generators  # :nodoc:
+  class Rcov         # :nodoc:
+    def self.rant_gen(app, ch, args, &block)
+      if !args || args.empty?
+        self.new(app, ch, &block)
+      elsif args.size == 1
+        name, pre = app.normalize_task_arg(args.first, ch)
+        self.new(app, ch, name, pre, &block)
+      else
+        app.abort_at(ch,
+                     "Rcov takes only one additional argument, " +
+                     "which should be like one given to the `task' command.")
+      end
+    end
+
+    attr_accessor :verbose
+    attr_accessor :libs
+    attr_accessor :test_dirs
+    attr_accessor :pattern
+    attr_accessor :test_files
+    attr_accessor :rcov_opts
+    # Directory where to put the generated XHTML reports
+    attr_accessor :output_dir
+
+    def initialize(app, cinf, name = :rcov, prerequisites = [], &block)
+      @rac = app
+      @name = name
+      @pre = prerequisites
+      #@block = block
+      @verbose = nil
+      cf = cinf[:file]
+      @libs = []
+      libdir = File.join(File.dirname(File.expand_path(cf)), 'lib')
+      @libs << libdir if test(?d, libdir)
+      @rcov_opts = ["--text-report"]
+      @test_dirs = []
+      @pattern = nil
+      @test_files = nil
+      yield self if block_given?
+      @pattern = "test*.rb" if @pattern.nil? && @test_files.nil?
+      @output_dir ||= "coverage"
+
+      @pre ||= []
+      # define the task
+      app.task(:__caller__ => cinf, @name => @pre) { |t|
+        args = []
+        if @libs && !@libs.empty?
+          args << "-I#{@libs.join File::PATH_SEPARATOR}"
+        end
+        if rcov_path = ENV['RCOVPATH'] 
+          args << rcov_path
+        else
+          args << "-S" << "rcov"
+        end
+        args.concat rcov_opts
+        args << "-o" << @output_dir
+        if test(?d, "test")
+          @test_dirs << "test" 
+        elsif test(?d, "tests")
+          @test_dirs << "tests"
+        end
+        args.concat filelist
+        app.context.sys.ruby args
+      }
+    end
+    
+    def filelist
+      return @rac.sys[@rac.var['TEST']] if @rac.var['TEST']
+      filelist = @test_files || []
+      if filelist.empty?
+        if @test_dirs && !@test_dirs.empty?
+          @test_dirs.each { |dir|
+            filelist.concat(@rac.sys[File.join(dir, @pattern)])
+          }
+        else
+          filelist.concat(@rac.sys[@pattern]) if @pattern
+        end
+      end
+      filelist
+    end
+  end	# class Rcov
+  end   # module Generators
+end	# module Rant

data/lib/gems/rcov-0.8.1.2.0/lib/rcov/rcovtask.rb

@@ -0,0 +1,156 @@
+#!/usr/bin/env ruby
+
+# Define a task library for performing code coverage analysis of unit tests
+# using rcov.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Rcov
+
+  # Create a task that runs a set of tests through rcov, generating code
+  # coverage reports.
+  #
+  # Example:
+  #   
+  #   require 'rcov/rcovtask'
+  #   
+  #   Rcov::RcovTask.new do |t|
+  #     t.libs << "test"
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.verbose = true
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "RCOVOPTS=options" command line option,
+  # then the given options are passed to rcov.
+  #
+  # If rake is invoked with a "RCOVPATH=path/to/rcov" command line option,
+  # then the given rcov executable will be used; otherwise the one in your
+  # PATH will be used.
+  #
+  # Examples:
+  #
+  #   rake rcov                           # run tests normally
+  #   rake rcov TEST=just_one_file.rb     # run just one test file.
+  #   rake rcov RCOVOPTS="-p"             # run in profile mode
+  #   rake rcov RCOVOPTS="-T"             # generate text report
+  #
+  class RcovTask < Rake::TaskLib
+
+    # Name of test task. (default is :rcov)
+    attr_accessor :name
+
+    # List of directories to added to $LOAD_PATH before running the
+    # tests. (default is 'lib')
+    attr_accessor :libs
+
+    # True if verbose test output desired. (default is false)
+    attr_accessor :verbose
+
+    # Request that the tests be run with the warning flag set.
+    # E.g. warning=true implies "ruby -w" used to run the tests.
+    attr_accessor :warning
+
+    # Glob pattern to match test files. (default is 'test/test*.rb')
+    attr_accessor :pattern
+    
+    # Array of commandline options to pass to ruby when running the rcov loader.
+    attr_accessor :ruby_opts
+
+    # Array of commandline options to pass to rcov. An explicit
+    # RCOVOPTS=opts on the command line will override this. (default
+    # is <tt>["--text-report"]</tt>)
+    attr_accessor :rcov_opts
+
+    # Output directory for the XHTML report.
+    attr_accessor :output_dir
+
+    # Explicitly define the list of test files to be included in a
+    # test.  +list+ is expected to be an array of file names (a
+    # FileList is acceptable).  If both +pattern+ and +test_files+ are
+    # used, then the list of test files is the union of the two.
+    def test_files=(list)
+      @test_files = list
+    end
+
+    # Create a testing task.
+    def initialize(name=:rcov)
+      @name = name
+      @libs = ["lib"]
+      @pattern = nil
+      @test_files = nil
+      @verbose = false
+      @warning = false
+      @rcov_opts = ["--text-report"]
+      @ruby_opts = []
+      @output_dir = "coverage"
+      yield self if block_given?
+      @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil?
+      define
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      actual_name = Hash === name ? name.keys.first : name
+      unless Rake.application.last_comment
+        desc "Analyze code coverage with tests" + 
+          (@name==:rcov ? "" : " for #{actual_name}")
+      end
+      task @name do
+	run_code = ''
+	RakeFileUtils.verbose(@verbose) do
+	  run_code =
+	    case rcov_path
+	    when nil, ''
+              "-S rcov"
+            else %!"#{rcov_path}"!
+	    end
+          ruby_opts = @ruby_opts.clone
+          ruby_opts.push( "-I#{lib_path}" )
+          ruby_opts.push run_code
+	  ruby_opts.push( "-w" ) if @warning
+	  ruby ruby_opts.join(" ") + " " + option_list +
+            %[ -o "#{@output_dir}" ] +
+	    file_list.collect { |fn| %["#{fn}"] }.join(' ')
+	end
+      end
+
+      desc "Remove rcov products for #{actual_name}"
+      task paste("clobber_", actual_name) do
+	rm_r @output_dir rescue nil
+      end
+
+      clobber_task = paste("clobber_", actual_name)
+      task :clobber => [clobber_task]
+
+      task actual_name => clobber_task
+      self
+    end
+
+    def rcov_path # :nodoc:
+      ENV['RCOVPATH']
+    end
+
+    def option_list # :nodoc:
+      ENV['RCOVOPTS'] || @rcov_opts.join(" ") || ""
+    end
+
+    def file_list # :nodoc:
+      if ENV['TEST']
+	FileList[ ENV['TEST'] ]
+      else
+	result = []
+	result += @test_files.to_a if @test_files
+	result += FileList[ @pattern ].to_a if @pattern
+	FileList[result]
+      end
+    end
+  end
+end
+

data/lib/gems/rcov-0.8.1.2.0/lib/rcov/report.rb

@@ -0,0 +1,1236 @@
+# rcov Copyright (c) 2004-2006 Mauricio Fernandez <mfp@acm.org>
+# See LEGAL and LICENSE for additional licensing information.
+
+require 'pathname'
+module Rcov
+
+# Try to fix bugs in the REXML shipped with Ruby 1.8.6
+# They affect Mac OSX 10.5.1 users and motivates endless bug reports.
+begin 
+    require 'rexml/formatters/transitive'
+    require 'rexml/formatter/pretty'
+rescue LoadError
+end
+
+if RUBY_VERSION == "1.8.6" && defined? REXML::Formatters::Transitive
+    class REXML::Document
+        remove_method :write rescue nil
+        def write( output=$stdout, indent=-1, trans=false, ie_hack=false )
+            if xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
+                output = Output.new( output, xml_decl.encoding )
+            end
+            formatter = if indent > -1
+                #if trans
+                    REXML::Formatters::Transitive.new( indent )
+                #else
+                #    REXML::Formatters::Pretty.new( indent, ie_hack )
+                #end
+            else
+                REXML::Formatters::Default.new( ie_hack )
+            end
+            formatter.write( self, output )
+        end
+    end
+
+    class REXML::Formatters::Transitive
+        remove_method :write_element rescue nil
+        def write_element( node, output )
+            output << "<#{node.expanded_name}"
+
+            node.attributes.each_attribute do |attr|
+                output << " "
+                attr.write( output )
+            end unless node.attributes.empty?
+
+            if node.children.empty?
+                output << "/>" 
+            else
+                output << ">"
+                # If compact and all children are text, and if the formatted output
+                # is less than the specified width, then try to print everything on
+                # one line
+                skip = false
+                @level += @indentation
+                node.children.each { |child|
+                    write( child, output )
+                }
+                @level -= @indentation
+                output << "</#{node.expanded_name}>"
+            end
+            output << "\n"
+            output << ' '*@level
+        end
+    end
+end
+
+class Formatter # :nodoc:
+    require 'pathname'
+    ignore_files = [
+        /\A#{Regexp.escape(Pathname.new(Config::CONFIG["libdir"]).cleanpath.to_s)}/,
+        /\btc_[^.]*.rb/,
+        /_test\.rb\z/,
+        /\btest\//,
+        /\bvendor\//,
+        /\A#{Regexp.escape(__FILE__)}\z/]
+    DEFAULT_OPTS = {:ignore => ignore_files, :sort => :name, :sort_reverse => false,
+                    :output_threshold => 101, :dont_ignore => [], 
+                    :callsite_analyzer => nil, :comments_run_by_default => false}
+    def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        @files = {}
+        @ignore_files = options[:ignore]
+        @dont_ignore_files = options[:dont_ignore]
+        @sort_criterium = case options[:sort]
+            when :loc : lambda{|fname, finfo| finfo.num_code_lines}
+            when :coverage : lambda{|fname, finfo| finfo.code_coverage}
+            else lambda{|fname, finfo| fname}
+        end
+        @sort_reverse = options[:sort_reverse]
+        @output_threshold = options[:output_threshold]
+        @callsite_analyzer = options[:callsite_analyzer]
+        @comments_run_by_default = options[:comments_run_by_default]
+        @callsite_index = nil
+
+        @mangle_filename = Hash.new{|h,base|
+            h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".html"
+        }
+    end
+
+    def add_file(filename, lines, coverage, counts)
+        old_filename = filename
+        filename = normalize_filename(filename)
+        SCRIPT_LINES__[filename] = SCRIPT_LINES__[old_filename]
+        if @ignore_files.any?{|x| x === filename} && 
+           !@dont_ignore_files.any?{|x| x === filename}
+            return nil
+        end
+        if @files[filename]
+            @files[filename].merge(lines, coverage, counts)
+        else
+            @files[filename] = FileStatistics.new(filename, lines, counts, 
+                                                  @comments_run_by_default)
+        end
+    end
+
+    def normalize_filename(filename)
+        File.expand_path(filename).gsub(/^#{Regexp.escape(Dir.getwd)}\//, '')
+    end
+
+    def mangle_filename(base)
+        @mangle_filename[base]
+    end
+
+    def each_file_pair_sorted(&b)
+        return sorted_file_pairs unless block_given?
+        sorted_file_pairs.each(&b)
+    end
+
+    def sorted_file_pairs
+        pairs = @files.sort_by do |fname, finfo|
+            @sort_criterium.call(fname, finfo)
+        end.select{|_, finfo| 100 * finfo.code_coverage < @output_threshold}
+        @sort_reverse ? pairs.reverse : pairs
+    end
+
+    def total_coverage
+        lines = 0
+        total = 0.0
+        @files.each do |k,f| 
+            total += f.num_lines * f.total_coverage 
+            lines += f.num_lines 
+        end
+        return 0 if lines == 0
+        total / lines
+    end
+
+    def code_coverage
+        lines = 0
+        total = 0.0
+        @files.each do |k,f| 
+            total += f.num_code_lines * f.code_coverage 
+            lines += f.num_code_lines 
+        end
+        return 0 if lines == 0
+        total / lines
+    end
+
+    def num_code_lines
+        lines = 0
+        @files.each{|k, f| lines += f.num_code_lines }
+        lines
+    end
+
+    def num_lines
+        lines = 0
+        @files.each{|k, f| lines += f.num_lines }
+        lines
+    end
+
+    private
+    def cross_references_for(filename, lineno)
+        return nil unless @callsite_analyzer
+        @callsite_index ||= build_callsite_index
+        @callsite_index[normalize_filename(filename)][lineno]
+    end
+
+    def reverse_cross_references_for(filename, lineno)
+        return nil unless @callsite_analyzer
+        @callsite_reverse_index ||= build_reverse_callsite_index
+        @callsite_reverse_index[normalize_filename(filename)][lineno]
+    end
+
+    def build_callsite_index
+        index = Hash.new{|h,k| h[k] = {}}
+        @callsite_analyzer.analyzed_classes.each do |classname|
+            @callsite_analyzer.analyzed_methods(classname).each do |methname|
+                defsite = @callsite_analyzer.defsite(classname, methname)
+                index[normalize_filename(defsite.file)][defsite.line] = 
+                    @callsite_analyzer.callsites(classname, methname)
+            end
+        end
+        index
+    end
+    
+    def build_reverse_callsite_index
+        index = Hash.new{|h,k| h[k] = {}}
+        @callsite_analyzer.analyzed_classes.each do |classname|
+            @callsite_analyzer.analyzed_methods(classname).each do |methname|
+                callsites = @callsite_analyzer.callsites(classname, methname)
+                defsite = @callsite_analyzer.defsite(classname, methname)
+                callsites.each_pair do |callsite, count|
+                    next unless callsite.file
+                    fname = normalize_filename(callsite.file)
+                    (index[fname][callsite.line] ||= []) << [classname, methname, defsite, count]
+                end
+            end
+        end
+        index
+    end
+
+    class XRefHelper < Struct.new(:file, :line, :klass, :mid, :count) # :nodoc:
+    end
+
+    def _get_defsites(ref_blocks, filename, lineno, linetext, label, &format_call_ref)
+        if @do_cross_references and 
+           (rev_xref = reverse_cross_references_for(filename, lineno))
+            refs = rev_xref.map do |classname, methodname, defsite, count|
+                XRefHelper.new(defsite.file, defsite.line, classname, methodname, count)
+            end.sort_by{|r| r.count}.reverse
+            ref_blocks << [refs, label, format_call_ref]
+        end
+    end
+
+    def _get_callsites(ref_blocks, filename, lineno, linetext, label, &format_called_ref)
+        if @do_callsites and
+           (refs = cross_references_for(filename, lineno))
+            refs = refs.sort_by{|k,count| count}.map do |ref, count|
+                XRefHelper.new(ref.file, ref.line, ref.calling_class, ref.calling_method, count)
+            end.reverse
+            ref_blocks << [refs, label, format_called_ref]
+        end
+    end
+end
+
+class TextSummary < Formatter # :nodoc:
+    def execute
+        puts summary
+    end
+
+    def summary
+        "%.1f%%   %d file(s)   %d Lines   %d LOC" % [code_coverage * 100,
+            @files.size, num_lines, num_code_lines]
+    end
+end
+
+class TextReport < TextSummary # :nodoc:
+    def execute
+        print_lines
+        print_header
+        print_lines
+        each_file_pair_sorted do |fname, finfo|
+            name = fname.size < 52 ? fname : "..." + fname[-48..-1]
+            print_info(name, finfo.num_lines, finfo.num_code_lines, 
+                       finfo.code_coverage)
+        end
+        print_lines
+        print_info("Total", num_lines, num_code_lines, code_coverage)
+        print_lines
+        puts summary
+    end
+
+    def print_info(name, lines, loc, coverage)
+        puts "|%-51s | %5d | %5d | %5.1f%% |" % [name, lines, loc, 100 * coverage]
+    end
+
+    def print_lines
+        puts "+----------------------------------------------------+-------+-------+--------+"
+    end
+
+    def print_header
+        puts "|                  File                              | Lines |  LOC  |  COV   |"
+    end
+end
+
+class FullTextReport < Formatter # :nodoc:
+    DEFAULT_OPTS = {:textmode => :coverage}
+    def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        @textmode = options[:textmode]
+        @color = options[:color]
+        super(options)
+    end
+
+    def execute
+        each_file_pair_sorted do |filename, fileinfo|
+            puts "=" * 80
+            puts filename
+            puts "=" * 80
+            lines = SCRIPT_LINES__[filename]
+            unless lines
+                # try to get the source code from the global code coverage
+                # analyzer
+                re = /#{Regexp.escape(filename)}\z/
+                if $rcov_code_coverage_analyzer and 
+                    (data = $rcov_code_coverage_analyzer.data_matching(re))
+                    lines = data[0]
+                end
+            end
+            (lines || []).each_with_index do |line, i|
+                case @textmode
+                when :counts
+                    puts "%-70s| %6d" % [line.chomp[0,70], fileinfo.counts[i]]
+                when :gcc
+                    puts "%s:%d:%s" % [filename, i+1, line.chomp] unless fileinfo.coverage[i]
+                when :coverage
+                    if @color
+                        prefix = fileinfo.coverage[i] ? "\e[32;40m" : "\e[31;40m"
+                        puts "#{prefix}%s\e[37;40m" % line.chomp
+                    else
+                        prefix = fileinfo.coverage[i] ? "   " : "!! "
+                        puts "#{prefix}#{line}"
+                    end
+                end
+            end
+        end
+    end
+end
+
+class TextCoverageDiff < Formatter # :nodoc:
+    FORMAT_VERSION = [0, 1, 0]
+    DEFAULT_OPTS = {:textmode => :coverage_diff, 
+                    :coverage_diff_mode => :record,
+                    :coverage_diff_file => "coverage.info",
+                    :diff_cmd => "diff", :comments_run_by_default => true}
+    def SERIALIZER
+        # mfp> this was going to be YAML but I caught it failing at basic
+        # round-tripping, turning "\n" into "" and corrupting the data, so
+        # it must be Marshal for now
+        Marshal
+    end
+
+    def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        @textmode = options[:textmode]
+        @color = options[:color]
+        @mode = options[:coverage_diff_mode]
+        @state_file = options[:coverage_diff_file]
+        @diff_cmd = options[:diff_cmd]
+        @gcc_output = options[:gcc_output]
+       super(options)
+    end
+
+    def execute
+        case @mode
+        when :record
+            record_state
+        when :compare
+            compare_state
+        else
+            raise "Unknown TextCoverageDiff mode: #{mode.inspect}."
+        end
+    end
+
+    def record_state
+        state = {}
+        each_file_pair_sorted do |filename, fileinfo|
+            state[filename] = {:lines    => SCRIPT_LINES__[filename],
+                               :coverage => fileinfo.coverage.to_a, 
+                               :counts   => fileinfo.counts}
+        end
+        File.open(@state_file, "w") do |f|
+            self.SERIALIZER.dump([FORMAT_VERSION, state], f)
+        end
+    rescue
+        $stderr.puts <<-EOF
+Couldn't save coverage data to #{@state_file}.
+EOF
+    end                         # '
+
+    require 'tempfile'
+    def compare_state
+        return unless verify_diff_available
+        begin
+            format, prev_state = File.open(@state_file){|f| self.SERIALIZER.load(f) }
+        rescue
+            $stderr.puts <<-EOF
+Couldn't load coverage data from #{@state_file}.
+EOF
+            return              # '
+        end
+        if !(Array === format) or
+            FORMAT_VERSION[0] != format[0] || FORMAT_VERSION[1] < format[1]
+            $stderr.puts <<-EOF
+Couldn't load coverage data from #{@state_file}.
+The file is saved in the format  #{format.inspect[0..20]}.
+This rcov executable understands #{FORMAT_VERSION.inspect}.
+EOF
+            return              # '
+        end
+        each_file_pair_sorted do |filename, fileinfo|
+            old_data = Tempfile.new("#{mangle_filename(filename)}-old")
+            new_data = Tempfile.new("#{mangle_filename(filename)}-new")
+            if prev_state.has_key? filename
+                old_code, old_cov = prev_state[filename].values_at(:lines, :coverage)
+                old_code.each_with_index do |line, i|
+                    prefix = old_cov[i] ? "   " : "!! "
+                    old_data.write "#{prefix}#{line}"
+                end
+            else
+                old_data.write ""
+            end
+            old_data.close
+            SCRIPT_LINES__[filename].each_with_index do |line, i|
+                prefix = fileinfo.coverage[i] ? "   " : "!! "
+                new_data.write "#{prefix}#{line}"
+            end
+            new_data.close
+
+            diff = `#{@diff_cmd} -u "#{old_data.path}" "#{new_data.path}"`
+            new_uncovered_hunks = process_unified_diff(filename, diff)
+            old_data.close!
+            new_data.close!
+            display_hunks(filename, new_uncovered_hunks)
+        end
+    end
+
+    def display_hunks(filename, hunks)
+        return if hunks.empty?
+        puts 
+        puts "=" * 80
+        puts <<EOF
+!!!!! Uncovered code introduced in #{filename}
+
+EOF
+        hunks.each do |offset, lines|
+            if @gcc_output
+                lines.each_with_index do |line,i|
+                    lineno = offset + i
+                    flag = (/^!! / !~ line) ? "-" : ":"
+                    prefix = "#{filename}#{flag}#{lineno}#{flag}"
+                    puts "#{prefix}#{line[3..-1]}"
+                end
+            elsif @color
+                puts "### #{filename}:#{offset}"
+                lines.each do |line| 
+                    prefix = (/^!! / !~ line) ? "\e[32;40m" : "\e[31;40m"
+                    puts "#{prefix}#{line[3..-1].chomp}\e[37;40m"
+                end
+            else
+                puts "### #{filename}:#{offset}"
+                puts lines
+            end
+        end
+    end
+
+    def verify_diff_available
+        old_stderr = STDERR.dup
+        old_stdout = STDOUT.dup
+        # TODO: should use /dev/null or NUL(?), but I don't want to add the
+        # win32 check right now
+        new_stderr = Tempfile.new("rcov_check_diff")
+        STDERR.reopen new_stderr.path
+        STDOUT.reopen new_stderr.path
+
+        retval = system "#{@diff_cmd} --version"
+        unless retval
+            old_stderr.puts <<EOF
+
+The '#{@diff_cmd}' executable seems not to be available.
+You can specify which diff executable should be used with --diff-cmd.
+If your system doesn't have one, you might want to use Diff::LCS's:
+  gem install diff-lcs
+and use --diff-cmd=ldiff.
+EOF
+            return false
+        end
+        true
+    ensure
+        STDOUT.reopen old_stdout
+        STDERR.reopen old_stderr
+        new_stderr.close!
+    end
+
+    HUNK_HEADER = /@@ -\d+,\d+ \+(\d+),(\d+) @@/
+    def process_unified_diff(filename, diff)
+        current_hunk = []
+        current_hunk_start = 0
+        keep_current_hunk = false
+        state = :init
+        interesting_hunks = []
+        diff.each_with_index do |line, i|
+            #puts "#{state} %5d #{line}" % i
+            case state
+            when :init
+                if md = HUNK_HEADER.match(line)
+                    current_hunk = []
+                    current_hunk_start = md[1].to_i
+                    state = :body
+                end
+            when :body
+                case line
+                when HUNK_HEADER
+                    new_start = $1.to_i
+                    if keep_current_hunk
+                        interesting_hunks << [current_hunk_start, current_hunk]
+                    end
+                    current_hunk_start = new_start
+                    current_hunk = []
+                    keep_current_hunk = false
+                when /^-/
+                    # ignore
+                when /^\+!! /
+                    keep_current_hunk = true
+                    current_hunk << line[1..-1]
+                else
+                    current_hunk << line[1..-1]
+                end
+            end
+        end
+        if keep_current_hunk
+            interesting_hunks << [current_hunk_start, current_hunk]
+        end
+
+        interesting_hunks
+    end
+end
+
+
+class HTMLCoverage < Formatter # :nodoc:
+    include XX::XHTML
+    include XX::XMLish
+    require 'fileutils'
+    JAVASCRIPT_PROLOG = <<-EOS
+
+// <![CDATA[
+  function toggleCode( id ) {
+    if ( document.getElementById )
+      elem = document.getElementById( id );
+    else if ( document.all )
+      elem = eval( "document.all." + id );
+    else
+      return false;
+
+    elemStyle = elem.style;
+    
+    if ( elemStyle.display != "block" ) {
+      elemStyle.display = "block"
+    } else {
+      elemStyle.display = "none"
+    }
+
+    return true;
+  }
+  
+  // Make cross-references hidden by default
+  document.writeln( "<style type=\\"text/css\\">span.cross-ref { display: none }</style>" )
+  // ]]>
+    EOS
+
+    CSS_PROLOG = <<-EOS
+span.cross-ref-title {
+    font-size: 140%;
+}
+span.cross-ref a {
+  text-decoration: none;
+}
+span.cross-ref {
+    background-color:#f3f7fa;
+    border: 1px dashed #333;
+    margin: 1em;
+    padding: 0.5em;
+    overflow: hidden;
+}
+a.crossref-toggle {
+  text-decoration: none;
+}
+span.marked0 {
+  background-color: rgb(185, 210, 200);
+  display: block;
+}
+span.marked1 {
+  background-color: rgb(190, 215, 205);
+  display: block;
+}
+span.inferred0 {
+  background-color: rgb(175, 200, 200);
+  display: block;
+}
+span.inferred1 {
+  background-color: rgb(180, 205, 205);
+  display: block;
+}
+span.uncovered0 {
+  background-color: rgb(225, 110, 110);
+  display: block;
+}
+span.uncovered1 {
+  background-color: rgb(235, 120, 120);
+  display: block;
+}
+span.overview {
+  border-bottom: 8px solid black;
+}
+div.overview {
+  border-bottom: 8px solid black;
+}
+body {
+    font-family: verdana, arial, helvetica;
+}
+
+div.footer {
+    font-size: 68%;
+    margin-top: 1.5em;
+}
+
+h1, h2, h3, h4, h5, h6 {
+    margin-bottom: 0.5em;
+}
+
+h5 {
+    margin-top: 0.5em;
+}
+
+.hidden {
+    display: none;
+}
+
+div.separator {
+    height: 10px;
+}
+/* Commented out for better readability, esp. on IE */
+/*
+table tr td, table tr th {
+    font-size: 68%;
+}
+
+td.value table tr td {
+    font-size: 11px;
+}
+*/
+
+table.percent_graph {
+    height: 12px;
+    border: #808080 1px solid;
+    empty-cells: show;
+}
+
+table.percent_graph td.covered {
+    height: 10px;
+    background: #00f000;
+}
+
+table.percent_graph td.uncovered {
+    height: 10px;
+    background: #e00000;
+}
+
+table.percent_graph td.NA {
+    height: 10px;
+    background: #eaeaea;
+}
+
+table.report {
+    border-collapse: collapse;
+    width: 100%;
+}
+
+table.report td.heading {
+    background: #dcecff;
+    border: #d0d0d0 1px solid;
+    font-weight: bold;
+    text-align: center;
+}
+
+table.report td.heading:hover {
+    background: #c0ffc0;
+}
+
+table.report td.text {
+    border: #d0d0d0 1px solid;
+}
+
+table.report td.value,
+table.report td.lines_total,
+table.report td.lines_code {
+    text-align: right;
+    border: #d0d0d0 1px solid;
+}
+table.report tr.light {
+    background-color: rgb(240, 240, 245);
+}
+table.report tr.dark {
+    background-color: rgb(230, 230, 235);
+}
+EOS
+
+    DEFAULT_OPTS = {:color => false, :fsr => 30, :destdir => "coverage",
+                    :callsites => false, :cross_references => false,
+                    :validator_links => true, :charset => nil
+                   }
+    def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        super(options)
+        @dest = options[:destdir]
+        @color = options[:color]
+        @fsr = options[:fsr]
+        @do_callsites = options[:callsites]
+        @do_cross_references = options[:cross_references]
+        @span_class_index = 0
+        @show_validator_links = options[:validator_links]
+        @charset = options[:charset]
+    end
+
+    def execute
+        return if @files.empty?
+        FileUtils.mkdir_p @dest
+        create_index(File.join(@dest, "index.html"))
+        each_file_pair_sorted do |filename, fileinfo|
+            create_file(File.join(@dest, mangle_filename(filename)), fileinfo)
+        end
+    end
+
+    private
+
+    def blurb
+        xmlish_ {
+                p_ { 
+                    t_{ "Generated using the " }
+                    a_(:href => "http://eigenclass.org/hiki.rb?rcov") {
+                        t_{ "rcov code coverage analysis tool for Ruby" }
+                    }
+                    t_{ " version #{Rcov::VERSION}." }
+                }
+        }.pretty
+    end
+
+    def output_color_table?
+        true
+    end
+
+    def default_color
+        "rgb(240, 240, 245)"
+    end
+
+    def default_title
+        "C0 code coverage information"
+    end
+
+    def format_overview(*file_infos)
+        table_text = xmlish_ {
+            table_(:class => "report") {
+                thead_ {
+                    tr_ { 
+                        ["Name", "Total lines", "Lines of code", "Total coverage",
+                         "Code coverage"].each do |heading|
+                            td_(:class => "heading") { heading }
+                         end
+                    }
+                }
+                tbody_ { 
+                    color_class_index = 1
+                    color_classes = %w[light dark]
+                    file_infos.each do |f|
+                        color_class_index += 1
+                        color_class_index %= color_classes.size
+                        tr_(:class => color_classes[color_class_index]) {
+                            td_ { 
+                                case f.name
+                                when "TOTAL": 
+                                    t_ { "TOTAL" }
+                                else
+                                    a_(:href => mangle_filename(f.name)){ t_ { f.name } } 
+                                end
+                            }
+                            [[f.num_lines, "lines_total"], 
+                             [f.num_code_lines, "lines_code"]].each do |value, css_class| 
+                                td_(:class => css_class) { tt_{ value } }
+                            end
+                            [[f.total_coverage, "coverage_total"],
+                             [f.code_coverage, "coverage_code"]].each do |value, css_class|
+                                value *= 100
+                                td_ { 
+                                    table_(:cellpadding => "0", :cellspacing => "0", :align => "right") { 
+                                        tr_ { 
+                                            td_ {
+                                                 tt_(:class => css_class) { "%3.1f%%" % value } 
+                                                 x_ "&nbsp;"
+                                            }
+                                            ivalue = value.round
+                                            td_ {
+                                                table_(:class => "percent_graph", :cellpadding => "0",
+                                                   :cellspacing => "0", :width => "100") {
+                                                    tr_ {
+                                                        td_(:class => "covered", :width => ivalue.to_s)
+                                                        td_(:class => "uncovered", :width => (100-ivalue).to_s)
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            end
+                        }
+                    end
+                }
+            }
+        }
+        table_text.pretty
+    end
+
+    class SummaryFileInfo  # :nodoc:
+        def initialize(obj); @o = obj end
+        %w[num_lines num_code_lines code_coverage total_coverage].each do |m|
+            define_method(m){ @o.send(m) }
+        end
+        def name; "TOTAL" end
+    end
+
+    def create_index(destname)
+        files = [SummaryFileInfo.new(self)] + each_file_pair_sorted.map{|k,v| v}
+        title = default_title
+        output = xhtml_ { html_ {
+            head_ {
+                if @charset
+                    meta_("http-equiv".to_sym => "Content-Type",
+                          :content => "text/html;charset=#{@charset}")
+                end
+                title_{ title }
+                style_(:type => "text/css") { t_{ "body { background-color: #{default_color}; }" }  }
+                style_(:type => "text/css") { CSS_PROLOG }
+                script_(:type => "text/javascript") { h_{ JAVASCRIPT_PROLOG } }
+            }
+            body_ {
+                h3_{
+                    t_{ title }
+                }
+                p_ {
+                    t_{ "Generated on #{Time.new.to_s} with " }
+                    a_(:href => Rcov::UPSTREAM_URL){ "rcov #{Rcov::VERSION}" }
+                }
+                p_ { "Threshold: #{@output_threshold}%" } if @output_threshold != 101
+                hr_
+                x_{ format_overview(*files) }
+                hr_
+                x_{ blurb }
+
+                if @show_validator_links
+                    p_ {
+                        a_(:href => "http://validator.w3.org/check/referer") {
+                            img_(:src => "http://www.w3.org/Icons/valid-xhtml11",
+                                 :alt => "Valid XHTML 1.1!", :height => "31", :width => "88")
+                        }
+                        a_(:href => "http://jigsaw.w3.org/css-validator/check/referer") {
+                            img_(:style => "border:0;width:88px;height:31px",
+                                 :src => "http://jigsaw.w3.org/css-validator/images/vcss",
+                                 :alt => "Valid CSS!")
+                        }
+                    }
+                end
+            }
+        } }
+        lines = output.pretty.to_a
+        lines.unshift lines.pop if /DOCTYPE/ =~ lines[-1]
+        File.open(destname, "w") do |f|
+            f.puts lines
+        end
+    end
+
+    def format_lines(file)
+        result = ""
+        last = nil
+        end_of_span = ""
+        format_line = "%#{file.num_lines.to_s.size}d"
+        file.num_lines.times do |i|
+            line = file.lines[i].chomp
+            marked = file.coverage[i]
+            count = file.counts[i]
+            spanclass = span_class(file, marked, count)
+            if spanclass != last
+                result += end_of_span
+                case spanclass
+                when nil
+                    end_of_span = ""
+                else
+                    result += %[<span class="#{spanclass}">]
+                    end_of_span = "</span>"
+                end
+            end
+            result += %[<a name="line#{i+1}"></a>] + (format_line % (i+1)) + 
+                " " + create_cross_refs(file.name, i+1, CGI.escapeHTML(line)) + "\n"
+            last = spanclass
+        end
+        result += end_of_span
+        "<pre>#{result}</pre>"
+    end
+
+    def create_cross_refs(filename, lineno, linetext)
+        return linetext unless @callsite_analyzer && @do_callsites
+        ref_blocks = []
+        _get_defsites(ref_blocks, filename, lineno, "Calls", linetext) do |ref|
+            if ref.file
+                where = "at #{normalize_filename(ref.file)}:#{ref.line}"
+            else
+                where = "(C extension/core)"
+            end
+            CGI.escapeHTML("%7d   %s" % 
+                               [ref.count, "#{ref.klass}##{ref.mid} " + where])
+        end
+        _get_callsites(ref_blocks, filename, lineno, "Called by", linetext) do |ref|
+            r = "%7d   %s" % [ref.count, 
+                "#{normalize_filename(ref.file||'C code')}:#{ref.line} " +
+                    "in '#{ref.klass}##{ref.mid}'"]
+            CGI.escapeHTML(r)
+        end
+        
+        create_cross_reference_block(linetext, ref_blocks)
+    end
+
+    def create_cross_reference_block(linetext, ref_blocks)
+        return linetext if ref_blocks.empty?
+        ret = ""
+        @cross_ref_idx ||= 0
+        @known_files ||= sorted_file_pairs.map{|fname, finfo| normalize_filename(fname)}
+        ret << %[<a class="crossref-toggle" href="#" onclick="toggleCode('XREF-#{@cross_ref_idx+=1}'); return false;">#{linetext}</a>]
+        ret << %[<span class="cross-ref" id="XREF-#{@cross_ref_idx}">]
+        ret << "\n"
+        ref_blocks.each do |refs, toplabel, label_proc|
+            unless !toplabel || toplabel.empty?
+                ret << %!<span class="cross-ref-title">#{toplabel}</span>\n!
+            end
+            refs.each do |dst|
+                dstfile = normalize_filename(dst.file) if dst.file
+                dstline = dst.line
+                label = label_proc.call(dst)
+                if dst.file && @known_files.include?(dstfile)
+                    ret << %[<a href="#{mangle_filename(dstfile)}#line#{dstline}">#{label}</a>]
+                else
+                    ret << label
+                end
+                ret << "\n"
+            end
+        end
+        ret << "</span>"
+    end
+
+    def span_class(sourceinfo, marked, count)
+        @span_class_index ^= 1
+        case marked
+        when true
+            "marked#{@span_class_index}"
+        when :inferred
+            "inferred#{@span_class_index}"
+        else 
+            "uncovered#{@span_class_index}"
+        end
+    end
+
+    def create_file(destfile, fileinfo)
+        #$stderr.puts "Generating #{destfile.inspect}"
+        body = format_overview(fileinfo) + format_lines(fileinfo)
+        title = fileinfo.name + " - #{default_title}"
+        do_ctable = output_color_table?
+        output = xhtml_ { html_ {
+            head_ { 
+                if @charset
+                    meta_("http-equiv".to_sym => "Content-Type",
+                          :content => "text/html;charset=#{@charset}")
+                end
+                title_{ title } 
+                style_(:type => "text/css") { t_{ "body { background-color: #{default_color}; }" }  }
+                style_(:type => "text/css") { CSS_PROLOG }
+                script_(:type => "text/javascript") { h_ { JAVASCRIPT_PROLOG } }
+                style_(:type => "text/css") { h_ { colorscale } }
+            }
+            body_ {
+                h3_{ t_{ default_title } }
+                p_ {
+                    t_{ "Generated on #{Time.new.to_s} with " }
+                    a_(:href => Rcov::UPSTREAM_URL){ "rcov #{Rcov::VERSION}" }
+                }
+                hr_
+                if do_ctable
+                    # this kludge needed to ensure .pretty doesn't mangle it
+                    x_ { <<EOS
+<pre><span class='marked0'>Code reported as executed by Ruby looks like this...
+</span><span class='marked1'>and this: this line is also marked as covered.
+</span><span class='inferred0'>Lines considered as run by rcov, but not reported by Ruby, look like this,
+</span><span class='inferred1'>and this: these lines were inferred by rcov (using simple heuristics).
+</span><span class='uncovered0'>Finally, here&apos;s a line marked as not executed.
+</span></pre>                       
+EOS
+                    }
+                end
+                x_{ body }
+                hr_
+                x_ { blurb }
+
+                if @show_validator_links
+                    p_ {
+                        a_(:href => "http://validator.w3.org/check/referer") {
+                            img_(:src => "http://www.w3.org/Icons/valid-xhtml10",
+                                 :alt => "Valid XHTML 1.0!", :height => "31", :width => "88")
+                        }
+                        a_(:href => "http://jigsaw.w3.org/css-validator/check/referer") {
+                            img_(:style => "border:0;width:88px;height:31px",
+                                 :src => "http://jigsaw.w3.org/css-validator/images/vcss",
+                                 :alt => "Valid CSS!")
+                        }
+                    }
+                end
+            }
+        } }
+        # .pretty needed to make sure DOCTYPE is in a separate line
+        lines = output.pretty.to_a
+        lines.unshift lines.pop if /DOCTYPE/ =~ lines[-1]
+        File.open(destfile, "w") do |f|
+            f.puts lines
+        end
+    end
+
+    def colorscale
+        colorscalebase =<<EOF
+span.run%d {
+  background-color: rgb(%d, %d, %d);
+  display: block;
+}
+EOF
+        cscale = ""
+        101.times do |i|
+            if @color
+                r, g, b = hsv2rgb(220-(2.2*i).to_i, 0.3, 1)
+                r = (r * 255).to_i
+                g = (g * 255).to_i
+                b = (b * 255).to_i
+            else
+                r = g = b = 255 - i 
+            end
+            cscale << colorscalebase % [i, r, g, b]
+        end
+        cscale
+    end
+
+    # thanks to kig @ #ruby-lang for this one
+    def hsv2rgb(h,s,v)
+        return [v,v,v] if s == 0
+        h = h/60.0
+        i = h.floor
+        f = h-i
+        p = v * (1-s)
+        q = v * (1-s*f)
+        t = v * (1-s*(1-f))
+        case i
+        when 0
+            r = v
+            g = t
+            b = p
+        when 1
+            r = q
+            g = v
+            b = p
+        when 2
+            r = p
+            g = v
+            b = t
+        when 3
+            r = p
+            g = q
+            b = v
+        when 4
+            r = t
+            g = p
+            b = v
+        when 5
+            r = v
+            g = p
+            b = q
+        end
+        [r,g,b]
+    end
+end
+
+class HTMLProfiling < HTMLCoverage # :nodoc:
+
+    DEFAULT_OPTS = {:destdir => "profiling"}
+    def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        super(options)
+        @max_cache = {}
+        @median_cache = {}
+    end
+    
+    def default_title
+        "Bogo-profile information"
+    end
+    
+    def default_color
+        if @color
+            "rgb(179,205,255)"
+        else
+            "rgb(255, 255, 255)"
+        end
+    end
+
+    def output_color_table?
+        false
+    end
+
+    def span_class(sourceinfo, marked, count)
+        full_scale_range = @fsr # dB
+        nz_count = sourceinfo.counts.select{|x| x && x != 0}
+        nz_count << 1 # avoid div by 0
+        max = @max_cache[sourceinfo] ||= nz_count.max
+        #avg = @median_cache[sourceinfo] ||= 1.0 * 
+        #    nz_count.inject{|a,b| a+b} / nz_count.size
+        median = @median_cache[sourceinfo] ||= 1.0 * nz_count.sort[nz_count.size/2]
+        max ||= 2
+        max = 2 if max == 1
+        if marked == true
+            count = 1 if !count || count == 0
+            idx = 50 + 1.0 * (500/full_scale_range) * Math.log(count/median) /
+                Math.log(10)
+            idx = idx.to_i
+            idx = 0 if idx < 0
+            idx = 100 if idx > 100
+            "run#{idx}"
+        else 
+            nil
+        end
+    end
+end
+
+class RubyAnnotation < Formatter # :nodoc:
+    DEFAULT_OPTS = { :destdir => "coverage" }
+    def initialize(opts = {})
+        options = DEFAULT_OPTS.clone.update(opts)
+        super(options)
+        @dest = options[:destdir]
+        @do_callsites = true
+        @do_cross_references = true
+
+        @mangle_filename = Hash.new{|h,base|
+            h[base] = Pathname.new(base).cleanpath.to_s.gsub(%r{^\w:[/\\]}, "").gsub(/\./, "_").gsub(/[\\\/]/, "-") + ".rb"
+        }
+    end
+
+    def execute
+        return if @files.empty?
+        FileUtils.mkdir_p @dest
+        each_file_pair_sorted do |filename, fileinfo|
+            create_file(File.join(@dest, mangle_filename(filename)), fileinfo)
+        end
+    end
+
+    private
+
+    def format_lines(file)
+        result = ""
+        format_line = "%#{file.num_lines.to_s.size}d"
+        file.num_lines.times do |i|
+            line = file.lines[i].chomp
+            marked = file.coverage[i]
+            count = file.counts[i]
+            result << create_cross_refs(file.name, i+1, line, marked) + "\n"
+        end
+        result
+    end
+
+    def create_cross_refs(filename, lineno, linetext, marked)
+        return linetext unless @callsite_analyzer && @do_callsites
+        ref_blocks = []
+        _get_defsites(ref_blocks, filename, lineno, linetext, ">>") do |ref|
+            if ref.file
+                ref.file.sub!(%r!^./!, '')
+                where = "at #{mangle_filename(ref.file)}:#{ref.line}"
+            else
+                where = "(C extension/core)"
+            end
+            "#{ref.klass}##{ref.mid} " + where + ""
+        end
+        _get_callsites(ref_blocks, filename, lineno, linetext, "<<") do |ref| # "
+            ref.file.sub!(%r!^./!, '')
+            "#{mangle_filename(ref.file||'C code')}:#{ref.line} " +
+                "in #{ref.klass}##{ref.mid}"
+        end
+        
+        create_cross_reference_block(linetext, ref_blocks, marked)
+    end
+
+    def create_cross_reference_block(linetext, ref_blocks, marked)
+        codelen = 75
+        if ref_blocks.empty?
+            if marked
+                return "%-#{codelen}s #o" % linetext
+            else
+                return linetext
+            end
+        end
+        ret = ""
+        @cross_ref_idx ||= 0
+        @known_files ||= sorted_file_pairs.map{|fname, finfo| normalize_filename(fname)}
+        ret << "%-#{codelen}s # " % linetext
+        ref_blocks.each do |refs, toplabel, label_proc|
+            unless !toplabel || toplabel.empty?
+                ret << toplabel << " "
+            end
+            refs.each do |dst|
+                dstfile = normalize_filename(dst.file) if dst.file
+                dstline = dst.line
+                label = label_proc.call(dst)
+                if dst.file && @known_files.include?(dstfile)
+                    ret << "[[" << label << "]], "
+                else
+                    ret << label << ", "
+                end
+            end
+        end
+        
+        ret
+    end
+    
+    def create_file(destfile, fileinfo)
+        #$stderr.puts "Generating #{destfile.inspect}"
+        body = format_lines(fileinfo)
+        File.open(destfile, "w") do |f|
+            f.puts body
+            f.puts footer(fileinfo)
+        end
+    end
+
+    def footer(fileinfo)
+        s  = "# Total lines    : %d\n" % fileinfo.num_lines
+        s << "# Lines of code  : %d\n" % fileinfo.num_code_lines
+        s << "# Total coverage : %3.1f%%\n" % [ fileinfo.total_coverage*100 ]
+        s << "# Code coverage  : %3.1f%%\n\n" % [ fileinfo.code_coverage*100 ]
+        # prevents false positives on Emacs
+        s << "# Local " "Variables:\n" "# mode: " "rcov-xref\n" "# End:\n"
+    end
+end
+
+
+end # Rcov
+
+# vi: set sw=4:
+# Here is Emacs setting. DO NOT REMOVE!
+# Local Variables:
+# ruby-indent-level: 4
+# End: