rdoc 2.4.3 → 2.5

data/lib/rdoc/options.rb

@@ -12,21 +12,11 @@ class RDoc::Options
 
   attr_reader :charset
 
-  ##
-  # Should diagrams be drawn?
-
-  attr_accessor :diagram
-
   ##
   # Files matching this pattern will be excluded
 
   attr_accessor :exclude
 
-  ##
-  # Should we draw fileboxes in diagrams?
-
-  attr_reader :fileboxes
-
   ##
   # The list of files to be processed
 
@@ -47,27 +37,12 @@ class RDoc::Options
 
   attr_accessor :formatter
 
-  ##
-  # Image format for diagrams
-
-  attr_reader :image_format
-
-  ##
-  # Include line numbers in the source listings?
-
-  attr_reader :include_line_numbers
-
   ##
   # Name of the file, class or module to display in the initial index page (if
   # not specified the first file we encounter is used)
 
   attr_accessor :main_page
 
-  ##
-  # Merge into classes of the same name when generating ri
-
-  attr_reader :merge
-
   ##
   # The name of the output directory
 
@@ -103,11 +78,6 @@ class RDoc::Options
 
   attr_reader :template
 
-  ##
-  # Number of threads to parse with
-
-  attr_accessor :threads
-
   ##
   # Documentation title
 
@@ -125,10 +95,9 @@ class RDoc::Options
 
   def initialize # :nodoc:
     require 'rdoc/rdoc'
-    @op_dir = 'doc'
+    @op_dir = nil
     @show_all = false
     @main_page = nil
-    @merge = false
     @exclude = []
     @generators = RDoc::RDoc::GENERATORS
     @generator = RDoc::Generator::Darkfish
@@ -136,17 +105,8 @@ class RDoc::Options
     @rdoc_include = []
     @title = nil
     @template = nil
-    @threads = if RUBY_PLATFORM == 'java' then
-                 Java::java::lang::Runtime.getRuntime.availableProcessors * 2
-               else
-                 2
-               end
-    @diagram = false
-    @fileboxes = false
     @show_hash = false
-    @image_format = 'png'
     @tab_width = 8
-    @include_line_numbers = false
     @force_update = true
     @verbosity = 1
     @pipe = false
@@ -160,6 +120,8 @@ class RDoc::Options
   # Parse command line options.
 
   def parse(argv)
+    ignore_invalid = true
+
     opts = OptionParser.new do |opt|
       opt.program_name = File.basename $0
       opt.version = RDoc::VERSION
@@ -178,10 +140,22 @@ Usage: #{opt.program_name} [options] [names...]
   the options you give.
 
   - Darkfish creates frameless HTML output by Michael Granger.
-
   - ri creates ri data files
+
+  RDoc understands the following file formats:
+
       EOF
 
+      parsers = Hash.new { |h,parser| h[parser] = [] }
+
+      RDoc::Parser.parsers.each do |regexp, parser|
+        parsers[parser.name.sub('RDoc::Parser::', '')] << regexp.source
+      end
+
+      parsers.sort.each do |parser, regexp|
+        opt.banner << "  - #{parser}: #{regexp.join ', '}\n"
+      end
+
       opt.separator nil
       opt.separator "Parsing Options:"
       opt.separator nil
@@ -212,7 +186,7 @@ Usage: #{opt.program_name} [options] [names...]
           raise OptionParser::InvalidArgument, "Invalid parameter to '-E'"
         end
 
-        unless RDoc::ParserFactory.alias_extension old, new then
+        unless RDoc::Parser.alias_extension old, new then
           raise OptionParser::InvalidArgument, "Unknown extension .#{old} to -E"
         end
       end
@@ -232,13 +206,6 @@ Usage: #{opt.program_name} [options] [names...]
         @pipe = true
       end
 
-      opt.separator nil
-
-      opt.on("--threads=THREADS", Integer,
-             "Number of threads to parse with.") do |threads|
-        @threads = threads
-      end
-
       opt.separator nil
       opt.separator "Generator Options:"
       opt.separator nil
@@ -269,13 +236,6 @@ Usage: #{opt.program_name} [options] [names...]
 
       opt.separator nil
 
-      opt.on("--line-numbers", "-N",
-             "Include line numbers in the source code.") do |value|
-        @include_line_numbers = value
-      end
-
-      opt.separator nil
-
       opt.on("--main=NAME", "-m",
              "NAME will be the initial page displayed.") do |value|
         @main_page = value
@@ -331,41 +291,9 @@ Usage: #{opt.program_name} [options] [names...]
         @webcvs = value
       end
 
-      opt.separator nil
-      opt.separator "Diagram Options:"
       opt.separator nil
 
-      image_formats = %w[gif png jpg jpeg]
-      opt.on("--image-format=FORMAT", "-I", image_formats,
-             "Sets output image format for diagrams. Can",
-             "be #{image_formats.join ', '}. If this option",
-             "is omitted, png is used. Requires",
-             "diagrams.") do |value|
-        @image_format = value
-      end
-
-      opt.separator nil
-
-      opt.on("--diagram", "-d",
-             "Generate diagrams showing modules and",
-             "classes. You need dot V1.8.6 or later to",
-             "use the --diagram option correctly. Dot is",
-             "available from http://graphviz.org") do |value|
-        check_diagram
-        @diagram = true
-      end
-
-      opt.separator nil
-
-      opt.on("--fileboxes", "-F",
-             "Classes are put in boxes which represents",
-             "files, where these classes reside. Classes",
-             "shared between more than one file are",
-             "shown with list of files that are sharing",
-             "them. Silently discarded if --diagram is",
-             "not given.") do |value|
-        @fileboxes = value
-      end
+      opt.on("-d", "--diagram", "Prevents -d from tripping --debug")
 
       opt.separator nil
       opt.separator "ri Generator Options:"
@@ -378,7 +306,7 @@ Usage: #{opt.program_name} [options] [names...]
              "subsequent --op parameter, so no special",
              "privileges are needed.") do |value|
         @generator_name = "ri"
-        @op_dir = RDoc::RI::Paths::HOMEDIR
+        @op_dir ||= RDoc::RI::Paths::HOMEDIR
         setup_generator
       end
 
@@ -394,24 +322,20 @@ Usage: #{opt.program_name} [options] [names...]
         setup_generator
       end
 
-      opt.separator nil
-
-      opt.on("--merge", "-M",
-             "When creating ri output, merge previously",
-             "processed classes into previously",
-             "documented classes of the same name.") do |value|
-        @merge = value
-      end
-
       opt.separator nil
       opt.separator "Generic Options:"
       opt.separator nil
 
-      opt.on("--debug", "-D",
+      opt.on("-D", "--[no-]debug",
              "Displays lots on internal stuff.") do |value|
         $DEBUG_RDOC = value
       end
 
+      opt.on("--[no-]ignore-invalid",
+             "Ignore invalid options and continue.") do |value|
+        ignore_invalid = value
+      end
+
       opt.on("--quiet", "-q",
              "Don't show progress as we parse.") do |value|
         @verbosity = 0
@@ -422,25 +346,26 @@ Usage: #{opt.program_name} [options] [names...]
         @verbosity = 2
       end
 
-      opt.separator nil
-      opt.separator 'Deprecated options - these warn when set'
-      opt.separator nil
-
-      opt.on("--inline-source", "-S") do |value|
-        warn "--inline-source will be removed from RDoc on or after August 2009"
-      end
-
-      opt.on("--promiscuous", "-p") do |value|
-        warn "--promiscuous will be removed from RDoc on or after August 2009"
-      end
-
       opt.separator nil
     end
 
     argv.insert(0, *ENV['RDOCOPT'].split) if ENV['RDOCOPT']
 
-    opts.parse! argv
+    begin
+      opts.parse! argv
+    rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+      if ignore_invalid and not quiet then
+        $stderr.puts e
+        $stderr.puts '(invalid options are ignored)'
+      else
+        $stderr.puts opts
+        $stderr.puts
+        $stderr.puts e
+        exit 1
+      end
+    end
 
+    @op_dir ||= 'doc'
     @files = argv.dup
 
     @rdoc_include << "." if @rdoc_include.empty?
@@ -457,12 +382,6 @@ Usage: #{opt.program_name} [options] [names...]
     # formatter
 
     @template ||= @generator_name
-
-  rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
-    puts opts
-    puts
-    puts e
-    exit 1
   end
 
   ##
@@ -497,37 +416,6 @@ Usage: #{opt.program_name} [options] [names...]
     end
   end
 
-  # Check that the right version of 'dot' is available.  Unfortunately this
-  # doesn't work correctly under Windows NT, so we'll bypass the test under
-  # Windows.
-
-  def check_diagram
-    return if RUBY_PLATFORM =~ /mswin|cygwin|mingw|bccwin/
-
-    ok = false
-    ver = nil
-
-    IO.popen "dot -V 2>&1" do |io|
-      ver = io.read
-      if ver =~ /dot.+version(?:\s+gviz)?\s+(\d+)\.(\d+)/ then
-        ok = ($1.to_i > 1) || ($1.to_i == 1 && $2.to_i >= 8)
-      end
-    end
-
-    unless ok then
-      if ver =~ /^dot.+version/ then
-        $stderr.puts "Warning: You may need dot V1.8.6 or later to use\n",
-          "the --diagram option correctly. You have:\n\n   ",
-          ver,
-          "\nDiagrams might have strange background colors.\n\n"
-      else
-        $stderr.puts "You need the 'dot' program to produce diagrams.",
-          "(see http://www.research.att.com/sw/tools/graphviz/)\n\n"
-        exit
-      end
-    end
-  end
-
   ##
   # Check that the files on the command line exist
 

data/lib/rdoc/parser.rb

@@ -63,19 +63,37 @@ class RDoc::Parser
   end
 
   ##
-  # Shamelessly stolen from the ptools gem (since RDoc cannot depend on
-  # the gem).
+  # Determines if the file is a "binary" file which basically means it has
+  # content that an RDoc parser shouldn't try to consume.
 
   def self.binary?(file)
-    s = (File.read(file, File.stat(file).blksize) || "").split(//)
+    s = File.read(file, File.stat(file).blksize) || ""
 
-    if s.size > 0 then
-      ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
-    else
+    if s[0, 2] == Marshal.dump('')[0, 2] then
+      true
+    elsif file =~ /erb\.rb$/ then
       false
+    elsif s.scan(/<%|%>/).length >= 4 then
+      true
+    else
+      # From ptools under the Artistic License 2.0, (c) Daniel Berger.
+      s = s.split(//)
+
+      ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
     end
   end
-  private_class_method :binary?
+
+  ##
+  # Checks if +file+ is a zip file in disguise.  Signatures from
+  # http://www.garykessler.net/library/file_sigs.html
+
+  def self.zip? file
+    zip_signature = File.read file, 4
+    
+    zip_signature == "PK\x03\x04" or
+      zip_signature == "PK\x05\x06" or
+      zip_signature == "PK\x07\x08"
+  end
 
   ##
   # Return a parser that can handle a particular extension
@@ -83,16 +101,13 @@ class RDoc::Parser
   def self.can_parse(file_name)
     parser = RDoc::Parser.parsers.find { |regexp,| regexp =~ file_name }.last
 
-    #
-    # The default parser should *NOT* parse binary files.
-    #
-    if parser == RDoc::Parser::Simple && file_name !~ /\.(txt|rdoc)$/ then
-      if binary? file_name then
-        return nil
-      end
-    end
+    # HACK Selenium hides a jar file using a .txt extension
+    return if parser == RDoc::Parser::Simple and zip? file_name
+
+    # The default parser must not parse binary files
+    return if parser == RDoc::Parser::Simple and file_name !~ /\.(txt|rdoc)$/
 
-    return parser
+    parser
   end
 
   ##
@@ -100,6 +115,8 @@ class RDoc::Parser
   # for ones that we don't know
 
   def self.for(top_level, file_name, body, options, stats)
+    return if binary? file_name
+
     # If no extension, look for shebang
     if file_name !~ /\.\w+$/ && body =~ %r{\A#!(.+)} then
       shebang = $1
@@ -111,14 +128,15 @@ class RDoc::Parser
 
     parser = can_parse file_name
 
-    # This method must return a parser.
-    parser ||= RDoc::Parser::Simple
+    return unless parser
 
     parser.new top_level, file_name, body, options, stats
   end
 
   ##
   # Record which file types this parser can understand.
+  #
+  # It is ok to call this multiple times.
 
   def self.parse_files_matching(regexp)
     RDoc::Parser.parsers.unshift [regexp, self]

data/lib/rdoc/parser/c.rb

@@ -14,32 +14,32 @@ require 'rdoc/known_classes'
 # method, that is to say the method whose name is given in the
 # <tt>rb_define_method</tt> call. For example, you might write:
 #
-#  /*
-#   * Returns a new array that is a one-dimensional flattening of this
-#   * array (recursively). That is, for every element that is an array,
-#   * extract its elements into the new array.
-#   *
-#   *    s = [ 1, 2, 3 ]           #=> [1, 2, 3]
-#   *    t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
-#   *    a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
-#   *    a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-#   */
-#   static VALUE
-#   rb_ary_flatten(ary)
-#       VALUE ary;
-#   {
-#       ary = rb_obj_dup(ary);
-#       rb_ary_flatten_bang(ary);
-#       return ary;
-#   }
+#   /*
+#    * Returns a new array that is a one-dimensional flattening of this
+#    * array (recursively). That is, for every element that is an array,
+#    * extract its elements into the new array.
+#    *
+#    *    s = [ 1, 2, 3 ]           #=> [1, 2, 3]
+#    *    t = [ 4, 5, 6, [7, 8] ]   #=> [4, 5, 6, [7, 8]]
+#    *    a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
+#    *    a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+#    */
+#    static VALUE
+#    rb_ary_flatten(ary)
+#        VALUE ary;
+#    {
+#        ary = rb_obj_dup(ary);
+#        rb_ary_flatten_bang(ary);
+#        return ary;
+#    }
 #
-#   ...
+#    ...
 #
-#   void
-#   Init_Array()
-#   {
-#     ...
-#     rb_define_method(rb_cArray, "flatten", rb_ary_flatten, 0);
+#    void
+#    Init_Array()
+#    {
+#      ...
+#      rb_define_method(rb_cArray, "flatten", rb_ary_flatten, 0);
 #
 # Here RDoc will determine from the rb_define_method line that there's a
 # method called "flatten" in class Array, and will look for the implementation
@@ -47,9 +47,6 @@ require 'rdoc/known_classes'
 # method in the HTML output. This method must be in the same source file
 # as the rb_define_method.
 #
-# C classes can be diagrammed (see /tc/dl/ruby/ruby/error.c), and RDoc
-# integrates C and Ruby source into one tree
-#
 # The comment blocks may include special directives:
 #
 # [Document-class: <i>name</i>]
@@ -68,7 +65,7 @@ require 'rdoc/known_classes'
 # Ruby function is in the same source file as the rb_define_method call.
 # If this isn't the case, add the comment:
 #
-#    rb_define_method(....);  // in: filename
+#   rb_define_method(....);  // in: filename
 #
 # As an example, we might have an extension that defines multiple classes
 # in its Init_xxx method. We could document them using
@@ -96,6 +93,8 @@ class RDoc::Parser::C < RDoc::Parser
 
   parse_files_matching(/\.(?:([CcHh])\1?|c([+xp])\2|y)\z/)
 
+  include RDoc::Text
+
   ##
   # C file the parser is parsing
 
@@ -177,19 +176,17 @@ class RDoc::Parser::C < RDoc::Parser
 
   def do_constants
     @content.scan(%r{\Wrb_define_
-                   (
-                      variable |
-                      readonly_variable |
-                      const |
-                      global_const |
-                    )
+                   ( variable          |
+                     readonly_variable |
+                     const             |
+                     global_const      | )
                \s*\(
                  (?:\s*(\w+),)?
                  \s*"(\w+)",
                  \s*(.*?)\s*\)\s*;
                  }xm) do |type, var_name, const_name, definition|
       var_name = "rb_cObject" if !var_name or var_name == "rb_mKernel"
-      handle_constants(type, var_name, const_name, definition)
+      handle_constants type, var_name, const_name, definition
     end
   end
 
@@ -309,8 +306,10 @@ class RDoc::Parser::C < RDoc::Parser
 
 #        meth_obj.params = params
       meth_obj.start_collecting_tokens
-      meth_obj.add_token RDoc::RubyToken::Token.new(1,1).set_text(body_text)
-      meth_obj.comment = mangle_comment comment
+      tk = RDoc::RubyToken::Token.new nil, 1, 1
+      tk.set_text body_text
+      meth_obj.add_token tk
+      meth_obj.comment = strip_stars comment
     when %r{((?>/\*.*?\*/\s*))^\s*(\#\s*define\s+#{meth_name}\s+(\w+))}m
       comment = $1
       body_text = $2
@@ -318,8 +317,10 @@ class RDoc::Parser::C < RDoc::Parser
       find_modifiers comment, meth_obj
 
       meth_obj.start_collecting_tokens
-      meth_obj.add_token RDoc::RubyToken::Token.new(1,1).set_text(body_text)
-      meth_obj.comment = mangle_comment(comment) + meth_obj.comment.to_s
+      tk = RDoc::RubyToken::Token.new nil, 1, 1
+      tk.set_text body_text
+      meth_obj.add_token tk
+      meth_obj.comment = strip_stars(comment) + meth_obj.comment.to_s
     when %r{^\s*\#\s*define\s+#{meth_name}\s+(\w+)}m
       unless find_body(class_name, $1, meth_obj, body, true)
         warn "No definition for #{meth_name}" unless @options.quiet
@@ -331,7 +332,7 @@ class RDoc::Parser::C < RDoc::Parser
 
       if comment
         find_modifiers(comment, meth_obj)
-        meth_obj.comment = mangle_comment(comment)
+        meth_obj.comment = strip_stars comment
       else
         warn "No definition for #{meth_name}" unless @options.quiet
         return false
@@ -380,11 +381,14 @@ class RDoc::Parser::C < RDoc::Parser
   #    */
   #   VALUE cFoo = rb_define_class("Foo", rb_cObject);
 
-  def find_class_comment(class_name, class_meth)
+  def find_class_comment(class_name, class_mod)
     comment = nil
 
-    if @content =~ %r{((?>/\*.*?\*/\s+))
-                   (static\s+)?void\s+Init_#{class_name}\s*(?:_\(\s*)?\(\s*(?:void\s*)\)}xmi then
+    if @content =~ %r{
+        ((?>/\*.*?\*/\s+))
+        (static\s+)?
+        void\s+
+        Init_#{class_name}\s*(?:_\(\s*)?\(\s*(?:void\s*)?\)}xmi then # )
       comment = $1
     elsif @content =~ %r{Document-(?:class|module):\s+#{class_name}\s*?(?:<\s+[:,\w]+)?\n((?>.*?\*/))}m then
       comment = $1
@@ -393,7 +397,7 @@ class RDoc::Parser::C < RDoc::Parser
       comment = $1
     end
 
-    class_meth.comment = mangle_comment comment if comment
+    class_mod.comment = strip_stars comment if comment
   end
 
   ##
@@ -444,53 +448,45 @@ class RDoc::Parser::C < RDoc::Parser
 
   def handle_attr(var_name, attr_name, reader, writer)
     rw = ''
-    if reader
-      #@stats.num_methods += 1
-      rw << 'R'
-    end
-    if writer
-      #@stats.num_methods += 1
-      rw << 'W'
-    end
+    rw << 'R' if reader
+    rw << 'W' if writer
 
     class_name = @known_classes[var_name]
 
     return unless class_name
 
-    class_obj  = find_class(var_name, class_name)
+    class_obj = find_class(var_name, class_name)
 
     if class_obj
       comment = find_attr_comment(attr_name)
-      unless comment.empty?
-        comment = mangle_comment(comment)
-      end
+      comment = strip_stars comment
       att = RDoc::Attr.new '', attr_name, rw, comment
+      @stats.add_method att
       class_obj.add_attribute(att)
     end
   end
 
-  def handle_class_module(var_name, class_mod, class_name, parent, in_module)
+  def handle_class_module(var_name, type, class_name, parent, in_module)
     parent_name = @known_classes[parent] || parent
 
-    if in_module
+    if in_module then
       enclosure = @classes[in_module] || @@enclosure_classes[in_module]
-      unless enclosure
-        if enclosure = @known_classes[in_module]
-          handle_class_module(in_module, (/^rb_m/ =~ in_module ? "module" : "class"),
-                              enclosure, nil, nil)
-          enclosure = @classes[in_module]
-        end
+
+      if enclosure.nil? and enclosure = @known_classes[in_module] then
+        type = /^rb_m/ =~ in_module ? "module" : "class"
+        handle_class_module in_module, type, enclosure, nil, nil
+        enclosure = @classes[in_module]
       end
-      unless enclosure
-        warn("Enclosing class/module '#{in_module}' for " +
-              "#{class_mod} #{class_name} not known")
+
+      unless enclosure then
+        warn("Enclosing class/module '#{in_module}' for #{type} #{class_name} not known")
         return
       end
     else
       enclosure = @top_level
     end
 
-    if class_mod == "class" then
+    if type == "class" then
       full_name = if RDoc::ClassModule === enclosure then
                     enclosure.full_name + "::#{class_name}"
                   else
@@ -500,7 +496,9 @@ class RDoc::Parser::C < RDoc::Parser
       if @content =~ %r{Document-class:\s+#{full_name}\s*<\s+([:,\w]+)} then
         parent_name = $1
       end
+
       cm = enclosure.add_class RDoc::NormalClass, class_name, parent_name
+
       @stats.add_class cm
     else
       cm = enclosure.add_module RDoc::NormalModule, class_name
@@ -528,46 +526,55 @@ class RDoc::Parser::C < RDoc::Parser
   # Values may include quotes and escaped colons (\:).
 
   def handle_constants(type, var_name, const_name, definition)
-    #@stats.num_constants += 1
     class_name = @known_classes[var_name]
 
     return unless class_name
 
-    class_obj  = find_class(var_name, class_name)
+    class_obj = find_class var_name, class_name
 
-    unless class_obj
-      warn("Enclosing class/module '#{const_name}' for not known")
+    unless class_obj then
+      warn "Enclosing class/module #{const_name.inspect} not known"
       return
     end
 
-    comment = find_const_comment(type, const_name)
+    comment = find_const_comment type, const_name
+    comment = strip_stars comment
+    comment = normalize_comment comment
 
     # In the case of rb_define_const, the definition and comment are in
     # "/* definition: comment */" form.  The literal ':' and '\' characters
     # can be escaped with a backslash.
     if type.downcase == 'const' then
-       elements = mangle_comment(comment).split(':')
-       if elements.nil? or elements.empty? then
-          con = RDoc::Constant.new(const_name, definition,
-                                   mangle_comment(comment))
-       else
-          new_definition = elements[0..-2].join(':')
-          if new_definition.empty? then # Default to literal C definition
-             new_definition = definition
-          else
-             new_definition.gsub!("\:", ":")
-             new_definition.gsub!("\\", '\\')
-          end
-          new_definition.sub!(/\A(\s+)/, '')
-          new_comment = $1.nil? ? elements.last : "#{$1}#{elements.last.lstrip}"
-          con = RDoc::Constant.new(const_name, new_definition,
-                                   mangle_comment(new_comment))
-       end
+      elements = comment.split ':'
+
+      if elements.nil? or elements.empty? then
+        con = RDoc::Constant.new const_name, definition, comment
+      else
+        new_definition = elements[0..-2].join(':')
+
+        if new_definition.empty? then # Default to literal C definition
+          new_definition = definition
+        else
+          new_definition.gsub!("\:", ":")
+          new_definition.gsub!("\\", '\\')
+        end
+
+        new_definition.sub!(/\A(\s+)/, '')
+
+        new_comment = if $1.nil? then
+                        elements.last.lstrip
+                      else
+                        "#{$1}#{elements.last.lstrip}"
+                      end
+
+        con = RDoc::Constant.new const_name, new_definition, new_comment
+      end
     else
-       con = RDoc::Constant.new const_name, definition, mangle_comment(comment)
+      con = RDoc::Constant.new const_name, definition, comment
     end
 
-    class_obj.add_constant(con)
+    @stats.add_constant con
+    class_obj.add_constant con
   end
 
   ##
@@ -604,9 +611,11 @@ class RDoc::Parser::C < RDoc::Parser
         meth_obj.params = "(" + (1..p_count).map{|i| "p#{i}"}.join(", ") + ")"
       end
 
-      if source_file then
+      if source_file and File.exist? source_file then
         file_name = File.join(@file_dir, source_file)
         body = (@@known_bodies[source_file] ||= File.read(file_name))
+      elsif source_file then
+        warn "unknown source file #{source_file}"
       else
         body = @content
       end
@@ -631,16 +640,6 @@ class RDoc::Parser::C < RDoc::Parser
     end
   end
 
-  ##
-  # Remove the /*'s and leading asterisks from C comments
-
-  def mangle_comment(comment)
-    comment.sub!(%r{/\*+}) { " " * $&.length }
-    comment.sub!(%r{\*+/}) { " " * $&.length }
-    comment.gsub!(/^[ \t]*\*/m) { " " * $&.length }
-    comment
-  end
-
   ##
   # Removes lines that are commented out that might otherwise get picked up
   # when scanning for classes and methods
@@ -668,11 +667,5 @@ class RDoc::Parser::C < RDoc::Parser
     @top_level
   end
 
-  def warn(msg)
-    $stderr.puts
-    $stderr.puts msg
-    $stderr.flush
-  end
-
 end