rdtool 0.6.23

data/lib/rd/labeled-element.rb

@@ -0,0 +1,14 @@
+
+module RD
+  # interface
+  module LabeledElement
+    def to_label
+      @label ||= calculate_label
+    end
+    alias label to_label
+    
+    def calculate_label
+      raise "[BUG] must override."
+    end
+  end
+end

data/lib/rd/list.rb

@@ -0,0 +1,57 @@
+require 'rd/block-element'
+require 'rd/element'
+
+module RD
+  class List < BlockElement
+    include NonterminalElement
+    attr_reader :items
+    
+    def initialize
+      @items = []
+    end
+    
+    alias each_item each_child
+  
+    def children
+      @items
+    end
+  end
+  
+  class ListItem < BlockElement
+    include NonterminalElement
+    
+    attr_reader :content
+    
+    def initialize
+      @content = []
+    end
+    
+    alias each_block each_child
+    
+    def children
+      @content
+    end
+  end
+  
+  class ItemList < List
+    def accept(visitor)
+      visitor.visit_ItemList(self)
+    end
+  end
+  class ItemListItem < ListItem
+    def accept(visitor)
+      visitor.visit_ItemListItem(self)
+    end
+  end
+  
+  class EnumList < List
+    def accept(visitor)
+      visitor.visit_EnumList(self)
+    end
+  end
+  class EnumListItem < ListItem
+    def accept(visitor)
+      visitor.visit_EnumListItem(self)
+    end
+  end
+end # RD

data/lib/rd/loose-struct.rb

@@ -0,0 +1,11 @@
+require 'rd/document-struct'
+require 'rd/element'
+require 'rd/tree'
+
+module RD
+  class DocumentStructure
+    LOOSE = DocumentStructure.new
+    LOOSE.define_relationship(NonterminalElement, Element)
+    LOOSE.define_relationship(Tree, DocumentElement)
+  end
+end

data/lib/rd/methodlist.rb

@@ -0,0 +1,57 @@
+require 'rd/element'
+require 'rd/list'
+require 'rd/complex-list-item'
+require 'rd/labeled-element'
+
+module RD
+  class MethodList < List
+    def accept(visitor)
+      visitor.visit_MethodList(self)
+    end
+  end
+  
+  class MethodListItem < ListItem
+    include ComplexListItem
+    
+    attr_reader :term
+    attr_reader :description
+    
+    def initialize
+      @term = nil
+      @description = []
+    end
+    
+    def accept(visitor)
+      visitor.visit_MethodListItem(self)
+    end
+    
+    def children
+      @description
+    end
+
+    class Term < Element
+      include TerminalElement
+      include LabeledElement
+      
+      attr_reader :content
+      
+      def initialize(content = "")
+	@content = content
+      end
+
+      def each_element
+	yield(self)
+      end
+      alias each each_element
+
+      def accept(visitor)
+	visitor.visit_MethodListItemTerm(self)
+      end
+
+     def calculate_label
+	@content.sub(/\s*(?:\(|\{).*$/, "")
+     end
+     private :calculate_label
+    end
+  end
+end # RD

data/lib/rd/output-format-visitor.rb

@@ -0,0 +1,28 @@
+require 'rd/visitor'
+require 'rd/rd-struct'
+require 'rd/search-file'
+
+module RD
+  class OutputFormatVisitor < Visitor
+    include SearchFile
+
+    # must-have constants
+    OUTPUT_SUFFIX = ""
+    INCLUDE_SUFFIX = []
+
+    attr_accessor :include_suffix
+    attr_accessor :filename
+
+    def initialize
+      super
+      @include_suffix = self.class::INCLUDE_SUFFIX.clone
+      @filename = nil
+    end
+
+    def apply_to_Include(element)
+      fname = search_file(element.filename, element.tree.include_paths,
+			  @include_suffix)
+      File.readlines(fname).join("") if fname
+    end
+  end 
+end # RD

data/lib/rd/package.rb

@@ -0,0 +1,4 @@
+
+module RD
+  PACKAGE_VERSION = "0.6.23"
+end

data/lib/rd/parser-util.rb

@@ -0,0 +1,14 @@
+
+module RD
+  module ParserUtility
+    def add_children_to_element(parent, *children)
+#      parent.add_children_under_document_struct(children,
+#						tree.document_struct)
+      parent.add_children_without_document_struct(children)
+    end
+
+    def tree
+      raise NotImplementedError, "Subclass Responsibility"
+    end
+  end
+end

data/lib/rd/post-install

@@ -0,0 +1 @@
+install_files ["dot.rd2rc"], "#{config('rbdir')}/rd", 0644

data/lib/rd/rbl-file.rb

@@ -0,0 +1,69 @@
+require 'rd/search-file'
+
+module RD
+  class RBLFile
+    include SearchFile
+
+    SUFFIX = "rbl"
+    attr_reader :labels
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = RBLFile.basename(filename)
+      @labels = []
+    end
+
+    def RBLFile.create_rbl_file(filename, resolver)
+      file = File.open(RBLFile.rbl_file_path(filename), "w")
+      file.print(RBLFile.labels_to_string(resolver))
+      file.close
+    end
+
+    def RBLFile.rbl_file_path(filename)
+      basename(filename) + "." + SUFFIX
+    end
+
+    def RBLFile.basename(path)
+      if /\.(rd|rb)$/ === path
+	$`
+      else
+	path
+      end
+    end
+    
+    def RBLFile.labels_to_string(resolver)
+      (resolver.collect do |i|
+	 i.to_label + " => " + resolver.get_anchor(i)
+       end).join("\n")
+    end
+
+    def load_rbl_file(search_paths)
+      f = search_file(@filename, search_paths, [SUFFIX])
+      raise "RBLFile not found." unless f
+      src = File.readlines(f).join("")
+      @labels = string_to_labels(src)
+    end
+		   
+    def string_to_labels(src)
+      labels = []
+      src.each_line do |i|
+	labels << parse_line(i)
+      end
+      labels
+    end
+
+    def parse_line(src)
+      col = src.rindex("=>")
+      raise "RBL file parse error." unless col
+      label = src[0 .. col - 1].strip
+      anchor = src[col + 2 .. -1].strip
+      [label, anchor]
+    end
+
+    def refer(label)
+      label = @labels.find{|i| i[0] == label}
+      return nil unless label
+      label[1]
+    end
+  end
+end

data/lib/rd/rbl-suite.rb

@@ -0,0 +1,37 @@
+require "rd/rbl-file"
+
+module RD
+  class RBLSuite
+    attr_reader :rbl_files
+    
+    def initialize(search_paths)
+      @search_paths = search_paths
+      @rbl_files = []
+    end
+
+    def refer(label, filename)
+      rbl = get_rbl_file(filename)
+      [rbl.filename, rbl.refer(label)]
+    end
+
+    def get_rbl_file(filename)
+      rbl = @rbl_files.find{|i| i.filename == RBLFile.basename(filename)}
+      if rbl
+	rbl
+      else
+	add_rbl_file(filename)
+      end
+    end
+      
+    def add_rbl_file(filename)
+      rbl = RBLFile.new(filename)
+      begin
+	rbl.load_rbl_file(@search_paths)
+      rescue RuntimeError
+      ensure
+	@rbl_files.push(rbl)
+      end
+      rbl
+    end
+  end
+end

data/lib/rd/rd-struct.rb

@@ -0,0 +1,86 @@
+require 'rd/document-struct'
+require 'rd/tree'
+require 'rd/element'
+require 'rd/block-element'
+require 'rd/list'
+require 'rd/desclist'
+require 'rd/methodlist'
+require 'rd/inline-element'
+
+# definition of RD document structure.
+
+module RD
+  # interface. can be component of ListItem.
+  module ListItemComposable
+  end
+  # interface. can be component of Headline and Reference.
+  module LabelComposable
+  end
+  # interface. can include Inline
+  module InlineIncludable
+  end
+
+  class DocumentStructure
+    RD = DocumentStructure.new
+
+    RD.define_relationship(Tree, DocumentElement)
+    RD.define_relationship(DocumentElement, BlockElement)
+    RD.define_relationship(Headline, LabelComposable)
+    RD.define_relationship(TextBlock, InlineElement)
+    RD.define_relationship(ItemList, ItemListItem)
+    RD.define_relationship(EnumList, EnumListItem)
+    RD.define_relationship(DescList, DescListItem)
+    RD.define_relationship(MethodList, MethodListItem)
+    RD.define_relationship(ListItem, ListItemComposable)
+    RD.define_relationship(DescListItem, DescListItem::Term) 
+    RD.define_relationship(DescListItem::Term, LabelComposable)
+    RD.define_relationship(MethodListItem, MethodListItem::Term)   
+    RD.define_relationship(InlineIncludable, InlineElement)
+    RD.define_relationship(Reference, LabelComposable)
+  end
+  
+  class TextBlock
+    include ListItemComposable
+  end
+  class Verbatim
+    include ListItemComposable
+  end
+  class ItemList
+    include ListItemComposable
+  end
+  class EnumList
+    include ListItemComposable
+  end
+  class DescList
+    include ListItemComposable
+  end
+  class StringElement
+    include LabelComposable
+  end
+  class Emphasis
+    include LabelComposable
+    include InlineIncludable
+  end
+  class Code
+    include LabelComposable
+    include InlineIncludable
+  end
+  class Var
+    include LabelComposable
+    include InlineIncludable
+  end
+  class Keyboard
+    include LabelComposable
+    include InlineIncludable
+  end
+  class Index
+    include LabelComposable
+    include InlineIncludable
+  end
+  class Footnote
+    include InlineIncludable
+  end
+  class Verb
+    include LabelComposable
+  end
+end

data/lib/rd/rd2html-lib.rb

@@ -0,0 +1,490 @@
+=begin
+= rd2html-lib.rb
+=end
+
+require "cgi"
+require "rd/rdvisitor"
+require "rd/version"
+
+module RD
+  class RD2HTMLVisitor < RDVisitor
+    include MethodParse
+
+    SYSTEM_NAME = "RDtool -- RD2HTMLVisitor"
+    SYSTEM_VERSION = "$Version: 0.6.23$" #"
+    VERSION = Version.new_from_version_string(SYSTEM_NAME, SYSTEM_VERSION)
+
+    def self.version
+      VERSION
+    end
+    
+    # must-have constants
+    OUTPUT_SUFFIX = "html"
+    INCLUDE_SUFFIX = ["html"]
+    
+    METACHAR = { "<" => "&lt;", ">" => "&gt;", "&" => "&amp;" }
+
+    attr_accessor :css
+    attr_accessor :charset
+    alias charcode charset
+    alias charcode= charset=
+    attr_accessor :lang
+    attr_accessor :title
+    attr_reader :html_link_rel
+    attr_reader :html_link_rev
+    attr_accessor :use_old_anchor
+    # output external Label file.
+    attr_accessor :output_rbl
+
+    attr_reader :footnotes
+    attr_reader :foottexts
+
+    def initialize
+      @css = nil
+      @charset = nil
+      @lang = nil
+      @title = nil
+      @html_link_rel = {}
+      @html_link_rev = {}
+
+      @footnotes = []
+      @index = {}
+
+      #      @use_old_anchor = nil
+      @use_old_anchor = true # MUST -> nil
+      @output_rbl = nil
+      super
+    end
+    
+    def visit(tree)
+      prepare_labels(tree, "label-")
+      prepare_footnotes(tree)
+      tmp = super(tree)
+      make_rbl_file(@filename) if @output_rbl and @filename
+      tmp
+    end
+
+    def apply_to_DocumentElement(element, content)
+      ret = ""
+      ret << xml_decl + "\n"
+      ret << doctype_decl + "\n"
+      ret << html_open_tag + "\n"
+      ret << html_head + "\n"
+      ret << html_body(content) + "\n"
+      ret << "</html>\n"
+      ret
+    end
+
+    def document_title
+      return @title if @title
+      return @filename if @filename
+      return ARGF.filename if ARGF.filename != "-"
+      "Untitled"
+    end
+    private :document_title
+
+    def xml_decl
+      encoding = %[encoding="#{@charset}" ] if @charset
+      %|<?xml version="1.0" #{encoding}?>|
+    end
+    private :xml_decl
+
+    def doctype_decl
+      %|<!DOCTYPE html \n| +
+      %|  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"\n| +
+      %|  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">|
+    end
+    private :doctype_decl
+
+    def html_open_tag
+      lang_attr = %[ lang="#{@lang}" xml:lang="#{@lang}"] if @lang
+      %|<html xmlns="http://www.w3.org/1999/xhtml"#{lang_attr}>|
+    end
+    private :html_open_tag
+
+    def html_head
+      ret = %|<head>\n|
+	ret << html_title + "\n"
+	ret << html_content_type + "\n" if html_content_type
+      ret << link_to_css + "\n" if link_to_css
+      ret << forward_links + "\n" if forward_links
+      ret << backward_links + "\n" if backward_links
+      ret << %Q[</head>]
+    end 
+    private :html_head
+
+    def html_title
+      "<title>#{document_title}</title>"
+    end
+    private :html_title
+
+    def html_content_type
+      if @charset
+	%Q[<meta http-equiv="Content-type" ] +
+	  %Q[content="text/html; charset=#{@charset}" ] +
+	  "/>"
+      end
+    end
+    private :html_content_type
+
+    def link_to_css
+      if @css
+	%|<link href="#{@css}" type="text/css" rel="stylesheet" | +
+	  "/>" # for ruby-mode.el fontlock, it is separated into 2 lines.
+      end
+    end
+    private :link_to_css
+
+    def forward_links
+      return nil if @html_link_rel.empty?
+      rels = @html_link_rel.sort{|i, j| i[0] <=> j[0] }
+      (rels.collect do |rel, href|
+	%Q[<link href="#{href}" rel="#{rel}" />]
+      end).join("\n")
+    end
+    private :forward_links
+
+    def backward_links
+      return nil if @html_link_rev.empty?
+      revs = @html_link_rev.sort{|i, j| i[0] <=> j[0] }
+      (revs.collect do |rev, href|
+	%Q[<link href="#{href}" rev="#{rev}" />]
+      end).join("\n")
+    end
+    private :backward_links
+
+    def html_body(contents)
+      content = contents.join("\n")
+      foottext = make_foottext
+      %Q|<body>\n#{content}\n#{foottext}\n</body>|
+    end
+    private :html_body
+    
+    def apply_to_Headline(element, title)
+      anchor = get_anchor(element)
+      label = hyphen_escape(element.label)
+      title = title.join("")
+      %Q[<h#{element.level}><a name="#{anchor}" id="#{anchor}">#{title}</a>] +
+      %Q[</h#{element.level}><!-- RDLabel: "#{label}" -->]
+    end
+
+    # RDVisitor#apply_to_Include 
+
+    def apply_to_TextBlock(element, content)
+      content = content.join("")
+      if (is_this_textblock_only_one_block_of_parent_listitem?(element) or
+	  is_this_textblock_only_one_block_other_than_sublists_in_parent_listitem?(element))
+	content.chomp
+      else
+	%Q[<p>#{content.chomp}</p>]
+      end
+    end
+
+    def is_this_textblock_only_one_block_of_parent_listitem?(element)
+      parent = element.parent
+      (parent.is_a?(ItemListItem) or
+       parent.is_a?(EnumListItem) or
+       parent.is_a?(DescListItem) or
+       parent.is_a?(MethodListItem)) and
+	consist_of_one_textblock?(parent)
+    end
+
+    def is_this_textblock_only_one_block_other_than_sublists_in_parent_listitem?(element)
+      parent = element.parent
+      (parent.is_a?(ItemListItem) or
+       parent.is_a?(EnumListItem) or
+       parent.is_a?(DescListItem) or
+       parent.is_a?(MethodListItem)) and
+	consist_of_one_textblock_and_sublists(element.parent)
+    end
+
+    def consist_of_one_textblock_and_sublists(element)
+      i = 0
+      element.each_child do |child|
+	if i == 0
+	  return false unless child.is_a?(TextBlock)
+	else
+	  return false unless child.is_a?(List)
+	end
+	i += 1
+      end
+      return true
+    end
+
+    def apply_to_Verbatim(element)
+      content = []
+      element.each_line do |i|
+	content.push(apply_to_String(i))
+      end
+      %Q[<pre>#{content.join("").chomp}</pre>]
+    end
+  
+    def apply_to_ItemList(element, items)
+      %Q[<ul>\n#{items.join("\n").chomp}\n</ul>]
+    end
+  
+    def apply_to_EnumList(element, items)
+      %Q[<ol>\n#{items.join("\n").chomp}\n</ol>]
+    end
+    
+    def apply_to_DescList(element, items)
+      %Q[<dl>\n#{items.join("\n").chomp}\n</dl>]
+    end
+
+    def apply_to_MethodList(element, items)
+      %Q[<dl>\n#{items.join("\n").chomp}\n</dl>]
+    end
+    
+    def apply_to_ItemListItem(element, content)
+      %Q[<li>#{content.join("\n").chomp}</li>]
+    end
+    
+    def apply_to_EnumListItem(element, content)
+      %Q[<li>#{content.join("\n").chomp}</li>]
+    end
+
+    def consist_of_one_textblock?(listitem)
+      listitem.children.size == 1 and listitem.children[0].is_a?(TextBlock)
+    end
+    private :consist_of_one_textblock?
+    
+    def apply_to_DescListItem(element, term, description)
+      anchor = get_anchor(element.term)
+      label = hyphen_escape(element.label)
+      term = term.join("")
+      if description.empty?
+	%Q[<dt><a name="#{anchor}" id="#{anchor}">#{term}</a></dt>] +
+	%Q[<!-- RDLabel: "#{label}" -->]
+      else
+        %Q[<dt><a name="#{anchor}" id="#{anchor}">#{term}</a></dt>] +
+        %Q[<!-- RDLabel: "#{label}" -->\n] +
+        %Q[<dd>\n#{description.join("\n").chomp}\n</dd>]
+      end
+    end
+
+    def apply_to_MethodListItem(element, term, description)
+      term = parse_method(term)  # maybe: term -> element.term
+      anchor = get_anchor(element.term)
+      label = hyphen_escape(element.label)
+      if description.empty?
+	%Q[<dt><a name="#{anchor}" id="#{anchor}"><code>#{term}] +
+        %Q[</code></a></dt><!-- RDLabel: "#{label}" -->]
+      else
+        %Q[<dt><a name="#{anchor}" id="#{anchor}"><code>#{term}] +
+	%Q[</code></a></dt><!-- RDLabel: "#{label}" -->\n] +
+	%Q[<dd>\n#{description.join("\n")}</dd>]
+      end
+    end
+  
+    def apply_to_StringElement(element)
+      apply_to_String(element.content)
+    end
+    
+    def apply_to_Emphasis(element, content)
+      %Q[<em>#{content.join("")}</em>]
+    end
+  
+    def apply_to_Code(element, content)
+      %Q[<code>#{content.join("")}</code>]
+    end
+  
+    def apply_to_Var(element, content)
+      %Q[<var>#{content.join("")}</var>]
+    end
+  
+    def apply_to_Keyboard(element, content)
+      %Q[<kbd>#{content.join("")}</kbd>]
+    end
+  
+    def apply_to_Index(element, content)
+      tmp = []
+      element.each do |i|
+	tmp.push(i) if i.is_a?(String)
+      end
+      key = meta_char_escape(tmp.join(""))
+      if @index.has_key?(key)
+	# warning?
+	%Q[<!-- Index, but conflict -->#{content.join("")}<!-- Index end -->]
+      else
+	num = @index[key] = @index.size
+	anchor = a_name("index", num)
+	%Q[<a name="#{anchor}" id="#{anchor}">#{content.join("")}</a>]
+      end
+    end
+
+    def apply_to_Reference_with_RDLabel(element, content)
+      if element.label.filename
+	apply_to_RefToOtherFile(element, content)
+      else
+	apply_to_RefToElement(element, content)
+      end
+    end
+
+    def apply_to_Reference_with_URL(element, content)
+      %Q[<a href="#{meta_char_escape(element.label.url)}">] +
+	%Q[#{content.join("")}</a>]
+    end
+
+    def apply_to_RefToElement(element, content)
+      content = content.join("")
+      if anchor = refer(element)
+	content = content.sub(/^function#/, "")
+	%Q[<a href="\##{anchor}">#{content}</a>]
+      else
+	# warning?
+	label = hyphen_escape(element.to_label)
+	%Q[<!-- Reference, RDLabel "#{label}" doesn't exist -->] +
+	  %Q[<em class="label-not-found">#{content}</em><!-- Reference end -->]
+	#' 
+      end
+    end
+
+    def apply_to_RefToOtherFile(element, content)
+      content = content.join("")
+      filename = element.label.filename.sub(/\.(rd|rb)(\.\w+)?$/, "." +
+					    OUTPUT_SUFFIX)
+      anchor = refer_external(element)
+      if anchor
+	%Q[<a href="#{filename}\##{anchor}">#{content}</a>]
+      else
+	%Q[<a href="#{filename}">#{content}</a>]
+      end
+    end
+    
+    def apply_to_Footnote(element, content)
+      num = get_footnote_num(element)
+      raise ArgumentError, "[BUG?] #{element} is not registered." unless num
+      
+      add_foottext(num, content)
+      anchor = a_name("footmark", num)
+      href = a_name("foottext", num)
+      %Q|<a name="#{anchor}" id="#{anchor}" | +
+	%Q|href="##{href}"><sup><small>| +
+      %Q|*#{num}</small></sup></a>|
+    end
+
+    def get_footnote_num(fn)
+      raise ArgumentError, "#{fn} must be Footnote." unless fn.is_a? Footnote
+      i = @footnotes.index(fn)
+      if i
+	i + 1
+      else
+	nil
+      end
+    end
+
+    def prepare_footnotes(tree)
+      @footnotes = tree.find_all{|i| i.is_a? Footnote }
+      @foottexts = []
+    end
+    private :prepare_footnotes
+
+    def apply_to_Foottext(element, content)
+      num = get_footnote_num(element)
+      raise ArgumentError, "[BUG] #{element} isn't registered." unless num
+      anchor = a_name("foottext", num)
+      href = a_name("footmark", num)
+      content = content.join("")
+      %|<a name="#{anchor}" id="#{anchor}" href="##{href}">|+
+	%|<sup><small>*#{num}</small></sup></a>| +
+	%|<small>#{content}</small><br />|
+    end
+
+    def add_foottext(num, foottext)
+      raise ArgumentError, "[BUG] footnote ##{num} isn't here." unless
+	footnotes[num - 1]
+      @foottexts[num - 1] = foottext
+    end
+    
+    def apply_to_Verb(element)
+      content = apply_to_String(element.content)
+      %Q[#{content}]
+    end
+
+    def sp2nbsp(str)
+      str.gsub(/\s/, "&nbsp;")
+    end
+    private :sp2nbsp
+    
+    def apply_to_String(element)
+      meta_char_escape(element)
+    end
+    
+    def parse_method(method)
+      klass, kind, method, args = MethodParse.analize_method(method)
+      
+      if kind == :function
+	klass = kind = nil
+      else
+	kind = MethodParse.kind2str(kind)
+      end
+      
+      args.gsub!(/&?\w+;?/){ |m|
+	if /&\w+;/ =~ m then m else '<var>'+m+'</var>' end }
+
+      case method
+      when "self"
+	klass, kind, method, args = MethodParse.analize_method(args)
+	"#{klass}#{kind}<var>self</var> #{method}#{args}"
+      when "[]"
+	args.strip!
+	args.sub!(/^\((.*)\)$/, '\\1')
+	"#{klass}#{kind}[#{args}]"
+      when "[]="
+	args.tr!(' ', '')
+	args.sub!(/^\((.*)\)$/, '\\1')
+	ary = args.split(/,/)
+
+	case ary.length
+	when 1
+	  val = '<var>val</var>'
+	when 2
+	  args, val = *ary
+	when 3
+	  args, val = ary[0, 2].join(', '), ary[2]
+	end
+
+	"#{klass}#{kind}[#{args}] = #{val}"
+      else
+	"#{klass}#{kind}#{method}#{args}"
+      end
+    end
+    private :parse_method
+
+    def meta_char_escape(str)
+      str.gsub(/[<>&]/) {
+	METACHAR[$&]
+      }
+    end
+    private :meta_char_escape
+
+    def hyphen_escape(str)
+      str.gsub(/--/, "&shy;&shy;")
+    end
+    
+    def make_foottext
+      return nil if foottexts.empty?
+      content = []
+      foottexts.each_with_index do |ft, num|
+	content.push(apply_to_Foottext(footnotes[num], ft))
+      end
+      %|<hr />\n<p class="foottext">\n#{content.join("\n")}\n</p>|
+    end
+    private :make_foottext
+
+    def a_name(prefix, num)
+      "#{prefix}-#{num}"
+    end
+    private :a_name
+  end # RD2HTMLVisitor
+end # RD
+
+$Visitor_Class = RD::RD2HTMLVisitor
+$RD2_Sub_OptionParser = "rd/rd2html-opt"
+
+=begin
+== script info.
+ RD to HTML translate library for rdfmt.rb
+ $Id: rd2html-lib.rb,v 1.53 2003/03/08 12:45:08 tosh Exp $
+
+=end