rdoc 6.3.4.1 → 8.0.0

data/lib/rdoc/parser/c.rb

@@ -122,6 +122,11 @@ class RDoc::Parser::C < RDoc::Parser
 
   include RDoc::Text
 
+  # :stopdoc:
+  BOOL_ARG_PATTERN = /\s*+\b([01]|Q?(?:true|false)|TRUE|FALSE)\b\s*/
+  TRUE_VALUES = ['1', 'TRUE', 'true', 'Qtrue'].freeze
+  # :startdoc:
+
   ##
   # Maps C variable names to names of Ruby classes or modules
 
@@ -163,7 +168,7 @@ class RDoc::Parser::C < RDoc::Parser
   # Prepares for parsing a C file.  See RDoc::Parser#initialize for details on
   # the arguments.
 
-  def initialize top_level, file_name, content, options, stats
+  def initialize(top_level, content, options, stats)
     super
 
     @known_classes = RDoc::KNOWN_CLASSES.dup
@@ -173,6 +178,8 @@ class RDoc::Parser::C < RDoc::Parser
     @classes           = load_variable_map :c_class_variables
     @singleton_classes = load_variable_map :c_singleton_class_variables
 
+    @markup = @options.markup
+
     # class_variable => { function => [method, ...] }
     @methods = Hash.new { |h, f| h[f] = Hash.new { |i, m| i[m] = [] } }
 
@@ -186,7 +193,7 @@ class RDoc::Parser::C < RDoc::Parser
 
     @enclosure_dependencies.extend TSort
 
-    def @enclosure_dependencies.tsort_each_node &block
+    def @enclosure_dependencies.tsort_each_node(&block)
       each_key(&block)
     rescue TSort::Cyclic => e
       cycle_vars = e.message.scan(/"(.*?)"/).flatten
@@ -204,7 +211,7 @@ class RDoc::Parser::C < RDoc::Parser
       retry
     end
 
-    def @enclosure_dependencies.tsort_each_child node, &block
+    def @enclosure_dependencies.tsort_each_child(node, &block)
       fetch(node, []).each(&block)
     end
   end
@@ -241,9 +248,7 @@ class RDoc::Parser::C < RDoc::Parser
   # 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 = RDoc::Alias.new old_name, new_name, comment, singleton: @singleton_classes.key?(var_name)
     al.record_location @top_level
     class_obj.add_alias al
     @stats.add_alias al
@@ -257,18 +262,18 @@ class RDoc::Parser::C < RDoc::Parser
     @content.scan(/rb_attr\s*\(
                    \s*(\w+),
                    \s*([\w"()]+),
-                   \s*([01]),
-                   \s*([01]),
-                   \s*\w+\);/xm) do |var_name, attr_name, read, write|
+                   #{BOOL_ARG_PATTERN},
+                   #{BOOL_ARG_PATTERN},
+                   \s*\w+\);/xmo) do |var_name, attr_name, read, write|
       handle_attr var_name, attr_name, read, write
     end
 
     @content.scan(%r%rb_define_attr\(
                              \s*([\w\.]+),
                              \s*"([^"]+)",
-                             \s*(\d+),
-                             \s*(\d+)\s*\);
-                %xm) do |var_name, attr_name, read, write|
+                             #{BOOL_ARG_PATTERN},
+                             #{BOOL_ARG_PATTERN}\);
+                %xmo) do |var_name, attr_name, read, write|
       handle_attr var_name, attr_name, read, write
     end
   end
@@ -293,94 +298,92 @@ class RDoc::Parser::C < RDoc::Parser
 
     @content.scan(
       %r(
+        (?<open>\s*\(\s*) {0}
+        (?<close>\s*\)\s*) {0}
+        (?<name>\s*"(?<class_name>\w+)") {0}
+        (?<parent>\s*(?:
+          (?<parent_name>[\w\*\s\(\)\.\->]+) |
+          rb_path2class\s*\(\s*"(?<path>[\w:]+)"\s*\)
+        )) {0}
+        (?<under>\w+) {0}
+
         (?<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:]+)"\)
-                )
+            class(?: # rb_define_class(name, parent_name)
+              \(\s*
+                \g<name>,
+                \g<parent>
               \s*\)
+            |
+              _under\g<open> # rb_define_class_under(under, name, parent_name...)
+                \g<under>,
+                \g<name>,
+                \g<parent>
+              \g<close>
             )
           |
-            module(?: # rb_define_module(module_name_1)
-              \s*\(
-                \s*"(?<module_name_1>\w+)"\s*
-              \)
+            (?<module>)
+            module(?: # rb_define_module(name)
+              \g<open>
+                \g<name>
+              \g<close>
             |
-              _under\s*\( # rb_define_module_under(module_under, module_name_2)
-                \s*(?<module_under>\w+),
-                \s*"(?<module_name_2>\w+)"
-              \s*\)
+              _under\g<open> # rb_define_module_under(under, name)
+                \g<under>,
+                \g<name>
+              \g<close>
             )
           )
       |
-        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
-        \)
+        (?<attributes>(?:\s*"\w+",)*\s*NULL\s*) {0}
+        struct_define(?:
+          \g<open> # rb_struct_define(name, ...)
+            \g<name>,
+        |
+          _under\g<open> # rb_struct_define_under(under, name, ...)
+            \g<under>,
+            \g<name>,
+        |
+          _without_accessor(?:
+            \g<open> # rb_struct_define_without_accessor(name, parent_name, ...)
+          |
+            _under\g<open> # rb_struct_define_without_accessor_under(under, name, parent_name, ...)
+              \g<under>,
+          )
+            \g<name>,
+            \g<parent>,
+            \s*\w+,        # Allocation function
+        )
+          \g<attributes>
+        \g<close>
       |
-        singleton_class\s*\( # rb_singleton_class(target_class_name)
-          \s*(?<target_class_name>\w+)
-        \)
+        singleton_class\g<open> # rb_singleton_class(target_class_name)
+          (?<target_class_name>\w+)
+        \g<close>
         )
       )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
+      if target_class_name = $~[:target_class_name]
+        # rb_singleton_class(target_class_name)
+        handle_singleton $~[:var_name], target_class_name
+        next
       end
 
-      handle_class_module($~[:var_name], type, class_name, parent_name, under)
+      var_name = $~[:var_name]
+      type = $~[:module] ? :module : :class
+      class_name = $~[:class_name]
+      parent_name = $~[:parent_name] || $~[:path]
+      under = $~[:under]
+      attributes = $~[:attributes]
+
+      handle_class_module(var_name, type, class_name, parent_name, under)
+      if attributes and !parent_name # rb_struct_define *not* without_accessor
+        true_flag = 'Qtrue'
+        attributes.scan(/"\K\w+(?=")/) do |attr_name|
+          handle_attr var_name, attr_name, true_flag, true_flag
+        end
+      end
     end
   end
 
@@ -400,6 +403,7 @@ class RDoc::Parser::C < RDoc::Parser
                  \s*(.*?)\s*\)\s*;
                  %xm) do |type, var_name, const_name, definition|
       var_name = "rb_cObject" if !var_name or var_name == "rb_mKernel"
+      type = "const" if type == "global_const"
       handle_constants type, var_name, const_name, definition
     end
 
@@ -435,11 +439,11 @@ class RDoc::Parser::C < RDoc::Parser
   # Scans #content for rb_include_module
 
   def do_includes
-    @content.scan(/rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/) do |c,m|
+    @content.scan(/rb_include_module\s*\(\s*(\w+?),\s*(\w+?)\s*\)/) do |c, m|
       next unless cls = @classes[c]
       m = @known_classes[m] || m
 
-      comment = RDoc::Comment.new '', @top_level, :c
+      comment = new_comment '', @top_level, :c
       incl = cls.add_include RDoc::Include.new(m, comment)
       incl.record_location @top_level
     end
@@ -515,13 +519,13 @@ class RDoc::Parser::C < RDoc::Parser
   # Finds the comment for an alias on +class_name+ from +new_name+ to
   # +old_name+
 
-  def find_alias_comment class_name, new_name, old_name
+  def find_alias_comment(class_name, new_name, old_name)
     content =~ %r%((?>/\*.*?\*/\s+))
                   rb_define_alias\(\s*#{Regexp.escape class_name}\s*,
                                    \s*"#{Regexp.escape new_name}"\s*,
                                    \s*"#{Regexp.escape old_name}"\s*\);%xm
 
-    RDoc::Comment.new($1 || '', @top_level, :c)
+    new_comment($1 || '', @top_level, :c)
   end
 
   ##
@@ -533,7 +537,7 @@ class RDoc::Parser::C < RDoc::Parser
   # +read+ and +write+ are the read/write flags ('1' or '0').  Either both or
   # neither must be provided.
 
-  def find_attr_comment var_name, attr_name, read = nil, write = nil
+  def find_attr_comment(var_name, attr_name, read = nil, write = nil)
     attr_name = Regexp.escape attr_name
 
     rw = if read and write then
@@ -560,29 +564,28 @@ class RDoc::Parser::C < RDoc::Parser
                 ''
               end
 
-    RDoc::Comment.new comment, @top_level, :c
+    new_comment comment, @top_level, :c
   end
 
   ##
   # Generate a Ruby-method table
 
-  def gen_body_table file_content
+  def gen_body_table(file_content)
     table = {}
     file_content.scan(%r{
       ((?>/\*.*?\*/\s*)?)
-      ((?:(?:\w+)\s+)?
-        (?:intern\s+)?VALUE\s+(\w+)
-        \s*(?:\([^)]*\))(?:[^\);]|$))
+      ((?:\w+\s+){0,2} VALUE\s+(\w+)
+        \s*(?:\([^\)]*\))(?:[^\);]|$))
     | ((?>/\*.*?\*/\s*))^\s*(\#\s*define\s+(\w+)\s+(\w+))
     | ^\s*\#\s*define\s+(\w+)\s+(\w+)
     }xm) do
       case
-      when $1
-        table[$3] = [:func_def, $1, $2, $~.offset(2)] if !table[$3] || table[$3][0] != :func_def
-      when $4
-        table[$6] = [:macro_def, $4, $5, $~.offset(5), $7] if !table[$6] || table[$6][0] == :macro_alias
-      when $8
-        table[$8] ||= [:macro_alias, $9]
+      when name = $3
+        table[name] = [:func_def, $1, $2, $~.offset(2)] if !(t = table[name]) || t[0] != :func_def
+      when name = $6
+        table[name] = [:macro_def, $4, $5, $~.offset(5), $7] if !(t = table[name]) || t[0] == :macro_alias
+      when name = $8
+        table[name] ||= [:macro_alias, $9]
       end
     end
     table
@@ -591,7 +594,7 @@ class RDoc::Parser::C < RDoc::Parser
   ##
   # Find the C code corresponding to a Ruby method
 
-  def find_body class_name, meth_name, meth_obj, file_content, quiet = false
+  def find_body(class_name, meth_name, meth_obj, file_content, quiet = false)
     if file_content
       @body_table ||= {}
       @body_table[file_content] ||= gen_body_table file_content
@@ -600,12 +603,10 @@ class RDoc::Parser::C < RDoc::Parser
 
     case type
     when :func_def
-      comment = RDoc::Comment.new args[0], @top_level, :c
+      comment = new_comment args[0], @top_level, :c
       body = args[1]
       offset, = args[2]
 
-      comment.remove_private if comment
-
       # try to find the whole body
       body = $& if /#{Regexp.escape body}[^(]*?\{.*?^\}/m =~ file_content
 
@@ -618,11 +619,10 @@ class RDoc::Parser::C < RDoc::Parser
       override_comment = find_override_comment class_name, meth_obj
       comment = override_comment if override_comment
 
-      comment.normalize
       find_modifiers comment, meth_obj if comment
 
       #meth_obj.params = params
-      meth_obj.start_collecting_tokens
+      meth_obj.start_collecting_tokens(:c)
       tk = { :line_no => 1, :char_no => 1, :text => body }
       meth_obj.add_token tk
       meth_obj.comment = comment
@@ -630,16 +630,15 @@ class RDoc::Parser::C < RDoc::Parser
 
       body
     when :macro_def
-      comment = RDoc::Comment.new args[0], @top_level, :c
+      comment = new_comment args[0], @top_level, :c
       body = args[1]
       offset, = args[2]
 
       find_body class_name, args[3], meth_obj, file_content, true
 
-      comment.normalize
       find_modifiers comment, meth_obj
 
-      meth_obj.start_collecting_tokens
+      meth_obj.start_collecting_tokens(:c)
       tk = { :line_no => 1, :char_no => 1, :text => body }
       meth_obj.add_token tk
       meth_obj.comment = comment
@@ -660,7 +659,6 @@ class RDoc::Parser::C < RDoc::Parser
       comment = find_override_comment class_name, meth_obj
 
       if comment then
-        comment.normalize
         find_modifiers comment, meth_obj
         meth_obj.comment = comment
 
@@ -675,15 +673,17 @@ class RDoc::Parser::C < RDoc::Parser
   ##
   # Finds a RDoc::NormalClass or RDoc::NormalModule for +raw_name+
 
-  def find_class(raw_name, name)
+  def find_class(raw_name, name, base_name = nil)
     unless @classes[raw_name]
       if raw_name =~ /^rb_m/
         container = @top_level.add_module RDoc::NormalModule, name
       else
         container = @top_level.add_class RDoc::NormalClass, name
       end
+      container.name = base_name if base_name
 
       container.record_location @top_level
+      @top_level.add_to_classes_or_modules container
       @classes[raw_name] = container
     end
     @classes[raw_name]
@@ -715,14 +715,14 @@ class RDoc::Parser::C < RDoc::Parser
   #    */
   #   VALUE cFoo = rb_define_class("Foo", rb_cObject);
 
-  def find_class_comment class_name, class_mod
+  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
+        Init(?:VM)?_(?i:#{class_name})\s*(?:_\(\s*)?\(\s*(?:void\s*)?\)%xm then
       comment = $1.sub(%r%Document-(?:class|module):\s+#{class_name}%, '')
     elsif @content =~ %r%Document-(?:class|module):\s+#{class_name}\s*?
                          (?:<\s+[:,\w]+)?\n((?>.*?\*/))%xm then
@@ -737,8 +737,7 @@ class RDoc::Parser::C < RDoc::Parser
       comment = ''
     end
 
-    comment = RDoc::Comment.new comment, @top_level, :c
-    comment.normalize
+    comment = new_comment comment, @top_level, :c
 
     look_for_directives_in class_mod, comment
 
@@ -748,20 +747,34 @@ class RDoc::Parser::C < RDoc::Parser
   ##
   # Generate a const table
 
-  def gen_const_table file_content
+  def gen_const_table(file_content)
     table = {}
     @content.scan(%r{
-      ((?>^\s*/\*.*?\*/\s+))
-        rb_define_(\w+)\((?:\s*(?:\w+),)?\s*
-                           "(\w+)"\s*,
+      (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_define_(?<type>\w+)\(\s*(?:\w+),\s*
+                           "(?<name>\w+)"\s*,
                            .*?\)\s*;
+    | (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_define_global_(?<type>const)\(\s*
+                           "(?<name>\w+)"\s*,
+                           .*?\)\s*;
+    |  (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_file_(?<type>const)\(\s*
+                           "(?<name>\w+)"\s*,
+                           .*?\)\s*;
+    |  (?<doc>(?>^\s*/\*.*?\*/\s+))
+        rb_curses_define_(?<type>const)\(\s*
+                           (?<name>\w+)
+                           \s*\)\s*;
     | Document-(?:const|global|variable):\s
-        ((?:\w+::)*\w+)
-        \s*?\n((?>.*?\*/))
+        (?<name>(?:\w+::)*\w+)
+        \s*?\n(?<doc>(?>.*?\*/))
     }mxi) do
-      case
-      when $1 then table[[$2, $3]] = $1
-      when $4 then table[$4] = "/*\n" + $5
+      name, doc, type = $~.values_at(:name, :doc, :type)
+      if type
+        table[[type, name]] = doc
+      else
+        table[name] = "/*\n" + doc
       end
     end
     table
@@ -782,38 +795,35 @@ class RDoc::Parser::C < RDoc::Parser
       table[const_name] ||
       ''
 
-    RDoc::Comment.new comment, @top_level, :c
+    new_comment comment, @top_level, :c
   end
 
   ##
   # Handles modifiers in +comment+ and updates +meth_obj+ as appropriate.
 
-  def find_modifiers comment, meth_obj
-    comment.normalize
-    comment.extract_call_seq meth_obj
-
+  def find_modifiers(comment, meth_obj)
     look_for_directives_in meth_obj, comment
   end
 
   ##
   # Finds a <tt>Document-method</tt> override for +meth_obj+ on +class_name+
 
-  def find_override_comment class_name, meth_obj
+  def find_override_comment(class_name, meth_obj)
     name = Regexp.escape meth_obj.name
     prefix = Regexp.escape meth_obj.name_prefix
 
     comment = if @content =~ %r%Document-method:
                                 \s+#{class_name}#{prefix}#{name}
                                 \s*?\n((?>.*?\*/))%xm then
-                "/*#{$1}"
+                "/*\n#{$1}"
               elsif @content =~ %r%Document-method:
                                    \s#{name}\s*?\n((?>.*?\*/))%xm then
-                "/*#{$1}"
+                "/*\n#{$1}"
               end
 
     return unless comment
 
-    RDoc::Comment.new comment, @top_level, :c
+    new_comment comment, @top_level, :c
   end
 
   ##
@@ -822,8 +832,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 TRUE_VALUES.include?(read)
+    rw += 'W' if TRUE_VALUES.include?(write)
 
     class_name = @known_classes[var_name]
 
@@ -838,7 +848,7 @@ class RDoc::Parser::C < RDoc::Parser
 
     name = attr_name.gsub(/rb_intern(?:_const)?\("([^"]+)"\)/, '\1')
 
-    attr = RDoc::Attr.new '', name, rw, comment
+    attr = RDoc::Attr.new name, rw, comment
 
     attr.record_location @top_level
     class_obj.add_attribute attr
@@ -889,6 +899,7 @@ class RDoc::Parser::C < RDoc::Parser
     end
 
     cm.record_location enclosure.top_level
+    enclosure.top_level.add_to_classes_or_modules cm
 
     find_class_comment cm.full_name, cm
 
@@ -919,7 +930,7 @@ class RDoc::Parser::C < RDoc::Parser
 
     return unless class_name
 
-    class_obj = find_class var_name, class_name
+    class_obj = find_class var_name, class_name, class_name[/::\K[^:]+\z/]
 
     unless class_obj then
       @options.warn 'Enclosing class or module %p is not known' % [const_name]
@@ -933,21 +944,20 @@ class RDoc::Parser::C < RDoc::Parser
     # "/* definition: comment */" form.  The literal ':' and '\' characters
     # can be escaped with a backslash.
     if type.downcase == 'const' then
-      no_match, new_definition, new_comment = comment.text.split(/(\A.*):/)
+      if /\A(.+?)?:(?!\S)/ =~ comment.text
+        new_definition, new_comment = $1, $'
 
-      if no_match and no_match.empty? then
-        if new_definition.empty? then # Default to literal C definition
+        if !new_definition # Default to literal C definition
           new_definition = definition
         else
-          new_definition = new_definition.gsub("\:", ":")
-          new_definition = new_definition.gsub("\\", '\\')
+          new_definition = new_definition.gsub(/\\([\\:])/, '\1')
         end
 
         new_definition.sub!(/\A(\s+)/, '')
 
         new_comment = "#{$1}#{new_comment.lstrip}"
 
-        new_comment = RDoc::Comment.new new_comment, @top_level, :c
+        new_comment = self.new_comment(new_comment, @top_level, :c)
 
         con = RDoc::Constant.new const_name, new_definition, new_comment
       else
@@ -996,10 +1006,9 @@ class RDoc::Parser::C < RDoc::Parser
         type = 'method' # force public
       end
 
-      meth_obj = RDoc::AnyMethod.new '', meth_name
+      singleton = singleton || %w[singleton_method module_function].include?(type)
+      meth_obj = RDoc::AnyMethod.new meth_name, singleton: singleton
       meth_obj.c_function = function
-      meth_obj.singleton =
-        singleton || %w[singleton_method module_function].include?(type)
 
       p_count = Integer(param_count) rescue -1
 
@@ -1007,7 +1016,7 @@ class RDoc::Parser::C < RDoc::Parser
         file_name = File.join @file_dir, source_file
 
         if File.exist? file_name then
-          file_content = File.read file_name
+          file_content = RDoc::Encoding.read_file file_name, @options.encoding
         else
           @options.warn "unknown source #{source_file} for #{meth_name} in #{@file_name}"
         end
@@ -1023,12 +1032,18 @@ class RDoc::Parser::C < RDoc::Parser
                           elsif p_count == -1 then # argc, argv
                             rb_scan_args body
                           else
-                            "(#{(1..p_count).map { |i| "p#{i}" }.join ', '})"
+                            args = (1..p_count).map { |i| "p#{i}" }
+                            "(#{args.join ', '})"
                           end
 
 
         meth_obj.record_location @top_level
+
+        if meth_obj.section_title
+          class_obj.temporary_section = class_obj.add_section(meth_obj.section_title)
+        end
         class_obj.add_method meth_obj
+
         @stats.add_method meth_obj
         meth_obj.visibility = :private if 'private_method' == type
       end
@@ -1038,27 +1053,13 @@ class RDoc::Parser::C < RDoc::Parser
   ##
   # Registers a singleton class +sclass_var+ as a singleton of +class_var+
 
-  def handle_singleton sclass_var, class_var
-    class_name = @known_classes[class_var]
-
-    @known_classes[sclass_var]     = class_name
-    @singleton_classes[sclass_var] = class_name
-  end
-
-  ##
-  # Normalizes tabs in +body+
-
-  def handle_tab_width(body)
-    if /\t/ =~ body
-      tab_width = @options.tab_width
-      body.split(/\n/).map do |line|
-        1 while line.gsub!(/\t+/) do
-          ' ' * (tab_width * $&.length - $`.length % tab_width)
-        end && $~
-        line
-      end.join "\n"
-    else
-      body
+  def handle_singleton(sclass_var, class_var)
+    if (klass = @classes[class_var])
+      @classes[sclass_var] = klass
+    end
+    if (class_name = @known_classes[class_var])
+      @known_classes[sclass_var]     = class_name
+      @singleton_classes[sclass_var] = class_name
     end
   end
 
@@ -1066,7 +1067,7 @@ class RDoc::Parser::C < RDoc::Parser
   # Loads the variable map with the given +name+ from the RDoc::Store, if
   # present.
 
-  def load_variable_map map_name
+  def load_variable_map(map_name)
     return {} unless files = @store.cache[map_name]
     return {} unless name_map = files[@file_name]
 
@@ -1090,23 +1091,16 @@ class RDoc::Parser::C < RDoc::Parser
   # Look for directives in a normal comment block:
   #
   #   /*
-  #    * :title: My Awesome Project
+  #    * :nodoc:
   #    */
   #
   # This method modifies the +comment+
 
-  def look_for_directives_in context, comment
-    @preprocess.handle comment, context do |directive, param|
-      case directive
-      when 'main' then
-        @options.main_page = param
-        ''
-      when 'title' then
-        @options.default_title = param if @options.respond_to? :default_title=
-        ''
-      end
-    end
-
+  def look_for_directives_in(context, comment)
+    comment.text, format = @preprocess.run_pre_processes(comment.text, context, comment.line || 1, :c)
+    comment.format = format if format
+    @preprocess.run_post_processes(comment, context)
+    comment.normalized = true
     comment
   end
 
@@ -1114,7 +1108,7 @@ class RDoc::Parser::C < RDoc::Parser
   # Extracts parameters from the +method_body+ and returns a method
   # parameter string.  Follows 1.9.3dev's scan-arg-spec, see README.EXT
 
-  def rb_scan_args method_body
+  def rb_scan_args(method_body)
     method_body =~ /rb_scan_args\((.*?)\)/m
     return '(*args)' unless $1
 
@@ -1222,4 +1216,12 @@ class RDoc::Parser::C < RDoc::Parser
     @top_level
   end
 
+  ##
+  # Creates a RDoc::Comment instance.
+
+  def new_comment(text = nil, location = nil, language = nil)
+    RDoc::Comment.new(text, location, language).tap do |comment|
+      comment.format = @markup
+    end
+  end
 end