Renamespace lib/rdoc/markup from SM::SimpleMarkup to RDoc::Markup.

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

2 files changed, 1025 insertions, 1050 deletions

diff --git a/lib/rdoc/parsers/parse_rb.rb b/lib/rdoc/parsers/parse_rb.rb
index 42256b2523..baf90577cb 100644
--- a/lib/rdoc/parsers/parse_rb.rb
+++ b/lib/rdoc/parsers/parse_rb.rb
@@ -7,9 +7,9 @@
 
 # This file contains stuff stolen outright from:
 #
-#   rtags.rb - 
+#   rtags.rb -
 #   ruby-lex.rb - ruby lexcal analizer
-#   ruby-token.rb - ruby tokens 
+#   ruby-token.rb - ruby tokens
 #   	by Keiju ISHITSUKA (Nippon Rational Inc.)
 #
 
@@ -19,11 +19,11 @@ require "irb/slex"
 require "rdoc/code_objects"
 require "rdoc/tokenstream"
 
-require "rdoc/markup/simple_markup/preprocess"
+require "rdoc/markup/preprocess"
 
 require "rdoc/parsers/parserfactory"
 
-$TOKEN_DEBUG = $DEBUG_RDOC
+#$TOKEN_DEBUG = $DEBUG_RDOC
 
 # Definitions of all tokens involved in the lexical analysis
 
@@ -35,7 +35,7 @@ module RubyToken
   EXPR_FNAME = :EXPR_FNAME
   EXPR_DOT   = :EXPR_DOT
   EXPR_CLASS = :EXPR_CLASS
-  
+
   class Token
     NO_TEXT = "??".freeze
     attr_accessor :text
@@ -117,8 +117,8 @@ module RubyToken
       if (tk = source[token]).nil?
         fail TkReading2TokenNoKey, token
       end
-      tk = Token(tk[0], value) 
-    else 
+      tk = Token(tk[0], value)
+    else
       tk = if (token.ancestors & [TkId, TkVal, TkOPASGN, TkUnknownChar]).empty?
              token.new(@prev_line_no, @prev_char_no)
            else
@@ -218,14 +218,14 @@ module RubyToken
     [:TkASSOC,      TkOp,   "=>"],
     [:TkQUESTION,   TkOp,   "?"],	 #?
     [:TkCOLON,      TkOp,   ":"],        #:
-    
+
     [:TkfLPAREN],         # func( #
     [:TkfLBRACK],         # func[ #
     [:TkfLBRACE],         # func{ #
     [:TkSTAR],            # *arg
     [:TkAMPER],           # &arg #
     [:TkSYMBOL,     TkId],          # :SYMBOL
-    [:TkSYMBEG,     TkId], 
+    [:TkSYMBEG,     TkId],
     [:TkGT,	    TkOp,   ">"],
     [:TkLT,	    TkOp,   "<"],
     [:TkPLUS,	    TkOp,   "+"],
@@ -276,7 +276,7 @@ module RubyToken
     token_c =  Class.new super_token
     RubyToken.const_set token_n, token_c
 #    token_c.inspect
- 
+
     if reading
       if TkReading2Token[reading]
         fail TkReading2TokenDuplicateError, token_n, reading
@@ -338,14 +338,14 @@ class RubyLex
   # here document.  Once complete, it needs to read the rest of the
   # original line, but then skip the here document body.
   #
-  
+
   class BufferedReader
-    
+
     attr_reader :line_num
-    
+
     def initialize(content, options)
       @options = options
-      
+
       if /\t/ =~ content
         tab_width = @options.tab_width
         content = content.split(/\n/).map do |line|
@@ -363,34 +363,34 @@ class RubyLex
       @last_newline = 0
       @newline_pending = false
     end
-    
+
     def column
       @offset - @last_newline
     end
-    
+
     def getc
       return nil if @offset >= @size
       ch = @content[@offset, 1]
-      
+
       @offset += 1
       @hwm = @offset if @hwm < @offset
-      
+
       if @newline_pending
         @line_num += 1
         @last_newline = @offset - 1
         @newline_pending = false
       end
-      
+
       if ch == "\n"
         @newline_pending = true
       end
       ch
     end
-    
+
     def getc_already_read
       getc
     end
-    
+
     def ungetc(ch)
       raise "unget past beginning of file" if @offset <= 0
       @offset -= 1
@@ -398,13 +398,13 @@ class RubyLex
         @newline_pending = false
       end
     end
-    
+
     def get_read
       res = @content[@read_back_offset...@offset]
       @read_back_offset = @offset
       res
     end
-    
+
     def peek(at)
       pos = @offset + at
       if pos >= @size
@@ -413,11 +413,11 @@ class RubyLex
         @content[pos, 1]
       end
     end
-    
+
     def peek_equal(str)
       @content[@offset, str.length] == str
     end
-    
+
     def divert_read_from(reserve)
       @content[@offset, 0] = reserve
       @size      = @content.size
@@ -430,10 +430,10 @@ class RubyLex
   def_exception(:AlreadyDefinedToken, "Already defined token(%s)")
   def_exception(:TkReading2TokenNoKey, "key nothing(key='%s')")
   def_exception(:TkSymbol2TokenNoKey, "key nothing(key='%s')")
-  def_exception(:TkReading2TokenDuplicateError, 
+  def_exception(:TkReading2TokenDuplicateError,
 		"key duplicate(token_n='%s', key='%s')")
   def_exception(:SyntaxError, "%s")
-  
+
   include RubyToken
   include IRB
 
@@ -459,7 +459,7 @@ class RubyLex
     @quoted = nil
     @lex_state = EXPR_BEG
     @space_seen = false
-    
+
     @continue = false
     @line = ""
 
@@ -546,10 +546,9 @@ class RubyLex
       get_read
     end
 #   throw :eof unless tk
-    p tk if $DEBUG_RDOC
     tk
   end
-  
+
   ENINDENT_CLAUSE = [
     "case", "class", "def", "do", "for", "if",
     "module", "unless", "until", "while", "begin" #, "when"
@@ -564,7 +563,7 @@ class RubyLex
     "r" => "/",
     "w" => "]"
   }
-  
+
   PERCENT_PAREN = {
     "{" => "}",
     "[" => "]",
@@ -647,10 +646,10 @@ class RubyLex
       Token(TkNL).set_text("\n")
     end
 
-    @OP.def_rules("*", "**",	
+    @OP.def_rules("*", "**",
 		  "!", "!=", "!~",
-		  "=", "==", "===", 
-		  "=~", "<=>",	
+		  "=", "==", "===",
+		  "=~", "<=>",
 		  "<", "<=",
 		  ">", ">=", ">>") do
       |op, io|
@@ -717,8 +716,8 @@ class RubyLex
       @lex_state = EXPR_BEG
       Token(op).set_text(op)
     end
-    
-    @OP.def_rules("+=", "-=", "*=", "**=", 
+
+    @OP.def_rules("+=", "-=", "*=", "**=",
 		  "&=", "|=", "^=", "<<=", ">>=", "||=", "&&=") do
       |op, io|
       @lex_state = EXPR_BEG
@@ -772,7 +771,7 @@ class RubyLex
 
     lex_int2
   end
-  
+
   def lex_int2
     @OP.def_rules("]", "}", ")") do
       |op, io|
@@ -814,7 +813,7 @@ class RubyLex
 	Token(TkOPASGN, :/).set_text("/=") #")
       elsif @lex_state == EXPR_ARG and @space_seen and peek(0) !~ /\s/
 	identify_string(op)
-      else 
+      else
 	@lex_state = EXPR_BEG
         Token("/").set_text(op)
       end
@@ -829,7 +828,7 @@ class RubyLex
     # 	@lex_state = EXPR_BEG
     # 	Token(TkOPASGN, :^)
     #       end
-    
+
     @OP.def_rules(",", ";") do
       |op, io|
       @lex_state = EXPR_BEG
@@ -845,7 +844,7 @@ class RubyLex
       @lex_state = EXPR_BEG
       Token("~").set_text("~@")
     end
-    
+
     @OP.def_rule("(") do
       @indent += 1
       if @lex_state == EXPR_BEG || @lex_state == EXPR_MID
@@ -895,15 +894,15 @@ class RubyLex
     end
 
     @OP.def_rule('\\') do   #'
-      if getc == "\n" 
+      if getc == "\n"
 	@space_seen = true
 	@continue = true
 	Token(TkSPACE).set_text("\\\n")
-      else 
+      else
 	ungetc
 	Token("\\").set_text("\\")  #"
-      end 
-    end 
+      end
+    end
 
     @OP.def_rule('%') do
       |op, io|
@@ -933,7 +932,7 @@ class RubyLex
       end
     end
 
-    #       @OP.def_rule("def", proc{|op, io| /\s/ =~ io.peek(0)}) do 
+    #       @OP.def_rule("def", proc{|op, io| /\s/ =~ io.peek(0)}) do
     # 	|op, io|
     # 	@indent += 1
     # 	@lex_state = EXPR_FNAME
@@ -958,10 +957,10 @@ class RubyLex
       printf "MATCH: end %s: %s\n", op, io.inspect if RubyLex.debug?
       t
     end
-    
+
     p @OP if RubyLex.debug?
   end
-  
+
   def identify_gvar
     @lex_state = EXPR_END
     str = "$"
@@ -970,15 +969,15 @@ class RubyLex
          when /[~_*$?!@\/\\;,=:<>".]/   #"
            str << ch
            Token(TkGVAR, str)
-           
+
          when "-"
            str << "-" << getc
            Token(TkGVAR, str)
-           
+
          when "&", "`", "'", "+"
            str << ch
            Token(TkBACK_REF, str)
-           
+
          when /[1-9]/
            str << ch
            while (ch = getc) =~ /[0-9]/
@@ -990,13 +989,13 @@ class RubyLex
            ungetc
            ungetc
            return identify_identifier
-         else 
+         else
            ungetc
-           Token("$")     
+           Token("$")
          end
     tk.set_text(str)
   end
-  
+
   def identify_identifier
     token = ""
     token.concat getc if peek(0) =~ /[$@]/
@@ -1007,7 +1006,7 @@ class RubyLex
       token.concat ch
     end
     ungetc
-    
+
     if ch == "!" or ch == "?"
       token.concat getc
     end
@@ -1022,7 +1021,7 @@ class RubyLex
       @lex_state = EXPR_END
       return Token(TkIVAR, token).set_text(token)
     end
-    
+
     if @lex_state != EXPR_DOT
       print token, "\n" if RubyLex.debug?
 
@@ -1120,7 +1119,7 @@ class RubyLex
     @lex_state = EXPR_END
     Token(Ltype2Token[lt], str).set_text(str.dump)
   end
-  
+
   def identify_quotation(initial_char)
     ch = getc
     if lt = PERCENT_LTYPE[ch]
@@ -1201,7 +1200,7 @@ class RubyLex
     end
     Token(type).set_text(str)
   end
-  
+
   def identify_string(ltype, quoted = ltype, opener=nil, initial_char = nil)
     @ltype = ltype
     @quoted = quoted
@@ -1213,9 +1212,9 @@ class RubyLex
 
     nest = 0
     begin
-      while ch = getc 
+      while ch = getc
 	str << ch
-	if @quoted == ch 
+	if @quoted == ch
           if nest == 0
             break
           else
@@ -1276,7 +1275,7 @@ class RubyLex
         if ch == "\n"
           ch = " "
         else
-          comment << "\\" 
+          comment << "\\"
         end
       else
         if ch == "\n"
@@ -1289,7 +1288,7 @@ class RubyLex
     end
     return Token(TkCOMMENT).set_text(comment)
   end
-  
+
   def read_escape
     res = ""
     case ch = getc
@@ -1306,7 +1305,7 @@ class RubyLex
 	end
         res << ch
       end
-      
+
     when "x"
       res << ch
       2.times do
@@ -1361,493 +1360,476 @@ end
 #
 # This file is based on rtags
 
-module RDoc
-
-  GENERAL_MODIFIERS = [ 'nodoc' ].freeze
-
-  CLASS_MODIFIERS = GENERAL_MODIFIERS
-
-  ATTR_MODIFIERS  = GENERAL_MODIFIERS
+class RDoc::RubyParser
 
-  CONSTANT_MODIFIERS = GENERAL_MODIFIERS
-
-  METHOD_MODIFIERS = GENERAL_MODIFIERS + 
-    [ 'arg', 'args', 'yield', 'yields', 'notnew', 'not-new', 'not_new', 'doc' ]
-
-
-  class RubyParser
-    include RubyToken
-    include TokenStream
+  include RubyToken
+  include RDoc::TokenStream
 
-    extend ParserFactory
+  extend RDoc::ParserFactory
 
-    parse_files_matching(/\.rbw?$/)
+  parse_files_matching(/\.rbw?$/)
 
+  def initialize(top_level, file_name, content, options, stats)
+    @options = options
+    @stats   = stats
+    @size = 0
+    @token_listeners = nil
+    @input_file_name = file_name
+    @scanner = RubyLex.new content, @options
+    @scanner.exception_on_syntax_error = false
+    @top_level = top_level
+    @progress = $stderr unless options.quiet
+  end
 
-    def initialize(top_level, file_name, content, options, stats)
-      @options = options
-      @stats   = stats
-      @size = 0
-      @token_listeners = nil
-      @input_file_name = file_name
-      @scanner = RubyLex.new content, @options
-      @scanner.exception_on_syntax_error = false
-      @top_level = top_level
-      @progress = $stderr unless options.quiet
-    end
-
-    def scan
-      @tokens = []
-      @unget_read = []
-      @read = []
-      catch(:eof) do
-        catch(:enddoc) do
-          begin
-            parse_toplevel_statements(@top_level)
-          rescue Exception => e
-            $stderr.puts "\n\n"
-            $stderr.puts "RDoc failure in #@input_file_name at or around " +
-                         "line #{@scanner.line_no} column #{@scanner.char_no}"
-            $stderr.puts 
-            $stderr.puts "Before reporting this, could you check that the file"
-            $stderr.puts "you're documenting compiles cleanly--RDoc is not a"
-            $stderr.puts "full Ruby parser, and gets confused easily if fed"
-            $stderr.puts "invalid programs."
-            $stderr.puts
-            $stderr.puts "The internal error was:\n\n"
-            
-            e.set_backtrace(e.backtrace[0,4])
-            raise
-          end
+  def scan
+    @tokens = []
+    @unget_read = []
+    @read = []
+    catch(:eof) do
+      catch(:enddoc) do
+        begin
+          parse_toplevel_statements(@top_level)
+        rescue Exception => e
+          $stderr.puts "\n\n"
+          $stderr.puts "RDoc failure in #@input_file_name at or around " +
+                       "line #{@scanner.line_no} column #{@scanner.char_no}"
+          $stderr.puts
+          $stderr.puts "Before reporting this, could you check that the file"
+          $stderr.puts "you're documenting compiles cleanly--RDoc is not a"
+          $stderr.puts "full Ruby parser, and gets confused easily if fed"
+          $stderr.puts "invalid programs."
+          $stderr.puts
+          $stderr.puts "The internal error was:\n\n"
+
+          e.set_backtrace(e.backtrace[0,4])
+          raise
         end
       end
-      @top_level
     end
+    @top_level
+  end
 
-    private 
+  private
 
-    def make_message(msg)
-      prefix = "\n" + @input_file_name + ":"
-      if @scanner
-        prefix << "#{@scanner.line_no}:#{@scanner.char_no}: "
-      end
-      return prefix + msg
+  def make_message(msg)
+    prefix = "\n" + @input_file_name + ":"
+    if @scanner
+      prefix << "#{@scanner.line_no}:#{@scanner.char_no}: "
     end
+    return prefix + msg
+  end
 
-    def warn(msg)
-      return if @options.quiet
-      msg = make_message msg
-      $stderr.puts msg
-    end
+  def warn(msg)
+    return if @options.quiet
+    msg = make_message msg
+    $stderr.puts msg
+  end
 
-    def error(msg)
-      msg = make_message msg
-      $stderr.puts msg
-      exit(1)
-    end
+  def error(msg)
+    msg = make_message msg
+    $stderr.puts msg
+    exit(1)
+  end
 
-    def progress(char)
-      unless @options.quiet
-        @progress.print(char)
-	@progress.flush
-      end
+  def progress(char)
+    unless @options.quiet
+      @progress.print(char)
+      @progress.flush
     end
+  end
 
-    def add_token_listener(obj)
-      @token_listeners ||= []
-      @token_listeners << obj
-    end
+  def add_token_listener(obj)
+    @token_listeners ||= []
+    @token_listeners << obj
+  end
 
-    def remove_token_listener(obj)
-      @token_listeners.delete(obj)
-    end
+  def remove_token_listener(obj)
+    @token_listeners.delete(obj)
+  end
 
-    def get_tk
-      tk = nil
-      if @tokens.empty?
-	tk = @scanner.token
-	@read.push @scanner.get_read
-	puts "get_tk1 => #{tk.inspect}" if $TOKEN_DEBUG
-      else
-	@read.push @unget_read.shift
-	tk = @tokens.shift
-	puts "get_tk2 => #{tk.inspect}" if $TOKEN_DEBUG
-      end
+  def get_tk
+    tk = nil
+    if @tokens.empty?
+      tk = @scanner.token
+      @read.push @scanner.get_read
+      puts "get_tk1 => #{tk.inspect}" if $TOKEN_DEBUG
+    else
+      @read.push @unget_read.shift
+      tk = @tokens.shift
+      puts "get_tk2 => #{tk.inspect}" if $TOKEN_DEBUG
+    end
 
-      if tk.kind_of?(TkSYMBEG)
-        set_token_position(tk.line_no, tk.char_no)
-        tk1 = get_tk
-        if tk1.kind_of?(TkId) || tk1.kind_of?(TkOp) || tk1.kind_of?(TkSTRING)
-          if tk1.respond_to?(:name)
-            tk = Token(TkSYMBOL).set_text(":" + tk1.name)
-          else
-            tk = Token(TkSYMBOL).set_text(":" + tk1.text)
-          end
-          # remove the identifier we just read (we're about to
-          # replace it with a symbol)
-          @token_listeners.each do |obj|
-            obj.pop_token
-          end if @token_listeners
+    if tk.kind_of?(TkSYMBEG)
+      set_token_position(tk.line_no, tk.char_no)
+      tk1 = get_tk
+      if tk1.kind_of?(TkId) || tk1.kind_of?(TkOp) || tk1.kind_of?(TkSTRING)
+        if tk1.respond_to?(:name)
+          tk = Token(TkSYMBOL).set_text(":" + tk1.name)
         else
-          warn("':' not followed by identifier or operator")
-          tk = tk1
+          tk = Token(TkSYMBOL).set_text(":" + tk1.text)
         end
+        # remove the identifier we just read (we're about to
+        # replace it with a symbol)
+        @token_listeners.each do |obj|
+          obj.pop_token
+        end if @token_listeners
+      else
+        warn("':' not followed by identifier or operator")
+        tk = tk1
       end
+    end
 
-      # inform any listeners of our shiny new token
-      @token_listeners.each do |obj|
-        obj.add_token(tk)
-      end if @token_listeners
+    # inform any listeners of our shiny new token
+    @token_listeners.each do |obj|
+      obj.add_token(tk)
+    end if @token_listeners
 
-      tk
-    end
+    tk
+  end
 
-    def peek_tk
-      unget_tk(tk = get_tk)
-      tk
-    end
+  def peek_tk
+    unget_tk(tk = get_tk)
+    tk
+  end
 
-    def unget_tk(tk)
-      @tokens.unshift tk
-      @unget_read.unshift @read.pop
+  def unget_tk(tk)
+    @tokens.unshift tk
+    @unget_read.unshift @read.pop
 
-      # Remove this token from any listeners
-      @token_listeners.each do |obj|
-        obj.pop_token
-      end if @token_listeners
-    end
+    # Remove this token from any listeners
+    @token_listeners.each do |obj|
+      obj.pop_token
+    end if @token_listeners
+  end
 
-    def skip_tkspace(skip_nl = true)
-      tokens = []
-      while ((tk = get_tk).kind_of?(TkSPACE) ||
-	     (skip_nl && tk.kind_of?(TkNL)))
-	tokens.push tk
-      end
-      unget_tk(tk)
-      tokens
+  def skip_tkspace(skip_nl = true)
+    tokens = []
+    while ((tk = get_tk).kind_of?(TkSPACE) ||
+     (skip_nl && tk.kind_of?(TkNL)))
+      tokens.push tk
     end
+    unget_tk(tk)
+    tokens
+  end
 
-    def get_tkread
-      read = @read.join("")
-      @read = []
-      read
-    end
+  def get_tkread
+    read = @read.join("")
+    @read = []
+    read
+  end
 
-    def peek_read
-      @read.join('')
-    end
+  def peek_read
+    @read.join('')
+  end
 
-    NORMAL = "::"
-    SINGLE = "<<"
+  NORMAL = "::"
+  SINGLE = "<<"
 
-    # Look for the first comment in a file that isn't
-    # a shebang line.
+  ##
+  # Look for the first comment in a file that isn't a shebang line.
 
-    def collect_first_comment
-      skip_tkspace
-      res = ''
-      first_line = true
+  def collect_first_comment
+    skip_tkspace
+    res = ''
+    first_line = true
 
-      tk = get_tk
-      while tk.kind_of?(TkCOMMENT)
-        if first_line && tk.text[0,2] == "#!"
-          skip_tkspace
-          tk = get_tk
-        else
-          res << tk.text << "\n"
+    tk = get_tk
+    while tk.kind_of?(TkCOMMENT)
+      if first_line && tk.text[0,2] == "#!"
+        skip_tkspace
+        tk = get_tk
+      else
+        res << tk.text << "\n"
+        tk = get_tk
+        if tk.kind_of? TkNL
+          skip_tkspace(false)
           tk = get_tk
-          if tk.kind_of? TkNL
-            skip_tkspace(false)
-            tk = get_tk
-          end
         end
-        first_line = false
       end
-      unget_tk(tk)
-      res
+      first_line = false
     end
+    unget_tk(tk)
+    res
+  end
+
+  def parse_toplevel_statements(container)
+    comment = collect_first_comment
+    look_for_directives_in(container, comment)
+    container.comment = comment unless comment.empty?
+    parse_statements(container, NORMAL, nil, comment)
+  end
+
+  def parse_statements(container, single=NORMAL, current_method=nil, comment='')
+    nest = 1
+    save_visibility = container.visibility
 
-    def parse_toplevel_statements(container)
-      comment = collect_first_comment
-      look_for_directives_in(container, comment)
-      container.comment = comment unless comment.empty?
-      parse_statements(container, NORMAL, nil, comment)
-    end
-    
-    def parse_statements(container, single=NORMAL, current_method=nil, comment='')
-      nest = 1
-      save_visibility = container.visibility
-      
 #      if container.kind_of?(TopLevel)
 #      else
 #        comment = ''
 #      end
 
-      non_comment_seen = true
-      
-      while tk = get_tk
-        
-        keep_comment = false
-        
-        non_comment_seen = true unless tk.kind_of?(TkCOMMENT)
-        
-	case tk
+    non_comment_seen = true
 
-        when TkNL
-          skip_tkspace(true)   # Skip blanks and newlines
-          tk = get_tk
-          if tk.kind_of?(TkCOMMENT)
-            if non_comment_seen
-              comment = ''
-              non_comment_seen = false
-            end
-            while tk.kind_of?(TkCOMMENT)
-              comment << tk.text << "\n"
-              tk = get_tk          # this is the newline 
-              skip_tkspace(false)  # leading spaces
-              tk = get_tk
-            end
-            unless comment.empty?
-              look_for_directives_in(container, comment) 
-              if container.done_documenting
-                container.ongoing_visibility = save_visibility
-#                return
-              end
+    while tk = get_tk
+      keep_comment = false
+
+      non_comment_seen = true unless tk.kind_of?(TkCOMMENT)
+
+      case tk
+      when TkNL
+        skip_tkspace(true)   # Skip blanks and newlines
+        tk = get_tk
+        if tk.kind_of?(TkCOMMENT)
+          if non_comment_seen
+            comment = ''
+            non_comment_seen = false
+          end
+          while tk.kind_of?(TkCOMMENT)
+            comment << tk.text << "\n"
+            tk = get_tk          # this is the newline
+            skip_tkspace(false)  # leading spaces
+            tk = get_tk
+          end
+          unless comment.empty?
+            look_for_directives_in(container, comment)
+            if container.done_documenting
+              container.ongoing_visibility = save_visibility
+              #                return
             end
-            keep_comment = true
-          else
-            non_comment_seen = true
           end
-          unget_tk(tk)
           keep_comment = true
+        else
+          non_comment_seen = true
+        end
+        unget_tk(tk)
+        keep_comment = true
 
+      when TkCLASS
+        if container.document_children
+          parse_class(container, single, tk, comment)
+        else
+          nest += 1
+        end
 
-	when TkCLASS
-	  if container.document_children
-            parse_class(container, single, tk, comment)
-	  else
-	    nest += 1
-          end
-
-	when TkMODULE
-	  if container.document_children
-            parse_module(container, single, tk, comment)
-	  else
-	    nest += 1
-          end
+      when TkMODULE
+        if container.document_children
+          parse_module(container, single, tk, comment)
+        else
+          nest += 1
+        end
 
-	when TkDEF
-	  if container.document_self
-	    parse_method(container, single, tk, comment)
-	  else
-	    nest += 1
-          end
+      when TkDEF
+        if container.document_self
+          parse_method(container, single, tk, comment)
+        else
+          nest += 1
+        end
 
-        when TkCONSTANT
-          if container.document_self
-            parse_constant(container, single, tk, comment)
-          end
+      when TkCONSTANT
+        if container.document_self
+          parse_constant(container, single, tk, comment)
+        end
 
-	when TkALIAS
- 	  if container.document_self
-	    parse_alias(container, single, tk, comment)
-	  end
+      when TkALIAS
+        if container.document_self
+          parse_alias(container, single, tk, comment)
+        end
 
-        when TkYIELD
-          if current_method.nil?
-            warn("Warning: yield outside of method") if container.document_self
-          else
-            parse_yield(container, single, tk, current_method)
-          end
+      when TkYIELD
+        if current_method.nil?
+          warn("Warning: yield outside of method") if container.document_self
+        else
+          parse_yield(container, single, tk, current_method)
+        end
 
-          # Until and While can have a 'do', which shouldn't increas
-          # the nesting. We can't solve the general case, but we can
-          # handle most occurrences by ignoring a do at the end of a line
+        # Until and While can have a 'do', which shouldn't increas
+        # the nesting. We can't solve the general case, but we can
+        # handle most occurrences by ignoring a do at the end of a line
 
-        when  TkUNTIL, TkWHILE
-          nest += 1
-          puts "FOUND #{tk.class} in #{container.name}, nest = #{nest}, " +
-            "line #{tk.line_no}" if $DEBUG_RDOC
-          skip_optional_do_after_expression
+      when  TkUNTIL, TkWHILE
+        nest += 1
+        puts "Found #{tk.class} in #{container.name}, nest = #{nest}, " +
+             "line #{tk.line_no}" if $DEBUG_RDOC
+        skip_optional_do_after_expression
 
           # 'for' is trickier
-        when TkFOR
-          nest += 1
-          puts "FOUND #{tk.class} in #{container.name}, nest = #{nest}, " +
-            "line #{tk.line_no}" if $DEBUG_RDOC
-          skip_for_variable
-          skip_optional_do_after_expression
-
-	when TkCASE, TkDO, TkIF, TkUNLESS, TkBEGIN
-	  nest += 1
-          puts "Found #{tk.class} in #{container.name}, nest = #{nest}, " +
-            "line #{tk.line_no}" if $DEBUG_RDOC
-
-	when TkIDENTIFIER
-          if nest == 1 and current_method.nil?
-            case tk.name
-            when "private", "protected", "public",
-                 "private_class_method", "public_class_method"
-              parse_visibility(container, single, tk)
-              keep_comment = true
-            when "attr"
-              parse_attr(container, single, tk, comment)
-            when /^attr_(reader|writer|accessor)$/, @options.extra_accessors
-              parse_attr_accessor(container, single, tk, comment)
-            when "alias_method"
-              if container.document_self
-	        parse_alias(container, single, tk, comment)
-	      end
-            end
-	  end
-	  
-	  case tk.name
-	  when "require"
-	    parse_require(container, comment)
-	  when "include"
-	    parse_include(container, comment)
-	  end
-
+      when TkFOR
+        nest += 1
+        puts "Found #{tk.class} in #{container.name}, nest = #{nest}, " +
+             "line #{tk.line_no}" if $DEBUG_RDOC
+        skip_for_variable
+        skip_optional_do_after_expression
 
-	when TkEND
-          nest -= 1
-          puts "Found 'end' in #{container.name}, nest = #{nest}, line #{tk.line_no}" if $DEBUG_RDOC
-          puts "Method = #{current_method.name}" if $DEBUG_RDOC and current_method
-	  if nest == 0
-            read_documentation_modifiers(container, CLASS_MODIFIERS)
-            container.ongoing_visibility = save_visibility
-            return
+      when TkCASE, TkDO, TkIF, TkUNLESS, TkBEGIN
+        nest += 1
+        puts "Found #{tk.class} in #{container.name}, nest = #{nest}, " +
+             "line #{tk.line_no}" if $DEBUG_RDOC
+
+      when TkIDENTIFIER
+        if nest == 1 and current_method.nil?
+          case tk.name
+          when "private", "protected", "public",
+               "private_class_method", "public_class_method"
+               parse_visibility(container, single, tk)
+            keep_comment = true
+          when "attr"
+            parse_attr(container, single, tk, comment)
+          when /^attr_(reader|writer|accessor)$/, @options.extra_accessors
+            parse_attr_accessor(container, single, tk, comment)
+          when "alias_method"
+            if container.document_self
+              parse_alias(container, single, tk, comment)
+            end
           end
+        end
 
-	end
+        case tk.name
+        when "require"
+          parse_require(container, comment)
+        when "include"
+          parse_include(container, comment)
+        end
 
-        comment = '' unless keep_comment
-	begin
-	  get_tkread
-	  skip_tkspace(false)
-	end while peek_tk == TkNL
+
+      when TkEND
+        nest -= 1
+        puts "Found 'end' in #{container.name}, nest = #{nest}, line #{tk.line_no}" if $DEBUG_RDOC
+        puts "Method = #{current_method.name}" if $DEBUG_RDOC and current_method
+        if nest == 0
+          read_documentation_modifiers container, RDoc::CLASS_MODIFIERS
+          container.ongoing_visibility = save_visibility
+          return
+        end
 
       end
+
+      comment = '' unless keep_comment
+
+      begin
+        get_tkread
+        skip_tkspace(false)
+      end while peek_tk == TkNL
     end
-    
-    def parse_class(container, single, tk, comment, &block)
-      progress("c")
+  end
 
-      @stats.num_classes += 1
+  def parse_class(container, single, tk, comment, &block)
+    progress("c")
 
-      container, name_t = get_class_or_module(container)
+    @stats.num_classes += 1
 
-      case name_t
-      when TkCONSTANT
-	name = name_t.name
-        superclass = "Object"
-
-        if peek_tk.kind_of?(TkLT)
-          get_tk
-          skip_tkspace(true)
-          superclass = get_class_specification
-          superclass = "<unknown>" if superclass.empty?
-        end
+    container, name_t = get_class_or_module(container)
 
-	if single == SINGLE
-	  cls_type = SingleClass
-	else
-	  cls_type = NormalClass
-	end
+    case name_t
+    when TkCONSTANT
+      name = name_t.name
+      superclass = "Object"
 
-        cls = container.add_class(cls_type, name, superclass)
-        read_documentation_modifiers(cls, CLASS_MODIFIERS)
-        cls.record_location(@top_level)
-	parse_statements(cls)
-        cls.comment = comment
+      if peek_tk.kind_of?(TkLT)
+        get_tk
+        skip_tkspace(true)
+        superclass = get_class_specification
+        superclass = "<unknown>" if superclass.empty?
+      end
 
-      when TkLSHFT
-	case name = get_class_specification
-	when "self", container.name
-	  parse_statements(container, SINGLE, &block)
-	else
-          other = TopLevel.find_class_named(name)
-          unless other
-#            other = @top_level.add_class(NormalClass, name, nil)
-#            other.record_location(@top_level)
-#            other.comment = comment
-            other = NormalClass.new("Dummy", nil)
-          end
-          read_documentation_modifiers(other, CLASS_MODIFIERS)
-          parse_statements(other, SINGLE, &block)
-	end
+      if single == SINGLE
+        cls_type = RDoc::SingleClass
+      else
+        cls_type = RDoc::NormalClass
+      end
+
+      cls = container.add_class cls_type, name, superclass
+      read_documentation_modifiers cls, RDoc::CLASS_MODIFIERS
+      cls.record_location(@top_level)
+      parse_statements(cls)
+      cls.comment = comment
 
+    when TkLSHFT
+      case name = get_class_specification
+      when "self", container.name
+        parse_statements(container, SINGLE, &block)
       else
-	warn("Expected class name or '<<'. Got #{name_t.class}: #{name_t.text.inspect}")
+        other = RDoc::TopLevel.find_class_named(name)
+        unless other
+          #            other = @top_level.add_class(NormalClass, name, nil)
+          #            other.record_location(@top_level)
+          #            other.comment = comment
+          other = RDoc::NormalClass.new "Dummy", nil
+        end
+        read_documentation_modifiers other, RDoc::CLASS_MODIFIERS
+        parse_statements(other, SINGLE, &block)
       end
+
+    else
+      warn("Expected class name or '<<'. Got #{name_t.class}: #{name_t.text.inspect}")
     end
+  end
 
-    def parse_module(container, single, tk, comment)
-      progress("m")
-      @stats.num_modules += 1
-      container, name_t  = get_class_or_module(container)
+  def parse_module(container, single, tk, comment)
+    progress("m")
+    @stats.num_modules += 1
+    container, name_t  = get_class_or_module(container)
 #      skip_tkspace
-      name = name_t.name
-      mod = container.add_module(NormalModule, name)
-      mod.record_location(@top_level)
-      read_documentation_modifiers(mod, CLASS_MODIFIERS)
-      parse_statements(mod)
-      mod.comment = comment
-    end
+    name = name_t.name
+    mod = container.add_module RDoc::NormalModule, name
+    mod.record_location @top_level
+    read_documentation_modifiers mod, RDoc::CLASS_MODIFIERS
+    parse_statements(mod)
+    mod.comment = comment
+  end
 
-    # Look for the name of a class of module (optionally with a leading :: or
-    # with :: separated named) and return the ultimate name and container
+  # Look for the name of a class of module (optionally with a leading :: or
+  # with :: separated named) and return the ultimate name and container
 
-    def get_class_or_module(container)
-      skip_tkspace
-      name_t = get_tk
+  def get_class_or_module(container)
+    skip_tkspace
+    name_t = get_tk
 
-      # class ::A -> A is in the top level
-      if name_t.kind_of?(TkCOLON2)
-        name_t = get_tk
-        container = @top_level
-      end
+    # class ::A -> A is in the top level
+    if name_t.kind_of?(TkCOLON2)
+      name_t = get_tk
+      container = @top_level
+    end
 
-      skip_tkspace(false)
+    skip_tkspace(false)
 
-      while peek_tk.kind_of?(TkCOLON2)
-        prev_container = container
-        container = container.find_module_named(name_t.name)
-        if !container
+    while peek_tk.kind_of?(TkCOLON2)
+      prev_container = container
+      container = container.find_module_named(name_t.name)
+      if !container
 #          warn("Couldn't find module #{name_t.name}")
-          container = prev_container.add_module(NormalModule, name_t.name)
-        end
-        get_tk
-        name_t = get_tk
+        container = prev_container.add_module RDoc::NormalModule, name_t.name
       end
-      skip_tkspace(false)
-      return [container, name_t]
+      get_tk
+      name_t = get_tk
     end
+    skip_tkspace(false)
+    return [container, name_t]
+  end
 
-    def parse_constant(container, single, tk, comment)
-      name = tk.name
-      skip_tkspace(false)
-      eq_tk = get_tk
+  def parse_constant(container, single, tk, comment)
+    name = tk.name
+    skip_tkspace(false)
+    eq_tk = get_tk
 
-      unless eq_tk.kind_of?(TkASSIGN)
-        unget_tk(eq_tk)
-        return
-      end
+    unless eq_tk.kind_of?(TkASSIGN)
+      unget_tk(eq_tk)
+      return
+    end
 
 
-      nest = 0
-      get_tkread
+    nest = 0
+    get_tkread
 
-      tk = get_tk
-      if tk.kind_of? TkGT
-        unget_tk(tk)
-        unget_tk(eq_tk)
-        return
-      end
+    tk = get_tk
+    if tk.kind_of? TkGT
+      unget_tk(tk)
+      unget_tk(eq_tk)
+      return
+    end
 
-      loop do
-        puts("Param: #{tk}, #{@scanner.continue} " +
-          "#{@scanner.lex_state} #{nest}")  if $DEBUG_RDOC
+    loop do
+      puts "Param: %p, %s %s %s" %
+        [tk.text, @scanner.continue, @scanner.lex_state, nest] if $DEBUG_RDOC
 
         case tk
         when TkSEMICOLON
@@ -1868,182 +1850,184 @@ module RDoc
           end
         end
         tk = get_tk
-      end
+    end
 
-      res = get_tkread.tr("\n", " ").strip
-      res = "" if res == ";"
-      con = Constant.new(name, res, comment)
-      read_documentation_modifiers(con, CONSTANT_MODIFIERS)
-      if con.document_self
-	container.add_constant(con)
-      end
+    res = get_tkread.tr("\n", " ").strip
+    res = "" if res == ";"
+
+    con = RDoc::Constant.new name, res, comment
+    read_documentation_modifiers con, RDoc::CONSTANT_MODIFIERS
+
+    if con.document_self
+      container.add_constant(con)
     end
+  end
 
-    def parse_method(container, single, tk, comment)
-      progress(".")
-      @stats.num_methods += 1
-      line_no = tk.line_no
-      column  = tk.char_no
-      
-      start_collecting_tokens
-      add_token(tk)
-      add_token_listener(self)
-      
+  def parse_method(container, single, tk, comment)
+    progress(".")
+    @stats.num_methods += 1
+    line_no = tk.line_no
+    column  = tk.char_no
+
+    start_collecting_tokens
+    add_token(tk)
+    add_token_listener(self)
+
+    @scanner.instance_eval{@lex_state = EXPR_FNAME}
+    skip_tkspace(false)
+    name_t = get_tk
+    back_tk = skip_tkspace
+    meth = nil
+    added_container = false
+
+    dot = get_tk
+    if dot.kind_of?(TkDOT) or dot.kind_of?(TkCOLON2)
       @scanner.instance_eval{@lex_state = EXPR_FNAME}
-      skip_tkspace(false)
-      name_t = get_tk
-      back_tk = skip_tkspace
-      meth = nil
-      added_container = false
-
-      dot = get_tk
-      if dot.kind_of?(TkDOT) or dot.kind_of?(TkCOLON2)
-	@scanner.instance_eval{@lex_state = EXPR_FNAME}
-	skip_tkspace
-	name_t2 = get_tk
-	case name_t
-	when TkSELF
-	  name = name_t2.name
-	when TkCONSTANT
-          name = name_t2.name
-          prev_container = container
-          container = container.find_module_named(name_t.name)
-          if !container
-            added_container = true
-            obj = name_t.name.split("::").inject(Object) do |state, item|
-              state.const_get(item)
-            end rescue nil
-
-            type = obj.class == Class ? NormalClass : NormalModule
-            if not [Class, Module].include?(obj.class)
-              warn("Couldn't find #{name_t.name}. Assuming it's a module")
-            end
+      skip_tkspace
+      name_t2 = get_tk
+      case name_t
+      when TkSELF
+        name = name_t2.name
+      when TkCONSTANT
+        name = name_t2.name
+        prev_container = container
+        container = container.find_module_named(name_t.name)
+        if !container
+          added_container = true
+          obj = name_t.name.split("::").inject(Object) do |state, item|
+            state.const_get(item)
+          end rescue nil
+
+          type = obj.class == Class ? RDoc::NormalClass : RDoc::NormalModule
+          if not [Class, Module].include?(obj.class)
+            warn("Couldn't find #{name_t.name}. Assuming it's a module")
+          end
 
-            if type == NormalClass then
-              container = prev_container.add_class(type, name_t.name, obj.superclass.name)
-            else
-              container = prev_container.add_module(type, name_t.name)
-            end
+          if type == RDoc::NormalClass then
+            container = prev_container.add_class(type, name_t.name, obj.superclass.name)
+          else
+            container = prev_container.add_module(type, name_t.name)
           end
-	else
-	  # warn("Unexpected token '#{name_t2.inspect}'")
-	  # break
-          skip_method(container)
-          return
-	end
-	meth =  AnyMethod.new(get_tkread, name)
-        meth.singleton = true
+        end
       else
-	unget_tk dot
-	back_tk.reverse_each do |token|
-	  unget_tk token
-	end
-	name = name_t.name
-
-        meth =  AnyMethod.new(get_tkread, name)
-        meth.singleton = (single == SINGLE)
+        # warn("Unexpected token '#{name_t2.inspect}'")
+        # break
+        skip_method(container)
+        return
       end
+      meth = RDoc::AnyMethod.new(get_tkread, name)
+      meth.singleton = true
+    else
+      unget_tk dot
+      back_tk.reverse_each do |token|
+        unget_tk token
+      end
+      name = name_t.name
 
-      remove_token_listener(self)
+      meth = RDoc::AnyMethod.new get_tkread, name
+      meth.singleton = (single == SINGLE)
+    end
 
-      meth.start_collecting_tokens
-      indent = TkSPACE.new(1,1)
-      indent.set_text(" " * column)
+    remove_token_listener(self)
 
-      meth.add_tokens([TkCOMMENT.new(line_no,
-                                     1,
-                                     "# File #{@top_level.file_absolute_name}, line #{line_no}"),
-                        NEWLINE_TOKEN,
-                        indent])
+    meth.start_collecting_tokens
+    indent = TkSPACE.new(1,1)
+    indent.set_text(" " * column)
 
-      meth.add_tokens(@token_stream)
+    meth.add_tokens([TkCOMMENT.new(line_no,
+                                   1,
+                                   "# File #{@top_level.file_absolute_name}, line #{line_no}"),
+                      NEWLINE_TOKEN,
+                      indent])
 
-      add_token_listener(meth)
+    meth.add_tokens(@token_stream)
 
-      @scanner.instance_eval{@continue = false}
-      parse_method_parameters(meth)
+    add_token_listener(meth)
 
-      if meth.document_self
-        container.add_method(meth)
-      elsif added_container
-        container.document_self = false
-      end
+    @scanner.instance_eval{@continue = false}
+    parse_method_parameters(meth)
 
-      # Having now read the method parameters and documentation modifiers, we
-      # now know whether we have to rename #initialize to ::new
+    if meth.document_self
+      container.add_method(meth)
+    elsif added_container
+      container.document_self = false
+    end
 
-      if name == "initialize" && !meth.singleton
-        if meth.dont_rename_initialize
-          meth.visibility = :protected
-        else
-          meth.singleton = true
-          meth.name = "new"
-          meth.visibility = :public
-        end
-      end
-      
-      parse_statements(container, single, meth)
-      
-      remove_token_listener(meth)
-
-      # Look for a 'call-seq' in the comment, and override the
-      # normal parameter stuff
-
-      if comment.sub!(/:?call-seq:(.*?)^\s*\#?\s*$/m, '')
-        seq = $1
-        seq.gsub!(/^\s*\#\s*/, '')
-        meth.call_seq = seq
-      end
-      
-      meth.comment = comment
-
-    end
-    
-    def skip_method(container)
-      meth =  AnyMethod.new("", "anon")
-      parse_method_parameters(meth)
-      parse_statements(container, false, meth)
-    end
-    
-    # Capture the method's parameters. Along the way,
-    # look for a comment containing 
-    #
-    #    # yields: ....
-    #
-    # and add this as the block_params for the method
-
-    def parse_method_parameters(method)
-      res = parse_method_or_yield_parameters(method)
-      res = "(" + res + ")" unless res[0] == ?(
-      method.params = res unless method.params
-      if method.block_params.nil?
-          skip_tkspace(false)
-	  read_documentation_modifiers(method, METHOD_MODIFIERS)
+    # Having now read the method parameters and documentation modifiers, we
+    # now know whether we have to rename #initialize to ::new
+
+    if name == "initialize" && !meth.singleton
+      if meth.dont_rename_initialize
+        meth.visibility = :protected
+      else
+        meth.singleton = true
+        meth.name = "new"
+        meth.visibility = :public
       end
     end
 
-    def parse_method_or_yield_parameters(method=nil, modifiers=METHOD_MODIFIERS)
+    parse_statements(container, single, meth)
+
+    remove_token_listener(meth)
+
+    # Look for a 'call-seq' in the comment, and override the
+    # normal parameter stuff
+
+    if comment.sub!(/:?call-seq:(.*?)^\s*\#?\s*$/m, '')
+      seq = $1
+      seq.gsub!(/^\s*\#\s*/, '')
+      meth.call_seq = seq
+    end
+
+    meth.comment = comment
+  end
+
+  def skip_method(container)
+    meth = RDoc::AnyMethod.new "", "anon"
+    parse_method_parameters(meth)
+    parse_statements(container, false, meth)
+  end
+
+  # Capture the method's parameters. Along the way, look for a comment
+  # containing.
+  #
+  #    # yields: ....
+  #
+  # and add this as the block_params for the method
+
+  def parse_method_parameters(method)
+    res = parse_method_or_yield_parameters(method)
+    res = "(" + res + ")" unless res[0] == ?(
+    method.params = res unless method.params
+    if method.block_params.nil?
       skip_tkspace(false)
-      tk = get_tk
+      read_documentation_modifiers method, RDoc::METHOD_MODIFIERS
+    end
+  end
 
-      # Little hack going on here. In the statement
-      #  f = 2*(1+yield)
-      # We see the RPAREN as the next token, so we need
-      # to exit early. This still won't catch all cases
-      # (such as "a = yield + 1"
-      end_token = case tk
-                  when TkLPAREN, TkfLPAREN
-                    TkRPAREN
-                  when TkRPAREN
-                    return ""
-                  else
-                    TkNL
-                  end
-      nest = 0
+  def parse_method_or_yield_parameters(method = nil,
+                                       modifiers = RDoc::METHOD_MODIFIERS)
+    skip_tkspace(false)
+    tk = get_tk
 
-      loop do
-        puts("Param: #{tk.inspect}, #{@scanner.continue} " +
-          "#{@scanner.lex_state} #{nest}")  if $DEBUG_RDOC
+    # Little hack going on here. In the statement
+    #  f = 2*(1+yield)
+    # We see the RPAREN as the next token, so we need
+    # to exit early. This still won't catch all cases
+    # (such as "a = yield + 1"
+    end_token = case tk
+                when TkLPAREN, TkfLPAREN
+                  TkRPAREN
+                when TkRPAREN
+                  return ""
+                else
+                  TkNL
+                end
+    nest = 0
+
+    loop do
+      puts "Param: %p, %s %s %s" %
+        [tk.text, @scanner.continue, @scanner.lex_state, nest] if $DEBUG_RDOC
         case tk
         when TkSEMICOLON
           break
@@ -2064,113 +2048,113 @@ module RDoc
             break unless @scanner.continue
           end
         when method && method.block_params.nil? && TkCOMMENT
-	  unget_tk(tk)
-	  read_documentation_modifiers(method, modifiers)
+          unget_tk(tk)
+          read_documentation_modifiers(method, modifiers)
         end
-        tk = get_tk
-      end
-      res = get_tkread.tr("\n", " ").strip
-      res = "" if res == ";"
-      res
+      tk = get_tk
     end
+    res = get_tkread.tr("\n", " ").strip
+    res = "" if res == ";"
+    res
+  end
 
-    # skip the var [in] part of a 'for' statement
-    def skip_for_variable
-      skip_tkspace(false)
-      tk = get_tk
-      skip_tkspace(false)
-      tk = get_tk
-      unget_tk(tk) unless tk.kind_of?(TkIN)
+  # skip the var [in] part of a 'for' statement
+  def skip_for_variable
+    skip_tkspace(false)
+    tk = get_tk
+    skip_tkspace(false)
+    tk = get_tk
+    unget_tk(tk) unless tk.kind_of?(TkIN)
+  end
+
+  # while, until, and for have an optional
+  def skip_optional_do_after_expression
+    skip_tkspace(false)
+    tk = get_tk
+    case tk
+    when TkLPAREN, TkfLPAREN
+      end_token = TkRPAREN
+    else
+      end_token = TkNL
     end
 
-    # while, until, and for have an optional 
-    def skip_optional_do_after_expression
-      skip_tkspace(false)
-      tk = get_tk
+    nest = 0
+    @scanner.instance_eval{@continue = false}
+
+    loop do
+      puts("\nWhile: #{tk.text.inspect}, #{@scanner.continue} " \
+           "#{@scanner.lex_state} #{nest}") if $DEBUG_RDOC
       case tk
+      when TkSEMICOLON
+        break
       when TkLPAREN, TkfLPAREN
-        end_token = TkRPAREN
-      else
-        end_token = TkNL
-      end
-
-      nest = 0
-      @scanner.instance_eval{@continue = false}
-
-      loop do
-        puts("\nWhile: #{tk}, #{@scanner.continue} " +
-          "#{@scanner.lex_state} #{nest}") if $DEBUG_RDOC
-        case tk
-        when TkSEMICOLON
-          break
-        when TkLPAREN, TkfLPAREN
-          nest += 1
-        when TkDO
-          break if nest.zero?
-        when end_token
-          if end_token == TkRPAREN
-            nest -= 1
-            break if @scanner.lex_state == EXPR_END and nest.zero?
-          else
-            break unless @scanner.continue
-          end
+        nest += 1
+      when TkDO
+        break if nest.zero?
+      when end_token
+        if end_token == TkRPAREN
+          nest -= 1
+          break if @scanner.lex_state == EXPR_END and nest.zero?
+        else
+          break unless @scanner.continue
         end
-        tk = get_tk
-      end
-      skip_tkspace(false)
-      if peek_tk.kind_of? TkDO
-        get_tk
       end
+      tk = get_tk
     end
-    
-    # Return a superclass, which can be either a constant
-    # of an expression
+    skip_tkspace(false)
+    if peek_tk.kind_of? TkDO
+      get_tk
+    end
+  end
 
-    def get_class_specification
-      tk = get_tk
-      return "self" if tk.kind_of?(TkSELF)
-        
-      res = ""
-      while tk.kind_of?(TkCOLON2) ||
-          tk.kind_of?(TkCOLON3)   ||
-          tk.kind_of?(TkCONSTANT)   
-        
-        res += tk.text
-        tk = get_tk
-      end
+  # Return a superclass, which can be either a constant
+  # of an expression
 
-      unget_tk(tk)
-      skip_tkspace(false)
+  def get_class_specification
+    tk = get_tk
+    return "self" if tk.kind_of?(TkSELF)
 
-      get_tkread # empty out read buffer
+    res = ""
+    while tk.kind_of?(TkCOLON2) ||
+        tk.kind_of?(TkCOLON3)   ||
+        tk.kind_of?(TkCONSTANT)
 
+      res += tk.text
       tk = get_tk
+    end
 
-      case tk
-      when TkNL, TkCOMMENT, TkSEMICOLON
-        unget_tk(tk)
-        return res
-      end
+    unget_tk(tk)
+    skip_tkspace(false)
 
-      res += parse_call_parameters(tk)
-      res
+    get_tkread # empty out read buffer
+
+    tk = get_tk
+
+    case tk
+    when TkNL, TkCOMMENT, TkSEMICOLON
+      unget_tk(tk)
+      return res
     end
 
-    def parse_call_parameters(tk)
+    res += parse_call_parameters(tk)
+    res
+  end
+
+  def parse_call_parameters(tk)
 
-      end_token = case tk
-                  when TkLPAREN, TkfLPAREN
-                    TkRPAREN
-                  when TkRPAREN
-                    return ""
-                  else
-                    TkNL
-                  end
-      nest = 0
+    end_token = case tk
+                when TkLPAREN, TkfLPAREN
+                  TkRPAREN
+                when TkRPAREN
+                  return ""
+                else
+                  TkNL
+                end
+    nest = 0
 
-      loop do
-        puts("Call param: #{tk}, #{@scanner.continue} " +
-          "#{@scanner.lex_state} #{nest}") if $DEBUG_RDOC
+    loop do
+      puts("Call param: #{tk}, #{@scanner.continue} " +
+        "#{@scanner.lex_state} #{nest}") if $DEBUG_RDOC
         case tk
         when TkSEMICOLON
           break
@@ -2184,214 +2168,209 @@ module RDoc
             break unless @scanner.continue
           end
         when TkCOMMENT
-	  unget_tk(tk)
-	  break
+          unget_tk(tk)
+          break
         end
         tk = get_tk
-      end
-      res = get_tkread.tr("\n", " ").strip
-      res = "" if res == ";"
-      res
     end
+    res = get_tkread.tr("\n", " ").strip
+    res = "" if res == ";"
+    res
+  end
 
+  # Parse a constant, which might be qualified by
+  # one or more class or module names
 
-    # Parse a constant, which might be qualified by
-    # one or more class or module names
+  def get_constant
+    res = ""
+    skip_tkspace(false)
+    tk = get_tk
 
-    def get_constant
-      res = ""
-      skip_tkspace(false)
-      tk = get_tk
+    while tk.kind_of?(TkCOLON2) ||
+        tk.kind_of?(TkCOLON3)   ||
+        tk.kind_of?(TkCONSTANT)
 
-      while tk.kind_of?(TkCOLON2) ||
-          tk.kind_of?(TkCOLON3)   ||
-          tk.kind_of?(TkCONSTANT)          
-        
-        res += tk.text
-        tk = get_tk
-      end
+      res += tk.text
+      tk = get_tk
+    end
 
 #      if res.empty?
 #        warn("Unexpected token #{tk} in constant")
-#      end 
-      unget_tk(tk)
-      res
-    end
+#      end
+    unget_tk(tk)
+    res
+  end
 
-    # Get a constant that may be surrounded by parens
-    
-    def get_constant_with_optional_parens
-      skip_tkspace(false)
-      nest = 0
-      while (tk = peek_tk).kind_of?(TkLPAREN)  || tk.kind_of?(TkfLPAREN)
-        get_tk
-        skip_tkspace(true)
-        nest += 1
-      end
+  # Get a constant that may be surrounded by parens
+
+  def get_constant_with_optional_parens
+    skip_tkspace(false)
+    nest = 0
+    while (tk = peek_tk).kind_of?(TkLPAREN)  || tk.kind_of?(TkfLPAREN)
+      get_tk
+      skip_tkspace(true)
+      nest += 1
+    end
 
-      name = get_constant
+    name = get_constant
 
-      while nest > 0
-        skip_tkspace(true)
-        tk = get_tk
-        nest -= 1 if tk.kind_of?(TkRPAREN)
-      end
-      name
-    end
-
-    # Directives are modifier comments that can appear after class, module,
-    # or method names. For example
-    #
-    #   def fred    # :yields:  a, b
-    #
-    # or
-    #
-    #   class SM  # :nodoc:
-    #
-    # we return the directive name and any parameters as a two element array
-    
-    def read_directive(allowed)
+    while nest > 0
+      skip_tkspace(true)
       tk = get_tk
-      puts "directive: #{tk.inspect}" if $DEBUG_RDOC
-      result = nil
-      if tk.kind_of?(TkCOMMENT) 
-        if tk.text =~ /\s*:?(\w+):\s*(.*)/
-          directive = $1.downcase
-          if allowed.include?(directive)
-            result = [directive, $2]
-          end
+      nest -= 1 if tk.kind_of?(TkRPAREN)
+    end
+    name
+  end
+
+  # Directives are modifier comments that can appear after class, module,
+  # or method names. For example:
+  #
+  #   def fred # :yields:  a, b
+  #
+  # or:
+  #
+  #   class MyClass # :nodoc:
+  #
+  # We return the directive name and any parameters as a two element array
+
+  def read_directive(allowed)
+    tk = get_tk
+    puts "directive: #{tk.text.inspect}" if $DEBUG_RDOC
+    result = nil
+    if tk.kind_of?(TkCOMMENT)
+      if tk.text =~ /\s*:?(\w+):\s*(.*)/
+        directive = $1.downcase
+        if allowed.include?(directive)
+          result = [directive, $2]
         end
-      else
-        unget_tk(tk)
       end
-      result
+    else
+      unget_tk(tk)
     end
+    result
+  end
 
-    
-    def read_documentation_modifiers(context, allow)
-      dir = read_directive(allow)
+  def read_documentation_modifiers(context, allow)
+    dir = read_directive(allow)
 
-      case dir[0]
+    case dir[0]
 
-      when "notnew", "not_new", "not-new"
-        context.dont_rename_initialize = true
+    when "notnew", "not_new", "not-new"
+      context.dont_rename_initialize = true
 
-      when "nodoc"
-        context.document_self = false
-	if dir[1].downcase == "all"
-	  context.document_children = false
-	end
+    when "nodoc"
+      context.document_self = false
+      if dir[1].downcase == "all"
+        context.document_children = false
+      end
 
-      when "doc"
-        context.document_self = true
-        context.force_documentation = true
+    when "doc"
+      context.document_self = true
+      context.force_documentation = true
 
-      when "yield", "yields"
-        unless context.params.nil?
-          context.params.sub!(/(,|)\s*&\w+/,'') # remove parameter &proc
-        end
-	context.block_params = dir[1]
-
-      when "arg", "args"
-        context.params = dir[1]
-      end if dir
-    end
-
-    
-    # Look for directives in a normal comment block:
-    #
-    #   #--       - don't display comment from this point forward
-    #  
-    #
-    # This routine modifies it's parameter
-
-    def look_for_directives_in(context, comment)
-
-      preprocess = SM::PreProcess.new(@input_file_name,
-                                      @options.rdoc_include)
-
-      preprocess.handle(comment) do |directive, param|
-        case directive
-        when "stopdoc"
-          context.stop_doc
-          ""
-        when "startdoc"
-          context.start_doc
-          context.force_documentation = true
-          ""
-
-        when "enddoc"
-          #context.done_documenting = true
-          #""
-          throw :enddoc
-
-        when "main"
-          @options.main_page = param
-          ""
-
-        when "title"
-          @options.title = param
-          ""
-
-        when "section"
-          context.set_current_section(param, comment)
-          comment.clear
-          break 
-        else
-          warn "Unrecognized directive '#{directive}'"
-          break
-        end
+    when "yield", "yields"
+      unless context.params.nil?
+        context.params.sub!(/(,|)\s*&\w+/,'') # remove parameter &proc
       end
+    context.block_params = dir[1]
 
-      remove_private_comments(comment)
-    end
+    when "arg", "args"
+      context.params = dir[1]
+    end if dir
+  end
 
-    def remove_private_comments(comment)
-      comment.gsub!(/^#--.*?^#\+\+/m, '')
-      comment.sub!(/^#--.*/m, '')
-    end
+  ##
+  # Look for directives in a normal comment block:
+  #
+  #   #--       - don't display comment from this point forward
+  #
+  # This routine modifies it's parameter
+
+  def look_for_directives_in(context, comment)
+    preprocess = RDoc::Markup::PreProcess.new(@input_file_name,
+                                              @options.rdoc_include)
+
+    preprocess.handle(comment) do |directive, param|
+      case directive
+      when "stopdoc"
+        context.stop_doc
+        ""
+      when "startdoc"
+        context.start_doc
+        context.force_documentation = true
+        ""
 
+      when "enddoc"
+        #context.done_documenting = true
+        #""
+        throw :enddoc
 
+      when "main"
+        @options.main_page = param
+        ""
+
+      when "title"
+        @options.title = param
+        ""
+
+      when "section"
+        context.set_current_section(param, comment)
+        comment.clear
+        break
 
-    def get_symbol_or_name
-      tk = get_tk
-      case tk
-      when  TkSYMBOL
-        tk.text.sub(/^:/, '')
-      when TkId, TkOp
-        tk.name
-      when TkSTRING
-        tk.text
       else
-        raise "Name or symbol expected (got #{tk})"
+        warn "Unrecognized directive '#{directive}'"
+        break
       end
     end
-    
-    def parse_alias(context, single, tk, comment)
+
+    remove_private_comments(comment)
+  end
+
+  def remove_private_comments(comment)
+    comment.gsub!(/^#--.*?^#\+\+/m, '')
+    comment.sub!(/^#--.*/m, '')
+  end
+
+  def get_symbol_or_name
+    tk = get_tk
+    case tk
+    when  TkSYMBOL
+      tk.text.sub(/^:/, '')
+    when TkId, TkOp
+      tk.name
+    when TkSTRING
+      tk.text
+    else
+      raise "Name or symbol expected (got #{tk})"
+    end
+  end
+
+  def parse_alias(context, single, tk, comment)
+    skip_tkspace
+    if (peek_tk.kind_of? TkLPAREN)
+      get_tk
       skip_tkspace
-      if (peek_tk.kind_of? TkLPAREN)
-        get_tk
-        skip_tkspace
-      end
-      new_name = get_symbol_or_name
-      @scanner.instance_eval{@lex_state = EXPR_FNAME}
+    end
+    new_name = get_symbol_or_name
+    @scanner.instance_eval{@lex_state = EXPR_FNAME}
+    skip_tkspace
+    if (peek_tk.kind_of? TkCOMMA)
+      get_tk
       skip_tkspace
-      if (peek_tk.kind_of? TkCOMMA)
-        get_tk
-        skip_tkspace
-      end
-      old_name = get_symbol_or_name
-
-      al = Alias.new(get_tkread, old_name, new_name, comment)
-      read_documentation_modifiers(al, ATTR_MODIFIERS)
-      if al.document_self
-	context.add_alias(al)
-      end
     end
+    old_name = get_symbol_or_name
 
-    def parse_yield_parameters
-      parse_method_or_yield_parameters
+    al = RDoc::Alias.new get_tkread, old_name, new_name, comment
+    read_documentation_modifiers al, RDoc::ATTR_MODIFIERS
+    if al.document_self
+      context.add_alias(al)
     end
+  end
+
+  def parse_yield_parameters
+    parse_method_or_yield_parameters
+  end
 
   def parse_yield(context, single, tk, method)
     if method.block_params.nil?
@@ -2413,15 +2392,15 @@ module RDoc
     case tk
     when TkSTRING
       name = tk.text
-#    when TkCONSTANT, TkIDENTIFIER, TkIVAR, TkGVAR
-#      name = tk.name
+      #    when TkCONSTANT, TkIDENTIFIER, TkIVAR, TkGVAR
+      #      name = tk.name
     when TkDSTRING
       warn "Skipping require of dynamic string: #{tk.text}"
- #   else
- #     warn "'require' used as variable"
+      #   else
+      #     warn "'require' used as variable"
     end
     if name
-      context.add_require(Require.new(name, comment))
+      context.add_require(RDoc::Require.new(name, comment))
     else
       unget_tk(tk)
     end
@@ -2432,174 +2411,171 @@ module RDoc
       skip_tkspace_comment
       name = get_constant_with_optional_parens
       unless name.empty?
-        context.add_include(Include.new(name, comment))
+        context.add_include RDoc::Include.new(name, comment)
       end
       return unless peek_tk.kind_of?(TkCOMMA)
       get_tk
     end
   end
 
-    def get_bool
-      skip_tkspace
+  def get_bool
+    skip_tkspace
+    tk = get_tk
+    case tk
+    when TkTRUE
+      true
+    when TkFALSE, TkNIL
+      false
+    else
+      unget_tk tk
+      true
+    end
+  end
+
+  def parse_attr(context, single, tk, comment)
+    args = parse_symbol_arg(1)
+    if args.size > 0
+      name = args[0]
+      rw = "R"
+      skip_tkspace(false)
       tk = get_tk
-      case tk
-      when TkTRUE
-        true
-      when TkFALSE, TkNIL
-        false
+      if tk.kind_of? TkCOMMA
+        rw = "RW" if get_bool
       else
         unget_tk tk
-        true
       end
-    end
-
-    def parse_attr(context, single, tk, comment)
-      args = parse_symbol_arg(1)
-      if args.size > 0
-	name = args[0]
-        rw = "R"
-        skip_tkspace(false)
-        tk = get_tk
-        if tk.kind_of? TkCOMMA
-          rw = "RW" if get_bool
-        else
-          unget_tk tk
-        end
-	att = Attr.new(get_tkread, name, rw, comment)
-	read_documentation_modifiers(att, ATTR_MODIFIERS)
-	if att.document_self
-	  context.add_attribute(att)
-	end
-      else
-	warn("'attr' ignored - looks like a variable")
-      end    
-
-    end
-
-    def parse_visibility(container, single, tk)
-      singleton = (single == SINGLE)
-      vis = case tk.name
-            when "private"   then :private
-            when "protected" then :protected
-            when "public"    then :public
-            when "private_class_method"
-              singleton = true
-              :private
-            when "public_class_method"
-              singleton = true
-              :public
-            else raise "Invalid visibility: #{tk.name}"
-            end
-            
-      skip_tkspace_comment(false)
-      case peek_tk
-        # Ryan Davis suggested the extension to ignore modifiers, because he
-        # often writes
-        #
-        #   protected unless $TESTING
-        #
-      when TkNL, TkUNLESS_MOD, TkIF_MOD
-#        error("Missing argument") if singleton        
-        container.ongoing_visibility = vis
-      else
-        args = parse_symbol_arg
-        container.set_visibility_for(args, vis, singleton)
+      att = RDoc::Attr.new get_tkread, name, rw, comment
+      read_documentation_modifiers att, RDoc::ATTR_MODIFIERS
+      if att.document_self
+        context.add_attribute(att)
       end
+    else
+      warn("'attr' ignored - looks like a variable")
     end
+  end
+
+  def parse_visibility(container, single, tk)
+    singleton = (single == SINGLE)
+    vis = case tk.name
+          when "private"   then :private
+          when "protected" then :protected
+          when "public"    then :public
+          when "private_class_method"
+            singleton = true
+            :private
+          when "public_class_method"
+            singleton = true
+            :public
+          else raise "Invalid visibility: #{tk.name}"
+          end
 
-    def parse_attr_accessor(context, single, tk, comment)
+    skip_tkspace_comment(false)
+    case peek_tk
+      # Ryan Davis suggested the extension to ignore modifiers, because he
+      # often writes
+      #
+      #   protected unless $TESTING
+      #
+    when TkNL, TkUNLESS_MOD, TkIF_MOD
+      #        error("Missing argument") if singleton
+      container.ongoing_visibility = vis
+    else
       args = parse_symbol_arg
-      read = get_tkread
-      rw = "?"
+      container.set_visibility_for(args, vis, singleton)
+    end
+  end
 
-      # If nodoc is given, don't document any of them
+  def parse_attr_accessor(context, single, tk, comment)
+    args = parse_symbol_arg
+    read = get_tkread
+    rw = "?"
 
-      tmp = CodeObject.new
-      read_documentation_modifiers(tmp, ATTR_MODIFIERS)
-      return unless tmp.document_self
+    # If nodoc is given, don't document any of them
 
-      case tk.name
-      when "attr_reader"   then rw = "R"
-      when "attr_writer"   then rw = "W"
-      when "attr_accessor" then rw = "RW"
-      else
-        rw = @options.extra_accessor_flags[tk.name]
-      end
-      
-      for name in args
-	att = Attr.new(get_tkread, name, rw, comment)
-        context.add_attribute(att)
-      end    
+    tmp = RDoc::CodeObject.new
+    read_documentation_modifiers tmp, RDoc::ATTR_MODIFIERS
+    return unless tmp.document_self
+
+    case tk.name
+    when "attr_reader"   then rw = "R"
+    when "attr_writer"   then rw = "W"
+    when "attr_accessor" then rw = "RW"
+    else
+      rw = @options.extra_accessor_flags[tk.name]
     end
 
-    def skip_tkspace_comment(skip_nl = true)
-      loop do
-        skip_tkspace(skip_nl)
-        return unless peek_tk.kind_of? TkCOMMENT
-        get_tk
-      end
+    for name in args
+      att = RDoc::Attr.new get_tkread, name, rw, comment
+      context.add_attribute att
     end
+  end
 
-    def parse_symbol_arg(no = nil)
+  def skip_tkspace_comment(skip_nl = true)
+    loop do
+      skip_tkspace(skip_nl)
+      return unless peek_tk.kind_of? TkCOMMENT
+      get_tk
+    end
+  end
 
-      args = []
-      skip_tkspace_comment
-      case tk = get_tk
-      when TkLPAREN
-	loop do
-	  skip_tkspace_comment
-	  if tk1 = parse_symbol_in_arg
-	    args.push tk1
-	    break if no and args.size >= no
-	  end
-	  
-	  skip_tkspace_comment
-	  case tk2 = get_tk
-	  when TkRPAREN
-	    break
-	  when TkCOMMA
-	  else
-           warn("unexpected token: '#{tk2.inspect}'") if $DEBUG_RDOC
-	    break
-	  end
-	end
-      else
-	unget_tk tk
-	if tk = parse_symbol_in_arg
-	  args.push tk
-	  return args if no and args.size >= no
-	end
+  def parse_symbol_arg(no = nil)
+    args = []
+    skip_tkspace_comment
+    case tk = get_tk
+    when TkLPAREN
+      loop do
+        skip_tkspace_comment
+        if tk1 = parse_symbol_in_arg
+          args.push tk1
+          break if no and args.size >= no
+        end
 
-	loop do
-#	  skip_tkspace_comment(false)
-	  skip_tkspace(false)
+        skip_tkspace_comment
+        case tk2 = get_tk
+        when TkRPAREN
+          break
+        when TkCOMMA
+        else
+          warn("unexpected token: '#{tk2.inspect}'") if $DEBUG_RDOC
+          break
+        end
+      end
+    else
+      unget_tk tk
+      if tk = parse_symbol_in_arg
+        args.push tk
+        return args if no and args.size >= no
+      end
 
-	  tk1 = get_tk
-	  unless tk1.kind_of?(TkCOMMA) 
-	    unget_tk tk1
-	    break
-	  end
-	  
-	  skip_tkspace_comment
-	  if tk = parse_symbol_in_arg
-	    args.push tk
-	    break if no and args.size >= no
-	  end
-	end
+      loop do
+        #	  skip_tkspace_comment(false)
+        skip_tkspace(false)
+
+        tk1 = get_tk
+        unless tk1.kind_of?(TkCOMMA)
+          unget_tk tk1
+          break
+        end
+
+        skip_tkspace_comment
+        if tk = parse_symbol_in_arg
+          args.push tk
+          break if no and args.size >= no
+        end
       end
-      args
     end
+    args
+  end
 
-    def parse_symbol_in_arg
-      case tk = get_tk
-      when TkSYMBOL
-        tk.text.sub(/^:/, '')
-      when TkSTRING
-	eval @read[-1]
-      else
-	warn("Expected symbol or string, got #{tk.inspect}") if $DEBUG_RDOC
-	nil
-      end
+  def parse_symbol_in_arg
+    case tk = get_tk
+    when TkSYMBOL
+      tk.text.sub(/^:/, '')
+    when TkSTRING
+      eval @read[-1]
+    else
+      warn("Expected symbol or string, got #{tk.inspect}") if $DEBUG_RDOC
+      nil
     end
   end
 
diff --git a/lib/rdoc/parsers/parse_simple.rb b/lib/rdoc/parsers/parse_simple.rb
index 3f1a546964..f4b501fe93 100644
--- a/lib/rdoc/parsers/parse_simple.rb
+++ b/lib/rdoc/parsers/parse_simple.rb
@@ -1,41 +1,40 @@
-# Parse a non-source file. We basically take the whole thing 
-# as one big comment. If the first character in the file
-# is '#', we strip leading pound signs.
-
-
-require "rdoc/code_objects"
-require "rdoc/markup/simple_markup/preprocess"
-
-module RDoc
-  # See rdoc/parsers/parse_c.rb
-
-  class SimpleParser
-    
-    # prepare to parse a plain file
-    def initialize(top_level, file_name, body, options, stats)
-      
-      preprocess = SM::PreProcess.new(file_name, options.rdoc_include)
-      
-      preprocess.handle(body) do |directive, param|
-        $stderr.puts "Unrecognized directive '#{directive}' in #{file_name}"
-      end
-      
-      @body = body
-      @options = options
-      @top_level = top_level
-    end
-    
-    # Extract the file contents and attach them to the toplevel as a
-    # comment
-    
-    def scan
-      #    @body.gsub(/^(\s\n)+/, '')
-      @top_level.comment = remove_private_comments(@body)
-      @top_level
-    end
+require 'rdoc'
+require 'rdoc/code_objects'
+require 'rdoc/markup/preprocess'
+
+##
+# Parse a non-source file. We basically take the whole thing as one big
+# comment. If the first character in the file is '#', we strip leading pound
+# signs.
+
+class RDoc::SimpleParser
 
-    def remove_private_comments(comment)
-      comment.gsub(/^--.*?^\+\+/m, '').sub(/^--.*/m, '')
+  ##
+  # Prepare to parse a plain file
+
+  def initialize(top_level, file_name, body, options, stats)
+    preprocess = RDoc::Markup::PreProcess.new(file_name, options.rdoc_include)
+
+    preprocess.handle(body) do |directive, param|
+      warn "Unrecognized directive '#{directive}' in #{file_name}"
     end
+
+    @body = body
+    @options = options
+    @top_level = top_level
   end
+
+  ##
+  # Extract the file contents and attach them to the toplevel as a comment
+
+  def scan
+    @top_level.comment = remove_private_comments(@body)
+    @top_level
+  end
+
+  def remove_private_comments(comment)
+    comment.gsub(/^--[^-].*?^\+\+/m, '').sub(/^--.*/m, '')
+  end
+
 end
+