rdoc 5.0.0 → 6.3.1

data/lib/rdoc/markup/to_test.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # This Markup outputter is used for testing purposes.
 

data/lib/rdoc/markup/to_tt_only.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # Extracts sections of text enclosed in plus, tt or code.  Used to discover
 # undocumented parameters.
@@ -91,8 +91,8 @@ class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
       when RDoc::Markup::AttrChanger then
         off_tags res, item
         on_tags res, item
-      when RDoc::Markup::Special then
-        @res << convert_special(item) if in_tt? # TODO can this happen?
+      when RDoc::Markup::RegexpHandling then
+        @res << convert_regexp_handling(item) if in_tt? # TODO can this happen?
       else
         raise "Unknown flow element: #{item.inspect}"
       end

data/lib/rdoc/markup/verbatim.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A section of verbatim text
 

data/lib/rdoc/markup.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # RDoc::Markup parses plain text documents and attempts to decompose them into
 # their constituent parts.  Some of these parts are high-level: paragraphs,
@@ -65,17 +65,16 @@
 #   puts h.convert(input_string)
 #
 # You can extend the RDoc::Markup parser to recognize new markup
-# sequences, and to add special processing for text that matches a
-# regular expression.  Here we make WikiWords significant to the parser,
-# and also make the sequences {word} and \<no>text...</no> signify
+# sequences, and to add regexp handling. Here we make WikiWords significant to
+# the parser, and also make the sequences {word} and \<no>text...</no> signify
 # strike-through text.  We then subclass the HTML output class to deal
 # with these:
 #
 #   require 'rdoc'
 #
 #   class WikiHtml < RDoc::Markup::ToHtml
-#     def handle_special_WIKIWORD(special)
-#       "<font color=red>" + special.text + "</font>"
+#     def handle_regexp_WIKIWORD(target)
+#       "<font color=red>" + target.text + "</font>"
 #     end
 #   end
 #
@@ -83,7 +82,7 @@
 #   markup.add_word_pair("{", "}", :STRIKE)
 #   markup.add_html("no", :STRIKE)
 #
-#   markup.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
+#   markup.add_regexp_handling(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
 #
 #   wh = WikiHtml.new RDoc::Options.new, markup
 #   wh.add_tag(:STRIKE, "<strike>", "</strike>")
@@ -377,7 +376,7 @@
 #
 # Example links:
 #
-#   https://github.com/rdoc/rdoc
+#   https://github.com/ruby/rdoc
 #   mailto:user@example.com
 #   {RDoc Documentation}[http://rdoc.rubyforge.org]
 #   {RDoc Markup}[rdoc-ref:RDoc::Markup]
@@ -764,7 +763,7 @@ Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE}
 
 Please file a bug report with the above information at:
 
-https://github.com/rdoc/rdoc/issues
+https://github.com/ruby/rdoc/issues
 
     EOF
     raise
@@ -800,13 +799,12 @@ https://github.com/rdoc/rdoc/issues
   # Add to other inline sequences.  For example, we could add WikiWords using
   # something like:
   #
-  #    parser.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
+  #    parser.add_regexp_handling(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
   #
-  # Each wiki word will be presented to the output formatter via the
-  # accept_special method.
+  # Each wiki word will be presented to the output formatter.
 
-  def add_special(pattern, name)
-    @attribute_manager.add_special(pattern, name)
+  def add_regexp_handling(pattern, name)
+    @attribute_manager.add_regexp_handling(pattern, name)
   end
 
   ##
@@ -832,7 +830,7 @@ https://github.com/rdoc/rdoc/issues
   autoload :AttrSpan,              'rdoc/markup/attr_span'
   autoload :Attributes,            'rdoc/markup/attributes'
   autoload :AttributeManager,      'rdoc/markup/attribute_manager'
-  autoload :Special,               'rdoc/markup/special'
+  autoload :RegexpHandling,        'rdoc/markup/regexp_handling'
 
   # RDoc::Markup AST
   autoload :BlankLine,             'rdoc/markup/blank_line'
@@ -845,14 +843,13 @@ https://github.com/rdoc/rdoc/issues
   autoload :List,                  'rdoc/markup/list'
   autoload :ListItem,              'rdoc/markup/list_item'
   autoload :Paragraph,             'rdoc/markup/paragraph'
+  autoload :Table,                 'rdoc/markup/table'
   autoload :Raw,                   'rdoc/markup/raw'
   autoload :Rule,                  'rdoc/markup/rule'
   autoload :Verbatim,              'rdoc/markup/verbatim'
 
   # Formatters
   autoload :Formatter,             'rdoc/markup/formatter'
-  autoload :FormatterTestCase,     'rdoc/markup/formatter_test_case'
-  autoload :TextFormatterTestCase, 'rdoc/markup/text_formatter_test_case'
 
   autoload :ToAnsi,                'rdoc/markup/to_ansi'
   autoload :ToBs,                  'rdoc/markup/to_bs'

data/lib/rdoc/meta_method.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # MetaMethod represents a meta-programmed method
 

data/lib/rdoc/method_attr.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # Abstract class representing either a method or an attribute.
 
@@ -188,7 +188,7 @@ class RDoc::MethodAttr < RDoc::CodeObject
       next if String === ancestor
       next if parent == ancestor
 
-      other = ancestor.find_method_named('#' << name) ||
+      other = ancestor.find_method_named('#' + name) ||
               ancestor.find_attribute_named(name)
 
       return other if other

data/lib/rdoc/mixin.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A Mixin adds features from a module into another context.  RDoc::Include and
 # RDoc::Extend are both mixins.

data/lib/rdoc/normal_class.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A normal class, neither singleton nor anonymous
 
@@ -47,9 +47,9 @@ class RDoc::NormalClass < RDoc::ClassModule
   def to_s # :nodoc:
     display = "#{self.class.name} #{self.full_name}"
     if superclass
-      display << ' < ' << (superclass.is_a?(String) ? superclass : superclass.full_name)
+      display += ' < ' + (superclass.is_a?(String) ? superclass : superclass.full_name)
     end
-    display << ' -> ' << is_alias_for.to_s if is_alias_for
+    display += ' -> ' + is_alias_for.to_s if is_alias_for
     display
   end
 

data/lib/rdoc/normal_module.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 ##
 # A normal module, like NormalClass
 

data/lib/rdoc/options.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'optparse'
 require 'pathname'
 
@@ -164,7 +164,7 @@ class RDoc::Options
   ##
   # Files matching this pattern will be excluded
 
-  attr_accessor :exclude
+  attr_writer :exclude
 
   ##
   # The list of files to be processed
@@ -338,13 +338,17 @@ class RDoc::Options
 
   attr_reader :visibility
 
-  def initialize # :nodoc:
+  def initialize loaded_options = nil # :nodoc:
     init_ivars
+    override loaded_options if loaded_options
   end
 
   def init_ivars # :nodoc:
     @dry_run = false
-    @exclude = []
+    @exclude = %w[
+      ~\z \.orig\z \.rej\z \.bak\z
+      \.gemspec\z
+    ]
     @files = nil
     @force_output = false
     @force_update = true
@@ -414,6 +418,37 @@ class RDoc::Options
     init_with map
   end
 
+  def override map # :nodoc:
+    if map.has_key?('encoding')
+      encoding = map['encoding']
+      @encoding = encoding ? Encoding.find(encoding) : encoding
+    end
+
+    @charset        = map['charset']        if map.has_key?('charset')
+    @exclude        = map['exclude']        if map.has_key?('exclude')
+    @generator_name = map['generator_name'] if map.has_key?('generator_name')
+    @hyperlink_all  = map['hyperlink_all']  if map.has_key?('hyperlink_all')
+    @line_numbers   = map['line_numbers']   if map.has_key?('line_numbers')
+    @locale_name    = map['locale_name']    if map.has_key?('locale_name')
+    @locale_dir     = map['locale_dir']     if map.has_key?('locale_dir')
+    @main_page      = map['main_page']      if map.has_key?('main_page')
+    @markup         = map['markup']         if map.has_key?('markup')
+    @op_dir         = map['op_dir']         if map.has_key?('op_dir')
+    @show_hash      = map['show_hash']      if map.has_key?('show_hash')
+    @tab_width      = map['tab_width']      if map.has_key?('tab_width')
+    @template_dir   = map['template_dir']   if map.has_key?('template_dir')
+    @title          = map['title']          if map.has_key?('title')
+    @visibility     = map['visibility']     if map.has_key?('visibility')
+    @webcvs         = map['webcvs']         if map.has_key?('webcvs')
+
+    if map.has_key?('rdoc_include')
+      @rdoc_include = sanitize_path map['rdoc_include']
+    end
+    if map.has_key?('static_path')
+      @static_path  = sanitize_path map['static_path']
+    end
+  end
+
   def == other # :nodoc:
     self.class === other and
       @encoding       == other.encoding       and
@@ -493,6 +528,20 @@ class RDoc::Options
     end
   end
 
+  ##
+  # Create a regexp for #exclude
+
+  def exclude
+    if @exclude.nil? or Regexp === @exclude then
+      # done, #finish is being re-run
+      @exclude
+    elsif @exclude.empty? then
+      nil
+    else
+      Regexp.new(@exclude.join("|"))
+    end
+  end
+
   ##
   # Completes any unfinished option setup business such as filtering for
   # existent files, creating a regexp for #exclude and setting a default
@@ -505,13 +554,7 @@ class RDoc::Options
     root = @root.to_s
     @rdoc_include << root unless @rdoc_include.include?(root)
 
-    if @exclude.nil? or Regexp === @exclude then
-      # done, #finish is being re-run
-    elsif @exclude.empty? then
-      @exclude = nil
-    else
-      @exclude = Regexp.new(@exclude.join("|"))
-    end
+    @exclude = self.exclude
 
     finish_page_dir
 
@@ -544,7 +587,13 @@ class RDoc::Options
 
     @files << @page_dir.to_s
 
-    page_dir = @page_dir.expand_path.relative_path_from @root
+    page_dir = nil
+    begin
+      page_dir = @page_dir.expand_path.relative_path_from @root
+    rescue ArgumentError
+      # On Windows, sometimes crosses different drive letters.
+      page_dir = @page_dir.expand_path
+    end
 
     @page_dir = page_dir
   end
@@ -624,16 +673,16 @@ Usage: #{opt.program_name} [options] [names...]
       end
 
       parsers.sort.each do |parser, regexp|
-        opt.banner << "  - #{parser}: #{regexp.join ', '}\n"
+        opt.banner += "  - #{parser}: #{regexp.join ', '}\n"
       end
-      opt.banner << "  - TomDoc:  Only in ruby files\n"
+      opt.banner += "  - TomDoc:  Only in ruby files\n"
 
-      opt.banner << "\n  The following options are deprecated:\n\n"
+      opt.banner += "\n  The following options are deprecated:\n\n"
 
       name_length = DEPRECATED.keys.sort_by { |k| k.length }.last.length
 
       DEPRECATED.sort_by { |k,| k }.each do |name, reason|
-        opt.banner << "    %*1$2$s  %3$s\n" % [-name_length, name, reason]
+        opt.banner += "    %*1$2$s  %3$s\n" % [-name_length, name, reason]
       end
 
       opt.accept Template do |template|
@@ -738,7 +787,7 @@ Usage: #{opt.program_name} [options] [names...]
 
       opt.on("--[no-]force-update", "-U",
              "Forces rdoc to scan all sources even if",
-             "newer than the flag file.") do |value|
+             "no files are newer than the flag file.") do |value|
         @force_update = value
       end
 
@@ -1087,7 +1136,7 @@ Usage: #{opt.program_name} [options] [names...]
 
     unless quiet then
       deprecated.each do |opt|
-        $stderr.puts 'option ' << opt << ' is deprecated: ' << DEPRECATED[opt]
+        $stderr.puts 'option ' + opt + ' is deprecated: ' + DEPRECATED[opt]
       end
     end
 
@@ -1143,8 +1192,17 @@ Usage: #{opt.program_name} [options] [names...]
 
     path.reject do |item|
       path = Pathname.new(item).expand_path
-      relative = path.relative_path_from(dot).to_s
-      relative.start_with? '..'
+      is_reject = nil
+      relative = nil
+      begin
+        relative = path.relative_path_from(dot).to_s
+      rescue ArgumentError
+        # On Windows, sometimes crosses different drive letters.
+        is_reject = true
+      else
+        is_reject = relative.start_with? '..'
+      end
+      is_reject
     end
   end
 
@@ -1217,7 +1275,7 @@ Usage: #{opt.program_name} [options] [names...]
   def write_options
     RDoc.load_yaml
 
-    open '.rdoc_options', 'w' do |io|
+    File.open '.rdoc_options', 'w' do |io|
       io.set_encoding Encoding::UTF_8
 
       YAML.dump self, io

data/lib/rdoc/parser/c.rb

@@ -1,17 +1,17 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 require 'tsort'
 
 ##
 # RDoc::Parser::C attempts to parse C extension files.  It looks for
-# the standard patterns that you find in extensions: <tt>rb_define_class,
-# rb_define_method</tt> and so on.  It tries to find the corresponding
+# the standard patterns that you find in extensions: +rb_define_class+,
+# +rb_define_method+ and so on.  It tries to find the corresponding
 # C source for the methods and extract comments, but if we fail
 # we don't worry too much.
 #
 # The comments associated with a Ruby method are extracted from the C
 # comment block associated with the routine that _implements_ that
 # method, that is to say the method whose name is given in the
-# <tt>rb_define_method</tt> call. For example, you might write:
+# +rb_define_method+ call. For example, you might write:
 #
 #   /*
 #    * Returns a new array that is a one-dimensional flattening of this
@@ -24,8 +24,7 @@ require 'tsort'
 #    *    a.flatten                 #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 #    */
 #    static VALUE
-#    rb_ary_flatten(ary)
-#        VALUE ary;
+#    rb_ary_flatten(VALUE ary)
 #    {
 #        ary = rb_obj_dup(ary);
 #        rb_ary_flatten_bang(ary);
@@ -35,16 +34,16 @@ require 'tsort'
 #    ...
 #
 #    void
-#    Init_Array()
+#    Init_Array(void)
 #    {
 #      ...
 #      rb_define_method(rb_cArray, "flatten", rb_ary_flatten, 0);
 #
-# Here RDoc will determine from the rb_define_method line that there's a
+# 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
-# in the method rb_ary_flatten. It will then use the comment from that
+# in the method +rb_ary_flatten+. It will then use the comment from that
 # method in the HTML output. This method must be in the same source file
-# as the rb_define_method.
+# as the +rb_define_method+.
 #
 # The comment blocks may include special directives:
 #
@@ -70,15 +69,15 @@ require 'tsort'
 # [Document-variable: +name+]
 #   Documentation for the named +rb_define_variable+
 #
-# [Document-method: +method_name+]
+# [Document-method\: +method_name+]
 #   Documentation for the named method.  Use this when the method name is
 #   unambiguous.
 #
-# [Document-method: <tt>ClassName::method_name<tt>]
+# [Document-method\: <tt>ClassName::method_name</tt>]
 #   Documentation for a singleton method in the given class.  Use this when
 #   the method name alone is ambiguous.
 #
-# [Document-method: <tt>ClassName#method_name<tt>]
+# [Document-method\: <tt>ClassName#method_name</tt>]
 #   Documentation for a instance method in the given class.  Use this when the
 #   method name alone is ambiguous.
 #
@@ -210,47 +209,6 @@ class RDoc::Parser::C < RDoc::Parser
     end
   end
 
-  ##
-  # Removes duplicate call-seq entries for methods using the same
-  # implementation.
-
-  def deduplicate_call_seq
-    @methods.each do |var_name, functions|
-      class_name = @known_classes[var_name]
-      class_obj  = find_class var_name, class_name
-
-      functions.each_value do |method_names|
-        next if method_names.length == 1
-
-        method_names.each do |method_name|
-          deduplicate_method_name class_obj, method_name
-        end
-      end
-    end
-  end
-
-  ##
-  # If two ruby methods share a C implementation (and comment) this
-  # deduplicates the examples in the call_seq for the method to reduce
-  # confusion in the output.
-
-  def deduplicate_method_name class_obj, method_name # :nodoc:
-    return unless
-      method = class_obj.method_list.find { |m| m.name == method_name }
-    return unless call_seq = method.call_seq
-
-    method_name = method_name[0, 1] if method_name =~ /\A\[/
-
-    entries = call_seq.split "\n"
-
-    matching = entries.select do |entry|
-      entry =~ /^\w*\.?#{Regexp.escape method_name}/ or
-        entry =~ /\s#{Regexp.escape method_name}\s/
-    end
-
-    method.call_seq = matching.join "\n"
-  end
-
   ##
   # Scans #content for rb_define_alias
 
@@ -269,23 +227,29 @@ class RDoc::Parser::C < RDoc::Parser
       end
 
       class_obj = find_class var_name, class_name
-
-      al = RDoc::Alias.new '', old_name, new_name, ''
-      al.singleton = @singleton_classes.key? var_name
-
       comment = find_alias_comment var_name, new_name, old_name
-
       comment.normalize
-
-      al.comment = comment
-
-      al.record_location @top_level
-
-      class_obj.add_alias al
-      @stats.add_alias al
+      if comment.to_s.empty? and existing_method = class_obj.method_list.find { |m| m.name == old_name}
+        comment = existing_method.comment
+      end
+      add_alias(var_name, class_obj, old_name, new_name, comment)
     end
   end
 
+  ##
+  # Add alias, either from a direct alias definition, or from two
+  # method that reference the same function.
+
+  def add_alias(var_name, class_obj, old_name, new_name, comment)
+    al = RDoc::Alias.new '', old_name, new_name, ''
+    al.singleton = @singleton_classes.key? var_name
+    al.comment = comment
+    al.record_location @top_level
+    class_obj.add_alias al
+    @stats.add_alias al
+    al
+  end
+
   ##
   # Scans #content for rb_attr and rb_define_attr
 
@@ -324,12 +288,100 @@ class RDoc::Parser::C < RDoc::Parser
   # Scans #content for rb_define_class, boot_defclass, rb_define_class_under
   # and rb_singleton_class
 
-  def do_classes
-    do_boot_defclass
-    do_define_class
-    do_define_class_under
-    do_singleton_class
-    do_struct_define_without_accessor
+  def do_classes_and_modules
+    do_boot_defclass if @file_name == "class.c"
+
+    @content.scan(
+      %r(
+        (?<var_name>[\w\.]+)\s* =
+        \s*rb_(?:
+          define_(?:
+            class(?: # rb_define_class(class_name_1, parent_name_1)
+              \s*\(
+                \s*"(?<class_name_1>\w+)",
+                \s*(?<parent_name_1>\w+)\s*
+              \)
+            |
+              _under\s*\( # rb_define_class_under(class_under, class_name2, parent_name2...)
+                \s* (?<class_under>\w+),
+                \s* "(?<class_name_2>\w+)",
+                \s*
+                (?:
+                  (?<parent_name_2>[\w\*\s\(\)\.\->]+) |
+                  rb_path2class\("(?<path>[\w:]+)"\)
+                )
+              \s*\)
+            )
+          |
+            module(?: # rb_define_module(module_name_1)
+              \s*\(
+                \s*"(?<module_name_1>\w+)"\s*
+              \)
+            |
+              _under\s*\( # rb_define_module_under(module_under, module_name_2)
+                \s*(?<module_under>\w+),
+                \s*"(?<module_name_2>\w+)"
+              \s*\)
+            )
+          )
+      |
+        struct_define_without_accessor\s*\( # rb_struct_define_without_accessor(class_name_3, parent_name_3, ...)
+          \s*"(?<class_name_3>\w+)",
+          \s*(?<parent_name_3>\w+),
+          \s*\w+,        # Allocation function
+          (?:\s*"\w+",)* # Attributes
+          \s*NULL
+        \)
+      |
+        singleton_class\s*\( # rb_singleton_class(target_class_name)
+          \s*(?<target_class_name>\w+)
+        \)
+        )
+      )mx
+    ) do
+      class_name = $~[:class_name_1]
+      type = :class
+      if class_name
+        # rb_define_class(class_name_1, parent_name_1)
+        parent_name = $~[:parent_name_1]
+        #under = nil
+      else
+        class_name = $~[:class_name_2]
+        if class_name
+          # rb_define_class_under(class_under, class_name2, parent_name2...)
+          parent_name = $~[:parent_name_2] || $~[:path]
+          under = $~[:class_under]
+        else
+          class_name = $~[:class_name_3]
+          if class_name
+            # rb_struct_define_without_accessor(class_name_3, parent_name_3, ...)
+            parent_name = $~[:parent_name_3]
+            #under = nil
+          else
+            type = :module
+            class_name = $~[:module_name_1]
+            #parent_name = nil
+            if class_name
+              # rb_define_module(module_name_1)
+              #under = nil
+            else
+              class_name = $~[:module_name_2]
+              if class_name
+                # rb_define_module_under(module_under, module_name_1)
+                under = $~[:module_under]
+              else
+                # rb_singleton_class(target_class_name)
+                target_class_name = $~[:target_class_name]
+                handle_singleton $~[:var_name], target_class_name
+                next
+              end
+            end
+          end
+        end
+      end
+
+      handle_class_module($~[:var_name], type, class_name, parent_name, under)
+    end
   end
 
   ##
@@ -378,65 +430,6 @@ class RDoc::Parser::C < RDoc::Parser
     end
   end
 
-  ##
-  # Scans #content for rb_define_class
-
-  def do_define_class
-    # The '.' lets us handle SWIG-generated files
-    @content.scan(/([\w\.]+)\s* = \s*rb_define_class\s*
-              \(
-                 \s*"(\w+)",
-                 \s*(\w+)\s*
-              \)/mx) do |var_name, class_name, parent|
-      handle_class_module(var_name, :class, class_name, parent, nil)
-    end
-  end
-
-  ##
-  # Scans #content for rb_define_class_under
-
-  def do_define_class_under
-    @content.scan(/([\w\.]+)\s* =                  # var_name
-                   \s*rb_define_class_under\s*
-                   \(
-                     \s* (\w+),                    # under
-                     \s* "(\w+)",                  # class_name
-                     \s*
-                     (?:
-                       ([\w\*\s\(\)\.\->]+) |      # parent_name
-                       rb_path2class\("([\w:]+)"\) # path
-                     )
-                     \s*
-                   \)
-                  /mx) do |var_name, under, class_name, parent_name, path|
-      parent = path || parent_name
-
-      handle_class_module var_name, :class, class_name, parent, under
-    end
-  end
-
-  ##
-  # Scans #content for rb_define_module
-
-  def do_define_module
-    @content.scan(/(\w+)\s* = \s*rb_define_module\s*\(\s*"(\w+)"\s*\)/mx) do
-      |var_name, class_name|
-      handle_class_module(var_name, :module, class_name, nil, nil)
-    end
-  end
-
-  ##
-  # Scans #content for rb_define_module_under
-
-  def do_define_module_under
-    @content.scan(/(\w+)\s* = \s*rb_define_module_under\s*
-              \(
-                 \s*(\w+),
-                 \s*"(\w+)"
-              \s*\)/mx) do |var_name, in_module, class_name|
-      handle_class_module(var_name, :module, class_name, nil, in_module)
-    end
-  end
 
   ##
   # Scans #content for rb_include_module
@@ -446,7 +439,7 @@ class RDoc::Parser::C < RDoc::Parser
       next unless cls = @classes[c]
       m = @known_classes[m] || m
 
-      comment = RDoc::Comment.new '', @top_level
+      comment = RDoc::Comment.new '', @top_level, :c
       incl = cls.add_include RDoc::Include.new(m, comment)
       incl.record_location @top_level
     end
@@ -518,42 +511,6 @@ class RDoc::Parser::C < RDoc::Parser
     end
   end
 
-  ##
-  # Scans #content for rb_define_module and rb_define_module_under
-
-  def do_modules
-    do_define_module
-    do_define_module_under
-  end
-
-  ##
-  # Scans #content for rb_singleton_class
-
-  def do_singleton_class
-    @content.scan(/([\w\.]+)\s* = \s*rb_singleton_class\s*
-                  \(
-                    \s*(\w+)
-                  \s*\)/mx) do |sclass_var, class_var|
-      handle_singleton sclass_var, class_var
-    end
-  end
-
-  ##
-  # Scans #content for struct_define_without_accessor
-
-  def do_struct_define_without_accessor
-    @content.scan(/([\w\.]+)\s* = \s*rb_struct_define_without_accessor\s*
-              \(
-                 \s*"(\w+)",  # Class name
-                 \s*(\w+),    # Parent class
-                 \s*\w+,      # Allocation function
-                 (\s*"\w+",)* # Attributes
-                 \s*NULL
-              \)/mx) do |var_name, class_name, parent|
-      handle_class_module(var_name, :class, class_name, parent, nil)
-    end
-  end
-
   ##
   # Finds the comment for an alias on +class_name+ from +new_name+ to
   # +old_name+
@@ -564,7 +521,7 @@ class RDoc::Parser::C < RDoc::Parser
                                    \s*"#{Regexp.escape new_name}"\s*,
                                    \s*"#{Regexp.escape old_name}"\s*\);%xm
 
-    RDoc::Comment.new($1 || '', @top_level)
+    RDoc::Comment.new($1 || '', @top_level, :c)
   end
 
   ##
@@ -603,7 +560,7 @@ class RDoc::Parser::C < RDoc::Parser
                 ''
               end
 
-    RDoc::Comment.new comment, @top_level
+    RDoc::Comment.new comment, @top_level, :c
   end
 
   ##
@@ -615,7 +572,7 @@ class RDoc::Parser::C < RDoc::Parser
       ((?>/\*.*?\*/\s*)?)
       ((?:(?:\w+)\s+)?
         (?:intern\s+)?VALUE\s+(\w+)
-        \s*(?:\([^)]*\))(?:[^;]|$))
+        \s*(?:\([^)]*\))(?:[^\);]|$))
     | ((?>/\*.*?\*/\s*))^\s*(\#\s*define\s+(\w+)\s+(\w+))
     | ^\s*\#\s*define\s+(\w+)\s+(\w+)
     }xm) do
@@ -643,7 +600,7 @@ class RDoc::Parser::C < RDoc::Parser
 
     case type
     when :func_def
-      comment = RDoc::Comment.new args[0], @top_level
+      comment = RDoc::Comment.new args[0], @top_level, :c
       body = args[1]
       offset, = args[2]
 
@@ -666,16 +623,14 @@ class RDoc::Parser::C < RDoc::Parser
 
       #meth_obj.params = params
       meth_obj.start_collecting_tokens
-      tk = RDoc::RubyToken::Token.new nil, 1, 1
-      tk.set_text body
+      tk = { :line_no => 1, :char_no => 1, :text => body }
       meth_obj.add_token tk
       meth_obj.comment = comment
-      meth_obj.offset  = offset
       meth_obj.line    = file_content[0, offset].count("\n") + 1
 
       body
     when :macro_def
-      comment = RDoc::Comment.new args[0], @top_level
+      comment = RDoc::Comment.new args[0], @top_level, :c
       body = args[1]
       offset, = args[2]
 
@@ -685,11 +640,9 @@ class RDoc::Parser::C < RDoc::Parser
       find_modifiers comment, meth_obj
 
       meth_obj.start_collecting_tokens
-      tk = RDoc::RubyToken::Token.new nil, 1, 1
-      tk.set_text body
+      tk = { :line_no => 1, :char_no => 1, :text => body }
       meth_obj.add_token tk
       meth_obj.comment = comment
-      meth_obj.offset  = offset
       meth_obj.line    = file_content[0, offset].count("\n") + 1
 
       body
@@ -784,7 +737,7 @@ class RDoc::Parser::C < RDoc::Parser
       comment = ''
     end
 
-    comment = RDoc::Comment.new comment, @top_level
+    comment = RDoc::Comment.new comment, @top_level, :c
     comment.normalize
 
     look_for_directives_in class_mod, comment
@@ -829,7 +782,7 @@ class RDoc::Parser::C < RDoc::Parser
       table[const_name] ||
       ''
 
-    RDoc::Comment.new comment, @top_level
+    RDoc::Comment.new comment, @top_level, :c
   end
 
   ##
@@ -860,7 +813,7 @@ class RDoc::Parser::C < RDoc::Parser
 
     return unless comment
 
-    RDoc::Comment.new comment, @top_level
+    RDoc::Comment.new comment, @top_level, :c
   end
 
   ##
@@ -869,8 +822,8 @@ class RDoc::Parser::C < RDoc::Parser
 
   def handle_attr(var_name, attr_name, read, write)
     rw = ''
-    rw << 'R' if '1' == read
-    rw << 'W' if '1' == write
+    rw += 'R' if '1' == read
+    rw += 'W' if '1' == write
 
     class_name = @known_classes[var_name]
 
@@ -956,7 +909,7 @@ class RDoc::Parser::C < RDoc::Parser
   # can override the C value of the comment to give a friendly definition.
   #
   #   /* 300: The perfect score in bowling */
-  #   rb_define_const(cFoo, "PERFECT", INT2FIX(300);
+  #   rb_define_const(cFoo, "PERFECT", INT2FIX(300));
   #
   # Will override <tt>INT2FIX(300)</tt> with the value +300+ in the output
   # RDoc.  Values may include quotes and escaped colons (\:).
@@ -986,15 +939,15 @@ class RDoc::Parser::C < RDoc::Parser
         if new_definition.empty? then # Default to literal C definition
           new_definition = definition
         else
-          new_definition.gsub!("\:", ":")
-          new_definition.gsub!("\\", '\\')
+          new_definition = new_definition.gsub("\:", ":")
+          new_definition = new_definition.gsub("\\", '\\')
         end
 
         new_definition.sub!(/\A(\s+)/, '')
 
         new_comment = "#{$1}#{new_comment.lstrip}"
 
-        new_comment = RDoc::Comment.new new_comment, @top_level
+        new_comment = RDoc::Comment.new new_comment, @top_level, :c
 
         con = RDoc::Constant.new const_name, new_definition, new_comment
       else
@@ -1032,6 +985,10 @@ class RDoc::Parser::C < RDoc::Parser
 
     class_obj = find_class var_name, class_name
 
+    if existing_method = class_obj.method_list.find { |m| m.c_function == function }
+      add_alias(var_name, class_obj, existing_method.name, meth_name, existing_method.comment)
+    end
+
     if class_obj then
       if meth_name == 'initialize' then
         meth_name = 'new'
@@ -1241,7 +1198,7 @@ class RDoc::Parser::C < RDoc::Parser
   # when scanning for classes and methods
 
   def remove_commented_out_lines
-    @content.gsub!(%r%//.*rb_define_%, '//')
+    @content = @content.gsub(%r%//.*rb_define_%, '//')
   end
 
   ##
@@ -1251,8 +1208,7 @@ class RDoc::Parser::C < RDoc::Parser
   def scan
     remove_commented_out_lines
 
-    do_modules
-    do_classes
+    do_classes_and_modules
     do_missing
 
     do_constants
@@ -1261,12 +1217,9 @@ class RDoc::Parser::C < RDoc::Parser
     do_aliases
     do_attrs
 
-    deduplicate_call_seq
-
     @store.add_c_variables self
 
     @top_level
   end
 
 end
-