.rdoc_options file to specify the default documentation
# format for your entire project. See RDoc::Options@Saved+Options for
# instructions.
#
# At the top of a file the +:markup:+ directive applies to the entire file:
#
# # coding: UTF-8
# # :markup: TomDoc
#
# # TomDoc comment here ...
#
# class MyClass
# # ...
#
# For just one comment:
#
# # ...
# end
#
# # :markup: RDoc
# #
# # This is a comment in RDoc markup format ...
#
# def some_method
# # ...
#
# See Markup@DEVELOPERS for instructions on adding a new markup format.
#
# [+:include:+ _filename_]
# Include the contents of the named file at this point. This directive
# must appear alone on one line, possibly preceded by spaces. In this
# position, it can be escaped with a \ in front of the first colon.
#
# The file will be searched for in the directories listed by the +--include+
# option, or in the current directory by default. The contents of the file
# will be shifted to have the same indentation as the ':' at the start of
# the +:include:+ directive.
#
# [+:title:+ _text_]
# Sets the title for the document. Equivalent to the --title
# command line parameter. (The command line parameter overrides any :title:
# directive in the source).
#
# [+:main:+ _name_]
# Equivalent to the --main command line parameter.
#
#--
# Original Author:: Dave Thomas, dave@pragmaticprogrammer.com
# License:: Ruby license
class RDoc::Markup
##
# An AttributeManager which handles inline markup.
attr_reader :attribute_manager
##
# Parses +str+ into an RDoc::Markup::Document.
def self.parse str
RDoc::Markup::Parser.parse str
rescue RDoc::Markup::Parser::Error => e
$stderr.puts <<-EOF
While parsing markup, RDoc encountered a #{e.class}:
#{e}
\tfrom #{e.backtrace.join "\n\tfrom "}
---8<---
#{text}
---8<---
RDoc #{RDoc::VERSION}
Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE}
Please file a bug report with the above information at:
https://github.com/rdoc/rdoc/issues
EOF
raise
end
##
# Take a block of text and use various heuristics to determine its
# structure (paragraphs, lists, and so on). Invoke an event handler as we
# identify significant chunks.
def initialize attribute_manager = nil
@attribute_manager = attribute_manager || RDoc::Markup::AttributeManager.new
@output = nil
end
##
# Add to the sequences used to add formatting to an individual word (such
# as *bold*). Matching entries will generate attributes that the output
# formatters can recognize by their +name+.
def add_word_pair(start, stop, name)
@attribute_manager.add_word_pair(start, stop, name)
end
##
# Add to the sequences recognized as general markup.
def add_html(tag, name)
@attribute_manager.add_html(tag, name)
end
##
# Add to other inline sequences. For example, we could add WikiWords using
# something like:
#
# parser.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
#
# Each wiki word will be presented to the output formatter via the
# accept_special method.
def add_special(pattern, name)
@attribute_manager.add_special(pattern, name)
end
##
# We take +input+, parse it if necessary, then invoke the output +formatter+
# using a Visitor to render the result.
def convert input, formatter
document = case input
when RDoc::Markup::Document then
input
else
RDoc::Markup::Parser.parse input
end
document.accept formatter
end
autoload :Parser, 'rdoc/markup/parser'
autoload :PreProcess, 'rdoc/markup/pre_process'
# Inline markup classes
autoload :AttrChanger, 'rdoc/markup/attr_changer'
autoload :AttrSpan, 'rdoc/markup/attr_span'
autoload :Attributes, 'rdoc/markup/attributes'
autoload :AttributeManager, 'rdoc/markup/attribute_manager'
autoload :Special, 'rdoc/markup/special'
# RDoc::Markup AST
autoload :BlankLine, 'rdoc/markup/blank_line'
autoload :BlockQuote, 'rdoc/markup/block_quote'
autoload :Document, 'rdoc/markup/document'
autoload :HardBreak, 'rdoc/markup/hard_break'
autoload :Heading, 'rdoc/markup/heading'
autoload :Include, 'rdoc/markup/include'
autoload :IndentedParagraph, 'rdoc/markup/indented_paragraph'
autoload :List, 'rdoc/markup/list'
autoload :ListItem, 'rdoc/markup/list_item'
autoload :Paragraph, 'rdoc/markup/paragraph'
autoload :Raw, 'rdoc/markup/raw'
autoload :Rule, 'rdoc/markup/rule'
autoload :Verbatim, 'rdoc/markup/verbatim'
# Formatters
autoload :Formatter, 'rdoc/markup/formatter'
autoload :FormatterTestCase, 'rdoc/markup/formatter_test_case'
autoload :TextFormatterTestCase, 'rdoc/markup/text_formatter_test_case'
autoload :ToAnsi, 'rdoc/markup/to_ansi'
autoload :ToBs, 'rdoc/markup/to_bs'
autoload :ToHtml, 'rdoc/markup/to_html'
autoload :ToHtmlCrossref, 'rdoc/markup/to_html_crossref'
autoload :ToHtmlSnippet, 'rdoc/markup/to_html_snippet'
autoload :ToLabel, 'rdoc/markup/to_label'
autoload :ToMarkdown, 'rdoc/markup/to_markdown'
autoload :ToRdoc, 'rdoc/markup/to_rdoc'
autoload :ToTableOfContents, 'rdoc/markup/to_table_of_contents'
autoload :ToTest, 'rdoc/markup/to_test'
autoload :ToTtOnly, 'rdoc/markup/to_tt_only'
end
markup/verbatim.rb 0000644 00000002405 14763537411 0010215 0 ustar 00 ##
# A section of verbatim text
class RDoc::Markup::Verbatim < RDoc::Markup::Raw
##
# Format of this verbatim section
attr_accessor :format
def initialize *parts # :nodoc:
super
@format = nil
end
def == other # :nodoc:
super and @format == other.format
end
##
# Calls #accept_verbatim on +visitor+
def accept visitor
visitor.accept_verbatim self
end
##
# Collapses 3+ newlines into two newlines
def normalize
parts = []
newlines = 0
@parts.each do |part|
case part
when /^\s*\n/ then
newlines += 1
parts << part if newlines == 1
else
newlines = 0
parts << part
end
end
parts.pop if parts.last =~ /\A\r?\n\z/
@parts = parts
end
def pretty_print q # :nodoc:
self.class.name =~ /.*::(\w{1,4})/i
q.group 2, "[#{$1.downcase}: ", ']' do
if @format then
q.text "format: #{@format}"
q.breakable
end
q.seplist @parts do |part|
q.pp part
end
end
end
##
# Is this verbatim section ruby code?
def ruby?
@format ||= nil # TODO for older ri data, switch the tree to marshal_dump
@format == :ruby
end
##
# The text of the section
def text
@parts.join
end
end
markup/rule.rb 0000644 00000000435 14763537411 0007354 0 ustar 00 ##
# A horizontal rule with a weight
class RDoc::Markup::Rule < Struct.new :weight
##
# Calls #accept_rule on +visitor+
def accept visitor
visitor.accept_rule self
end
def pretty_print q # :nodoc:
q.group 2, '[rule:', ']' do
q.pp weight
end
end
end
markup/paragraph.rb 0000644 00000000717 14763537411 0010355 0 ustar 00 ##
# A Paragraph of text
class RDoc::Markup::Paragraph < RDoc::Markup::Raw
##
# Calls #accept_paragraph on +visitor+
def accept visitor
visitor.accept_paragraph self
end
##
# Joins the raw paragraph text and converts inline HardBreaks to the
# +hard_break+ text.
def text hard_break = ''
@parts.map do |part|
if RDoc::Markup::HardBreak === part then
hard_break
else
part
end
end.join
end
end
markup/hard_break.rb 0000644 00000000640 14763537411 0010465 0 ustar 00 ##
# A hard-break in the middle of a paragraph.
class RDoc::Markup::HardBreak
@instance = new
##
# RDoc::Markup::HardBreak is a singleton
def self.new
@instance
end
##
# Calls #accept_hard_break on +visitor+
def accept visitor
visitor.accept_hard_break self
end
def == other # :nodoc:
self.class === other
end
def pretty_print q # :nodoc:
q.text "[break]"
end
end
markup/raw.rb 0000644 00000001712 14763537411 0007175 0 ustar 00 ##
# A section of text that is added to the output document as-is
class RDoc::Markup::Raw
##
# The component parts of the list
attr_reader :parts
##
# Creates a new Raw containing +parts+
def initialize *parts
@parts = []
@parts.concat parts
end
##
# Appends +text+
def << text
@parts << text
end
def == other # :nodoc:
self.class == other.class and @parts == other.parts
end
##
# Calls #accept_raw+ on +visitor+
def accept visitor
visitor.accept_raw self
end
##
# Appends +other+'s parts
def merge other
@parts.concat other.parts
end
def pretty_print q # :nodoc:
self.class.name =~ /.*::(\w{1,4})/i
q.group 2, "[#{$1.downcase}: ", ']' do
q.seplist @parts do |part|
q.pp part
end
end
end
##
# Appends +texts+ onto this Paragraph
def push *texts
self.parts.concat texts
end
##
# The raw text
def text
@parts.join ' '
end
end
markup/to_label.rb 0000644 00000003422 14763537411 0010165 0 ustar 00 require 'cgi'
##
# Creates HTML-safe labels suitable for use in id attributes. Tidylinks are
# converted to their link part and cross-reference links have the suppression
# marks removed (\\SomeClass is converted to SomeClass).
class RDoc::Markup::ToLabel < RDoc::Markup::Formatter
attr_reader :res # :nodoc:
##
# Creates a new formatter that will output HTML-safe labels
def initialize markup = nil
super nil, markup
@markup.add_special RDoc::CrossReference::CROSSREF_REGEXP, :CROSSREF
@markup.add_special(/(((\{.*?\})|\b\S+?)\[\S+?\])/, :TIDYLINK)
add_tag :BOLD, '', ''
add_tag :TT, '', ''
add_tag :EM, '', ''
@res = []
end
##
# Converts +text+ to an HTML-safe label
def convert text
label = convert_flow @am.flow text
CGI.escape label
end
##
# Converts the CROSSREF +special+ to plain text, removing the suppression
# marker, if any
def handle_special_CROSSREF special
text = special.text
text.sub(/^\\/, '')
end
##
# Converts the TIDYLINK +special+ to just the text part
def handle_special_TIDYLINK special
text = special.text
return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
$1
end
alias accept_blank_line ignore
alias accept_block_quote ignore
alias accept_heading ignore
alias accept_list_end ignore
alias accept_list_item_end ignore
alias accept_list_item_start ignore
alias accept_list_start ignore
alias accept_paragraph ignore
alias accept_raw ignore
alias accept_rule ignore
alias accept_verbatim ignore
alias end_accepting ignore
alias handle_special_HARD_BREAK ignore
alias start_accepting ignore
end
markup/to_tt_only.rb 0000644 00000004361 14763537411 0010601 0 ustar 00 ##
# Extracts sections of text enclosed in plus, tt or code. Used to discover
# undocumented parameters.
class RDoc::Markup::ToTtOnly < RDoc::Markup::Formatter
##
# Stack of list types
attr_reader :list_type
##
# Output accumulator
attr_reader :res
##
# Creates a new tt-only formatter.
def initialize markup = nil
super nil, markup
add_tag :TT, nil, nil
end
##
# Adds tts from +block_quote+ to the output
def accept_block_quote block_quote
tt_sections block_quote.text
end
##
# Pops the list type for +list+ from #list_type
def accept_list_end list
@list_type.pop
end
##
# Pushes the list type for +list+ onto #list_type
def accept_list_start list
@list_type << list.type
end
##
# Prepares the visitor for consuming +list_item+
def accept_list_item_start list_item
case @list_type.last
when :NOTE, :LABEL then
Array(list_item.label).map do |label|
tt_sections label
end.flatten
end
end
##
# Adds +paragraph+ to the output
def accept_paragraph paragraph
tt_sections(paragraph.text)
end
##
# Does nothing to +markup_item+ because it doesn't have any user-built
# content
def do_nothing markup_item
end
alias accept_blank_line do_nothing # :nodoc:
alias accept_heading do_nothing # :nodoc:
alias accept_list_item_end do_nothing # :nodoc:
alias accept_raw do_nothing # :nodoc:
alias accept_rule do_nothing # :nodoc:
alias accept_verbatim do_nothing # :nodoc:
##
# Extracts tt sections from +text+
def tt_sections text
flow = @am.flow text.dup
flow.each do |item|
case item
when String then
@res << item if in_tt?
when RDoc::Markup::AttrChanger then
off_tags res, item
on_tags res, item
when RDoc::Markup::Special then
@res << convert_special(item) if in_tt? # TODO can this happen?
else
raise "Unknown flow element: #{item.inspect}"
end
end
res
end
##
# Returns an Array of items that were wrapped in plus, tt or code.
def end_accepting
@res.compact
end
##
# Prepares the visitor for gathering tt sections
def start_accepting
@res = []
@list_type = []
end
end
markup/to_html.rb 0000644 00000020160 14763537411 0010050 0 ustar 00 require 'cgi'
##
# Outputs RDoc markup as HTML.
class RDoc::Markup::ToHtml < RDoc::Markup::Formatter
include RDoc::Text
# :section: Utilities
##
# Maps RDoc::Markup::Parser::LIST_TOKENS types to HTML tags
LIST_TYPE_TO_HTML = {
:BULLET => ['- ', '
- ', '
- ', '
- ', '
- ', '
- ', '
\n" # external links @markup.add_special(/(?:link:|https?:|mailto:|ftp:|irc:|www\.)\S+\w/, :HYPERLINK) add_special_RDOCLINK add_special_TIDYLINK init_tags end # :section: Special Handling # # These methods handle special markup added by RDoc::Markup#add_special. ## # +special+ is a
' end ## # +special+ is a potential link. The following schemes are handled: # # mailto::: # Inserted as-is. # http::: # Links are checked to see if they reference an image. If so, that image # gets inserted using an
" block_quote.parts.each do |part| part.accept self end @res << "\n" end ## # Adds +paragraph+ to the output def accept_paragraph paragraph @res << "\n
" text = paragraph.text @hard_break @res << wrap(to_html(text)) @res << "
\n" end ## # Adds +verbatim+ to the output def accept_verbatim verbatim text = verbatim.text.rstrip @res << if verbatim.ruby? or parseable? text then begin tokens = RDoc::RubyLex.tokenize text, @options html = RDoc::TokenStream.to_html tokens "\n#{html}\n"
rescue RDoc::RubyLex::Error
"\n#{CGI.escapeHTML text}\n"
end
else
"\n#{CGI.escapeHTML text}\n"
end
end
##
# Adds +rule+ to the output
def accept_rule(rule)
size = rule.weight
size = 10 if size > 10
@res << "\n" end ## # Prepares the visitor for consuming +list+ def accept_list_start(list) @list << list.type @res << html_list_name(list.type, true) @in_list_entry.push false end ## # Finishes consumption of +list+ def accept_list_end(list) @list.pop if tag = @in_list_entry.pop @res << tag end @res << html_list_name(list.type, false) << "\n" end ## # Prepares the visitor for consuming +list_item+ def accept_list_item_start(list_item) if tag = @in_list_entry.last @res << tag end @res << list_item_start(list_item, @list.last) end ## # Finishes consumption of +list_item+ def accept_list_item_end(list_item) @in_list_entry[-1] = list_end_for(@list.last) end ## # Adds +blank_line+ to the output def accept_blank_line(blank_line) # @res << annotate("") << "\n" end ## # Adds +heading+ to the output. The headings greater than 6 are trimmed to # level 6. def accept_heading heading level = [6, heading.level].min label = heading.aref label = [@code_object.aref, label].compact.join '-' if @code_object and @code_object.respond_to? :aref @res << "\n
", ""
add_tag :EM, "", ""
end
##
# Returns the HTML tag for +list_type+, possible using a label from
# +list_item+
def list_item_start(list_item, list_type)
case list_type
when :BULLET, :LALPHA, :NUMBER, :UALPHA then
"/, :HARD_BREAK) @attributes = @am.attributes @attr_tags = [] @in_tt = 0 @tt_bit = @attributes.bitmap_for :TT @hard_break = '' @from_path = '.' end ## # Adds +document+ to the output def accept_document document document.parts.each do |item| case item when RDoc::Markup::Document then # HACK accept_document item else item.accept self end end end ## # Adds a special for links of the form rdoc-...: def add_special_RDOCLINK @markup.add_special(/rdoc-[a-z]+:\S+/, :RDOCLINK) end ## # Adds a special for links of the form {
#{to_html heading.text}\n" add_paragraph end ## # Raw sections are untrusted and ignored alias accept_raw ignore ## # Rules are ignored alias accept_rule ignore def accept_paragraph paragraph para = @in_list_entry.last || "
"
text = paragraph.text @hard_break
@res << "#{para}#{wrap to_html text}\n"
add_paragraph
end
##
# Finishes consumption of +list_item+
def accept_list_item_end list_item
end
##
# Prepares the visitor for consuming +list_item+
def accept_list_item_start list_item
@res << list_item_start(list_item, @list.last)
end
##
# Prepares the visitor for consuming +list+
def accept_list_start list
@list << list.type
@res << html_list_name(list.type, true)
@in_list_entry.push ''
end
##
# Adds +verbatim+ to the output
def accept_verbatim verbatim
throw :done if @characters >= @character_limit
input = verbatim.text.rstrip
text = truncate input
text << ' ...' unless text == input
super RDoc::Markup::Verbatim.new text
add_paragraph
end
##
# Prepares the visitor for HTML snippet generation
def start_accepting
super
@characters = 0
end
##
# Removes escaping from the cross-references in +special+
def handle_special_CROSSREF special
special.text.sub(/\A\\/, '')
end
##
# +special+ is a
'
end
##
# Lists are paragraphs, but notes and labels have a separator
def list_item_start list_item, list_type
throw :done if @characters >= @character_limit
case list_type
when :BULLET, :LALPHA, :NUMBER, :UALPHA then
"
" when :LABEL, :NOTE then labels = Array(list_item.label).map do |label| to_html label end.join ', ' labels << " — " unless labels.empty? start = "
#{labels}"
@characters += 1 # try to include the label
start
else
raise RDoc::Error, "Invalid list type: #{list_type.inspect}"
end
end
##
# Returns just the text of +link+, +url+ is only used to determine the link
# type.
def gen_url url, text
if url =~ /^rdoc-label:([^:]*)(?::(.*))?/ then
type = "link"
elsif url =~ /([A-Za-z]+):(.*)/ then
type = $1
else
type = "http"
end
if (type == "http" or type == "https" or type == "link") and
url =~ /\.(gif|png|jpg|jpeg|bmp)$/ then
''
else
text.sub(%r%^#{type}:/*%, '')
end
end
##
# In snippets, there are no lists
def html_list_name list_type, open_tag
''
end
##
# Throws +:done+ when paragraph_limit paragraphs have been encountered
def add_paragraph
@paragraphs += 1
throw :done if @paragraphs >= @paragraph_limit
end
##
# Marks up +content+
def convert content
catch :done do
return super
end
end_accepting
end
##
# Converts flow items +flow+
def convert_flow flow
throw :done if @characters >= @character_limit
res = []
@mask = 0
flow.each do |item|
case item
when RDoc::Markup::AttrChanger then
off_tags res, item
on_tags res, item
when String then
text = convert_string item
res << truncate(text)
when RDoc::Markup::Special then
text = convert_special item
res << truncate(text)
else
raise "Unknown flow element: #{item.inspect}"
end
if @characters >= @character_limit then
off_tags res, RDoc::Markup::AttrChanger.new(0, @mask)
break
end
end
res << ' ...' if @characters >= @character_limit
res.join
end
##
# Maintains a bitmask to allow HTML elements to be closed properly. See
# RDoc::Markup::Formatter.
def on_tags res, item
@mask ^= item.turn_on
super
end
##
# Maintains a bitmask to allow HTML elements to be closed properly. See
# RDoc::Markup::Formatter.
def off_tags res, item
@mask ^= item.turn_off
super
end
##
# Truncates +text+ at the end of the first word after the character_limit.
def truncate text
length = text.length
characters = @characters
@characters += length
return text if @characters < @character_limit
remaining = @character_limit - characters
text =~ /\A(.{#{remaining},}?)(\s|$)/m # TODO word-break instead of \s?
$1
end
end
markup/formatter_test_case.rb 0000644 00000041541 14763537411 0012445 0 ustar 00 require 'minitest/unit'
##
# Test case for creating new RDoc::Markup formatters. See
# test/test_rdoc_markup_to_*.rb for examples.
#
# This test case adds a variety of tests to your subclass when
# #add_visitor_tests is called. Most tests set up a scenario then call a
# method you will provide to perform the assertion on the output.
#
# Your subclass must instantiate a visitor and assign it to @to.
#
# For example, test_accept_blank_line sets up a RDoc::Markup::BlockLine then
# calls accept_blank_line on your visitor. You are responsible for asserting
# that the output is correct.
#
# Example:
#
# class TestRDocMarkupToNewFormat < RDoc::Markup::FormatterTestCase
#
# add_visitor_tests
#
# def setup
# super
#
# @to = RDoc::Markup::ToNewFormat.new
# end
#
# def accept_blank_line
# assert_equal :junk, @to.res.join
# end
#
# # ...
#
# end
class RDoc::Markup::FormatterTestCase < RDoc::TestCase
##
# Call #setup when inheriting from this test case.
#
# Provides the following instance variables:
#
# +@m+:: RDoc::Markup.new
# +@RM+:: RDoc::Markup # to reduce typing
# +@bullet_list+:: @RM::List.new :BULLET, # ...
# +@label_list+:: @RM::List.new :LABEL, # ...
# +@lalpha_list+:: @RM::List.new :LALPHA, # ...
# +@note_list+:: @RM::List.new :NOTE, # ...
# +@number_list+:: @RM::List.new :NUMBER, # ...
# +@ualpha_list+:: @RM::List.new :UALPHA, # ...
def setup
super
@options = RDoc::Options.new
@m = @RM.new
@bullet_list = @RM::List.new(:BULLET,
@RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
@RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
@label_list = @RM::List.new(:LABEL,
@RM::ListItem.new('cat', @RM::Paragraph.new('cats are cool')),
@RM::ListItem.new('dog', @RM::Paragraph.new('dogs are cool too')))
@lalpha_list = @RM::List.new(:LALPHA,
@RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
@RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
@note_list = @RM::List.new(:NOTE,
@RM::ListItem.new('cat', @RM::Paragraph.new('cats are cool')),
@RM::ListItem.new('dog', @RM::Paragraph.new('dogs are cool too')))
@number_list = @RM::List.new(:NUMBER,
@RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
@RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
@ualpha_list = @RM::List.new(:UALPHA,
@RM::ListItem.new(nil, @RM::Paragraph.new('l1')),
@RM::ListItem.new(nil, @RM::Paragraph.new('l2')))
end
##
# Call to add the visitor tests to your test case
def self.add_visitor_tests
class_eval do
##
# Calls start_accepting which needs to verify startup state
def test_start_accepting
@to.start_accepting
start_accepting
end
##
# Calls end_accepting on your test case which needs to call
# @to.end_accepting and verify document generation
def test_end_accepting
@to.start_accepting
@to.res << 'hi'
end_accepting
end
##
# Calls accept_blank_line
def test_accept_blank_line
@to.start_accepting
@to.accept_blank_line @RM::BlankLine.new
accept_blank_line
end
##
# Calls accept_block_quote
def test_accept_block_quote
@to.start_accepting
@to.accept_block_quote block para 'quote'
accept_block_quote
end
##
# Test case that calls @to.accept_document
def test_accept_document
@to.start_accepting
@to.accept_document @RM::Document.new @RM::Paragraph.new 'hello'
accept_document
end
##
# Calls accept_heading with a level 5 RDoc::Markup::Heading
def test_accept_heading
@to.start_accepting
@to.accept_heading @RM::Heading.new(5, 'Hello')
accept_heading
end
##
# Calls accept_heading_1 with a level 1 RDoc::Markup::Heading
def test_accept_heading_1
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, 'Hello')
accept_heading_1
end
##
# Calls accept_heading_2 with a level 2 RDoc::Markup::Heading
def test_accept_heading_2
@to.start_accepting
@to.accept_heading @RM::Heading.new(2, 'Hello')
accept_heading_2
end
##
# Calls accept_heading_3 with a level 3 RDoc::Markup::Heading
def test_accept_heading_3
# HACK this doesn't belong here
skip "No String#chars, upgrade your ruby" unless ''.respond_to? :chars
@to.start_accepting
@to.accept_heading @RM::Heading.new(3, 'Hello')
accept_heading_3
end
##
# Calls accept_heading_4 with a level 4 RDoc::Markup::Heading
def test_accept_heading_4
@to.start_accepting
@to.accept_heading @RM::Heading.new(4, 'Hello')
accept_heading_4
end
##
# Calls accept_heading_b with a bold level 1 RDoc::Markup::Heading
def test_accept_heading_b
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, '*Hello*')
accept_heading_b
end
##
# Calls accept_heading_suppressed_crossref with a level 1
# RDoc::Markup::Heading containing a suppressed crossref
def test_accept_heading_suppressed_crossref # HACK to_html_crossref test
@to.start_accepting
@to.accept_heading @RM::Heading.new(1, '\\Hello')
accept_heading_suppressed_crossref
end
##
# Calls accept_paragraph
def test_accept_paragraph
@to.start_accepting
@to.accept_paragraph @RM::Paragraph.new('hi')
accept_paragraph
end
##
# Calls accept_paragraph_b with a RDoc::Markup::Paragraph containing
# bold words
def test_accept_paragraph_b
@to.start_accepting
@to.accept_paragraph @RM::Paragraph.new('reg bold words reg')
accept_paragraph_b
end
##
# Calls accept_paragraph_br with a RDoc::Markup::Paragraph containing
# a \
def test_accept_paragraph_br
@to.start_accepting
@to.accept_paragraph para 'one
two'
accept_paragraph_br
end
##
# Calls accept_paragraph with a Paragraph containing a hard break
def test_accept_paragraph_break
@to.start_accepting
@to.accept_paragraph para('hello', hard_break, 'world')
accept_paragraph_break
end
##
# Calls accept_paragraph_i with a RDoc::Markup::Paragraph containing
# emphasized words
def test_accept_paragraph_i
@to.start_accepting
@to.accept_paragraph @RM::Paragraph.new('reg italic words reg')
accept_paragraph_i
end
##
# Calls accept_paragraph_plus with a RDoc::Markup::Paragraph containing
# teletype words
def test_accept_paragraph_plus
@to.start_accepting
@to.accept_paragraph @RM::Paragraph.new('reg +teletype+ reg')
accept_paragraph_plus
end
##
# Calls accept_paragraph_star with a RDoc::Markup::Paragraph containing
# bold words
def test_accept_paragraph_star
@to.start_accepting
@to.accept_paragraph @RM::Paragraph.new('reg *bold* reg')
accept_paragraph_star
end
##
# Calls accept_paragraph_underscore with a RDoc::Markup::Paragraph
# containing emphasized words
def test_accept_paragraph_underscore
@to.start_accepting
@to.accept_paragraph @RM::Paragraph.new('reg _italic_ reg')
accept_paragraph_underscore
end
##
# Calls accept_verbatim with a RDoc::Markup::Verbatim
def test_accept_verbatim
@to.start_accepting
@to.accept_verbatim @RM::Verbatim.new("hi\n", " world\n")
accept_verbatim
end
##
# Calls accept_raw with a RDoc::Markup::Raw
def test_accept_raw
@to.start_accepting
@to.accept_raw @RM::Raw.new("
| Name | Count", " |
|---|---|
| a | 1", " |
| b | 2", " |
.rdoc_options file to store
# your project default.
#
# There are a few differences between this parser and the specification. A
# best-effort was made to follow the specification as closely as possible but
# some choices to deviate were made.
#
# A future version of RDoc will warn when a MUST or MUST NOT is violated and
# may warn when a SHOULD or SHOULD NOT is violated. RDoc will always try
# to emit documentation even if given invalid TomDoc.
#
# Here are some implementation choices this parser currently makes:
#
# This parser allows rdoc-style inline markup but you should not depended on
# it.
#
# This parser allows a space between the comment and the method body.
#
# This parser does not require the default value to be described for an
# optional argument.
#
# This parser does not examine the order of sections. An Examples section may
# precede the Arguments section.
#
# This class is documented in TomDoc format. Since this is a subclass of the
# RDoc markup parser there isn't much to see here, unfortunately.
class RDoc::TomDoc < RDoc::Markup::Parser
# Internal: Token accessor
attr_reader :tokens
# Internal: Adds a post-processor which sets the RDoc section based on the
# comment's status.
#
# Returns nothing.
def self.add_post_processor # :nodoc:
RDoc::Markup::PreProcess.post_process do |comment, code_object|
next unless code_object and
RDoc::Comment === comment and comment.format == 'tomdoc'
comment.text.gsub!(/(\A\s*# )(Public|Internal|Deprecated):\s+/) do
section = code_object.add_section $2
code_object.temporary_section = section
$1
end
end
end
add_post_processor
# Public: Parses TomDoc from text
#
# text - A String containing TomDoc-format text.
#
# Examples
#
# RDoc::TomDoc.parse <<-TOMDOC
# This method does some things
#
# Returns nothing.
# TOMDOC
# # => #<%= klass.type %> <%= klass.full_name %>
<%= klass.description %>
<% klass.each_section do |section, constants, attributes| %>
<% constants = constants.select { |const| const.display? } %>
<% attributes = attributes.select { |attr| attr.display? } %>
<%= section.title %>
↑ top
<%= section.description %>
<% end %>
<% unless constants.empty? then %>
Constants
-
<% constants.each do |const| %>
- <%= const.name %> <% if const.comment then %>
- <%= const.description.strip %>
<% else %>
- (Not documented) <% end %> <% end %>
Attributes
<% attributes.each do |attrib| %>
<%= h attrib.name %>[<%= attrib.rw %>]
<% if attrib.comment then %>
<%= attrib.description.strip %>
<% else %>
(Not documented) <% end %>
<%= visibility.to_s.capitalize %> <%= type.capitalize %> Methods
<% methods.each do |method| %>">
<% if method.call_seq then %>
<% method.call_seq.strip.split("\n").each_with_index do |call_seq, i| %>
<% end %>
<%= h(call_seq.strip.
gsub( /^\w+\./m, '')).
gsub(/(.*)[-=]>/, '\1→') %>
<% if i == 0 and method.token_stream then %>
click to toggle source
<% end %>
<% end %>
<% else %>
<%= h method.name %><%= method.param_seq %>
<% if method.token_stream then %>
click to toggle source
<% end %>
<% end %>
<% if method.comment then %>
<%= method.description.strip %>
<% else %>
<% end %>
<% unless method.aliases.empty? then %>
(Not documented) <% end %> <% if method.calls_super then %>
Calls superclass method
<%=
method.superclass_method ?
method.formatter.link(method.superclass_method.full_name, method.superclass_method.full_name) : nil
%>
<% end %>
<% if method.token_stream then %>
<%= method.markup_code %>
Also aliased as: <%= method.aliases.map do |aka|
if aka.parent then # HACK lib/rexml/encodings
%{#{h aka.name}}
else
h aka.name
end
end.join ", " %>
<% end %>
<% if method.is_alias_for then %>
Alias for: <%= h method.is_alias_for.name %>
<% end %>
Not Found
The page <%=h path %> was not found
Error
While processing #{ERB::Util.html_escape req.request_uri} the
RDoc (#{ERB::Util.html_escape RDoc::VERSION}) server has encountered a
#{ERB::Util.html_escape exception.class}
exception:
#{ERB::Util.html_escape exception.message}
Please report this to the RDoc issues tracker. Please include the RDoc version, the URI above and exception class, message and backtrace. If you're viewing a gem's documentation, include the gem name and version. If you're viewing Ruby's documentation, include the version of ruby.
Backtrace:
#{ERB::Util.html_escape backtrace}
BODY
end
##
# Instantiates a Darkfish generator for +store+
def generator_for store
generator = RDoc::Generator::Darkfish.new store, @options
generator.file_output = false
generator.asset_rel_path = '..'
rdoc = RDoc::RDoc.new
rdoc.store = store
rdoc.generator = generator
rdoc.options = @options
@options.main_page = store.main
@options.title = store.title
generator
end
##
# Handles the If-Modified-Since HTTP header on +req+ for +path+. If the
# file has not been modified a Not Modified response is returned. If the
# file has been modified a Last-Modified header is added to +res+.
def if_modified_since req, res, path = nil
last_modified = File.stat(path).mtime if path
res['last-modified'] = last_modified.httpdate
return unless ims = req['if-modified-since']
ims = Time.parse ims
unless ims < last_modified then
res.body = ''
raise WEBrick::HTTPStatus::NotModified
end
end
##
# Returns an Array of installed documentation.
#
# Each entry contains the documentation name (gem name, 'Ruby
# Documentation', etc.), the path relative to the mount point, whether the
# documentation exists, the type of documentation (See RDoc::RI::Paths#each)
# and the filesystem to the RDoc::Store for the documentation.
def installed_docs
ri_paths.map do |path, type|
store = RDoc::Store.new path, type
exists = File.exist? store.cache_path
case type
when :gem then
gem_path = path[%r%/([^/]*)/ri$%, 1]
[gem_path, "#{gem_path}/", exists, type, path]
when :system then
['Ruby Documentation', 'ruby/', exists, type, path]
when :site then
['Site Documentation', 'site/', exists, type, path]
when :home then
['Home Documentation', 'home/', exists, type, path]
end
end
end
##
# Returns a 404 page built by +generator+ for +req+ on +res+.
def not_found generator, req, res
res.body = generator.generate_servlet_not_found req.path
res.status = 404
end
##
# Enumerates the ri paths. See RDoc::RI::Paths#each
def ri_paths &block
RDoc::RI::Paths.each true, true, true, :all, &block
end
##
# Generates the root page on +res+. +req+ is ignored.
def root req, res
generator = RDoc::Generator::Darkfish.new nil, @options
res.body = generator.generate_servlet_root installed_docs
res.content_type = 'text/html'
end
##
# Generates a search index for the root page on +res+. +req+ is ignored.
def root_search req, res
search_index = []
info = []
installed_docs.map do |name, href, exists, type, path|
next unless exists
search_index << name
case type
when :gem
gemspec = path.gsub(%r%/doc/([^/]*?)/ri$%,
'/specifications/\1.gemspec')
spec = Gem::Specification.load gemspec
path = spec.full_name
comment = spec.summary
when :system then
path = 'ruby'
comment = 'Documentation for the Ruby standard library'
when :site then
path = 'site'
comment = 'Documentation for non-gem libraries'
when :home then
path = 'home'
comment = 'Documentation from your home directory'
end
info << [name, '', path, '', comment]
end
index = {
:index => {
:searchIndex => search_index,
:longSearchIndex => search_index,
:info => info,
}
}
res.body = "var search_data = #{JSON.dump index};"
res.content_type = 'application/javascript'
end
##
# Displays documentation for +req+ on +res+, whether that be HTML or some
# asset.
def show_documentation req, res
store, path = documentation_source req.path
if_modified_since req, res, store.cache_path
generator = generator_for store
case path
when nil, '', 'index.html' then
res.body = generator.generate_index
when 'table_of_contents.html' then
res.body = generator.generate_table_of_contents
when 'js/search_index.js' then
documentation_search store, generator, req, res
else
documentation_page store, generator, path, req, res
end
ensure
res.content_type ||= 'text/html'
end
##
# Returns an RDoc::Store for the given +source_name+ ('ruby' or a gem name).
def store_for source_name
case source_name
when 'home' then
RDoc::Store.new RDoc::RI::Paths.home_dir, :home
when 'ruby' then
RDoc::Store.new RDoc::RI::Paths.system_dir, :system
when 'site' then
RDoc::Store.new RDoc::RI::Paths.site_dir, :site
else
ri_dir, type = ri_paths.find do |dir, dir_type|
next unless dir_type == :gem
source_name == dir[%r%/([^/]*)/ri$%, 1]
end
raise RDoc::Error,
"could not find ri documentation for #{source_name}" unless
ri_dir
RDoc::Store.new ri_dir, type
end
end
end
method_attr.rb 0000644 00000021105 14763537411 0007415 0 ustar 00 ##
# Abstract class representing either a method or an attribute.
class RDoc::MethodAttr < RDoc::CodeObject
include Comparable
##
# Name of this method/attribute.
attr_accessor :name
##
# public, protected, private
attr_accessor :visibility
##
# Is this a singleton method/attribute?
attr_accessor :singleton
##
# Source file token stream
attr_reader :text
##
# Array of other names for this method/attribute
attr_reader :aliases
##
# The method/attribute we're aliasing
attr_accessor :is_alias_for
#--
# The attributes below are for AnyMethod only.
# They are left here for the time being to
# allow ri to operate.
# TODO modify ri to avoid calling these on attributes.
#++
##
# Parameters yielded by the called block
attr_reader :block_params
##
# Parameters for this method
attr_accessor :params
##
# Different ways to call this method
attr_accessor :call_seq
##
# The call_seq or the param_seq with method name, if there is no call_seq.
attr_reader :arglists
##
# Pretty parameter list for this method
attr_reader :param_seq
##
# Creates a new MethodAttr from token stream +text+ and method or attribute
# name +name+.
#
# Usually this is called by super from a subclass.
def initialize text, name
super()
@text = text
@name = name
@aliases = []
@is_alias_for = nil
@parent_name = nil
@singleton = nil
@visibility = :public
@see = false
@arglists = nil
@block_params = nil
@call_seq = nil
@param_seq = nil
@params = nil
end
##
# Order by #singleton then #name
def <=>(other)
[ @singleton ? 0 : 1, name] <=>
[other.singleton ? 0 : 1, other.name]
end
def == other # :nodoc:
super or self.class == other.class and full_name == other.full_name
end
##
# A method/attribute is documented if any of the following is true:
# - it was marked with :nodoc:;
# - it has a comment;
# - it is an alias for a documented method;
# - it has a +#see+ method that is documented.
def documented?
super or
(is_alias_for and is_alias_for.documented?) or
(see and see.documented?)
end
##
# A method/attribute to look at,
# in particular if this method/attribute has no documentation.
#
# It can be a method/attribute of the superclass or of an included module,
# including the Kernel module, which is always appended to the included
# modules.
#
# Returns +nil+ if there is no such method/attribute.
# The +#is_alias_for+ method/attribute, if any, is not included.
#
# Templates may generate a "see also ..." if this method/attribute
# has documentation, and "see ..." if it does not.
def see
@see = find_see if @see == false
@see
end
##
# Sets the store for this class or module and its contained code objects.
def store= store
super
@file = @store.add_file @file.full_name if @file
end
def find_see # :nodoc:
return nil if singleton || is_alias_for
# look for the method
other = find_method_or_attribute name
return other if other
# if it is a setter, look for a getter
return nil unless name =~ /[a-z_]=$/i # avoid == or ===
return find_method_or_attribute name[0..-2]
end
def find_method_or_attribute name # :nodoc:
return nil unless parent.respond_to? :ancestors
searched = parent.ancestors
kernel = @store.modules_hash['Kernel']
searched << kernel if kernel &&
parent != kernel && !searched.include?(kernel)
searched.each do |ancestor|
next if parent == ancestor
next if String === ancestor
other = ancestor.find_method_named('#' << name) ||
ancestor.find_attribute_named(name)
return other if other
end
nil
end
##
# Abstract method. Contexts in their building phase call this
# to register a new alias for this known method/attribute.
#
# - creates a new AnyMethod/Attribute named an_alias.new_name;
# - adds +self+ as an alias for the new method or attribute
# - adds the method or attribute to #aliases
# - adds the method or attribute to +context+.
def add_alias(an_alias, context)
raise NotImplementedError
end
##
# HTML fragment reference for this method
def aref
type = singleton ? 'c' : 'i'
# % characters are not allowed in html names => dash instead
"#{aref_prefix}-#{type}-#{html_name}"
end
##
# Prefix for +aref+, defined by subclasses.
def aref_prefix
raise NotImplementedError
end
##
# Attempts to sanitize the content passed by the ruby parser:
# remove outer parentheses, etc.
def block_params=(value)
# 'yield.to_s' or 'assert yield, msg'
return @block_params = '' if value =~ /^[\.,]/
# remove trailing 'if/unless ...'
return @block_params = '' if value =~ /^(if|unless)\s/
value = $1.strip if value =~ /^(.+)\s(if|unless)\s/
# outer parentheses
value = $1 if value =~ /^\s*\((.*)\)\s*$/
value = value.strip
# proc/lambda
return @block_params = $1 if value =~ /^(proc|lambda)(\s*\{|\sdo)/
# surrounding +...+ or [...]
value = $1.strip if value =~ /^\+(.*)\+$/
value = $1.strip if value =~ /^\[(.*)\]$/
return @block_params = '' if value.empty?
# global variable
return @block_params = 'str' if value =~ /^\$[&0-9]$/
# wipe out array/hash indices
value.gsub!(/(\w)\[[^\[]+\]/, '\1')
# remove @ from class/instance variables
value.gsub!(/@@?([a-z0-9_]+)/, '\1')
# method calls => method name
value.gsub!(/([A-Z:a-z0-9_]+)\.([a-z0-9_]+)(\s*\(\s*[a-z0-9_.,\s]*\s*\)\s*)?/) do
case $2
when 'to_s' then $1
when 'const_get' then 'const'
when 'new' then
$1.split('::').last. # ClassName => class_name
gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
gsub(/([a-z\d])([A-Z])/,'\1_\2').
downcase
else
$2
end
end
# class prefixes
value.gsub!(/[A-Za-z0-9_:]+::/, '')
# simple expressions
value = $1 if value =~ /^([a-z0-9_]+)\s*[-*+\/]/
@block_params = value.strip
end
##
# HTML id-friendly method/attribute name
def html_name
require 'cgi'
CGI.escape(@name.gsub('-', '-2D')).gsub('%','-').sub(/^-/, '')
end
##
# Full method/attribute name including namespace
def full_name
@full_name ||= "#{parent_name}#{pretty_name}"
end
def inspect # :nodoc:
alias_for = @is_alias_for ? " (alias for #{@is_alias_for.name})" : nil
visibility = self.visibility
visibility = "forced #{visibility}" if force_documentation
"#<%s:0x%x %s (%s)%s>" % [
self.class, object_id,
full_name,
visibility,
alias_for,
]
end
##
# '::' for a class method/attribute, '#' for an instance method.
def name_prefix
@singleton ? '::' : '#'
end
##
# Name for output to HTML. For class methods the full name with a "." is
# used like +SomeClass.method_name+. For instance methods the class name is
# used if +context+ does not match the parent.
#
# This is to help prevent people from using :: to call class methods.
def output_name context
return "#{name_prefix}#{@name}" if context == parent
"#{parent_name}#{@singleton ? '.' : '#'}#{@name}"
end
##
# Method/attribute name with class/instance indicator
def pretty_name
"#{name_prefix}#{@name}"
end
##
# Type of method/attribute (class or instance)
def type
singleton ? 'class' : 'instance'
end
##
# Path to this method for use with HTML generator output.
def path
"#{@parent.path}##{aref}"
end
##
# Name of our parent with special handling for un-marshaled methods
def parent_name
@parent_name || super
end
def pretty_print q # :nodoc:
alias_for = @is_alias_for ? "alias for #{@is_alias_for.name}" : nil
q.group 2, "[#{self.class.name} #{full_name} #{visibility}", "]" do
if alias_for then
q.breakable
q.text alias_for
end
if text then
q.breakable
q.text "text:"
q.breakable
q.pp @text
end
unless comment.empty? then
q.breakable
q.text "comment:"
q.breakable
q.pp @comment
end
end
end
##
# Used by RDoc::Generator::JsonIndex to create a record for the search
# engine.
def search_record
[
@name,
full_name,
@name,
@parent.full_name,
path,
params,
snippet(@comment),
]
end
def to_s # :nodoc:
if @is_alias_for
"#{self.class.name}: #{full_name} -> #{is_alias_for}"
else
"#{self.class.name}: #{full_name}"
end
end
end
task.rb 0000644 00000017244 14763537411 0006056 0 ustar 00 #--
# Copyright (c) 2003, 2004 Jim Weirich, 2009 Eric Hodel
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#++
require 'rubygems'
begin
gem 'rdoc'
rescue Gem::LoadError
end unless defined?(RDoc)
begin
gem 'rake'
rescue Gem::LoadError
end unless defined?(Rake)
require 'rdoc'
require 'rake'
require 'rake/tasklib'
##
# RDoc::Task creates the following rake tasks to generate and clean up RDoc
# output:
#
# [rdoc]
# Main task for this RDoc task.
#
# [clobber_rdoc]
# Delete all the rdoc files. This target is automatically added to the main
# clobber target.
#
# [rerdoc]
# Rebuild the rdoc files from scratch, even if they are not out of date.
#
# Simple Example:
#
# require 'rdoc/task'
#
# RDoc::Task.new do |rdoc|
# rdoc.main = "README.rdoc"
# rdoc.rdoc_files.include("README.rdoc", "lib/**/*.rb")
# end
#
# The +rdoc+ object passed to the block is an RDoc::Task object. See the
# attributes list for the RDoc::Task class for available customization options.
#
# == Specifying different task names
#
# You may wish to give the task a different name, such as if you are
# generating two sets of documentation. For instance, if you want to have a
# development set of documentation including private methods:
#
# require 'rdoc/task'
#
# RDoc::Task.new :rdoc_dev do |rdoc|
# rdoc.main = "README.doc"
# rdoc.rdoc_files.include("README.rdoc", "lib/**/*.rb")
# rdoc.options << "--all"
# end
#
# The tasks would then be named :rdoc_dev,
# :clobber_rdoc_dev, and :rerdoc_dev.
#
# If you wish to have completely different task names, then pass a Hash as
# first argument. With the :rdoc, :clobber_rdoc and
# :rerdoc options, you can customize the task names to your liking.
#
# For example:
#
# require 'rdoc/task'
#
# RDoc::Task.new(:rdoc => "rdoc", :clobber_rdoc => "rdoc:clean",
# :rerdoc => "rdoc:force")
#
# This will create the tasks :rdoc, :rdoc:clean and
# :rdoc:force.
class RDoc::Task < Rake::TaskLib
##
# Name of the main, top level task. (default is :rdoc)
attr_accessor :name
##
# Comment markup format. rdoc, rd and tomdoc are supported. (default is
# 'rdoc')
attr_accessor :markup
##
# Name of directory to receive the html output files. (default is "html")
attr_accessor :rdoc_dir
##
# Title of RDoc documentation. (defaults to rdoc's default)
attr_accessor :title
##
# Name of file to be used as the main, top level file of the RDoc. (default
# is none)
attr_accessor :main
##
# Name of template to be used by rdoc. (defaults to rdoc's default)
attr_accessor :template
##
# Name of format generator (--format) used by rdoc. (defaults to
# rdoc's default)
attr_accessor :generator
##
# List of files to be included in the rdoc generation. (default is [])
attr_accessor :rdoc_files
##
# Additional list of options to be passed rdoc. (default is [])
attr_accessor :options
##
# Whether to run the rdoc process as an external shell (default is false)
attr_accessor :external
##
# Create an RDoc task with the given name. See the RDoc::Task class overview
# for documentation.
def initialize name = :rdoc # :yield: self
defaults
check_names name
@name = name
yield self if block_given?
define
end
##
# Ensures that +names+ only includes names for the :rdoc, :clobber_rdoc and
# :rerdoc. If other names are given an ArgumentError is raised.
def check_names names
return unless Hash === names
invalid_options =
names.keys.map { |k| k.to_sym } - [:rdoc, :clobber_rdoc, :rerdoc]
unless invalid_options.empty? then
raise ArgumentError, "invalid options: #{invalid_options.join ', '}"
end
end
##
# Task description for the clobber rdoc task or its renamed equivalent
def clobber_task_description
"Remove RDoc HTML files"
end
##
# Sets default task values
def defaults
@name = :rdoc
@rdoc_files = Rake::FileList.new
@rdoc_dir = 'html'
@main = nil
@title = nil
@template = nil
@generator = nil
@options = []
end
##
# All source is inline now. This method is deprecated
def inline_source # :nodoc:
warn "RDoc::Task#inline_source is deprecated"
true
end
##
# All source is inline now. This method is deprecated
def inline_source=(value) # :nodoc:
warn "RDoc::Task#inline_source is deprecated"
end
##
# Create the tasks defined by this task lib.
def define
desc rdoc_task_description
task rdoc_task_name
desc rerdoc_task_description
task rerdoc_task_name => [clobber_task_name, rdoc_task_name]
desc clobber_task_description
task clobber_task_name do
rm_r @rdoc_dir rescue nil
end
task :clobber => [clobber_task_name]
directory @rdoc_dir
rdoc_target_deps = [
@rdoc_files,
Rake.application.rakefile
].flatten.compact
task rdoc_task_name => [rdoc_target]
file rdoc_target => rdoc_target_deps do
@before_running_rdoc.call if @before_running_rdoc
args = option_list + @rdoc_files
$stderr.puts "rdoc #{args.join ' '}" if Rake.application.options.trace
RDoc::RDoc.new.document args
end
self
end
##
# List of options that will be supplied to RDoc
def option_list
result = @options.dup
result << "-o" << @rdoc_dir
result << "--main" << main if main
result << "--markup" << markup if markup
result << "--title" << title if title
result << "-T" << template if template
result << '-f' << generator if generator
result
end
##
# The block passed to this method will be called just before running the
# RDoc generator. It is allowed to modify RDoc::Task attributes inside the
# block.
def before_running_rdoc(&block)
@before_running_rdoc = block
end
##
# Task description for the rdoc task or its renamed equivalent
def rdoc_task_description
'Build RDoc HTML files'
end
##
# Task description for the rerdoc task or its renamed description
def rerdoc_task_description
"Rebuild RDoc HTML files"
end
private
def rdoc_target
"#{rdoc_dir}/index.html"
end
def rdoc_task_name
case name
when Hash then (name[:rdoc] || "rdoc").to_s
else name.to_s
end
end
def clobber_task_name
case name
when Hash then (name[:clobber_rdoc] || "clobber_rdoc").to_s
else "clobber_#{name}"
end
end
def rerdoc_task_name
case name
when Hash then (name[:rerdoc] || "rerdoc").to_s
else "re#{name}"
end
end
end
# :stopdoc:
module Rake
##
# For backwards compatibility
RDocTask = RDoc::Task
end
# :startdoc:
parser/simple.rb 0000644 00000002615 14763537411 0007675 0 ustar 00 ##
# Parse a non-source file. We basically take the whole thing as one big
# comment.
class RDoc::Parser::Simple < RDoc::Parser
include RDoc::Parser::Text
parse_files_matching(//)
attr_reader :content # :nodoc:
##
# Prepare to parse a plain file
def initialize(top_level, file_name, content, options, stats)
super
preprocess = RDoc::Markup::PreProcess.new @file_name, @options.rdoc_include
preprocess.handle @content, @top_level
end
##
# Extract the file contents and attach them to the TopLevel as a comment
def scan
comment = remove_coding_comment @content
comment = remove_private_comment comment
comment = RDoc::Comment.new comment, @top_level
@top_level.comment = comment
@top_level
end
##
# Removes the encoding magic comment from +text+
def remove_coding_comment text
text.sub(/\A# .*coding[=:].*$/, '')
end
##
# Removes private comments.
#
# Unlike RDoc::Comment#remove_private this implementation only looks for two
# dashes at the beginning of the line. Three or more dashes are considered
# to be a rule and ignored.
def remove_private_comment comment
# Workaround for gsub encoding for Ruby 1.9.2 and earlier
empty = ''
empty.force_encoding comment.encoding if Object.const_defined? :Encoding
comment = comment.gsub(%r%^--\n.*?^\+\+\n?%m, empty)
comment.sub(%r%^--\n.*%m, empty)
end
end
parser/text.rb 0000644 00000000425 14763537411 0007365 0 ustar 00 ##
# Indicates this parser is text and doesn't contain code constructs.
#
# Include this module in a RDoc::Parser subclass to make it show up as a file,
# not as part of a class or module.
#--
# This is not named File to avoid overriding ::File
module RDoc::Parser::Text
end
parser/ruby_tools.rb 0000644 00000005670 14763537411 0010611 0 ustar 00 ##
# Collection of methods for writing parsers against RDoc::RubyLex and
# RDoc::RubyToken
module RDoc::Parser::RubyTools
include RDoc::RubyToken
##
# Adds a token listener +obj+, but you should probably use token_listener
def add_token_listener(obj)
@token_listeners ||= []
@token_listeners << obj
end
##
# Fetches the next token from the scanner
def get_tk
tk = nil
if @tokens.empty? then
tk = @scanner.token
@read.push @scanner.get_readed
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
tk = nil if TkEND_OF_SCRIPT === tk
if TkSYMBEG === tk then
set_token_position tk.line_no, tk.char_no
case tk1 = get_tk
when TkId, TkOp, TkSTRING, TkDSTRING, TkSTAR, TkAMPER then
if tk1.respond_to?(:name) then
tk = Token(TkSYMBOL).set_text(":" + tk1.name)
else
tk = Token(TkSYMBOL).set_text(":" + tk1.text)
end
# remove the identifier we just read to replace it with a symbol
@token_listeners.each do |obj|
obj.pop_token
end if @token_listeners
else
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
tk
end
##
# Reads and returns all tokens up to one of +tokens+. Leaves the matched
# token in the token list.
def get_tk_until(*tokens)
read = []
loop do
tk = get_tk
case tk
when *tokens then
unget_tk tk
break
end
read << tk
end
read
end
##
# Retrieves a String representation of the read tokens
def get_tkread
read = @read.join("")
@read = []
read
end
##
# Peek equivalent for get_tkread
def peek_read
@read.join('')
end
##
# Peek at the next token, but don't remove it from the stream
def peek_tk
unget_tk(tk = get_tk)
tk
end
##
# Removes the token listener +obj+
def remove_token_listener(obj)
@token_listeners.delete(obj)
end
##
# Resets the tools
def reset
@read = []
@tokens = []
@unget_read = []
@nest = 0
end
##
# Skips whitespace tokens including newlines if +skip_nl+ is true
def skip_tkspace(skip_nl = true) # HACK dup
tokens = []
while TkSPACE === (tk = get_tk) or (skip_nl and TkNL === tk) do
tokens.push tk
end
unget_tk tk
tokens
end
##
# Has +obj+ listen to tokens
def token_listener(obj)
add_token_listener obj
yield
ensure
remove_token_listener obj
end
##
# Returns +tk+ to the scanner
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
nil
end
end
parser/rd.rb 0000644 00000000630 14763537411 0007004 0 ustar 00 ##
# Parse a RD format file. The parsed RDoc::Markup::Document is attached as a
# file comment.
class RDoc::Parser::RD < RDoc::Parser
include RDoc::Parser::Text
parse_files_matching(/\.rd(?:\.[^.]+)?$/)
##
# Creates an rd-format TopLevel for the given file.
def scan
comment = RDoc::Comment.new @content, @top_level
comment.format = 'rd'
@top_level.comment = comment
end
end
parser/ruby.rb 0000644 00000132201 14763537411 0007360 0 ustar 00 ##
# This file contains stuff stolen outright from:
#
# rtags.rb -
# ruby-lex.rb - ruby lexcal analyzer
# ruby-token.rb - ruby tokens
# by Keiju ISHITSUKA (Nippon Rational Inc.)
#
$TOKEN_DEBUG ||= nil
##
# Extracts code elements from a source file returning a TopLevel object
# containing the constituent file elements.
#
# This file is based on rtags
#
# RubyParser understands how to document:
# * classes
# * modules
# * methods
# * constants
# * aliases
# * private, public, protected
# * private_class_function, public_class_function
# * module_function
# * attr, attr_reader, attr_writer, attr_accessor
# * extra accessors given on the command line
# * metaprogrammed methods
# * require
# * include
#
# == Method Arguments
#
#--
# NOTE: I don't think this works, needs tests, remove the paragraph following
# this block when known to work
#
# The parser extracts the arguments from the method definition. You can
# override this with a custom argument definition using the :args: directive:
#
# ##
# # This method tries over and over until it is tired
#
# def go_go_go(thing_to_try, tries = 10) # :args: thing_to_try
# puts thing_to_try
# go_go_go thing_to_try, tries - 1
# end
#
# If you have a more-complex set of overrides you can use the :call-seq:
# directive:
#++
#
# The parser extracts the arguments from the method definition. You can
# override this with a custom argument definition using the :call-seq:
# directive:
#
# ##
# # This method can be called with a range or an offset and length
# #
# # :call-seq:
# # my_method(Range)
# # my_method(offset, length)
#
# def my_method(*args)
# end
#
# The parser extracts +yield+ expressions from method bodies to gather the
# yielded argument names. If your method manually calls a block instead of
# yielding or you want to override the discovered argument names use
# the :yields: directive:
#
# ##
# # My method is awesome
#
# def my_method(&block) # :yields: happy, times
# block.call 1, 2
# end
#
# == Metaprogrammed Methods
#
# To pick up a metaprogrammed method, the parser looks for a comment starting
# with '##' before an identifier:
#
# ##
# # This is a meta-programmed method!
#
# add_my_method :meta_method, :arg1, :arg2
#
# The parser looks at the token after the identifier to determine the name, in
# this example, :meta_method. If a name cannot be found, a warning is printed
# and 'unknown is used.
#
# You can force the name of a method using the :method: directive:
#
# ##
# # :method: some_method!
#
# By default, meta-methods are instance methods. To indicate that a method is
# a singleton method instead use the :singleton-method: directive:
#
# ##
# # :singleton-method:
#
# You can also use the :singleton-method: directive with a name:
#
# ##
# # :singleton-method: some_method!
#
# Additionally you can mark a method as an attribute by
# using :attr:, :attr_reader:, :attr_writer: or :attr_accessor:. Just like
# for :method:, the name is optional.
#
# ##
# # :attr_reader: my_attr_name
#
# == Hidden methods and attributes
#
# You can provide documentation for methods that don't appear using
# the :method:, :singleton-method: and :attr: directives:
#
# ##
# # :attr_writer: ghost_writer
# # There is an attribute here, but you can't see it!
#
# ##
# # :method: ghost_method
# # There is a method here, but you can't see it!
#
# ##
# # this is a comment for a regular method
#
# def regular_method() end
#
# Note that by default, the :method: directive will be ignored if there is a
# standard rdocable item following it.
class RDoc::Parser::Ruby < RDoc::Parser
parse_files_matching(/\.rbw?$/)
include RDoc::RubyToken
include RDoc::TokenStream
include RDoc::Parser::RubyTools
##
# RDoc::NormalClass type
NORMAL = "::"
##
# RDoc::SingleClass type
SINGLE = "<<"
##
# Creates a new Ruby parser.
def initialize(top_level, file_name, content, options, stats)
super
@size = 0
@token_listeners = nil
@scanner = RDoc::RubyLex.new content, @options
@scanner.exception_on_syntax_error = false
@prev_seek = nil
@markup = @options.markup
@encoding = nil
@encoding = @options.encoding if Object.const_defined? :Encoding
reset
end
##
# Look for the first comment in a file that isn't a shebang line.
def collect_first_comment
skip_tkspace
comment = ''
comment.force_encoding @encoding if @encoding
first_line = true
tk = get_tk
while TkCOMMENT === tk
if first_line and tk.text =~ /\A#!/ then
skip_tkspace
tk = get_tk
elsif first_line and tk.text =~ /\A#\s*-\*-/ then
first_line = false
skip_tkspace
tk = get_tk
else
first_line = false
comment << tk.text << "\n"
tk = get_tk
if TkNL === tk then
skip_tkspace false
tk = get_tk
end
end
end
unget_tk tk
new_comment comment
end
##
# Aborts with +msg+
def error(msg)
msg = make_message msg
abort msg
end
##
# Looks for a true or false token. Returns false if TkFALSE or TkNIL are
# found.
def get_bool
skip_tkspace
tk = get_tk
case tk
when TkTRUE
true
when TkFALSE, TkNIL
false
else
unget_tk tk
true
end
end
##
# Look for the name of a class of module (optionally with a leading :: or
# with :: separated named) and return the ultimate name, the associated
# container, and the given name (with the ::).
def get_class_or_module container, ignore_constants = false
skip_tkspace
name_t = get_tk
given_name = ''
# class ::A -> A is in the top level
case name_t
when TkCOLON2, TkCOLON3 then # bug
name_t = get_tk
container = @top_level
given_name << '::'
end
skip_tkspace false
given_name << name_t.name
while TkCOLON2 === peek_tk do
prev_container = container
container = container.find_module_named name_t.name
container ||=
if ignore_constants then
RDoc::Context.new
else
c = prev_container.add_module RDoc::NormalModule, name_t.name
c.ignore unless prev_container.document_children
c
end
container.record_location @top_level
get_tk
skip_tkspace false
name_t = get_tk
given_name << '::' << name_t.name
end
skip_tkspace false
return [container, name_t, given_name]
end
##
# Return a superclass, which can be either a constant of an expression
def get_class_specification
tk = get_tk
return 'self' if TkSELF === tk
return '' if TkGVAR === tk
res = ''
while TkCOLON2 === tk or TkCOLON3 === tk or TkCONSTANT === tk do
res += tk.name
tk = get_tk
end
unget_tk(tk)
skip_tkspace false
get_tkread # empty out read buffer
tk = get_tk
case tk
when TkNL, TkCOMMENT, TkSEMICOLON then
unget_tk(tk)
return res
end
res += parse_call_parameters(tk)
res
end
##
# 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
while TkCOLON2 === tk or TkCOLON3 === tk or TkCONSTANT === tk do
res += tk.name
tk = get_tk
end
# if res.empty?
# warn("Unexpected token #{tk} in constant")
# 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 TkLPAREN === (tk = peek_tk) or TkfLPAREN === tk do
get_tk
skip_tkspace
nest += 1
end
name = get_constant
while nest > 0
skip_tkspace
tk = get_tk
nest -= 1 if TkRPAREN === tk
end
name
end
##
# Extracts a name or symbol from the token stream.
def get_symbol_or_name
tk = get_tk
case tk
when TkSYMBOL then
text = tk.text.sub(/^:/, '')
if TkASSIGN === peek_tk then
get_tk
text << '='
end
text
when TkId, TkOp then
tk.name
when TkAMPER,
TkDSTRING,
TkSTAR,
TkSTRING then
tk.text
else
raise RDoc::Error, "Name or symbol expected (got #{tk})"
end
end
##
# Look for directives in a normal comment block:
#
# # :stopdoc:
# # Don't display comment from this point forward
#
# This routine modifies its +comment+ parameter.
def look_for_directives_in context, comment
@preprocess.handle comment, context do |directive, param|
case directive
when 'method', 'singleton-method',
'attr', 'attr_accessor', 'attr_reader', 'attr_writer' then
false # handled elsewhere
when 'section' then
context.set_current_section param, comment.dup
comment.text = ''
break
end
end
remove_private_comments comment
end
##
# Adds useful info about the parser to +message+
def make_message message
prefix = "#{@file_name}:"
prefix << "#{@scanner.line_no}:#{@scanner.char_no}:" if @scanner
"#{prefix} #{message}"
end
##
# Creates a comment with the correct format
def new_comment comment
c = RDoc::Comment.new comment, @top_level
c.format = @markup
c
end
##
# Creates an RDoc::Attr for the name following +tk+, setting the comment to
# +comment+.
def parse_attr(context, single, tk, comment)
offset = tk.seek
line_no = tk.line_no
args = parse_symbol_arg 1
if args.size > 0 then
name = args[0]
rw = "R"
skip_tkspace false
tk = get_tk
if TkCOMMA === tk then
rw = "RW" if get_bool
else
unget_tk tk
end
att = RDoc::Attr.new get_tkread, name, rw, comment, single == SINGLE
att.record_location @top_level
att.offset = offset
att.line = line_no
read_documentation_modifiers att, RDoc::ATTR_MODIFIERS
context.add_attribute att
@stats.add_attribute att
else
warn "'attr' ignored - looks like a variable"
end
end
##
# Creates an RDoc::Attr for each attribute listed after +tk+, setting the
# comment for each to +comment+.
def parse_attr_accessor(context, single, tk, comment)
offset = tk.seek
line_no = tk.line_no
args = parse_symbol_arg
rw = "?"
tmp = RDoc::CodeObject.new
read_documentation_modifiers tmp, RDoc::ATTR_MODIFIERS
# TODO In most other places we let the context keep track of document_self
# and add found items appropriately but here we do not. I'm not sure why.
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 = '?'
end
for name in args
att = RDoc::Attr.new get_tkread, name, rw, comment, single == SINGLE
att.record_location @top_level
att.offset = offset
att.line = line_no
context.add_attribute att
@stats.add_attribute att
end
end
##
# Parses an +alias+ in +context+ with +comment+
def parse_alias(context, single, tk, comment)
offset = tk.seek
line_no = tk.line_no
skip_tkspace
if TkLPAREN === peek_tk then
get_tk
skip_tkspace
end
new_name = get_symbol_or_name
@scanner.instance_eval { @lex_state = EXPR_FNAME }
skip_tkspace
if TkCOMMA === peek_tk then
get_tk
skip_tkspace
end
begin
old_name = get_symbol_or_name
rescue RDoc::Error
return
end
al = RDoc::Alias.new(get_tkread, old_name, new_name, comment,
single == SINGLE)
al.record_location @top_level
al.offset = offset
al.line = line_no
read_documentation_modifiers al, RDoc::ATTR_MODIFIERS
context.add_alias al
@stats.add_alias al
al
end
##
# Extracts call parameters from the token stream.
def parse_call_parameters(tk)
end_token = case tk
when TkLPAREN, TkfLPAREN
TkRPAREN
when TkRPAREN
return ""
else
TkNL
end
nest = 0
loop do
case tk
when TkSEMICOLON
break
when TkLPAREN, TkfLPAREN
nest += 1
when end_token
if end_token == TkRPAREN
nest -= 1
break if @scanner.lex_state == EXPR_END and nest <= 0
else
break unless @scanner.continue
end
when TkCOMMENT, TkASSIGN, TkOPASGN
unget_tk(tk)
break
when nil then
break
end
tk = get_tk
end
res = get_tkread.tr("\n", " ").strip
res = "" if res == ";"
res
end
##
# Parses a class in +context+ with +comment+
def parse_class container, single, tk, comment
offset = tk.seek
line_no = tk.line_no
declaration_context = container
container, name_t, given_name = get_class_or_module container
case name_t
when TkCONSTANT
name = name_t.name
superclass = '::Object'
if given_name =~ /^::/ then
declaration_context = @top_level
given_name = $'
end
if TkLT === peek_tk then
get_tk
skip_tkspace
superclass = get_class_specification
superclass = '(unknown)' if superclass.empty?
end
cls_type = single == SINGLE ? RDoc::SingleClass : RDoc::NormalClass
cls = declaration_context.add_class cls_type, given_name, superclass
cls.ignore unless container.document_children
read_documentation_modifiers cls, RDoc::CLASS_MODIFIERS
cls.record_location @top_level
cls.offset = offset
cls.line = line_no
cls.add_comment comment, @top_level
@top_level.add_to_classes_or_modules cls
@stats.add_class cls
parse_statements cls
when TkLSHFT
case name = get_class_specification
when 'self', container.name
parse_statements container, SINGLE
else
other = @store.find_class_named name
unless other then
if name =~ /^::/ then
name = $'
container = @top_level
end
other = container.add_module RDoc::NormalModule, name
other.record_location @top_level
other.offset = offset
other.line = line_no
# class << $gvar
other.ignore if name.empty?
other.add_comment comment, @top_level
end
# notify :nodoc: all if not a constant-named class/module
# (and remove any comment)
unless name =~ /\A(::)?[A-Z]/ then
other.document_self = nil
other.document_children = false
other.clear_comment
end
@top_level.add_to_classes_or_modules other
@stats.add_class other
read_documentation_modifiers other, RDoc::CLASS_MODIFIERS
parse_statements(other, SINGLE)
end
else
warn("Expected class name or '<<'. Got #{name_t.class}: #{name_t.text.inspect}")
end
end
##
# Parses a constant in +context+ with +comment+. If +ignore_constants+ is
# true, no found constants will be added to RDoc.
def parse_constant container, tk, comment, ignore_constants = false
offset = tk.seek
line_no = tk.line_no
name = tk.name
skip_tkspace false
return unless name =~ /^\w+$/
eq_tk = get_tk
if TkCOLON2 === eq_tk then
unget_tk eq_tk
unget_tk tk
container, name_t, = get_class_or_module container, ignore_constants
name = name_t.name
eq_tk = get_tk
end
unless TkASSIGN === eq_tk then
unget_tk eq_tk
return false
end
value = ''
con = RDoc::Constant.new name, value, comment
nest = 0
get_tkread
tk = get_tk
if TkGT === tk then
unget_tk tk
unget_tk eq_tk
return false
end
rhs_name = ''
loop do
case tk
when TkSEMICOLON then
break if nest <= 0
when TkLPAREN, TkfLPAREN, TkLBRACE, TkfLBRACE, TkLBRACK, TkfLBRACK,
TkDO, TkIF, TkUNLESS, TkCASE, TkDEF, TkBEGIN then
nest += 1
when TkRPAREN, TkRBRACE, TkRBRACK, TkEND then
nest -= 1
when TkCOMMENT then
if nest <= 0 &&
(@scanner.lex_state == EXPR_END || !@scanner.continue) then
unget_tk tk
break
else
unget_tk tk
read_documentation_modifiers con, RDoc::CONSTANT_MODIFIERS
end
when TkCONSTANT then
rhs_name << tk.name
if nest <= 0 and TkNL === peek_tk then
mod = if rhs_name =~ /^::/ then
@store.find_class_or_module rhs_name
else
container.find_module_named rhs_name
end
container.add_module_alias mod, name, @top_level if mod
break
end
when TkNL then
if nest <= 0 &&
(@scanner.lex_state == EXPR_END || !@scanner.continue) then
unget_tk tk
break
end
when TkCOLON2, TkCOLON3 then
rhs_name << '::'
when nil then
break
end
tk = get_tk
end
res = get_tkread.gsub(/^[ \t]+/, '').strip
res = "" if res == ";"
value.replace res
con.record_location @top_level
con.offset = offset
con.line = line_no
read_documentation_modifiers con, RDoc::CONSTANT_MODIFIERS
@stats.add_constant con
con = container.add_constant con
true
end
##
# Generates an RDoc::Method or RDoc::Attr from +comment+ by looking for
# :method: or :attr: directives in +comment+.
def parse_comment container, tk, comment
return parse_comment_tomdoc container, tk, comment if @markup == 'tomdoc'
column = tk.char_no
offset = tk.seek
line_no = tk.line_no
text = comment.text
singleton = !!text.sub!(/(^# +:?)(singleton-)(method:)/, '\1\3')
# REFACTOR
if text.sub!(/^# +:?method: *(\S*).*?\n/i, '') then
name = $1 unless $1.empty?
meth = RDoc::GhostMethod.new get_tkread, name
meth.record_location @top_level
meth.singleton = singleton
meth.offset = offset
meth.line = line_no
meth.start_collecting_tokens
indent = TkSPACE.new 0, 1, 1
indent.set_text " " * column
position_comment = TkCOMMENT.new 0, line_no, 1
position_comment.set_text "# File #{@top_level.relative_name}, line #{line_no}"
meth.add_tokens [position_comment, NEWLINE_TOKEN, indent]
meth.params = ''
comment.normalize
comment.extract_call_seq meth
return unless meth.name
container.add_method meth
meth.comment = comment
@stats.add_method meth
elsif text.sub!(/# +:?(attr(_reader|_writer|_accessor)?): *(\S*).*?\n/i, '') then
rw = case $1
when 'attr_reader' then 'R'
when 'attr_writer' then 'W'
else 'RW'
end
name = $3 unless $3.empty?
# TODO authorize 'singleton-attr...'?
att = RDoc::Attr.new get_tkread, name, rw, comment
att.record_location @top_level
att.offset = offset
att.line = line_no
container.add_attribute att
@stats.add_attribute att
end
true
end
##
# Creates an RDoc::Method on +container+ from +comment+ if there is a
# Signature section in the comment
def parse_comment_tomdoc container, tk, comment
return unless signature = RDoc::TomDoc.signature(comment)
offset = tk.seek
line_no = tk.line_no
name, = signature.split %r%[ \(]%, 2
meth = RDoc::GhostMethod.new get_tkread, name
meth.record_location @top_level
meth.offset = offset
meth.line = line_no
meth.start_collecting_tokens
indent = TkSPACE.new 0, 1, 1
indent.set_text " " * offset
position_comment = TkCOMMENT.new 0, line_no, 1
position_comment.set_text "# File #{@top_level.relative_name}, line #{line_no}"
meth.add_tokens [position_comment, NEWLINE_TOKEN, indent]
meth.call_seq = signature
comment.normalize
return unless meth.name
container.add_method meth
meth.comment = comment
@stats.add_method meth
end
##
# Parses an +include+ in +context+ with +comment+
def parse_include context, comment
loop do
skip_tkspace_comment
name = get_constant_with_optional_parens
unless name.empty? then
incl = context.add_include RDoc::Include.new(name, comment)
incl.record_location @top_level
end
return unless TkCOMMA === peek_tk
get_tk
end
end
##
# Parses an +extend+ in +context+ with +comment+
def parse_extend context, comment
loop do
skip_tkspace_comment
name = get_constant_with_optional_parens
unless name.empty? then
incl = context.add_extend RDoc::Extend.new(name, comment)
incl.record_location @top_level
end
return unless TkCOMMA === peek_tk
get_tk
end
end
##
# Parses a meta-programmed attribute and creates an RDoc::Attr.
#
# To create foo and bar attributes on class C with comment "My attributes":
#
# class C
#
# ##
# # :attr:
# #
# # My attributes
#
# my_attr :foo, :bar
#
# end
#
# To create a foo attribute on class C with comment "My attribute":
#
# class C
#
# ##
# # :attr: foo
# #
# # My attribute
#
# my_attr :foo, :bar
#
# end
def parse_meta_attr(context, single, tk, comment)
args = parse_symbol_arg
rw = "?"
# If nodoc is given, don't document any of them
tmp = RDoc::CodeObject.new
read_documentation_modifiers tmp, RDoc::ATTR_MODIFIERS
if comment.text.sub!(/^# +:?(attr(_reader|_writer|_accessor)?): *(\S*).*?\n/i, '') then
rw = case $1
when 'attr_reader' then 'R'
when 'attr_writer' then 'W'
else 'RW'
end
name = $3 unless $3.empty?
end
if name then
att = RDoc::Attr.new get_tkread, name, rw, comment, single == SINGLE
att.record_location @top_level
context.add_attribute att
@stats.add_attribute att
else
args.each do |attr_name|
att = RDoc::Attr.new(get_tkread, attr_name, rw, comment,
single == SINGLE)
att.record_location @top_level
context.add_attribute att
@stats.add_attribute att
end
end
att
end
##
# Parses a meta-programmed method
def parse_meta_method(container, single, tk, comment)
column = tk.char_no
offset = tk.seek
line_no = tk.line_no
start_collecting_tokens
add_token tk
add_token_listener self
skip_tkspace false
singleton = !!comment.text.sub!(/(^# +:?)(singleton-)(method:)/, '\1\3')
if comment.text.sub!(/^# +:?method: *(\S*).*?\n/i, '') then
name = $1 unless $1.empty?
end
if name.nil? then
name_t = get_tk
case name_t
when TkSYMBOL then
name = name_t.text[1..-1]
when TkSTRING then
name = name_t.value[1..-2]
when TkASSIGN then # ignore
remove_token_listener self
return
else
warn "unknown name token #{name_t.inspect} for meta-method '#{tk.name}'"
name = 'unknown'
end
end
meth = RDoc::MetaMethod.new get_tkread, name
meth.record_location @top_level
meth.offset = offset
meth.line = line_no
meth.singleton = singleton
remove_token_listener self
meth.start_collecting_tokens
indent = TkSPACE.new 0, 1, 1
indent.set_text " " * column
position_comment = TkCOMMENT.new 0, line_no, 1
position_comment.value = "# File #{@top_level.relative_name}, line #{line_no}"
meth.add_tokens [position_comment, NEWLINE_TOKEN, indent]
meth.add_tokens @token_stream
token_listener meth do
meth.params = ''
comment.normalize
comment.extract_call_seq meth
container.add_method meth
last_tk = tk
while tk = get_tk do
case tk
when TkSEMICOLON then
break
when TkNL then
break unless last_tk and TkCOMMA === last_tk
when TkSPACE then
# expression continues
when TkDO then
parse_statements container, single, meth
break
else
last_tk = tk
end
end
end
meth.comment = comment
@stats.add_method meth
meth
end
##
# Parses a normal method defined by +def+
def parse_method(container, single, tk, comment)
added_container = nil
meth = nil
name = nil
column = tk.char_no
offset = tk.seek
line_no = tk.line_no
start_collecting_tokens
add_token tk
token_listener self do
@scanner.instance_eval do @lex_state = EXPR_FNAME end
skip_tkspace
name_t = get_tk
back_tk = skip_tkspace
meth = nil
added_container = false
case dot = get_tk
when TkDOT, TkCOLON2 then
@scanner.instance_eval do @lex_state = EXPR_FNAME end
skip_tkspace
name_t2 = get_tk
case name_t
when TkSELF, TkMOD then
name = case name_t2
# NOTE: work around '[' being consumed early and not being
# re-tokenized as a TkAREF
when TkfLBRACK then
get_tk
'[]'
else
name_t2.name
end
when TkCONSTANT then
name = name_t2.name
prev_container = container
container = container.find_module_named(name_t.name)
unless container then
constant = prev_container.constants.find do |const|
const.name == name_t.name
end
if constant then
parse_method_dummy prev_container
return
end
end
unless container then
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
unless [Class, Module].include?(obj.class) then
warn("Couldn't find #{name_t.name}. Assuming it's a module")
end
if type == RDoc::NormalClass then
sclass = obj.superclass ? obj.superclass.name : nil
container = prev_container.add_class type, name_t.name, sclass
else
container = prev_container.add_module type, name_t.name
end
container.record_location @top_level
end
when TkIDENTIFIER, TkIVAR, TkGVAR then
parse_method_dummy container
return
when TkTRUE, TkFALSE, TkNIL then
klass_name = "#{name_t.name.capitalize}Class"
container = @store.find_class_named klass_name
container ||= @top_level.add_class RDoc::NormalClass, klass_name
name = name_t2.name
else
warn "unexpected method name token #{name_t.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 = case name_t
when TkSTAR, TkAMPER then
name_t.text
else
unless name_t.respond_to? :name then
warn "expected method name token, . or ::, got #{name_t.inspect}"
skip_method container
return
end
name_t.name
end
meth = RDoc::AnyMethod.new get_tkread, name
meth.singleton = (single == SINGLE)
end
end
meth.record_location @top_level
meth.offset = offset
meth.line = line_no
meth.start_collecting_tokens
indent = TkSPACE.new 0, 1, 1
indent.set_text " " * column
token = TkCOMMENT.new 0, line_no, 1
token.set_text "# File #{@top_level.relative_name}, line #{line_no}"
meth.add_tokens [token, NEWLINE_TOKEN, indent]
meth.add_tokens @token_stream
token_listener meth do
@scanner.instance_eval do @continue = false end
parse_method_parameters meth
if meth.document_self then
container.add_method meth
elsif added_container then
container.document_self = false
end
# 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 then
if meth.dont_rename_initialize then
meth.visibility = :protected
else
meth.singleton = true
meth.name = "new"
meth.visibility = :public
end
end
parse_statements container, single, meth
end
comment.normalize
comment.extract_call_seq meth
meth.comment = comment
@stats.add_method meth
end
##
# Parses a method that needs to be ignored.
def parse_method_dummy container
dummy = RDoc::Context.new
dummy.parent = container
dummy.store = container.store
skip_method dummy
end
##
# Extracts +yield+ parameters from +method+
def parse_method_or_yield_parameters(method = nil,
modifiers = RDoc::METHOD_MODIFIERS)
skip_tkspace false
tk = get_tk
# 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
case tk
when TkSEMICOLON then
break if nest == 0
when TkLBRACE, TkfLBRACE then
nest += 1
when TkRBRACE then
nest -= 1
if nest <= 0
# we might have a.each { |i| yield i }
unget_tk(tk) if nest < 0
break
end
when TkLPAREN, TkfLPAREN then
nest += 1
when end_token then
if end_token == TkRPAREN
nest -= 1
break if nest <= 0
else
break unless @scanner.continue
end
when TkRPAREN then
nest -= 1
when method && method.block_params.nil? && TkCOMMENT then
unget_tk tk
read_documentation_modifiers method, modifiers
@read.pop
when TkCOMMENT then
@read.pop
when nil then
break
end
tk = get_tk
end
res = get_tkread.gsub(/\s+/, ' ').strip
res = '' if res == ';'
res
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 =~ /\A\(/
method.params = res unless method.params
return if method.block_params
skip_tkspace false
read_documentation_modifiers method, RDoc::METHOD_MODIFIERS
end
##
# Parses an RDoc::NormalModule in +container+ with +comment+
def parse_module container, single, tk, comment
container, name_t, = get_class_or_module container
name = name_t.name
mod = container.add_module RDoc::NormalModule, name
mod.ignore unless container.document_children
mod.record_location @top_level
read_documentation_modifiers mod, RDoc::CLASS_MODIFIERS
mod.add_comment comment, @top_level
parse_statements mod
@top_level.add_to_classes_or_modules mod
@stats.add_module mod
end
##
# Parses an RDoc::Require in +context+ containing +comment+
def parse_require(context, comment)
skip_tkspace_comment
tk = get_tk
if TkLPAREN === tk then
skip_tkspace_comment
tk = get_tk
end
name = tk.text if TkSTRING === tk
if name then
@top_level.add_require RDoc::Require.new(name, comment)
else
unget_tk tk
end
end
##
# Parses a rescue
def parse_rescue
skip_tkspace false
while tk = get_tk
case tk
when TkNL, TkSEMICOLON then
break
when TkCOMMA then
skip_tkspace false
get_tk if TkNL === peek_tk
end
skip_tkspace false
end
end
##
# The core of the ruby parser.
def parse_statements(container, single = NORMAL, current_method = nil,
comment = new_comment(''))
raise 'no' unless RDoc::Comment === comment
comment.force_encoding @encoding if @encoding
nest = 1
save_visibility = container.visibility
non_comment_seen = true
while tk = get_tk do
keep_comment = false
try_parse_comment = false
non_comment_seen = true unless TkCOMMENT === tk
case tk
when TkNL then
skip_tkspace
tk = get_tk
if TkCOMMENT === tk then
if non_comment_seen then
# Look for RDoc in a comment about to be thrown away
non_comment_seen = parse_comment container, tk, comment unless
comment.empty?
comment = ''
comment.force_encoding @encoding if @encoding
end
while TkCOMMENT === tk do
comment << tk.text << "\n"
tk = get_tk
if TkNL === tk then
skip_tkspace false # leading spaces
tk = get_tk
end
end
comment = new_comment comment
unless comment.empty? then
look_for_directives_in container, comment
if container.done_documenting then
container.ongoing_visibility = save_visibility
end
end
keep_comment = true
else
non_comment_seen = true
end
unget_tk tk
keep_comment = true
when TkCLASS then
parse_class container, single, tk, comment
when TkMODULE then
parse_module container, single, tk, comment
when TkDEF then
parse_method container, single, tk, comment
when TkCONSTANT then
unless parse_constant container, tk, comment, current_method then
try_parse_comment = true
end
when TkALIAS then
parse_alias container, single, tk, comment unless current_method
when TkYIELD then
if current_method.nil? then
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 increase 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 then
nest += 1
skip_optional_do_after_expression
# 'for' is trickier
when TkFOR then
nest += 1
skip_for_variable
skip_optional_do_after_expression
when TkCASE, TkDO, TkIF, TkUNLESS, TkBEGIN then
nest += 1
when TkSUPER then
current_method.calls_super = true if current_method
when TkRESCUE then
parse_rescue
when TkIDENTIFIER then
if nest == 1 and current_method.nil? then
case tk.name
when 'private', 'protected', 'public', 'private_class_method',
'public_class_method', 'module_function' then
parse_visibility container, single, tk
keep_comment = true
when 'attr' then
parse_attr container, single, tk, comment
when /^attr_(reader|writer|accessor)$/ then
parse_attr_accessor container, single, tk, comment
when 'alias_method' then
parse_alias container, single, tk, comment
when 'require', 'include' then
# ignore
else
if comment.text =~ /\A#\#$/ then
case comment.text
when /^# +:?attr(_reader|_writer|_accessor)?:/ then
parse_meta_attr container, single, tk, comment
else
method = parse_meta_method container, single, tk, comment
method.params = container.params if
container.params
method.block_params = container.block_params if
container.block_params
end
end
end
end
case tk.name
when "require" then
parse_require container, comment
when "include" then
parse_include container, comment
when "extend" then
parse_extend container, comment
end
when TkEND then
nest -= 1
if nest == 0 then
read_documentation_modifiers container, RDoc::CLASS_MODIFIERS
container.ongoing_visibility = save_visibility
parse_comment container, tk, comment unless comment.empty?
return
end
else
try_parse_comment = nest == 1
end
if try_parse_comment then
non_comment_seen = parse_comment container, tk, comment unless
comment.empty?
keep_comment = false
end
unless keep_comment then
comment = new_comment ''
comment.force_encoding @encoding if @encoding
container.params = nil
container.block_params = nil
end
begin
get_tkread
skip_tkspace false
end while peek_tk == TkNL
end
container.params = nil
container.block_params = nil
end
##
# Parse up to +no+ symbol arguments
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
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
loop do
skip_tkspace false
tk1 = get_tk
unless TkCOMMA === tk1 then
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
end
args
end
##
# Returns symbol text from the next token
def parse_symbol_in_arg
case tk = get_tk
when TkSYMBOL
tk.text.sub(/^:/, '')
when TkSTRING
eval @read[-1]
when TkDSTRING, TkIDENTIFIER then
nil # ignore
else
warn("Expected symbol or string, got #{tk.inspect}") if $DEBUG_RDOC
nil
end
end
##
# Parses statements in the top-level +container+
def parse_top_level_statements container
comment = collect_first_comment
look_for_directives_in container, comment
@markup = comment.format
# HACK move if to RDoc::Context#comment=
container.comment = comment if container.document_self unless comment.empty?
parse_statements container, NORMAL, nil, comment
end
##
# Determines the visibility in +container+ from +tk+
def parse_visibility(container, single, tk)
singleton = (single == SINGLE)
vis_type = tk.name
vis = case vis_type
when 'private' then :private
when 'protected' then :protected
when 'public' then :public
when 'private_class_method' then
singleton = true
:private
when 'public_class_method' then
singleton = true
:public
when 'module_function' then
singleton = true
:public
else
raise RDoc::Error, "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, TkSEMICOLON then
container.ongoing_visibility = vis
else
new_methods = []
case vis_type
when 'module_function' then
args = parse_symbol_arg
container.set_visibility_for args, :private, false
container.methods_matching args do |m|
s_m = m.dup
s_m.record_location @top_level
s_m.singleton = true
new_methods << s_m
end
when 'public_class_method', 'private_class_method' then
args = parse_symbol_arg
container.methods_matching args, true do |m|
if m.parent != container then
m = m.dup
m.record_location @top_level
new_methods << m
end
m.visibility = vis
end
else
args = parse_symbol_arg
container.set_visibility_for args, vis, singleton
end
new_methods.each do |method|
case method
when RDoc::AnyMethod then
container.add_method method
when RDoc::Attr then
container.add_attribute method
end
method.visibility = vis
end
end
end
##
# Determines the block parameter for +context+
def parse_yield(context, single, tk, method)
return if method.block_params
get_tkread
@scanner.instance_eval { @continue = false }
method.block_params = parse_method_or_yield_parameters
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 if
# the name is in +allowed+. A directive can be found anywhere up to the end
# of the current line.
def read_directive allowed
tokens = []
while tk = get_tk do
tokens << tk
case tk
when TkNL then return
when TkCOMMENT then
return unless tk.text =~ /\s*:?([\w-]+):\s*(.*)/
directive = $1.downcase
return [directive, $2] if allowed.include? directive
return
end
end
ensure
unless tokens.length == 1 and TkCOMMENT === tokens.first then
tokens.reverse_each do |token|
unget_tk token
end
end
end
##
# Handles directives following the definition for +context+ (any
# RDoc::CodeObject) if the directives are +allowed+ at this point.
#
# See also RDoc::Markup::PreProcess#handle_directive
def read_documentation_modifiers context, allowed
directive, value = read_directive allowed
return unless directive
@preprocess.handle_directive '', directive, value, context do |dir, param|
if %w[notnew not_new not-new].include? dir then
context.dont_rename_initialize = true
true
end
end
end
##
# Removes private comments from +comment+
#--
# TODO remove
def remove_private_comments comment
comment.remove_private
end
##
# Scans this ruby file for ruby constructs
def scan
reset
catch :eof do
begin
parse_top_level_statements @top_level
rescue StandardError => e
bytes = ''
20.times do @scanner.ungetc end
count = 0
60.times do |i|
count = i
byte = @scanner.getc
break unless byte
bytes << byte
end
count -= 20
count.times do @scanner.ungetc end
$stderr.puts <<-EOF
#{self.class} failure around line #{@scanner.line_no} of
#{@file_name}
EOF
unless bytes.empty? then
$stderr.puts
$stderr.puts bytes.inspect
end
raise e
end
end
@top_level
end
##
# while, until, and for have an optional do
def skip_optional_do_after_expression
skip_tkspace false
tk = get_tk
case tk
when TkLPAREN, TkfLPAREN then
end_token = TkRPAREN
else
end_token = TkNL
end
b_nest = 0
nest = 0
@scanner.instance_eval { @continue = false }
loop do
case tk
when TkSEMICOLON then
break if b_nest.zero?
when TkLPAREN, TkfLPAREN then
nest += 1
when TkBEGIN then
b_nest += 1
when TkEND then
b_nest -= 1
when TkDO
break if nest.zero?
when end_token then
if end_token == TkRPAREN
nest -= 1
break if @scanner.lex_state == EXPR_END and nest.zero?
else
break unless @scanner.continue
end
when nil then
break
end
tk = get_tk
end
skip_tkspace false
get_tk if TkDO === peek_tk
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 TkIN === tk
end
##
# Skips the next method in +container+
def skip_method container
meth = RDoc::AnyMethod.new "", "anon"
parse_method_parameters meth
parse_statements container, false, meth
end
##
# Skip spaces until a comment is found
def skip_tkspace_comment(skip_nl = true)
loop do
skip_tkspace skip_nl
return unless TkCOMMENT === peek_tk
get_tk
end
end
##
# Prints +message+ to +$stderr+ unless we're being quiet
def warn message
@options.warn make_message message
end
end
parser/changelog.rb 0000644 00000011054 14763537411 0010330 0 ustar 00 require 'time'
##
# A ChangeLog file parser.
#
# This parser converts a ChangeLog into an RDoc::Markup::Document. When
# viewed as HTML a ChangeLog page will have an entry for each day's entries in
# the sidebar table of contents.
#
# This parser is meant to parse the MRI ChangeLog, but can be used to parse any
# {GNU style Change
# Log}[http://www.gnu.org/prep/standards/html_node/Style-of-Change-Logs.html].
class RDoc::Parser::ChangeLog < RDoc::Parser
include RDoc::Parser::Text
parse_files_matching(/(\/|\\|\A)ChangeLog[^\/\\]*\z/)
##
# Attaches the +continuation+ of the previous line to the +entry_body+.
#
# Continued function listings are joined together as a single entry.
# Continued descriptions are joined to make a single paragraph.
def continue_entry_body entry_body, continuation
return unless last = entry_body.last
if last =~ /\)\s*\z/ and continuation =~ /\A\(/ then
last.sub!(/\)\s*\z/, ',')
continuation.sub!(/\A\(/, '')
end
if last =~ /\s\z/ then
last << continuation
else
last << ' ' << continuation
end
end
##
# Creates an RDoc::Markup::Document given the +groups+ of ChangeLog entries.
def create_document groups
doc = RDoc::Markup::Document.new
doc.omit_headings_below = 2
doc.file = @top_level
doc << RDoc::Markup::Heading.new(1, File.basename(@file_name))
doc << RDoc::Markup::BlankLine.new
groups.sort_by do |day,| day end.reverse_each do |day, entries|
doc << RDoc::Markup::Heading.new(2, day.dup)
doc << RDoc::Markup::BlankLine.new
doc.concat create_entries entries
end
doc
end
##
# Returns a list of ChangeLog entries an RDoc::Markup nodes for the given
# +entries+.
def create_entries entries
out = []
entries.each do |entry, items|
out << RDoc::Markup::Heading.new(3, entry)
out << RDoc::Markup::BlankLine.new
out << create_items(items)
end
out
end
##
# Returns an RDoc::Markup::List containing the given +items+ in the
# ChangeLog
def create_items items
list = RDoc::Markup::List.new :NOTE
items.each do |item|
item =~ /\A(.*?(?:\([^)]+\))?):\s*/
title = $1
body = $'
paragraph = RDoc::Markup::Paragraph.new body
list_item = RDoc::Markup::ListItem.new title, paragraph
list << list_item
end
list
end
##
# Groups +entries+ by date.
def group_entries entries
entries.group_by do |title, _|
begin
Time.parse(title).strftime '%Y-%m-%d'
rescue NoMethodError, ArgumentError
time, = title.split ' ', 2
Time.parse(time).strftime '%Y-%m-%d'
end
end
end
##
# Parses the entries in the ChangeLog.
#
# Returns an Array of each ChangeLog entry in order of parsing.
#
# A ChangeLog entry is an Array containing the ChangeLog title (date and
# committer) and an Array of ChangeLog items (file and function changed with
# description).
#
# An example result would be:
#
# [ 'Tue Dec 4 08:33:46 2012 Eric Hodel #{text}" }
def _Code
_save = self.pos
while true # sequence
_save1 = self.pos
while true # choice
_save2 = self.pos
while true # sequence
_tmp = apply(:_Ticks1)
unless _tmp
self.pos = _save2
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save2
break
end
_text_start = self.pos
_save3 = self.pos
_save4 = self.pos
while true # choice
_save5 = self.pos
_save6 = self.pos
while true # sequence
_save7 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save7
unless _tmp
self.pos = _save6
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save6
end
break
end # end sequence
if _tmp
while true
_save8 = self.pos
while true # sequence
_save9 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save9
unless _tmp
self.pos = _save8
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save8
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save5
end
break if _tmp
self.pos = _save4
_save10 = self.pos
while true # sequence
_save11 = self.pos
_tmp = apply(:_Ticks1)
_tmp = _tmp ? nil : true
self.pos = _save11
unless _tmp
self.pos = _save10
break
end
_save12 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save12
end
unless _tmp
self.pos = _save10
end
break
end # end sequence
break if _tmp
self.pos = _save4
_save13 = self.pos
while true # sequence
_save14 = self.pos
_save15 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save15
break
end
_tmp = apply(:_Ticks1)
unless _tmp
self.pos = _save15
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save14
unless _tmp
self.pos = _save13
break
end
_save16 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save16
_save17 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save17
break
end
_save18 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save18
unless _tmp
self.pos = _save17
end
break
end # end sequence
break if _tmp
self.pos = _save16
break
end # end choice
unless _tmp
self.pos = _save13
end
break
end # end sequence
break if _tmp
self.pos = _save4
break
end # end choice
if _tmp
while true
_save19 = self.pos
while true # choice
_save20 = self.pos
_save21 = self.pos
while true # sequence
_save22 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save22
unless _tmp
self.pos = _save21
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save21
end
break
end # end sequence
if _tmp
while true
_save23 = self.pos
while true # sequence
_save24 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save24
unless _tmp
self.pos = _save23
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save23
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save20
end
break if _tmp
self.pos = _save19
_save25 = self.pos
while true # sequence
_save26 = self.pos
_tmp = apply(:_Ticks1)
_tmp = _tmp ? nil : true
self.pos = _save26
unless _tmp
self.pos = _save25
break
end
_save27 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save27
end
unless _tmp
self.pos = _save25
end
break
end # end sequence
break if _tmp
self.pos = _save19
_save28 = self.pos
while true # sequence
_save29 = self.pos
_save30 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save30
break
end
_tmp = apply(:_Ticks1)
unless _tmp
self.pos = _save30
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save29
unless _tmp
self.pos = _save28
break
end
_save31 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save31
_save32 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save32
break
end
_save33 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save33
unless _tmp
self.pos = _save32
end
break
end # end sequence
break if _tmp
self.pos = _save31
break
end # end choice
unless _tmp
self.pos = _save28
end
break
end # end sequence
break if _tmp
self.pos = _save19
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save3
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save2
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save2
break
end
_tmp = apply(:_Ticks1)
unless _tmp
self.pos = _save2
end
break
end # end sequence
break if _tmp
self.pos = _save1
_save34 = self.pos
while true # sequence
_tmp = apply(:_Ticks2)
unless _tmp
self.pos = _save34
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save34
break
end
_text_start = self.pos
_save35 = self.pos
_save36 = self.pos
while true # choice
_save37 = self.pos
_save38 = self.pos
while true # sequence
_save39 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save39
unless _tmp
self.pos = _save38
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save38
end
break
end # end sequence
if _tmp
while true
_save40 = self.pos
while true # sequence
_save41 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save41
unless _tmp
self.pos = _save40
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save40
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save37
end
break if _tmp
self.pos = _save36
_save42 = self.pos
while true # sequence
_save43 = self.pos
_tmp = apply(:_Ticks2)
_tmp = _tmp ? nil : true
self.pos = _save43
unless _tmp
self.pos = _save42
break
end
_save44 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save44
end
unless _tmp
self.pos = _save42
end
break
end # end sequence
break if _tmp
self.pos = _save36
_save45 = self.pos
while true # sequence
_save46 = self.pos
_save47 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save47
break
end
_tmp = apply(:_Ticks2)
unless _tmp
self.pos = _save47
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save46
unless _tmp
self.pos = _save45
break
end
_save48 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save48
_save49 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save49
break
end
_save50 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save50
unless _tmp
self.pos = _save49
end
break
end # end sequence
break if _tmp
self.pos = _save48
break
end # end choice
unless _tmp
self.pos = _save45
end
break
end # end sequence
break if _tmp
self.pos = _save36
break
end # end choice
if _tmp
while true
_save51 = self.pos
while true # choice
_save52 = self.pos
_save53 = self.pos
while true # sequence
_save54 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save54
unless _tmp
self.pos = _save53
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save53
end
break
end # end sequence
if _tmp
while true
_save55 = self.pos
while true # sequence
_save56 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save56
unless _tmp
self.pos = _save55
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save55
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save52
end
break if _tmp
self.pos = _save51
_save57 = self.pos
while true # sequence
_save58 = self.pos
_tmp = apply(:_Ticks2)
_tmp = _tmp ? nil : true
self.pos = _save58
unless _tmp
self.pos = _save57
break
end
_save59 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save59
end
unless _tmp
self.pos = _save57
end
break
end # end sequence
break if _tmp
self.pos = _save51
_save60 = self.pos
while true # sequence
_save61 = self.pos
_save62 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save62
break
end
_tmp = apply(:_Ticks2)
unless _tmp
self.pos = _save62
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save61
unless _tmp
self.pos = _save60
break
end
_save63 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save63
_save64 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save64
break
end
_save65 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save65
unless _tmp
self.pos = _save64
end
break
end # end sequence
break if _tmp
self.pos = _save63
break
end # end choice
unless _tmp
self.pos = _save60
end
break
end # end sequence
break if _tmp
self.pos = _save51
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save35
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save34
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save34
break
end
_tmp = apply(:_Ticks2)
unless _tmp
self.pos = _save34
end
break
end # end sequence
break if _tmp
self.pos = _save1
_save66 = self.pos
while true # sequence
_tmp = apply(:_Ticks3)
unless _tmp
self.pos = _save66
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save66
break
end
_text_start = self.pos
_save67 = self.pos
_save68 = self.pos
while true # choice
_save69 = self.pos
_save70 = self.pos
while true # sequence
_save71 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save71
unless _tmp
self.pos = _save70
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save70
end
break
end # end sequence
if _tmp
while true
_save72 = self.pos
while true # sequence
_save73 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save73
unless _tmp
self.pos = _save72
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save72
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save69
end
break if _tmp
self.pos = _save68
_save74 = self.pos
while true # sequence
_save75 = self.pos
_tmp = apply(:_Ticks3)
_tmp = _tmp ? nil : true
self.pos = _save75
unless _tmp
self.pos = _save74
break
end
_save76 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save76
end
unless _tmp
self.pos = _save74
end
break
end # end sequence
break if _tmp
self.pos = _save68
_save77 = self.pos
while true # sequence
_save78 = self.pos
_save79 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save79
break
end
_tmp = apply(:_Ticks3)
unless _tmp
self.pos = _save79
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save78
unless _tmp
self.pos = _save77
break
end
_save80 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save80
_save81 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save81
break
end
_save82 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save82
unless _tmp
self.pos = _save81
end
break
end # end sequence
break if _tmp
self.pos = _save80
break
end # end choice
unless _tmp
self.pos = _save77
end
break
end # end sequence
break if _tmp
self.pos = _save68
break
end # end choice
if _tmp
while true
_save83 = self.pos
while true # choice
_save84 = self.pos
_save85 = self.pos
while true # sequence
_save86 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save86
unless _tmp
self.pos = _save85
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save85
end
break
end # end sequence
if _tmp
while true
_save87 = self.pos
while true # sequence
_save88 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save88
unless _tmp
self.pos = _save87
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save87
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save84
end
break if _tmp
self.pos = _save83
_save89 = self.pos
while true # sequence
_save90 = self.pos
_tmp = apply(:_Ticks3)
_tmp = _tmp ? nil : true
self.pos = _save90
unless _tmp
self.pos = _save89
break
end
_save91 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save91
end
unless _tmp
self.pos = _save89
end
break
end # end sequence
break if _tmp
self.pos = _save83
_save92 = self.pos
while true # sequence
_save93 = self.pos
_save94 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save94
break
end
_tmp = apply(:_Ticks3)
unless _tmp
self.pos = _save94
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save93
unless _tmp
self.pos = _save92
break
end
_save95 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save95
_save96 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save96
break
end
_save97 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save97
unless _tmp
self.pos = _save96
end
break
end # end sequence
break if _tmp
self.pos = _save95
break
end # end choice
unless _tmp
self.pos = _save92
end
break
end # end sequence
break if _tmp
self.pos = _save83
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save67
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save66
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save66
break
end
_tmp = apply(:_Ticks3)
unless _tmp
self.pos = _save66
end
break
end # end sequence
break if _tmp
self.pos = _save1
_save98 = self.pos
while true # sequence
_tmp = apply(:_Ticks4)
unless _tmp
self.pos = _save98
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save98
break
end
_text_start = self.pos
_save99 = self.pos
_save100 = self.pos
while true # choice
_save101 = self.pos
_save102 = self.pos
while true # sequence
_save103 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save103
unless _tmp
self.pos = _save102
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save102
end
break
end # end sequence
if _tmp
while true
_save104 = self.pos
while true # sequence
_save105 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save105
unless _tmp
self.pos = _save104
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save104
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save101
end
break if _tmp
self.pos = _save100
_save106 = self.pos
while true # sequence
_save107 = self.pos
_tmp = apply(:_Ticks4)
_tmp = _tmp ? nil : true
self.pos = _save107
unless _tmp
self.pos = _save106
break
end
_save108 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save108
end
unless _tmp
self.pos = _save106
end
break
end # end sequence
break if _tmp
self.pos = _save100
_save109 = self.pos
while true # sequence
_save110 = self.pos
_save111 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save111
break
end
_tmp = apply(:_Ticks4)
unless _tmp
self.pos = _save111
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save110
unless _tmp
self.pos = _save109
break
end
_save112 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save112
_save113 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save113
break
end
_save114 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save114
unless _tmp
self.pos = _save113
end
break
end # end sequence
break if _tmp
self.pos = _save112
break
end # end choice
unless _tmp
self.pos = _save109
end
break
end # end sequence
break if _tmp
self.pos = _save100
break
end # end choice
if _tmp
while true
_save115 = self.pos
while true # choice
_save116 = self.pos
_save117 = self.pos
while true # sequence
_save118 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save118
unless _tmp
self.pos = _save117
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save117
end
break
end # end sequence
if _tmp
while true
_save119 = self.pos
while true # sequence
_save120 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save120
unless _tmp
self.pos = _save119
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save119
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save116
end
break if _tmp
self.pos = _save115
_save121 = self.pos
while true # sequence
_save122 = self.pos
_tmp = apply(:_Ticks4)
_tmp = _tmp ? nil : true
self.pos = _save122
unless _tmp
self.pos = _save121
break
end
_save123 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save123
end
unless _tmp
self.pos = _save121
end
break
end # end sequence
break if _tmp
self.pos = _save115
_save124 = self.pos
while true # sequence
_save125 = self.pos
_save126 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save126
break
end
_tmp = apply(:_Ticks4)
unless _tmp
self.pos = _save126
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save125
unless _tmp
self.pos = _save124
break
end
_save127 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save127
_save128 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save128
break
end
_save129 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save129
unless _tmp
self.pos = _save128
end
break
end # end sequence
break if _tmp
self.pos = _save127
break
end # end choice
unless _tmp
self.pos = _save124
end
break
end # end sequence
break if _tmp
self.pos = _save115
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save99
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save98
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save98
break
end
_tmp = apply(:_Ticks4)
unless _tmp
self.pos = _save98
end
break
end # end sequence
break if _tmp
self.pos = _save1
_save130 = self.pos
while true # sequence
_tmp = apply(:_Ticks5)
unless _tmp
self.pos = _save130
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save130
break
end
_text_start = self.pos
_save131 = self.pos
_save132 = self.pos
while true # choice
_save133 = self.pos
_save134 = self.pos
while true # sequence
_save135 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save135
unless _tmp
self.pos = _save134
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save134
end
break
end # end sequence
if _tmp
while true
_save136 = self.pos
while true # sequence
_save137 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save137
unless _tmp
self.pos = _save136
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save136
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save133
end
break if _tmp
self.pos = _save132
_save138 = self.pos
while true # sequence
_save139 = self.pos
_tmp = apply(:_Ticks5)
_tmp = _tmp ? nil : true
self.pos = _save139
unless _tmp
self.pos = _save138
break
end
_save140 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save140
end
unless _tmp
self.pos = _save138
end
break
end # end sequence
break if _tmp
self.pos = _save132
_save141 = self.pos
while true # sequence
_save142 = self.pos
_save143 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save143
break
end
_tmp = apply(:_Ticks5)
unless _tmp
self.pos = _save143
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save142
unless _tmp
self.pos = _save141
break
end
_save144 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save144
_save145 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save145
break
end
_save146 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save146
unless _tmp
self.pos = _save145
end
break
end # end sequence
break if _tmp
self.pos = _save144
break
end # end choice
unless _tmp
self.pos = _save141
end
break
end # end sequence
break if _tmp
self.pos = _save132
break
end # end choice
if _tmp
while true
_save147 = self.pos
while true # choice
_save148 = self.pos
_save149 = self.pos
while true # sequence
_save150 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save150
unless _tmp
self.pos = _save149
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save149
end
break
end # end sequence
if _tmp
while true
_save151 = self.pos
while true # sequence
_save152 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save152
unless _tmp
self.pos = _save151
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save151
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save148
end
break if _tmp
self.pos = _save147
_save153 = self.pos
while true # sequence
_save154 = self.pos
_tmp = apply(:_Ticks5)
_tmp = _tmp ? nil : true
self.pos = _save154
unless _tmp
self.pos = _save153
break
end
_save155 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save155
end
unless _tmp
self.pos = _save153
end
break
end # end sequence
break if _tmp
self.pos = _save147
_save156 = self.pos
while true # sequence
_save157 = self.pos
_save158 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save158
break
end
_tmp = apply(:_Ticks5)
unless _tmp
self.pos = _save158
end
break
end # end sequence
_tmp = _tmp ? nil : true
self.pos = _save157
unless _tmp
self.pos = _save156
break
end
_save159 = self.pos
while true # choice
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save159
_save160 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save160
break
end
_save161 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save161
unless _tmp
self.pos = _save160
end
break
end # end sequence
break if _tmp
self.pos = _save159
break
end # end choice
unless _tmp
self.pos = _save156
end
break
end # end sequence
break if _tmp
self.pos = _save147
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save131
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save130
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save130
break
end
_tmp = apply(:_Ticks5)
unless _tmp
self.pos = _save130
end
break
end # end sequence
break if _tmp
self.pos = _save1
break
end # end choice
unless _tmp
self.pos = _save
break
end
@result = begin; "#{text}" ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_Code unless _tmp
return _tmp
end
# RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else '' end }
def _RawHtml
_save = self.pos
while true # sequence
_text_start = self.pos
_save1 = self.pos
while true # choice
_tmp = apply(:_HtmlComment)
break if _tmp
self.pos = _save1
_tmp = apply(:_HtmlBlockScript)
break if _tmp
self.pos = _save1
_tmp = apply(:_HtmlTag)
break if _tmp
self.pos = _save1
break
end # end choice
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
@result = begin; if html? then text else '' end ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_RawHtml unless _tmp
return _tmp
end
# BlankLine = Sp Newline { "\n" }
def _BlankLine
_save = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save
break
end
@result = begin; "\n" ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_BlankLine unless _tmp
return _tmp
end
# Quoted = ("\"" (!"\"" .)* "\"" | "'" (!"'" .)* "'")
def _Quoted
_save = self.pos
while true # choice
_save1 = self.pos
while true # sequence
_tmp = match_string("\"")
unless _tmp
self.pos = _save1
break
end
while true
_save3 = self.pos
while true # sequence
_save4 = self.pos
_tmp = match_string("\"")
_tmp = _tmp ? nil : true
self.pos = _save4
unless _tmp
self.pos = _save3
break
end
_tmp = get_byte
unless _tmp
self.pos = _save3
end
break
end # end sequence
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save1
break
end
_tmp = match_string("\"")
unless _tmp
self.pos = _save1
end
break
end # end sequence
break if _tmp
self.pos = _save
_save5 = self.pos
while true # sequence
_tmp = match_string("'")
unless _tmp
self.pos = _save5
break
end
while true
_save7 = self.pos
while true # sequence
_save8 = self.pos
_tmp = match_string("'")
_tmp = _tmp ? nil : true
self.pos = _save8
unless _tmp
self.pos = _save7
break
end
_tmp = get_byte
unless _tmp
self.pos = _save7
end
break
end # end sequence
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save5
break
end
_tmp = match_string("'")
unless _tmp
self.pos = _save5
end
break
end # end sequence
break if _tmp
self.pos = _save
break
end # end choice
set_failed_rule :_Quoted unless _tmp
return _tmp
end
# HtmlAttribute = (AlphanumericAscii | "-")+ Spnl ("=" Spnl (Quoted | (!">" Nonspacechar)+))? Spnl
def _HtmlAttribute
_save = self.pos
while true # sequence
_save1 = self.pos
_save2 = self.pos
while true # choice
_tmp = apply(:_AlphanumericAscii)
break if _tmp
self.pos = _save2
_tmp = match_string("-")
break if _tmp
self.pos = _save2
break
end # end choice
if _tmp
while true
_save3 = self.pos
while true # choice
_tmp = apply(:_AlphanumericAscii)
break if _tmp
self.pos = _save3
_tmp = match_string("-")
break if _tmp
self.pos = _save3
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save1
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save
break
end
_save4 = self.pos
_save5 = self.pos
while true # sequence
_tmp = match_string("=")
unless _tmp
self.pos = _save5
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save5
break
end
_save6 = self.pos
while true # choice
_tmp = apply(:_Quoted)
break if _tmp
self.pos = _save6
_save7 = self.pos
_save8 = self.pos
while true # sequence
_save9 = self.pos
_tmp = match_string(">")
_tmp = _tmp ? nil : true
self.pos = _save9
unless _tmp
self.pos = _save8
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save8
end
break
end # end sequence
if _tmp
while true
_save10 = self.pos
while true # sequence
_save11 = self.pos
_tmp = match_string(">")
_tmp = _tmp ? nil : true
self.pos = _save11
unless _tmp
self.pos = _save10
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save10
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save7
end
break if _tmp
self.pos = _save6
break
end # end choice
unless _tmp
self.pos = _save5
end
break
end # end sequence
unless _tmp
_tmp = true
self.pos = _save4
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_HtmlAttribute unless _tmp
return _tmp
end
# HtmlComment = "" .)* "-->"
def _HtmlComment
_save = self.pos
while true # sequence
_tmp = match_string("")
_tmp = _tmp ? nil : true
self.pos = _save3
unless _tmp
self.pos = _save2
break
end
_tmp = get_byte
unless _tmp
self.pos = _save2
end
break
end # end sequence
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save
break
end
_tmp = match_string("-->")
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_HtmlComment unless _tmp
return _tmp
end
# HtmlTag = "<" Spnl "/"? AlphanumericAscii+ Spnl HtmlAttribute* "/"? Spnl ">"
def _HtmlTag
_save = self.pos
while true # sequence
_tmp = match_string("<")
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save
break
end
_save1 = self.pos
_tmp = match_string("/")
unless _tmp
_tmp = true
self.pos = _save1
end
unless _tmp
self.pos = _save
break
end
_save2 = self.pos
_tmp = apply(:_AlphanumericAscii)
if _tmp
while true
_tmp = apply(:_AlphanumericAscii)
break unless _tmp
end
_tmp = true
else
self.pos = _save2
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save
break
end
while true
_tmp = apply(:_HtmlAttribute)
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save
break
end
_save4 = self.pos
_tmp = match_string("/")
unless _tmp
_tmp = true
self.pos = _save4
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save
break
end
_tmp = match_string(">")
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_HtmlTag unless _tmp
return _tmp
end
# Eof = !.
def _Eof
_save = self.pos
_tmp = get_byte
_tmp = _tmp ? nil : true
self.pos = _save
set_failed_rule :_Eof unless _tmp
return _tmp
end
# Nonspacechar = !Spacechar !Newline .
def _Nonspacechar
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = apply(:_Spacechar)
_tmp = _tmp ? nil : true
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_save2 = self.pos
_tmp = apply(:_Newline)
_tmp = _tmp ? nil : true
self.pos = _save2
unless _tmp
self.pos = _save
break
end
_tmp = get_byte
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_Nonspacechar unless _tmp
return _tmp
end
# Sp = Spacechar*
def _Sp
while true
_tmp = apply(:_Spacechar)
break unless _tmp
end
_tmp = true
set_failed_rule :_Sp unless _tmp
return _tmp
end
# Spnl = Sp (Newline Sp)?
def _Spnl
_save = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save
break
end
_save1 = self.pos
_save2 = self.pos
while true # sequence
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save2
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save2
end
break
end # end sequence
unless _tmp
_tmp = true
self.pos = _save1
end
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_Spnl unless _tmp
return _tmp
end
# SpecialChar = ("*" | "_" | "`" | "&" | "[" | "]" | "(" | ")" | "<" | "!" | "#" | "\\" | "'" | "\"" | ExtendedSpecialChar)
def _SpecialChar
_save = self.pos
while true # choice
_tmp = match_string("*")
break if _tmp
self.pos = _save
_tmp = match_string("_")
break if _tmp
self.pos = _save
_tmp = match_string("`")
break if _tmp
self.pos = _save
_tmp = match_string("&")
break if _tmp
self.pos = _save
_tmp = match_string("[")
break if _tmp
self.pos = _save
_tmp = match_string("]")
break if _tmp
self.pos = _save
_tmp = match_string("(")
break if _tmp
self.pos = _save
_tmp = match_string(")")
break if _tmp
self.pos = _save
_tmp = match_string("<")
break if _tmp
self.pos = _save
_tmp = match_string("!")
break if _tmp
self.pos = _save
_tmp = match_string("#")
break if _tmp
self.pos = _save
_tmp = match_string("\\")
break if _tmp
self.pos = _save
_tmp = match_string("'")
break if _tmp
self.pos = _save
_tmp = match_string("\"")
break if _tmp
self.pos = _save
_tmp = apply(:_ExtendedSpecialChar)
break if _tmp
self.pos = _save
break
end # end choice
set_failed_rule :_SpecialChar unless _tmp
return _tmp
end
# NormalChar = !(SpecialChar | Spacechar | Newline) .
def _NormalChar
_save = self.pos
while true # sequence
_save1 = self.pos
_save2 = self.pos
while true # choice
_tmp = apply(:_SpecialChar)
break if _tmp
self.pos = _save2
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save2
_tmp = apply(:_Newline)
break if _tmp
self.pos = _save2
break
end # end choice
_tmp = _tmp ? nil : true
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_tmp = get_byte
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_NormalChar unless _tmp
return _tmp
end
# Digit = [0-9]
def _Digit
_save = self.pos
_tmp = get_byte
if _tmp
unless _tmp >= 48 and _tmp <= 57
self.pos = _save
_tmp = nil
end
end
set_failed_rule :_Digit unless _tmp
return _tmp
end
# Alphanumeric = %literals.Alphanumeric
def _Alphanumeric
_tmp = @_grammar_literals.external_invoke(self, :_Alphanumeric)
set_failed_rule :_Alphanumeric unless _tmp
return _tmp
end
# AlphanumericAscii = %literals.AlphanumericAscii
def _AlphanumericAscii
_tmp = @_grammar_literals.external_invoke(self, :_AlphanumericAscii)
set_failed_rule :_AlphanumericAscii unless _tmp
return _tmp
end
# BOM = %literals.BOM
def _BOM
_tmp = @_grammar_literals.external_invoke(self, :_BOM)
set_failed_rule :_BOM unless _tmp
return _tmp
end
# Newline = %literals.Newline
def _Newline
_tmp = @_grammar_literals.external_invoke(self, :_Newline)
set_failed_rule :_Newline unless _tmp
return _tmp
end
# NonAlphanumeric = %literals.NonAlphanumeric
def _NonAlphanumeric
_tmp = @_grammar_literals.external_invoke(self, :_NonAlphanumeric)
set_failed_rule :_NonAlphanumeric unless _tmp
return _tmp
end
# Spacechar = %literals.Spacechar
def _Spacechar
_tmp = @_grammar_literals.external_invoke(self, :_Spacechar)
set_failed_rule :_Spacechar unless _tmp
return _tmp
end
# HexEntity = "&" "#" /[Xx]/ < /[0-9a-fA-F]+/ > ";" { [text.to_i(16)].pack 'U' }
def _HexEntity
_save = self.pos
while true # sequence
_tmp = match_string("&")
unless _tmp
self.pos = _save
break
end
_tmp = match_string("#")
unless _tmp
self.pos = _save
break
end
_tmp = scan(/\A(?-mix:[Xx])/)
unless _tmp
self.pos = _save
break
end
_text_start = self.pos
_tmp = scan(/\A(?-mix:[0-9a-fA-F]+)/)
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
_tmp = match_string(";")
unless _tmp
self.pos = _save
break
end
@result = begin; [text.to_i(16)].pack 'U' ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_HexEntity unless _tmp
return _tmp
end
# DecEntity = "&" "#" < /[0-9]+/ > ";" { [text.to_i].pack 'U' }
def _DecEntity
_save = self.pos
while true # sequence
_tmp = match_string("&")
unless _tmp
self.pos = _save
break
end
_tmp = match_string("#")
unless _tmp
self.pos = _save
break
end
_text_start = self.pos
_tmp = scan(/\A(?-mix:[0-9]+)/)
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
_tmp = match_string(";")
unless _tmp
self.pos = _save
break
end
@result = begin; [text.to_i].pack 'U' ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_DecEntity unless _tmp
return _tmp
end
# CharEntity = "&" < /[A-Za-z0-9]+/ > ";" { if entity = HTML_ENTITIES[text] then entity.pack 'U*' else "&#{text};" end }
def _CharEntity
_save = self.pos
while true # sequence
_tmp = match_string("&")
unless _tmp
self.pos = _save
break
end
_text_start = self.pos
_tmp = scan(/\A(?-mix:[A-Za-z0-9]+)/)
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
_tmp = match_string(";")
unless _tmp
self.pos = _save
break
end
@result = begin; if entity = HTML_ENTITIES[text] then
entity.pack 'U*'
else
"&#{text};"
end
; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_CharEntity unless _tmp
return _tmp
end
# NonindentSpace = (" " | " " | " " | "")
def _NonindentSpace
_save = self.pos
while true # choice
_tmp = match_string(" ")
break if _tmp
self.pos = _save
_tmp = match_string(" ")
break if _tmp
self.pos = _save
_tmp = match_string(" ")
break if _tmp
self.pos = _save
_tmp = match_string("")
break if _tmp
self.pos = _save
break
end # end choice
set_failed_rule :_NonindentSpace unless _tmp
return _tmp
end
# Indent = ("\t" | " ")
def _Indent
_save = self.pos
while true # choice
_tmp = match_string("\t")
break if _tmp
self.pos = _save
_tmp = match_string(" ")
break if _tmp
self.pos = _save
break
end # end choice
set_failed_rule :_Indent unless _tmp
return _tmp
end
# IndentedLine = Indent Line
def _IndentedLine
_save = self.pos
while true # sequence
_tmp = apply(:_Indent)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Line)
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_IndentedLine unless _tmp
return _tmp
end
# OptionallyIndentedLine = Indent? Line
def _OptionallyIndentedLine
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = apply(:_Indent)
unless _tmp
_tmp = true
self.pos = _save1
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Line)
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_OptionallyIndentedLine unless _tmp
return _tmp
end
# StartList = &. { [] }
def _StartList
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = get_byte
self.pos = _save1
unless _tmp
self.pos = _save
break
end
@result = begin; [] ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_StartList unless _tmp
return _tmp
end
# Line = RawLine:a { a }
def _Line
_save = self.pos
while true # sequence
_tmp = apply(:_RawLine)
a = @result
unless _tmp
self.pos = _save
break
end
@result = begin; a ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_Line unless _tmp
return _tmp
end
# RawLine = (< (!"\r" !"\n" .)* Newline > | < .+ > Eof) { text }
def _RawLine
_save = self.pos
while true # sequence
_save1 = self.pos
while true # choice
_text_start = self.pos
_save2 = self.pos
while true # sequence
while true
_save4 = self.pos
while true # sequence
_save5 = self.pos
_tmp = match_string("\r")
_tmp = _tmp ? nil : true
self.pos = _save5
unless _tmp
self.pos = _save4
break
end
_save6 = self.pos
_tmp = match_string("\n")
_tmp = _tmp ? nil : true
self.pos = _save6
unless _tmp
self.pos = _save4
break
end
_tmp = get_byte
unless _tmp
self.pos = _save4
end
break
end # end sequence
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save2
break
end
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save2
end
break
end # end sequence
if _tmp
text = get_text(_text_start)
end
break if _tmp
self.pos = _save1
_save7 = self.pos
while true # sequence
_text_start = self.pos
_save8 = self.pos
_tmp = get_byte
if _tmp
while true
_tmp = get_byte
break unless _tmp
end
_tmp = true
else
self.pos = _save8
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save7
break
end
_tmp = apply(:_Eof)
unless _tmp
self.pos = _save7
end
break
end # end sequence
break if _tmp
self.pos = _save1
break
end # end choice
unless _tmp
self.pos = _save
break
end
@result = begin; text ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_RawLine unless _tmp
return _tmp
end
# SkipBlock = (HtmlBlock | (!"#" !SetextBottom1 !SetextBottom2 !BlankLine RawLine)+ BlankLine* | BlankLine+ | RawLine)
def _SkipBlock
_save = self.pos
while true # choice
_tmp = apply(:_HtmlBlock)
break if _tmp
self.pos = _save
_save1 = self.pos
while true # sequence
_save2 = self.pos
_save3 = self.pos
while true # sequence
_save4 = self.pos
_tmp = match_string("#")
_tmp = _tmp ? nil : true
self.pos = _save4
unless _tmp
self.pos = _save3
break
end
_save5 = self.pos
_tmp = apply(:_SetextBottom1)
_tmp = _tmp ? nil : true
self.pos = _save5
unless _tmp
self.pos = _save3
break
end
_save6 = self.pos
_tmp = apply(:_SetextBottom2)
_tmp = _tmp ? nil : true
self.pos = _save6
unless _tmp
self.pos = _save3
break
end
_save7 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save7
unless _tmp
self.pos = _save3
break
end
_tmp = apply(:_RawLine)
unless _tmp
self.pos = _save3
end
break
end # end sequence
if _tmp
while true
_save8 = self.pos
while true # sequence
_save9 = self.pos
_tmp = match_string("#")
_tmp = _tmp ? nil : true
self.pos = _save9
unless _tmp
self.pos = _save8
break
end
_save10 = self.pos
_tmp = apply(:_SetextBottom1)
_tmp = _tmp ? nil : true
self.pos = _save10
unless _tmp
self.pos = _save8
break
end
_save11 = self.pos
_tmp = apply(:_SetextBottom2)
_tmp = _tmp ? nil : true
self.pos = _save11
unless _tmp
self.pos = _save8
break
end
_save12 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save12
unless _tmp
self.pos = _save8
break
end
_tmp = apply(:_RawLine)
unless _tmp
self.pos = _save8
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save2
end
unless _tmp
self.pos = _save1
break
end
while true
_tmp = apply(:_BlankLine)
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save1
end
break
end # end sequence
break if _tmp
self.pos = _save
_save14 = self.pos
_tmp = apply(:_BlankLine)
if _tmp
while true
_tmp = apply(:_BlankLine)
break unless _tmp
end
_tmp = true
else
self.pos = _save14
end
break if _tmp
self.pos = _save
_tmp = apply(:_RawLine)
break if _tmp
self.pos = _save
break
end # end choice
set_failed_rule :_SkipBlock unless _tmp
return _tmp
end
# ExtendedSpecialChar = &{ notes? } "^"
def _ExtendedSpecialChar
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = begin; notes? ; end
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_tmp = match_string("^")
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_ExtendedSpecialChar unless _tmp
return _tmp
end
# NoteReference = &{ notes? } RawNoteReference:ref { note_for ref }
def _NoteReference
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = begin; notes? ; end
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_RawNoteReference)
ref = @result
unless _tmp
self.pos = _save
break
end
@result = begin; note_for ref ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_NoteReference unless _tmp
return _tmp
end
# RawNoteReference = "[^" < (!Newline !"]" .)+ > "]" { text }
def _RawNoteReference
_save = self.pos
while true # sequence
_tmp = match_string("[^")
unless _tmp
self.pos = _save
break
end
_text_start = self.pos
_save1 = self.pos
_save2 = self.pos
while true # sequence
_save3 = self.pos
_tmp = apply(:_Newline)
_tmp = _tmp ? nil : true
self.pos = _save3
unless _tmp
self.pos = _save2
break
end
_save4 = self.pos
_tmp = match_string("]")
_tmp = _tmp ? nil : true
self.pos = _save4
unless _tmp
self.pos = _save2
break
end
_tmp = get_byte
unless _tmp
self.pos = _save2
end
break
end # end sequence
if _tmp
while true
_save5 = self.pos
while true # sequence
_save6 = self.pos
_tmp = apply(:_Newline)
_tmp = _tmp ? nil : true
self.pos = _save6
unless _tmp
self.pos = _save5
break
end
_save7 = self.pos
_tmp = match_string("]")
_tmp = _tmp ? nil : true
self.pos = _save7
unless _tmp
self.pos = _save5
break
end
_tmp = get_byte
unless _tmp
self.pos = _save5
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save1
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
_tmp = match_string("]")
unless _tmp
self.pos = _save
break
end
@result = begin; text ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_RawNoteReference unless _tmp
return _tmp
end
# Note = &{ notes? } NonindentSpace RawNoteReference:ref ":" Sp StartList:a RawNoteBlock (&Indent RawNoteBlock:i { a.concat i })* { @footnotes[ref] = paragraph a nil }
def _Note
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = begin; notes? ; end
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_NonindentSpace)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_RawNoteReference)
ref = @result
unless _tmp
self.pos = _save
break
end
_tmp = match_string(":")
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_StartList)
a = @result
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_RawNoteBlock)
unless _tmp
self.pos = _save
break
end
while true
_save3 = self.pos
while true # sequence
_save4 = self.pos
_tmp = apply(:_Indent)
self.pos = _save4
unless _tmp
self.pos = _save3
break
end
_tmp = apply(:_RawNoteBlock)
i = @result
unless _tmp
self.pos = _save3
break
end
@result = begin; a.concat i ; end
_tmp = true
unless _tmp
self.pos = _save3
end
break
end # end sequence
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save
break
end
@result = begin; @footnotes[ref] = paragraph a
nil
; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_Note unless _tmp
return _tmp
end
# InlineNote = &{ notes? } "^[" StartList:a (!"]" Inline:l { a << l })+ "]" { ref = [:inline, @note_order.length] @footnotes[ref] = paragraph a note_for ref }
def _InlineNote
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = begin; notes? ; end
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_tmp = match_string("^[")
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_StartList)
a = @result
unless _tmp
self.pos = _save
break
end
_save2 = self.pos
_save3 = self.pos
while true # sequence
_save4 = self.pos
_tmp = match_string("]")
_tmp = _tmp ? nil : true
self.pos = _save4
unless _tmp
self.pos = _save3
break
end
_tmp = apply(:_Inline)
l = @result
unless _tmp
self.pos = _save3
break
end
@result = begin; a << l ; end
_tmp = true
unless _tmp
self.pos = _save3
end
break
end # end sequence
if _tmp
while true
_save5 = self.pos
while true # sequence
_save6 = self.pos
_tmp = match_string("]")
_tmp = _tmp ? nil : true
self.pos = _save6
unless _tmp
self.pos = _save5
break
end
_tmp = apply(:_Inline)
l = @result
unless _tmp
self.pos = _save5
break
end
@result = begin; a << l ; end
_tmp = true
unless _tmp
self.pos = _save5
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save2
end
unless _tmp
self.pos = _save
break
end
_tmp = match_string("]")
unless _tmp
self.pos = _save
break
end
@result = begin;
ref = [:inline, @note_order.length]
@footnotes[ref] = paragraph a
note_for ref
; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_InlineNote unless _tmp
return _tmp
end
# Notes = (Note | SkipBlock)*
def _Notes
while true
_save1 = self.pos
while true # choice
_tmp = apply(:_Note)
break if _tmp
self.pos = _save1
_tmp = apply(:_SkipBlock)
break if _tmp
self.pos = _save1
break
end # end choice
break unless _tmp
end
_tmp = true
set_failed_rule :_Notes unless _tmp
return _tmp
end
# RawNoteBlock = StartList:a (!BlankLine OptionallyIndentedLine:l { a << l })+ < BlankLine* > { a << text } { a }
def _RawNoteBlock
_save = self.pos
while true # sequence
_tmp = apply(:_StartList)
a = @result
unless _tmp
self.pos = _save
break
end
_save1 = self.pos
_save2 = self.pos
while true # sequence
_save3 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save3
unless _tmp
self.pos = _save2
break
end
_tmp = apply(:_OptionallyIndentedLine)
l = @result
unless _tmp
self.pos = _save2
break
end
@result = begin; a << l ; end
_tmp = true
unless _tmp
self.pos = _save2
end
break
end # end sequence
if _tmp
while true
_save4 = self.pos
while true # sequence
_save5 = self.pos
_tmp = apply(:_BlankLine)
_tmp = _tmp ? nil : true
self.pos = _save5
unless _tmp
self.pos = _save4
break
end
_tmp = apply(:_OptionallyIndentedLine)
l = @result
unless _tmp
self.pos = _save4
break
end
@result = begin; a << l ; end
_tmp = true
unless _tmp
self.pos = _save4
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save1
end
unless _tmp
self.pos = _save
break
end
_text_start = self.pos
while true
_tmp = apply(:_BlankLine)
break unless _tmp
end
_tmp = true
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
@result = begin; a << text ; end
_tmp = true
unless _tmp
self.pos = _save
break
end
@result = begin; a ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_RawNoteBlock unless _tmp
return _tmp
end
# CodeFence = &{ github? } Ticks3 (Sp StrChunk:format)? Spnl < ((!"`" Nonspacechar)+ | !Ticks3 "`"+ | Spacechar | Newline)+ > Ticks3 Sp Newline* { verbatim = RDoc::Markup::Verbatim.new text verbatim.format = format.intern if format verbatim }
def _CodeFence
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = begin; github? ; end
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Ticks3)
unless _tmp
self.pos = _save
break
end
_save2 = self.pos
_save3 = self.pos
while true # sequence
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save3
break
end
_tmp = apply(:_StrChunk)
format = @result
unless _tmp
self.pos = _save3
end
break
end # end sequence
unless _tmp
_tmp = true
self.pos = _save2
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Spnl)
unless _tmp
self.pos = _save
break
end
_text_start = self.pos
_save4 = self.pos
_save5 = self.pos
while true # choice
_save6 = self.pos
_save7 = self.pos
while true # sequence
_save8 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save8
unless _tmp
self.pos = _save7
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save7
end
break
end # end sequence
if _tmp
while true
_save9 = self.pos
while true # sequence
_save10 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save10
unless _tmp
self.pos = _save9
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save9
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save6
end
break if _tmp
self.pos = _save5
_save11 = self.pos
while true # sequence
_save12 = self.pos
_tmp = apply(:_Ticks3)
_tmp = _tmp ? nil : true
self.pos = _save12
unless _tmp
self.pos = _save11
break
end
_save13 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save13
end
unless _tmp
self.pos = _save11
end
break
end # end sequence
break if _tmp
self.pos = _save5
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save5
_tmp = apply(:_Newline)
break if _tmp
self.pos = _save5
break
end # end choice
if _tmp
while true
_save14 = self.pos
while true # choice
_save15 = self.pos
_save16 = self.pos
while true # sequence
_save17 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save17
unless _tmp
self.pos = _save16
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save16
end
break
end # end sequence
if _tmp
while true
_save18 = self.pos
while true # sequence
_save19 = self.pos
_tmp = match_string("`")
_tmp = _tmp ? nil : true
self.pos = _save19
unless _tmp
self.pos = _save18
break
end
_tmp = apply(:_Nonspacechar)
unless _tmp
self.pos = _save18
end
break
end # end sequence
break unless _tmp
end
_tmp = true
else
self.pos = _save15
end
break if _tmp
self.pos = _save14
_save20 = self.pos
while true # sequence
_save21 = self.pos
_tmp = apply(:_Ticks3)
_tmp = _tmp ? nil : true
self.pos = _save21
unless _tmp
self.pos = _save20
break
end
_save22 = self.pos
_tmp = match_string("`")
if _tmp
while true
_tmp = match_string("`")
break unless _tmp
end
_tmp = true
else
self.pos = _save22
end
unless _tmp
self.pos = _save20
end
break
end # end sequence
break if _tmp
self.pos = _save14
_tmp = apply(:_Spacechar)
break if _tmp
self.pos = _save14
_tmp = apply(:_Newline)
break if _tmp
self.pos = _save14
break
end # end choice
break unless _tmp
end
_tmp = true
else
self.pos = _save4
end
if _tmp
text = get_text(_text_start)
end
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Ticks3)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save
break
end
while true
_tmp = apply(:_Newline)
break unless _tmp
end
_tmp = true
unless _tmp
self.pos = _save
break
end
@result = begin; verbatim = RDoc::Markup::Verbatim.new text
verbatim.format = format.intern if format
verbatim
; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_CodeFence unless _tmp
return _tmp
end
# DefinitionList = &{ definition_lists? } DefinitionListItem+:list { RDoc::Markup::List.new :NOTE, *list.flatten }
def _DefinitionList
_save = self.pos
while true # sequence
_save1 = self.pos
_tmp = begin; definition_lists? ; end
self.pos = _save1
unless _tmp
self.pos = _save
break
end
_save2 = self.pos
_ary = []
_tmp = apply(:_DefinitionListItem)
if _tmp
_ary << @result
while true
_tmp = apply(:_DefinitionListItem)
_ary << @result if _tmp
break unless _tmp
end
_tmp = true
@result = _ary
else
self.pos = _save2
end
list = @result
unless _tmp
self.pos = _save
break
end
@result = begin; RDoc::Markup::List.new :NOTE, *list.flatten ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_DefinitionList unless _tmp
return _tmp
end
# DefinitionListItem = DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << RDoc::Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| RDoc::Markup::ListItem.new nil, defn } unless list_items.empty? list_items }
def _DefinitionListItem
_save = self.pos
while true # sequence
_save1 = self.pos
_ary = []
_tmp = apply(:_DefinitionListLabel)
if _tmp
_ary << @result
while true
_tmp = apply(:_DefinitionListLabel)
_ary << @result if _tmp
break unless _tmp
end
_tmp = true
@result = _ary
else
self.pos = _save1
end
label = @result
unless _tmp
self.pos = _save
break
end
_save2 = self.pos
_ary = []
_tmp = apply(:_DefinitionListDefinition)
if _tmp
_ary << @result
while true
_tmp = apply(:_DefinitionListDefinition)
_ary << @result if _tmp
break unless _tmp
end
_tmp = true
@result = _ary
else
self.pos = _save2
end
defns = @result
unless _tmp
self.pos = _save
break
end
@result = begin; list_items = []
list_items <<
RDoc::Markup::ListItem.new(label, defns.shift)
list_items.concat defns.map { |defn|
RDoc::Markup::ListItem.new nil, defn
} unless list_items.empty?
list_items
; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_DefinitionListItem unless _tmp
return _tmp
end
# DefinitionListLabel = StrChunk:label Sp Newline { label }
def _DefinitionListLabel
_save = self.pos
while true # sequence
_tmp = apply(:_StrChunk)
label = @result
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Sp)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Newline)
unless _tmp
self.pos = _save
break
end
@result = begin; label ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_DefinitionListLabel unless _tmp
return _tmp
end
# DefinitionListDefinition = NonindentSpace ":" Space Inlines:a BlankLine+ { paragraph a }
def _DefinitionListDefinition
_save = self.pos
while true # sequence
_tmp = apply(:_NonindentSpace)
unless _tmp
self.pos = _save
break
end
_tmp = match_string(":")
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Space)
unless _tmp
self.pos = _save
break
end
_tmp = apply(:_Inlines)
a = @result
unless _tmp
self.pos = _save
break
end
_save1 = self.pos
_tmp = apply(:_BlankLine)
if _tmp
while true
_tmp = apply(:_BlankLine)
break unless _tmp
end
_tmp = true
else
self.pos = _save1
end
unless _tmp
self.pos = _save
break
end
@result = begin; paragraph a ; end
_tmp = true
unless _tmp
self.pos = _save
end
break
end # end sequence
set_failed_rule :_DefinitionListDefinition unless _tmp
return _tmp
end
Rules = {}
Rules[:_root] = rule_info("root", "Doc")
Rules[:_Doc] = rule_info("Doc", "BOM? Block*:a { RDoc::Markup::Document.new(*a.compact) }")
Rules[:_Block] = rule_info("Block", "BlankLine* (BlockQuote | Verbatim | CodeFence | Note | Reference | HorizontalRule | Heading | OrderedList | BulletList | DefinitionList | HtmlBlock | StyleBlock | Para | Plain)")
Rules[:_Para] = rule_info("Para", "NonindentSpace Inlines:a BlankLine+ { paragraph a }")
Rules[:_Plain] = rule_info("Plain", "Inlines:a { paragraph a }")
Rules[:_AtxInline] = rule_info("AtxInline", "!Newline !(Sp? \"\#\"* Sp Newline) Inline")
Rules[:_AtxStart] = rule_info("AtxStart", "< (\"\#\#\#\#\#\#\" | \"\#\#\#\#\#\" | \"\#\#\#\#\" | \"\#\#\#\" | \"\#\#\" | \"\#\") > { text.length }")
Rules[:_AtxHeading] = rule_info("AtxHeading", "AtxStart:s Sp? AtxInline+:a (Sp? \"\#\"* Sp)? Newline { RDoc::Markup::Heading.new(s, a.join) }")
Rules[:_SetextHeading] = rule_info("SetextHeading", "(SetextHeading1 | SetextHeading2)")
Rules[:_SetextBottom1] = rule_info("SetextBottom1", "\"===\" \"=\"* Newline")
Rules[:_SetextBottom2] = rule_info("SetextBottom2", "\"---\" \"-\"* Newline")
Rules[:_SetextHeading1] = rule_info("SetextHeading1", "&(RawLine SetextBottom1) StartList:a (!Endline Inline:b { a << b })+ Sp? Newline SetextBottom1 { RDoc::Markup::Heading.new(1, a.join) }")
Rules[:_SetextHeading2] = rule_info("SetextHeading2", "&(RawLine SetextBottom2) StartList:a (!Endline Inline:b { a << b })+ Sp? Newline SetextBottom2 { RDoc::Markup::Heading.new(2, a.join) }")
Rules[:_Heading] = rule_info("Heading", "(SetextHeading | AtxHeading)")
Rules[:_BlockQuote] = rule_info("BlockQuote", "BlockQuoteRaw:a { RDoc::Markup::BlockQuote.new(*a) }")
Rules[:_BlockQuoteRaw] = rule_info("BlockQuoteRaw", "StartList:a (\">\" \" \"? Line:l { a << l } (!\">\" !BlankLine Line:c { a << c })* (BlankLine:n { a << n })*)+ { inner_parse a.join }")
Rules[:_NonblankIndentedLine] = rule_info("NonblankIndentedLine", "!BlankLine IndentedLine")
Rules[:_VerbatimChunk] = rule_info("VerbatimChunk", "BlankLine*:a NonblankIndentedLine+:b { a.concat b }")
Rules[:_Verbatim] = rule_info("Verbatim", "VerbatimChunk+:a { RDoc::Markup::Verbatim.new(*a.flatten) }")
Rules[:_HorizontalRule] = rule_info("HorizontalRule", "NonindentSpace (\"*\" Sp \"*\" Sp \"*\" (Sp \"*\")* | \"-\" Sp \"-\" Sp \"-\" (Sp \"-\")* | \"_\" Sp \"_\" Sp \"_\" (Sp \"_\")*) Sp Newline BlankLine+ { RDoc::Markup::Rule.new 1 }")
Rules[:_Bullet] = rule_info("Bullet", "!HorizontalRule NonindentSpace (\"+\" | \"*\" | \"-\") Spacechar+")
Rules[:_BulletList] = rule_info("BulletList", "&Bullet (ListTight | ListLoose):a { RDoc::Markup::List.new(:BULLET, *a) }")
Rules[:_ListTight] = rule_info("ListTight", "ListItemTight+:a BlankLine* !(Bullet | Enumerator) { a }")
Rules[:_ListLoose] = rule_info("ListLoose", "StartList:a (ListItem:b BlankLine* { a << b })+ { a }")
Rules[:_ListItem] = rule_info("ListItem", "(Bullet | Enumerator) StartList:a ListBlock:b { a << b } (ListContinuationBlock:c { a.push(*c) })* { list_item_from a }")
Rules[:_ListItemTight] = rule_info("ListItemTight", "(Bullet | Enumerator) ListBlock:a (!BlankLine ListContinuationBlock:b { a.push(*b) })* !ListContinuationBlock { list_item_from a }")
Rules[:_ListBlock] = rule_info("ListBlock", "!BlankLine Line:a ListBlockLine*:c { [a, *c] }")
Rules[:_ListContinuationBlock] = rule_info("ListContinuationBlock", "StartList:a BlankLine* { a << \"\\n\" } (Indent ListBlock:b { a.concat b })+ { a }")
Rules[:_Enumerator] = rule_info("Enumerator", "NonindentSpace [0-9]+ \".\" Spacechar+")
Rules[:_OrderedList] = rule_info("OrderedList", "&Enumerator (ListTight | ListLoose):a { RDoc::Markup::List.new(:NUMBER, *a) }")
Rules[:_ListBlockLine] = rule_info("ListBlockLine", "!BlankLine !(Indent? (Bullet | Enumerator)) !HorizontalRule OptionallyIndentedLine")
Rules[:_HtmlBlockOpenAddress] = rule_info("HtmlBlockOpenAddress", "\"<\" Spnl (\"address\" | \"ADDRESS\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseAddress] = rule_info("HtmlBlockCloseAddress", "\"<\" Spnl \"/\" (\"address\" | \"ADDRESS\") Spnl \">\"")
Rules[:_HtmlBlockAddress] = rule_info("HtmlBlockAddress", "HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress")
Rules[:_HtmlBlockOpenBlockquote] = rule_info("HtmlBlockOpenBlockquote", "\"<\" Spnl (\"blockquote\" | \"BLOCKQUOTE\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseBlockquote] = rule_info("HtmlBlockCloseBlockquote", "\"<\" Spnl \"/\" (\"blockquote\" | \"BLOCKQUOTE\") Spnl \">\"")
Rules[:_HtmlBlockBlockquote] = rule_info("HtmlBlockBlockquote", "HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote")
Rules[:_HtmlBlockOpenCenter] = rule_info("HtmlBlockOpenCenter", "\"<\" Spnl (\"center\" | \"CENTER\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseCenter] = rule_info("HtmlBlockCloseCenter", "\"<\" Spnl \"/\" (\"center\" | \"CENTER\") Spnl \">\"")
Rules[:_HtmlBlockCenter] = rule_info("HtmlBlockCenter", "HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter")
Rules[:_HtmlBlockOpenDir] = rule_info("HtmlBlockOpenDir", "\"<\" Spnl (\"dir\" | \"DIR\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseDir] = rule_info("HtmlBlockCloseDir", "\"<\" Spnl \"/\" (\"dir\" | \"DIR\") Spnl \">\"")
Rules[:_HtmlBlockDir] = rule_info("HtmlBlockDir", "HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir")
Rules[:_HtmlBlockOpenDiv] = rule_info("HtmlBlockOpenDiv", "\"<\" Spnl (\"div\" | \"DIV\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseDiv] = rule_info("HtmlBlockCloseDiv", "\"<\" Spnl \"/\" (\"div\" | \"DIV\") Spnl \">\"")
Rules[:_HtmlBlockDiv] = rule_info("HtmlBlockDiv", "HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv")
Rules[:_HtmlBlockOpenDl] = rule_info("HtmlBlockOpenDl", "\"<\" Spnl (\"dl\" | \"DL\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseDl] = rule_info("HtmlBlockCloseDl", "\"<\" Spnl \"/\" (\"dl\" | \"DL\") Spnl \">\"")
Rules[:_HtmlBlockDl] = rule_info("HtmlBlockDl", "HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl")
Rules[:_HtmlBlockOpenFieldset] = rule_info("HtmlBlockOpenFieldset", "\"<\" Spnl (\"fieldset\" | \"FIELDSET\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseFieldset] = rule_info("HtmlBlockCloseFieldset", "\"<\" Spnl \"/\" (\"fieldset\" | \"FIELDSET\") Spnl \">\"")
Rules[:_HtmlBlockFieldset] = rule_info("HtmlBlockFieldset", "HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset")
Rules[:_HtmlBlockOpenForm] = rule_info("HtmlBlockOpenForm", "\"<\" Spnl (\"form\" | \"FORM\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseForm] = rule_info("HtmlBlockCloseForm", "\"<\" Spnl \"/\" (\"form\" | \"FORM\") Spnl \">\"")
Rules[:_HtmlBlockForm] = rule_info("HtmlBlockForm", "HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm")
Rules[:_HtmlBlockOpenH1] = rule_info("HtmlBlockOpenH1", "\"<\" Spnl (\"h1\" | \"H1\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseH1] = rule_info("HtmlBlockCloseH1", "\"<\" Spnl \"/\" (\"h1\" | \"H1\") Spnl \">\"")
Rules[:_HtmlBlockH1] = rule_info("HtmlBlockH1", "HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1")
Rules[:_HtmlBlockOpenH2] = rule_info("HtmlBlockOpenH2", "\"<\" Spnl (\"h2\" | \"H2\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseH2] = rule_info("HtmlBlockCloseH2", "\"<\" Spnl \"/\" (\"h2\" | \"H2\") Spnl \">\"")
Rules[:_HtmlBlockH2] = rule_info("HtmlBlockH2", "HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2")
Rules[:_HtmlBlockOpenH3] = rule_info("HtmlBlockOpenH3", "\"<\" Spnl (\"h3\" | \"H3\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseH3] = rule_info("HtmlBlockCloseH3", "\"<\" Spnl \"/\" (\"h3\" | \"H3\") Spnl \">\"")
Rules[:_HtmlBlockH3] = rule_info("HtmlBlockH3", "HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3")
Rules[:_HtmlBlockOpenH4] = rule_info("HtmlBlockOpenH4", "\"<\" Spnl (\"h4\" | \"H4\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseH4] = rule_info("HtmlBlockCloseH4", "\"<\" Spnl \"/\" (\"h4\" | \"H4\") Spnl \">\"")
Rules[:_HtmlBlockH4] = rule_info("HtmlBlockH4", "HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4")
Rules[:_HtmlBlockOpenH5] = rule_info("HtmlBlockOpenH5", "\"<\" Spnl (\"h5\" | \"H5\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseH5] = rule_info("HtmlBlockCloseH5", "\"<\" Spnl \"/\" (\"h5\" | \"H5\") Spnl \">\"")
Rules[:_HtmlBlockH5] = rule_info("HtmlBlockH5", "HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5")
Rules[:_HtmlBlockOpenH6] = rule_info("HtmlBlockOpenH6", "\"<\" Spnl (\"h6\" | \"H6\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseH6] = rule_info("HtmlBlockCloseH6", "\"<\" Spnl \"/\" (\"h6\" | \"H6\") Spnl \">\"")
Rules[:_HtmlBlockH6] = rule_info("HtmlBlockH6", "HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6")
Rules[:_HtmlBlockOpenMenu] = rule_info("HtmlBlockOpenMenu", "\"<\" Spnl (\"menu\" | \"MENU\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseMenu] = rule_info("HtmlBlockCloseMenu", "\"<\" Spnl \"/\" (\"menu\" | \"MENU\") Spnl \">\"")
Rules[:_HtmlBlockMenu] = rule_info("HtmlBlockMenu", "HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu")
Rules[:_HtmlBlockOpenNoframes] = rule_info("HtmlBlockOpenNoframes", "\"<\" Spnl (\"noframes\" | \"NOFRAMES\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseNoframes] = rule_info("HtmlBlockCloseNoframes", "\"<\" Spnl \"/\" (\"noframes\" | \"NOFRAMES\") Spnl \">\"")
Rules[:_HtmlBlockNoframes] = rule_info("HtmlBlockNoframes", "HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes")
Rules[:_HtmlBlockOpenNoscript] = rule_info("HtmlBlockOpenNoscript", "\"<\" Spnl (\"noscript\" | \"NOSCRIPT\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseNoscript] = rule_info("HtmlBlockCloseNoscript", "\"<\" Spnl \"/\" (\"noscript\" | \"NOSCRIPT\") Spnl \">\"")
Rules[:_HtmlBlockNoscript] = rule_info("HtmlBlockNoscript", "HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript")
Rules[:_HtmlBlockOpenOl] = rule_info("HtmlBlockOpenOl", "\"<\" Spnl (\"ol\" | \"OL\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseOl] = rule_info("HtmlBlockCloseOl", "\"<\" Spnl \"/\" (\"ol\" | \"OL\") Spnl \">\"")
Rules[:_HtmlBlockOl] = rule_info("HtmlBlockOl", "HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl")
Rules[:_HtmlBlockOpenP] = rule_info("HtmlBlockOpenP", "\"<\" Spnl (\"p\" | \"P\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseP] = rule_info("HtmlBlockCloseP", "\"<\" Spnl \"/\" (\"p\" | \"P\") Spnl \">\"")
Rules[:_HtmlBlockP] = rule_info("HtmlBlockP", "HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP")
Rules[:_HtmlBlockOpenPre] = rule_info("HtmlBlockOpenPre", "\"<\" Spnl (\"pre\" | \"PRE\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockClosePre] = rule_info("HtmlBlockClosePre", "\"<\" Spnl \"/\" (\"pre\" | \"PRE\") Spnl \">\"")
Rules[:_HtmlBlockPre] = rule_info("HtmlBlockPre", "HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre")
Rules[:_HtmlBlockOpenTable] = rule_info("HtmlBlockOpenTable", "\"<\" Spnl (\"table\" | \"TABLE\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseTable] = rule_info("HtmlBlockCloseTable", "\"<\" Spnl \"/\" (\"table\" | \"TABLE\") Spnl \">\"")
Rules[:_HtmlBlockTable] = rule_info("HtmlBlockTable", "HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable")
Rules[:_HtmlBlockOpenUl] = rule_info("HtmlBlockOpenUl", "\"<\" Spnl (\"ul\" | \"UL\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseUl] = rule_info("HtmlBlockCloseUl", "\"<\" Spnl \"/\" (\"ul\" | \"UL\") Spnl \">\"")
Rules[:_HtmlBlockUl] = rule_info("HtmlBlockUl", "HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl")
Rules[:_HtmlBlockOpenDd] = rule_info("HtmlBlockOpenDd", "\"<\" Spnl (\"dd\" | \"DD\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseDd] = rule_info("HtmlBlockCloseDd", "\"<\" Spnl \"/\" (\"dd\" | \"DD\") Spnl \">\"")
Rules[:_HtmlBlockDd] = rule_info("HtmlBlockDd", "HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd")
Rules[:_HtmlBlockOpenDt] = rule_info("HtmlBlockOpenDt", "\"<\" Spnl (\"dt\" | \"DT\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseDt] = rule_info("HtmlBlockCloseDt", "\"<\" Spnl \"/\" (\"dt\" | \"DT\") Spnl \">\"")
Rules[:_HtmlBlockDt] = rule_info("HtmlBlockDt", "HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt")
Rules[:_HtmlBlockOpenFrameset] = rule_info("HtmlBlockOpenFrameset", "\"<\" Spnl (\"frameset\" | \"FRAMESET\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseFrameset] = rule_info("HtmlBlockCloseFrameset", "\"<\" Spnl \"/\" (\"frameset\" | \"FRAMESET\") Spnl \">\"")
Rules[:_HtmlBlockFrameset] = rule_info("HtmlBlockFrameset", "HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset")
Rules[:_HtmlBlockOpenLi] = rule_info("HtmlBlockOpenLi", "\"<\" Spnl (\"li\" | \"LI\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseLi] = rule_info("HtmlBlockCloseLi", "\"<\" Spnl \"/\" (\"li\" | \"LI\") Spnl \">\"")
Rules[:_HtmlBlockLi] = rule_info("HtmlBlockLi", "HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi")
Rules[:_HtmlBlockOpenTbody] = rule_info("HtmlBlockOpenTbody", "\"<\" Spnl (\"tbody\" | \"TBODY\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseTbody] = rule_info("HtmlBlockCloseTbody", "\"<\" Spnl \"/\" (\"tbody\" | \"TBODY\") Spnl \">\"")
Rules[:_HtmlBlockTbody] = rule_info("HtmlBlockTbody", "HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody")
Rules[:_HtmlBlockOpenTd] = rule_info("HtmlBlockOpenTd", "\"<\" Spnl (\"td\" | \"TD\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseTd] = rule_info("HtmlBlockCloseTd", "\"<\" Spnl \"/\" (\"td\" | \"TD\") Spnl \">\"")
Rules[:_HtmlBlockTd] = rule_info("HtmlBlockTd", "HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd")
Rules[:_HtmlBlockOpenTfoot] = rule_info("HtmlBlockOpenTfoot", "\"<\" Spnl (\"tfoot\" | \"TFOOT\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseTfoot] = rule_info("HtmlBlockCloseTfoot", "\"<\" Spnl \"/\" (\"tfoot\" | \"TFOOT\") Spnl \">\"")
Rules[:_HtmlBlockTfoot] = rule_info("HtmlBlockTfoot", "HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot")
Rules[:_HtmlBlockOpenTh] = rule_info("HtmlBlockOpenTh", "\"<\" Spnl (\"th\" | \"TH\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseTh] = rule_info("HtmlBlockCloseTh", "\"<\" Spnl \"/\" (\"th\" | \"TH\") Spnl \">\"")
Rules[:_HtmlBlockTh] = rule_info("HtmlBlockTh", "HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh")
Rules[:_HtmlBlockOpenThead] = rule_info("HtmlBlockOpenThead", "\"<\" Spnl (\"thead\" | \"THEAD\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseThead] = rule_info("HtmlBlockCloseThead", "\"<\" Spnl \"/\" (\"thead\" | \"THEAD\") Spnl \">\"")
Rules[:_HtmlBlockThead] = rule_info("HtmlBlockThead", "HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead")
Rules[:_HtmlBlockOpenTr] = rule_info("HtmlBlockOpenTr", "\"<\" Spnl (\"tr\" | \"TR\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseTr] = rule_info("HtmlBlockCloseTr", "\"<\" Spnl \"/\" (\"tr\" | \"TR\") Spnl \">\"")
Rules[:_HtmlBlockTr] = rule_info("HtmlBlockTr", "HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr")
Rules[:_HtmlBlockOpenScript] = rule_info("HtmlBlockOpenScript", "\"<\" Spnl (\"script\" | \"SCRIPT\") Spnl HtmlAttribute* \">\"")
Rules[:_HtmlBlockCloseScript] = rule_info("HtmlBlockCloseScript", "\"<\" Spnl \"/\" (\"script\" | \"SCRIPT\") Spnl \">\"")
Rules[:_HtmlBlockScript] = rule_info("HtmlBlockScript", "HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript")
Rules[:_HtmlBlockInTags] = rule_info("HtmlBlockInTags", "(HtmlBlockAddress | HtmlBlockBlockquote | HtmlBlockCenter | HtmlBlockDir | HtmlBlockDiv | HtmlBlockDl | HtmlBlockFieldset | HtmlBlockForm | HtmlBlockH1 | HtmlBlockH2 | HtmlBlockH3 | HtmlBlockH4 | HtmlBlockH5 | HtmlBlockH6 | HtmlBlockMenu | HtmlBlockNoframes | HtmlBlockNoscript | HtmlBlockOl | HtmlBlockP | HtmlBlockPre | HtmlBlockTable | HtmlBlockUl | HtmlBlockDd | HtmlBlockDt | HtmlBlockFrameset | HtmlBlockLi | HtmlBlockTbody | HtmlBlockTd | HtmlBlockTfoot | HtmlBlockTh | HtmlBlockThead | HtmlBlockTr | HtmlBlockScript)")
Rules[:_HtmlBlock] = rule_info("HtmlBlock", "< (HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) > BlankLine+ { if html? then RDoc::Markup::Raw.new text end }")
Rules[:_HtmlUnclosed] = rule_info("HtmlUnclosed", "\"<\" Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl \">\"")
Rules[:_HtmlUnclosedType] = rule_info("HtmlUnclosedType", "(\"HR\" | \"hr\")")
Rules[:_HtmlBlockSelfClosing] = rule_info("HtmlBlockSelfClosing", "\"<\" Spnl HtmlBlockType Spnl HtmlAttribute* \"/\" Spnl \">\"")
Rules[:_HtmlBlockType] = rule_info("HtmlBlockType", "(\"ADDRESS\" | \"BLOCKQUOTE\" | \"CENTER\" | \"DD\" | \"DIR\" | \"DIV\" | \"DL\" | \"DT\" | \"FIELDSET\" | \"FORM\" | \"FRAMESET\" | \"H1\" | \"H2\" | \"H3\" | \"H4\" | \"H5\" | \"H6\" | \"HR\" | \"ISINDEX\" | \"LI\" | \"MENU\" | \"NOFRAMES\" | \"NOSCRIPT\" | \"OL\" | \"P\" | \"PRE\" | \"SCRIPT\" | \"TABLE\" | \"TBODY\" | \"TD\" | \"TFOOT\" | \"TH\" | \"THEAD\" | \"TR\" | \"UL\" | \"address\" | \"blockquote\" | \"center\" | \"dd\" | \"dir\" | \"div\" | \"dl\" | \"dt\" | \"fieldset\" | \"form\" | \"frameset\" | \"h1\" | \"h2\" | \"h3\" | \"h4\" | \"h5\" | \"h6\" | \"hr\" | \"isindex\" | \"li\" | \"menu\" | \"noframes\" | \"noscript\" | \"ol\" | \"p\" | \"pre\" | \"script\" | \"table\" | \"tbody\" | \"td\" | \"tfoot\" | \"th\" | \"thead\" | \"tr\" | \"ul\")")
Rules[:_StyleOpen] = rule_info("StyleOpen", "\"<\" Spnl (\"style\" | \"STYLE\") Spnl HtmlAttribute* \">\"")
Rules[:_StyleClose] = rule_info("StyleClose", "\"<\" Spnl \"/\" (\"style\" | \"STYLE\") Spnl \">\"")
Rules[:_InStyleTags] = rule_info("InStyleTags", "StyleOpen (!StyleClose .)* StyleClose")
Rules[:_StyleBlock] = rule_info("StyleBlock", "< InStyleTags > BlankLine* { if css? then RDoc::Markup::Raw.new text end }")
Rules[:_Inlines] = rule_info("Inlines", "(!Endline Inline:i { i } | Endline:c &Inline { c })+:chunks Endline? { chunks }")
Rules[:_Inline] = rule_info("Inline", "(Str | Endline | UlOrStarLine | Space | Strong | Emph | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol)")
Rules[:_Space] = rule_info("Space", "Spacechar+ { \" \" }")
Rules[:_Str] = rule_info("Str", "StartList:a < NormalChar+ > { a = text } (StrChunk:c { a << c })* { a }")
Rules[:_StrChunk] = rule_info("StrChunk", "< (NormalChar | \"_\"+ &Alphanumeric)+ > { text }")
Rules[:_EscapedChar] = rule_info("EscapedChar", "\"\\\\\" !Newline < /[:\\\\`|*_{}\\[\\]()\#+.!><-]/ > { text }")
Rules[:_Entity] = rule_info("Entity", "(HexEntity | DecEntity | CharEntity):a { a }")
Rules[:_Endline] = rule_info("Endline", "(LineBreak | TerminalEndline | NormalEndline)")
Rules[:_NormalEndline] = rule_info("NormalEndline", "Sp Newline !BlankLine !\">\" !AtxStart !(Line (\"===\" \"=\"* | \"---\" \"-\"*) Newline) { \"\\n\" }")
Rules[:_TerminalEndline] = rule_info("TerminalEndline", "Sp Newline Eof")
Rules[:_LineBreak] = rule_info("LineBreak", "\" \" NormalEndline { RDoc::Markup::HardBreak.new }")
Rules[:_Symbol] = rule_info("Symbol", "< SpecialChar > { text }")
Rules[:_UlOrStarLine] = rule_info("UlOrStarLine", "(UlLine | StarLine):a { a }")
Rules[:_StarLine] = rule_info("StarLine", "(< \"****\" \"*\"* > { text } | < Spacechar \"*\"+ &Spacechar > { text })")
Rules[:_UlLine] = rule_info("UlLine", "(< \"____\" \"_\"* > { text } | < Spacechar \"_\"+ &Spacechar > { text })")
Rules[:_Emph] = rule_info("Emph", "(EmphStar | EmphUl)")
Rules[:_OneStarOpen] = rule_info("OneStarOpen", "!StarLine \"*\" !Spacechar !Newline")
Rules[:_OneStarClose] = rule_info("OneStarClose", "!Spacechar !Newline Inline:a \"*\" { a }")
Rules[:_EmphStar] = rule_info("EmphStar", "OneStarOpen StartList:a (!OneStarClose Inline:l { a << l })* OneStarClose:l { a << l } { emphasis a.join }")
Rules[:_OneUlOpen] = rule_info("OneUlOpen", "!UlLine \"_\" !Spacechar !Newline")
Rules[:_OneUlClose] = rule_info("OneUlClose", "!Spacechar !Newline Inline:a \"_\" { a }")
Rules[:_EmphUl] = rule_info("EmphUl", "OneUlOpen StartList:a (!OneUlClose Inline:l { a << l })* OneUlClose:l { a << l } { emphasis a.join }")
Rules[:_Strong] = rule_info("Strong", "(StrongStar | StrongUl)")
Rules[:_TwoStarOpen] = rule_info("TwoStarOpen", "!StarLine \"**\" !Spacechar !Newline")
Rules[:_TwoStarClose] = rule_info("TwoStarClose", "!Spacechar !Newline Inline:a \"**\" { a }")
Rules[:_StrongStar] = rule_info("StrongStar", "TwoStarOpen StartList:a (!TwoStarClose Inline:l { a << l })* TwoStarClose:l { a << l } { strong a.join }")
Rules[:_TwoUlOpen] = rule_info("TwoUlOpen", "!UlLine \"__\" !Spacechar !Newline")
Rules[:_TwoUlClose] = rule_info("TwoUlClose", "!Spacechar !Newline Inline:a \"__\" { a }")
Rules[:_StrongUl] = rule_info("StrongUl", "TwoUlOpen StartList:a (!TwoUlClose Inline:i { a << i })* TwoUlClose:l { a << l } { strong a.join }")
Rules[:_Image] = rule_info("Image", "\"!\" (ExplicitLink | ReferenceLink):a { a }")
Rules[:_Link] = rule_info("Link", "(ExplicitLink | ReferenceLink | AutoLink)")
Rules[:_ReferenceLink] = rule_info("ReferenceLink", "(ReferenceLinkDouble | ReferenceLinkSingle)")
Rules[:_ReferenceLinkDouble] = rule_info("ReferenceLinkDouble", "Label:content < Spnl > !\"[]\" Label:label { link_to content, label, text }")
Rules[:_ReferenceLinkSingle] = rule_info("ReferenceLinkSingle", "Label:content < (Spnl \"[]\")? > { link_to content, content, text }")
Rules[:_ExplicitLink] = rule_info("ExplicitLink", "Label:l Spnl \"(\" Sp Source:s Spnl Title Sp \")\" { \"{\#{l}}[\#{s}]\" }")
Rules[:_Source] = rule_info("Source", "(\"<\" < SourceContents > \">\" | < SourceContents >) { text }")
Rules[:_SourceContents] = rule_info("SourceContents", "(((!\"(\" !\")\" !\">\" Nonspacechar)+ | \"(\" SourceContents \")\")* | \"\")")
Rules[:_Title] = rule_info("Title", "(TitleSingle | TitleDouble | \"\"):a { a }")
Rules[:_TitleSingle] = rule_info("TitleSingle", "\"'\" (!(\"'\" Sp (\")\" | Newline)) .)* \"'\"")
Rules[:_TitleDouble] = rule_info("TitleDouble", "\"\\\"\" (!(\"\\\"\" Sp (\")\" | Newline)) .)* \"\\\"\"")
Rules[:_AutoLink] = rule_info("AutoLink", "(AutoLinkUrl | AutoLinkEmail)")
Rules[:_AutoLinkUrl] = rule_info("AutoLinkUrl", "\"<\" < /[A-Za-z]+/ \"://\" (!Newline !\">\" .)+ > \">\" { text }")
Rules[:_AutoLinkEmail] = rule_info("AutoLinkEmail", "\"<\" \"mailto:\"? < /[\\w+.\\/!%~$-]+/i \"@\" (!Newline !\">\" .)+ > \">\" { \"mailto:\#{text}\" }")
Rules[:_Reference] = rule_info("Reference", "NonindentSpace !\"[]\" Label:label \":\" Spnl RefSrc:link RefTitle BlankLine+ { \# TODO use title reference label, link nil }")
Rules[:_Label] = rule_info("Label", "\"[\" (!\"^\" &{ notes? } | &. &{ !notes? }) StartList:a (!\"]\" Inline:l { a << l })* \"]\" { a.join.gsub(/\\s+/, ' ') }")
Rules[:_RefSrc] = rule_info("RefSrc", "< Nonspacechar+ > { text }")
Rules[:_RefTitle] = rule_info("RefTitle", "(RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle)")
Rules[:_EmptyTitle] = rule_info("EmptyTitle", "\"\"")
Rules[:_RefTitleSingle] = rule_info("RefTitleSingle", "Spnl \"'\" < (!(\"'\" Sp Newline | Newline) .)* > \"'\" { text }")
Rules[:_RefTitleDouble] = rule_info("RefTitleDouble", "Spnl \"\\\"\" < (!(\"\\\"\" Sp Newline | Newline) .)* > \"\\\"\" { text }")
Rules[:_RefTitleParens] = rule_info("RefTitleParens", "Spnl \"(\" < (!(\")\" Sp Newline | Newline) .)* > \")\" { text }")
Rules[:_References] = rule_info("References", "(Reference | SkipBlock)*")
Rules[:_Ticks1] = rule_info("Ticks1", "\"`\" !\"`\"")
Rules[:_Ticks2] = rule_info("Ticks2", "\"``\" !\"`\"")
Rules[:_Ticks3] = rule_info("Ticks3", "\"```\" !\"`\"")
Rules[:_Ticks4] = rule_info("Ticks4", "\"````\" !\"`\"")
Rules[:_Ticks5] = rule_info("Ticks5", "\"`````\" !\"`\"")
Rules[:_Code] = rule_info("Code", "(Ticks1 Sp < ((!\"`\" Nonspacechar)+ | !Ticks1 \"`\"+ | !(Sp Ticks1) (Spacechar | Newline !BlankLine))+ > Sp Ticks1 | Ticks2 Sp < ((!\"`\" Nonspacechar)+ | !Ticks2 \"`\"+ | !(Sp Ticks2) (Spacechar | Newline !BlankLine))+ > Sp Ticks2 | Ticks3 Sp < ((!\"`\" Nonspacechar)+ | !Ticks3 \"`\"+ | !(Sp Ticks3) (Spacechar | Newline !BlankLine))+ > Sp Ticks3 | Ticks4 Sp < ((!\"`\" Nonspacechar)+ | !Ticks4 \"`\"+ | !(Sp Ticks4) (Spacechar | Newline !BlankLine))+ > Sp Ticks4 | Ticks5 Sp < ((!\"`\" Nonspacechar)+ | !Ticks5 \"`\"+ | !(Sp Ticks5) (Spacechar | Newline !BlankLine))+ > Sp Ticks5) { \"\#{text}\" }")
Rules[:_RawHtml] = rule_info("RawHtml", "< (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else '' end }")
Rules[:_BlankLine] = rule_info("BlankLine", "Sp Newline { \"\\n\" }")
Rules[:_Quoted] = rule_info("Quoted", "(\"\\\"\" (!\"\\\"\" .)* \"\\\"\" | \"'\" (!\"'\" .)* \"'\")")
Rules[:_HtmlAttribute] = rule_info("HtmlAttribute", "(AlphanumericAscii | \"-\")+ Spnl (\"=\" Spnl (Quoted | (!\">\" Nonspacechar)+))? Spnl")
Rules[:_HtmlComment] = rule_info("HtmlComment", "\"\" .)* \"-->\"")
Rules[:_HtmlTag] = rule_info("HtmlTag", "\"<\" Spnl \"/\"? AlphanumericAscii+ Spnl HtmlAttribute* \"/\"? Spnl \">\"")
Rules[:_Eof] = rule_info("Eof", "!.")
Rules[:_Nonspacechar] = rule_info("Nonspacechar", "!Spacechar !Newline .")
Rules[:_Sp] = rule_info("Sp", "Spacechar*")
Rules[:_Spnl] = rule_info("Spnl", "Sp (Newline Sp)?")
Rules[:_SpecialChar] = rule_info("SpecialChar", "(\"*\" | \"_\" | \"`\" | \"&\" | \"[\" | \"]\" | \"(\" | \")\" | \"<\" | \"!\" | \"\#\" | \"\\\\\" | \"'\" | \"\\\"\" | ExtendedSpecialChar)")
Rules[:_NormalChar] = rule_info("NormalChar", "!(SpecialChar | Spacechar | Newline) .")
Rules[:_Digit] = rule_info("Digit", "[0-9]")
Rules[:_Alphanumeric] = rule_info("Alphanumeric", "%literals.Alphanumeric")
Rules[:_AlphanumericAscii] = rule_info("AlphanumericAscii", "%literals.AlphanumericAscii")
Rules[:_BOM] = rule_info("BOM", "%literals.BOM")
Rules[:_Newline] = rule_info("Newline", "%literals.Newline")
Rules[:_NonAlphanumeric] = rule_info("NonAlphanumeric", "%literals.NonAlphanumeric")
Rules[:_Spacechar] = rule_info("Spacechar", "%literals.Spacechar")
Rules[:_HexEntity] = rule_info("HexEntity", "\"&\" \"\#\" /[Xx]/ < /[0-9a-fA-F]+/ > \";\" { [text.to_i(16)].pack 'U' }")
Rules[:_DecEntity] = rule_info("DecEntity", "\"&\" \"\#\" < /[0-9]+/ > \";\" { [text.to_i].pack 'U' }")
Rules[:_CharEntity] = rule_info("CharEntity", "\"&\" < /[A-Za-z0-9]+/ > \";\" { if entity = HTML_ENTITIES[text] then entity.pack 'U*' else \"&\#{text};\" end }")
Rules[:_NonindentSpace] = rule_info("NonindentSpace", "(\" \" | \" \" | \" \" | \"\")")
Rules[:_Indent] = rule_info("Indent", "(\"\\t\" | \" \")")
Rules[:_IndentedLine] = rule_info("IndentedLine", "Indent Line")
Rules[:_OptionallyIndentedLine] = rule_info("OptionallyIndentedLine", "Indent? Line")
Rules[:_StartList] = rule_info("StartList", "&. { [] }")
Rules[:_Line] = rule_info("Line", "RawLine:a { a }")
Rules[:_RawLine] = rule_info("RawLine", "(< (!\"\r\" !\"\\n\" .)* Newline > | < .+ > Eof) { text }")
Rules[:_SkipBlock] = rule_info("SkipBlock", "(HtmlBlock | (!\"\#\" !SetextBottom1 !SetextBottom2 !BlankLine RawLine)+ BlankLine* | BlankLine+ | RawLine)")
Rules[:_ExtendedSpecialChar] = rule_info("ExtendedSpecialChar", "&{ notes? } \"^\"")
Rules[:_NoteReference] = rule_info("NoteReference", "&{ notes? } RawNoteReference:ref { note_for ref }")
Rules[:_RawNoteReference] = rule_info("RawNoteReference", "\"[^\" < (!Newline !\"]\" .)+ > \"]\" { text }")
Rules[:_Note] = rule_info("Note", "&{ notes? } NonindentSpace RawNoteReference:ref \":\" Sp StartList:a RawNoteBlock (&Indent RawNoteBlock:i { a.concat i })* { @footnotes[ref] = paragraph a nil }")
Rules[:_InlineNote] = rule_info("InlineNote", "&{ notes? } \"^[\" StartList:a (!\"]\" Inline:l { a << l })+ \"]\" { ref = [:inline, @note_order.length] @footnotes[ref] = paragraph a note_for ref }")
Rules[:_Notes] = rule_info("Notes", "(Note | SkipBlock)*")
Rules[:_RawNoteBlock] = rule_info("RawNoteBlock", "StartList:a (!BlankLine OptionallyIndentedLine:l { a << l })+ < BlankLine* > { a << text } { a }")
Rules[:_CodeFence] = rule_info("CodeFence", "&{ github? } Ticks3 (Sp StrChunk:format)? Spnl < ((!\"`\" Nonspacechar)+ | !Ticks3 \"`\"+ | Spacechar | Newline)+ > Ticks3 Sp Newline* { verbatim = RDoc::Markup::Verbatim.new text verbatim.format = format.intern if format verbatim }")
Rules[:_DefinitionList] = rule_info("DefinitionList", "&{ definition_lists? } DefinitionListItem+:list { RDoc::Markup::List.new :NOTE, *list.flatten }")
Rules[:_DefinitionListItem] = rule_info("DefinitionListItem", "DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << RDoc::Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| RDoc::Markup::ListItem.new nil, defn } unless list_items.empty? list_items }")
Rules[:_DefinitionListLabel] = rule_info("DefinitionListLabel", "StrChunk:label Sp Newline { label }")
Rules[:_DefinitionListDefinition] = rule_info("DefinitionListDefinition", "NonindentSpace \":\" Space Inlines:a BlankLine+ { paragraph a }")
# :startdoc:
end
generator.rb 0000644 00000003344 14763537411 0007076 0 ustar 00 ##
# RDoc uses generators to turn parsed source code in the form of an
# RDoc::CodeObject tree into some form of output. RDoc comes with the HTML
# generator RDoc::Generator::Darkfish and an ri data generator
# RDoc::Generator::RI.
#
# == Registering a Generator
#
# Generators are registered by calling RDoc::RDoc.add_generator with the class
# of the generator:
#
# class My::Awesome::Generator
# RDoc::RDoc.add_generator self
# end
#
# == Adding Options to +rdoc+
#
# Before option processing in +rdoc+, RDoc::Options will call ::setup_options
# on the generator class with an RDoc::Options instance. The generator can
# use RDoc::Options#option_parser to add command-line options to the +rdoc+
# tool. See RDoc::Options@Custom+Options for an example and see OptionParser
# for details on how to add options.
#
# You can extend the RDoc::Options instance with additional accessors for your
# generator.
#
# == Generator Instantiation
#
# After parsing, RDoc::RDoc will instantiate a generator by calling
# #initialize with an RDoc::Store instance and an RDoc::Options instance.
#
# The RDoc::Store instance holds documentation for parsed source code. In
# RDoc 3 and earlier the RDoc::TopLevel class held this data. When upgrading
# a generator from RDoc 3 and earlier you should only need to replace
# RDoc::TopLevel with the store instance.
#
# RDoc will then call #generate on the generator instance. You can use the
# various methods on RDoc::Store and in the RDoc::CodeObject tree to create
# your desired output format.
module RDoc::Generator
autoload :Markup, 'rdoc/generator/markup'
autoload :Darkfish, 'rdoc/generator/darkfish'
autoload :JsonIndex, 'rdoc/generator/json_index'
autoload :RI, 'rdoc/generator/ri'
end
markdown/literals_1_9.rb 0000644 00000021734 14763537411 0011224 0 ustar 00 # coding: UTF-8
# :markup: markdown
##
#--
# This set of literals is for ruby 1.9 regular expressions and gives full
# unicode support.
#
# Unlike peg-markdown, this set of literals recognizes Unicode alphanumeric
# characters, newlines and spaces.
class RDoc::Markdown::Literals
# :stopdoc:
# This is distinct from setup_parser so that a standalone parser
# can redefine #initialize and still have access to the proper
# parser setup code.
def initialize(str, debug=false)
setup_parser(str, debug)
end
# Prepares for parsing +str+. If you define a custom initialize you must
# call this method before #parse
def setup_parser(str, debug=false)
@string = str
@pos = 0
@memoizations = Hash.new { |h,k| h[k] = {} }
@result = nil
@failed_rule = nil
@failing_rule_offset = -1
setup_foreign_grammar
end
attr_reader :string
attr_reader :failing_rule_offset
attr_accessor :result, :pos
def current_column(target=pos)
if c = string.rindex("\n", target-1)
return target - c - 1
end
target + 1
end
def current_line(target=pos)
cur_offset = 0
cur_line = 0
string.each_line do |line|
cur_line += 1
cur_offset += line.size
return cur_line if cur_offset >= target
end
-1
end
def lines
lines = []
string.each_line { |l| lines << l }
lines
end
def get_text(start)
@string[start..@pos-1]
end
def show_pos
width = 10
if @pos < width
"#{@pos} (\"#{@string[0,@pos]}\" @ \"#{@string[@pos,width]}\")"
else
"#{@pos} (\"... #{@string[@pos - width, width]}\" @ \"#{@string[@pos,width]}\")"
end
end
def failure_info
l = current_line @failing_rule_offset
c = current_column @failing_rule_offset
if @failed_rule.kind_of? Symbol
info = self.class::Rules[@failed_rule]
"line #{l}, column #{c}: failed rule '#{info.name}' = '#{info.rendered}'"
else
"line #{l}, column #{c}: failed rule '#{@failed_rule}'"
end
end
def failure_caret
l = current_line @failing_rule_offset
c = current_column @failing_rule_offset
line = lines[l-1]
"#{line}\n#{' ' * (c - 1)}^"
end
def failure_character
l = current_line @failing_rule_offset
c = current_column @failing_rule_offset
lines[l-1][c-1, 1]
end
def failure_oneline
l = current_line @failing_rule_offset
c = current_column @failing_rule_offset
char = lines[l-1][c-1, 1]
if @failed_rule.kind_of? Symbol
info = self.class::Rules[@failed_rule]
"@#{l}:#{c} failed rule '#{info.name}', got '#{char}'"
else
"@#{l}:#{c} failed rule '#{@failed_rule}', got '#{char}'"
end
end
class ParseError < RuntimeError
end
def raise_error
raise ParseError, failure_oneline
end
def show_error(io=STDOUT)
error_pos = @failing_rule_offset
line_no = current_line(error_pos)
col_no = current_column(error_pos)
io.puts "On line #{line_no}, column #{col_no}:"
if @failed_rule.kind_of? Symbol
info = self.class::Rules[@failed_rule]
io.puts "Failed to match '#{info.rendered}' (rule '#{info.name}')"
else
io.puts "Failed to match rule '#{@failed_rule}'"
end
io.puts "Got: #{string[error_pos,1].inspect}"
line = lines[line_no-1]
io.puts "=> #{line}"
io.print(" " * (col_no + 3))
io.puts "^"
end
def set_failed_rule(name)
if @pos > @failing_rule_offset
@failed_rule = name
@failing_rule_offset = @pos
end
end
attr_reader :failed_rule
def match_string(str)
len = str.size
if @string[pos,len] == str
@pos += len
return str
end
return nil
end
def scan(reg)
if m = reg.match(@string[@pos..-1])
width = m.end(0)
@pos += width
return true
end
return nil
end
if "".respond_to? :getbyte
def get_byte
if @pos >= @string.size
return nil
end
s = @string.getbyte @pos
@pos += 1
s
end
else
def get_byte
if @pos >= @string.size
return nil
end
s = @string[@pos]
@pos += 1
s
end
end
def parse(rule=nil)
# We invoke the rules indirectly via apply
# instead of by just calling them as methods because
# if the rules use left recursion, apply needs to
# manage that.
if !rule
apply(:_root)
else
method = rule.gsub("-","_hyphen_")
apply :"_#{method}"
end
end
class MemoEntry
def initialize(ans, pos)
@ans = ans
@pos = pos
@result = nil
@set = false
@left_rec = false
end
attr_reader :ans, :pos, :result, :set
attr_accessor :left_rec
def move!(ans, pos, result)
@ans = ans
@pos = pos
@result = result
@set = true
@left_rec = false
end
end
def external_invoke(other, rule, *args)
old_pos = @pos
old_string = @string
@pos = other.pos
@string = other.string
begin
if val = __send__(rule, *args)
other.pos = @pos
other.result = @result
else
other.set_failed_rule "#{self.class}##{rule}"
end
val
ensure
@pos = old_pos
@string = old_string
end
end
def apply_with_args(rule, *args)
memo_key = [rule, args]
if m = @memoizations[memo_key][@pos]
@pos = m.pos
if !m.set
m.left_rec = true
return nil
end
@result = m.result
return m.ans
else
m = MemoEntry.new(nil, @pos)
@memoizations[memo_key][@pos] = m
start_pos = @pos
ans = __send__ rule, *args
lr = m.left_rec
m.move! ans, @pos, @result
# Don't bother trying to grow the left recursion
# if it's failing straight away (thus there is no seed)
if ans and lr
return grow_lr(rule, args, start_pos, m)
else
return ans
end
return ans
end
end
def apply(rule)
if m = @memoizations[rule][@pos]
@pos = m.pos
if !m.set
m.left_rec = true
return nil
end
@result = m.result
return m.ans
else
m = MemoEntry.new(nil, @pos)
@memoizations[rule][@pos] = m
start_pos = @pos
ans = __send__ rule
lr = m.left_rec
m.move! ans, @pos, @result
# Don't bother trying to grow the left recursion
# if it's failing straight away (thus there is no seed)
if ans and lr
return grow_lr(rule, nil, start_pos, m)
else
return ans
end
return ans
end
end
def grow_lr(rule, args, start_pos, m)
while true
@pos = start_pos
@result = m.result
if args
ans = __send__ rule, *args
else
ans = __send__ rule
end
return nil unless ans
break if @pos <= m.pos
m.move! ans, @pos, @result
end
@result = m.result
@pos = m.pos
return m.ans
end
class RuleInfo
def initialize(name, rendered)
@name = name
@rendered = rendered
end
attr_reader :name, :rendered
end
def self.rule_info(name, rendered)
RuleInfo.new(name, rendered)
end
# :startdoc:
# :stopdoc:
def setup_foreign_grammar; end
# Alphanumeric = /\p{Word}/
def _Alphanumeric
_tmp = scan(/\A(?-mix:\p{Word})/)
set_failed_rule :_Alphanumeric unless _tmp
return _tmp
end
# AlphanumericAscii = /[A-Za-z0-9]/
def _AlphanumericAscii
_tmp = scan(/\A(?-mix:[A-Za-z0-9])/)
set_failed_rule :_AlphanumericAscii unless _tmp
return _tmp
end
# BOM = "uFEFF"
def _BOM
_tmp = match_string("uFEFF")
set_failed_rule :_BOM unless _tmp
return _tmp
end
# Newline = /\n|\r\n?|\p{Zl}|\p{Zp}/
def _Newline
_tmp = scan(/\A(?-mix:\n|\r\n?|\p{Zl}|\p{Zp})/)
set_failed_rule :_Newline unless _tmp
return _tmp
end
# NonAlphanumeric = /\p{^Word}/
def _NonAlphanumeric
_tmp = scan(/\A(?-mix:\p{^Word})/)
set_failed_rule :_NonAlphanumeric unless _tmp
return _tmp
end
# Spacechar = /\t|\p{Zs}/
def _Spacechar
_tmp = scan(/\A(?-mix:\t|\p{Zs})/)
set_failed_rule :_Spacechar unless _tmp
return _tmp
end
Rules = {}
Rules[:_Alphanumeric] = rule_info("Alphanumeric", "/\\p{Word}/")
Rules[:_AlphanumericAscii] = rule_info("AlphanumericAscii", "/[A-Za-z0-9]/")
Rules[:_BOM] = rule_info("BOM", "\"uFEFF\"")
Rules[:_Newline] = rule_info("Newline", "/\\n|\\r\\n?|\\p{Zl}|\\p{Zp}/")
Rules[:_NonAlphanumeric] = rule_info("NonAlphanumeric", "/\\p{^Word}/")
Rules[:_Spacechar] = rule_info("Spacechar", "/\\t|\\p{Zs}/")
# :startdoc:
end
markdown/entities.rb 0000644 00000154003 14763537411 0010555 0 ustar 00 ##
# HTML entity name map for RDoc::Markdown
RDoc::Markdown::HTML_ENTITIES = {
"AElig" => [0x000C6],
"AMP" => [0x00026],
"Aacute" => [0x000C1],
"Abreve" => [0x00102],
"Acirc" => [0x000C2],
"Acy" => [0x00410],
"Afr" => [0x1D504],
"Agrave" => [0x000C0],
"Alpha" => [0x00391],
"Amacr" => [0x00100],
"And" => [0x02A53],
"Aogon" => [0x00104],
"Aopf" => [0x1D538],
"ApplyFunction" => [0x02061],
"Aring" => [0x000C5],
"Ascr" => [0x1D49C],
"Assign" => [0x02254],
"Atilde" => [0x000C3],
"Auml" => [0x000C4],
"Backslash" => [0x02216],
"Barv" => [0x02AE7],
"Barwed" => [0x02306],
"Bcy" => [0x00411],
"Because" => [0x02235],
"Bernoullis" => [0x0212C],
"Beta" => [0x00392],
"Bfr" => [0x1D505],
"Bopf" => [0x1D539],
"Breve" => [0x002D8],
"Bscr" => [0x0212C],
"Bumpeq" => [0x0224E],
"CHcy" => [0x00427],
"COPY" => [0x000A9],
"Cacute" => [0x00106],
"Cap" => [0x022D2],
"CapitalDifferentialD" => [0x02145],
"Cayleys" => [0x0212D],
"Ccaron" => [0x0010C],
"Ccedil" => [0x000C7],
"Ccirc" => [0x00108],
"Cconint" => [0x02230],
"Cdot" => [0x0010A],
"Cedilla" => [0x000B8],
"CenterDot" => [0x000B7],
"Cfr" => [0x0212D],
"Chi" => [0x003A7],
"CircleDot" => [0x02299],
"CircleMinus" => [0x02296],
"CirclePlus" => [0x02295],
"CircleTimes" => [0x02297],
"ClockwiseContourIntegral" => [0x02232],
"CloseCurlyDoubleQuote" => [0x0201D],
"CloseCurlyQuote" => [0x02019],
"Colon" => [0x02237],
"Colone" => [0x02A74],
"Congruent" => [0x02261],
"Conint" => [0x0222F],
"ContourIntegral" => [0x0222E],
"Copf" => [0x02102],
"Coproduct" => [0x02210],
"CounterClockwiseContourIntegral" => [0x02233],
"Cross" => [0x02A2F],
"Cscr" => [0x1D49E],
"Cup" => [0x022D3],
"CupCap" => [0x0224D],
"DD" => [0x02145],
"DDotrahd" => [0x02911],
"DJcy" => [0x00402],
"DScy" => [0x00405],
"DZcy" => [0x0040F],
"Dagger" => [0x02021],
"Darr" => [0x021A1],
"Dashv" => [0x02AE4],
"Dcaron" => [0x0010E],
"Dcy" => [0x00414],
"Del" => [0x02207],
"Delta" => [0x00394],
"Dfr" => [0x1D507],
"DiacriticalAcute" => [0x000B4],
"DiacriticalDot" => [0x002D9],
"DiacriticalDoubleAcute" => [0x002DD],
"DiacriticalGrave" => [0x00060],
"DiacriticalTilde" => [0x002DC],
"Diamond" => [0x022C4],
"DifferentialD" => [0x02146],
"Dopf" => [0x1D53B],
"Dot" => [0x000A8],
"DotDot" => [0x020DC],
"DotEqual" => [0x02250],
"DoubleContourIntegral" => [0x0222F],
"DoubleDot" => [0x000A8],
"DoubleDownArrow" => [0x021D3],
"DoubleLeftArrow" => [0x021D0],
"DoubleLeftRightArrow" => [0x021D4],
"DoubleLeftTee" => [0x02AE4],
"DoubleLongLeftArrow" => [0x027F8],
"DoubleLongLeftRightArrow" => [0x027FA],
"DoubleLongRightArrow" => [0x027F9],
"DoubleRightArrow" => [0x021D2],
"DoubleRightTee" => [0x022A8],
"DoubleUpArrow" => [0x021D1],
"DoubleUpDownArrow" => [0x021D5],
"DoubleVerticalBar" => [0x02225],
"DownArrow" => [0x02193],
"DownArrowBar" => [0x02913],
"DownArrowUpArrow" => [0x021F5],
"DownBreve" => [0x00311],
"DownLeftRightVector" => [0x02950],
"DownLeftTeeVector" => [0x0295E],
"DownLeftVector" => [0x021BD],
"DownLeftVectorBar" => [0x02956],
"DownRightTeeVector" => [0x0295F],
"DownRightVector" => [0x021C1],
"DownRightVectorBar" => [0x02957],
"DownTee" => [0x022A4],
"DownTeeArrow" => [0x021A7],
"Downarrow" => [0x021D3],
"Dscr" => [0x1D49F],
"Dstrok" => [0x00110],
"ENG" => [0x0014A],
"ETH" => [0x000D0],
"Eacute" => [0x000C9],
"Ecaron" => [0x0011A],
"Ecirc" => [0x000CA],
"Ecy" => [0x0042D],
"Edot" => [0x00116],
"Efr" => [0x1D508],
"Egrave" => [0x000C8],
"Element" => [0x02208],
"Emacr" => [0x00112],
"EmptySmallSquare" => [0x025FB],
"EmptyVerySmallSquare" => [0x025AB],
"Eogon" => [0x00118],
"Eopf" => [0x1D53C],
"Epsilon" => [0x00395],
"Equal" => [0x02A75],
"EqualTilde" => [0x02242],
"Equilibrium" => [0x021CC],
"Escr" => [0x02130],
"Esim" => [0x02A73],
"Eta" => [0x00397],
"Euml" => [0x000CB],
"Exists" => [0x02203],
"ExponentialE" => [0x02147],
"Fcy" => [0x00424],
"Ffr" => [0x1D509],
"FilledSmallSquare" => [0x025FC],
"FilledVerySmallSquare" => [0x025AA],
"Fopf" => [0x1D53D],
"ForAll" => [0x02200],
"Fouriertrf" => [0x02131],
"Fscr" => [0x02131],
"GJcy" => [0x00403],
"GT" => [0x0003E],
"Gamma" => [0x00393],
"Gammad" => [0x003DC],
"Gbreve" => [0x0011E],
"Gcedil" => [0x00122],
"Gcirc" => [0x0011C],
"Gcy" => [0x00413],
"Gdot" => [0x00120],
"Gfr" => [0x1D50A],
"Gg" => [0x022D9],
"Gopf" => [0x1D53E],
"GreaterEqual" => [0x02265],
"GreaterEqualLess" => [0x022DB],
"GreaterFullEqual" => [0x02267],
"GreaterGreater" => [0x02AA2],
"GreaterLess" => [0x02277],
"GreaterSlantEqual" => [0x02A7E],
"GreaterTilde" => [0x02273],
"Gscr" => [0x1D4A2],
"Gt" => [0x0226B],
"HARDcy" => [0x0042A],
"Hacek" => [0x002C7],
"Hat" => [0x0005E],
"Hcirc" => [0x00124],
"Hfr" => [0x0210C],
"HilbertSpace" => [0x0210B],
"Hopf" => [0x0210D],
"HorizontalLine" => [0x02500],
"Hscr" => [0x0210B],
"Hstrok" => [0x00126],
"HumpDownHump" => [0x0224E],
"HumpEqual" => [0x0224F],
"IEcy" => [0x00415],
"IJlig" => [0x00132],
"IOcy" => [0x00401],
"Iacute" => [0x000CD],
"Icirc" => [0x000CE],
"Icy" => [0x00418],
"Idot" => [0x00130],
"Ifr" => [0x02111],
"Igrave" => [0x000CC],
"Im" => [0x02111],
"Imacr" => [0x0012A],
"ImaginaryI" => [0x02148],
"Implies" => [0x021D2],
"Int" => [0x0222C],
"Integral" => [0x0222B],
"Intersection" => [0x022C2],
"InvisibleComma" => [0x02063],
"InvisibleTimes" => [0x02062],
"Iogon" => [0x0012E],
"Iopf" => [0x1D540],
"Iota" => [0x00399],
"Iscr" => [0x02110],
"Itilde" => [0x00128],
"Iukcy" => [0x00406],
"Iuml" => [0x000CF],
"Jcirc" => [0x00134],
"Jcy" => [0x00419],
"Jfr" => [0x1D50D],
"Jopf" => [0x1D541],
"Jscr" => [0x1D4A5],
"Jsercy" => [0x00408],
"Jukcy" => [0x00404],
"KHcy" => [0x00425],
"KJcy" => [0x0040C],
"Kappa" => [0x0039A],
"Kcedil" => [0x00136],
"Kcy" => [0x0041A],
"Kfr" => [0x1D50E],
"Kopf" => [0x1D542],
"Kscr" => [0x1D4A6],
"LJcy" => [0x00409],
"LT" => [0x0003C],
"Lacute" => [0x00139],
"Lambda" => [0x0039B],
"Lang" => [0x027EA],
"Laplacetrf" => [0x02112],
"Larr" => [0x0219E],
"Lcaron" => [0x0013D],
"Lcedil" => [0x0013B],
"Lcy" => [0x0041B],
"LeftAngleBracket" => [0x027E8],
"LeftArrow" => [0x02190],
"LeftArrowBar" => [0x021E4],
"LeftArrowRightArrow" => [0x021C6],
"LeftCeiling" => [0x02308],
"LeftDoubleBracket" => [0x027E6],
"LeftDownTeeVector" => [0x02961],
"LeftDownVector" => [0x021C3],
"LeftDownVectorBar" => [0x02959],
"LeftFloor" => [0x0230A],
"LeftRightArrow" => [0x02194],
"LeftRightVector" => [0x0294E],
"LeftTee" => [0x022A3],
"LeftTeeArrow" => [0x021A4],
"LeftTeeVector" => [0x0295A],
"LeftTriangle" => [0x022B2],
"LeftTriangleBar" => [0x029CF],
"LeftTriangleEqual" => [0x022B4],
"LeftUpDownVector" => [0x02951],
"LeftUpTeeVector" => [0x02960],
"LeftUpVector" => [0x021BF],
"LeftUpVectorBar" => [0x02958],
"LeftVector" => [0x021BC],
"LeftVectorBar" => [0x02952],
"Leftarrow" => [0x021D0],
"Leftrightarrow" => [0x021D4],
"LessEqualGreater" => [0x022DA],
"LessFullEqual" => [0x02266],
"LessGreater" => [0x02276],
"LessLess" => [0x02AA1],
"LessSlantEqual" => [0x02A7D],
"LessTilde" => [0x02272],
"Lfr" => [0x1D50F],
"Ll" => [0x022D8],
"Lleftarrow" => [0x021DA],
"Lmidot" => [0x0013F],
"LongLeftArrow" => [0x027F5],
"LongLeftRightArrow" => [0x027F7],
"LongRightArrow" => [0x027F6],
"Longleftarrow" => [0x027F8],
"Longleftrightarrow" => [0x027FA],
"Longrightarrow" => [0x027F9],
"Lopf" => [0x1D543],
"LowerLeftArrow" => [0x02199],
"LowerRightArrow" => [0x02198],
"Lscr" => [0x02112],
"Lsh" => [0x021B0],
"Lstrok" => [0x00141],
"Lt" => [0x0226A],
"Map" => [0x02905],
"Mcy" => [0x0041C],
"MediumSpace" => [0x0205F],
"Mellintrf" => [0x02133],
"Mfr" => [0x1D510],
"MinusPlus" => [0x02213],
"Mopf" => [0x1D544],
"Mscr" => [0x02133],
"Mu" => [0x0039C],
"NJcy" => [0x0040A],
"Nacute" => [0x00143],
"Ncaron" => [0x00147],
"Ncedil" => [0x00145],
"Ncy" => [0x0041D],
"NegativeMediumSpace" => [0x0200B],
"NegativeThickSpace" => [0x0200B],
"NegativeThinSpace" => [0x0200B],
"NegativeVeryThinSpace" => [0x0200B],
"NestedGreaterGreater" => [0x0226B],
"NestedLessLess" => [0x0226A],
"NewLine" => [0x0000A],
"Nfr" => [0x1D511],
"NoBreak" => [0x02060],
"NonBreakingSpace" => [0x000A0],
"Nopf" => [0x02115],
"Not" => [0x02AEC],
"NotCongruent" => [0x02262],
"NotCupCap" => [0x0226D],
"NotDoubleVerticalBar" => [0x02226],
"NotElement" => [0x02209],
"NotEqual" => [0x02260],
"NotEqualTilde" => [0x02242, 0x00338],
"NotExists" => [0x02204],
"NotGreater" => [0x0226F],
"NotGreaterEqual" => [0x02271],
"NotGreaterFullEqual" => [0x02267, 0x00338],
"NotGreaterGreater" => [0x0226B, 0x00338],
"NotGreaterLess" => [0x02279],
"NotGreaterSlantEqual" => [0x02A7E, 0x00338],
"NotGreaterTilde" => [0x02275],
"NotHumpDownHump" => [0x0224E, 0x00338],
"NotHumpEqual" => [0x0224F, 0x00338],
"NotLeftTriangle" => [0x022EA],
"NotLeftTriangleBar" => [0x029CF, 0x00338],
"NotLeftTriangleEqual" => [0x022EC],
"NotLess" => [0x0226E],
"NotLessEqual" => [0x02270],
"NotLessGreater" => [0x02278],
"NotLessLess" => [0x0226A, 0x00338],
"NotLessSlantEqual" => [0x02A7D, 0x00338],
"NotLessTilde" => [0x02274],
"NotNestedGreaterGreater" => [0x02AA2, 0x00338],
"NotNestedLessLess" => [0x02AA1, 0x00338],
"NotPrecedes" => [0x02280],
"NotPrecedesEqual" => [0x02AAF, 0x00338],
"NotPrecedesSlantEqual" => [0x022E0],
"NotReverseElement" => [0x0220C],
"NotRightTriangle" => [0x022EB],
"NotRightTriangleBar" => [0x029D0, 0x00338],
"NotRightTriangleEqual" => [0x022ED],
"NotSquareSubset" => [0x0228F, 0x00338],
"NotSquareSubsetEqual" => [0x022E2],
"NotSquareSuperset" => [0x02290, 0x00338],
"NotSquareSupersetEqual" => [0x022E3],
"NotSubset" => [0x02282, 0x020D2],
"NotSubsetEqual" => [0x02288],
"NotSucceeds" => [0x02281],
"NotSucceedsEqual" => [0x02AB0, 0x00338],
"NotSucceedsSlantEqual" => [0x022E1],
"NotSucceedsTilde" => [0x0227F, 0x00338],
"NotSuperset" => [0x02283, 0x020D2],
"NotSupersetEqual" => [0x02289],
"NotTilde" => [0x02241],
"NotTildeEqual" => [0x02244],
"NotTildeFullEqual" => [0x02247],
"NotTildeTilde" => [0x02249],
"NotVerticalBar" => [0x02224],
"Nscr" => [0x1D4A9],
"Ntilde" => [0x000D1],
"Nu" => [0x0039D],
"OElig" => [0x00152],
"Oacute" => [0x000D3],
"Ocirc" => [0x000D4],
"Ocy" => [0x0041E],
"Odblac" => [0x00150],
"Ofr" => [0x1D512],
"Ograve" => [0x000D2],
"Omacr" => [0x0014C],
"Omega" => [0x003A9],
"Omicron" => [0x0039F],
"Oopf" => [0x1D546],
"OpenCurlyDoubleQuote" => [0x0201C],
"OpenCurlyQuote" => [0x02018],
"Or" => [0x02A54],
"Oscr" => [0x1D4AA],
"Oslash" => [0x000D8],
"Otilde" => [0x000D5],
"Otimes" => [0x02A37],
"Ouml" => [0x000D6],
"OverBar" => [0x0203E],
"OverBrace" => [0x023DE],
"OverBracket" => [0x023B4],
"OverParenthesis" => [0x023DC],
"PartialD" => [0x02202],
"Pcy" => [0x0041F],
"Pfr" => [0x1D513],
"Phi" => [0x003A6],
"Pi" => [0x003A0],
"PlusMinus" => [0x000B1],
"Poincareplane" => [0x0210C],
"Popf" => [0x02119],
"Pr" => [0x02ABB],
"Precedes" => [0x0227A],
"PrecedesEqual" => [0x02AAF],
"PrecedesSlantEqual" => [0x0227C],
"PrecedesTilde" => [0x0227E],
"Prime" => [0x02033],
"Product" => [0x0220F],
"Proportion" => [0x02237],
"Proportional" => [0x0221D],
"Pscr" => [0x1D4AB],
"Psi" => [0x003A8],
"QUOT" => [0x00022],
"Qfr" => [0x1D514],
"Qopf" => [0x0211A],
"Qscr" => [0x1D4AC],
"RBarr" => [0x02910],
"REG" => [0x000AE],
"Racute" => [0x00154],
"Rang" => [0x027EB],
"Rarr" => [0x021A0],
"Rarrtl" => [0x02916],
"Rcaron" => [0x00158],
"Rcedil" => [0x00156],
"Rcy" => [0x00420],
"Re" => [0x0211C],
"ReverseElement" => [0x0220B],
"ReverseEquilibrium" => [0x021CB],
"ReverseUpEquilibrium" => [0x0296F],
"Rfr" => [0x0211C],
"Rho" => [0x003A1],
"RightAngleBracket" => [0x027E9],
"RightArrow" => [0x02192],
"RightArrowBar" => [0x021E5],
"RightArrowLeftArrow" => [0x021C4],
"RightCeiling" => [0x02309],
"RightDoubleBracket" => [0x027E7],
"RightDownTeeVector" => [0x0295D],
"RightDownVector" => [0x021C2],
"RightDownVectorBar" => [0x02955],
"RightFloor" => [0x0230B],
"RightTee" => [0x022A2],
"RightTeeArrow" => [0x021A6],
"RightTeeVector" => [0x0295B],
"RightTriangle" => [0x022B3],
"RightTriangleBar" => [0x029D0],
"RightTriangleEqual" => [0x022B5],
"RightUpDownVector" => [0x0294F],
"RightUpTeeVector" => [0x0295C],
"RightUpVector" => [0x021BE],
"RightUpVectorBar" => [0x02954],
"RightVector" => [0x021C0],
"RightVectorBar" => [0x02953],
"Rightarrow" => [0x021D2],
"Ropf" => [0x0211D],
"RoundImplies" => [0x02970],
"Rrightarrow" => [0x021DB],
"Rscr" => [0x0211B],
"Rsh" => [0x021B1],
"RuleDelayed" => [0x029F4],
"SHCHcy" => [0x00429],
"SHcy" => [0x00428],
"SOFTcy" => [0x0042C],
"Sacute" => [0x0015A],
"Sc" => [0x02ABC],
"Scaron" => [0x00160],
"Scedil" => [0x0015E],
"Scirc" => [0x0015C],
"Scy" => [0x00421],
"Sfr" => [0x1D516],
"ShortDownArrow" => [0x02193],
"ShortLeftArrow" => [0x02190],
"ShortRightArrow" => [0x02192],
"ShortUpArrow" => [0x02191],
"Sigma" => [0x003A3],
"SmallCircle" => [0x02218],
"Sopf" => [0x1D54A],
"Sqrt" => [0x0221A],
"Square" => [0x025A1],
"SquareIntersection" => [0x02293],
"SquareSubset" => [0x0228F],
"SquareSubsetEqual" => [0x02291],
"SquareSuperset" => [0x02290],
"SquareSupersetEqual" => [0x02292],
"SquareUnion" => [0x02294],
"Sscr" => [0x1D4AE],
"Star" => [0x022C6],
"Sub" => [0x022D0],
"Subset" => [0x022D0],
"SubsetEqual" => [0x02286],
"Succeeds" => [0x0227B],
"SucceedsEqual" => [0x02AB0],
"SucceedsSlantEqual" => [0x0227D],
"SucceedsTilde" => [0x0227F],
"SuchThat" => [0x0220B],
"Sum" => [0x02211],
"Sup" => [0x022D1],
"Superset" => [0x02283],
"SupersetEqual" => [0x02287],
"Supset" => [0x022D1],
"THORN" => [0x000DE],
"TRADE" => [0x02122],
"TSHcy" => [0x0040B],
"TScy" => [0x00426],
"Tab" => [0x00009],
"Tau" => [0x003A4],
"Tcaron" => [0x00164],
"Tcedil" => [0x00162],
"Tcy" => [0x00422],
"Tfr" => [0x1D517],
"Therefore" => [0x02234],
"Theta" => [0x00398],
"ThickSpace" => [0x0205F, 0x0200A],
"ThinSpace" => [0x02009],
"Tilde" => [0x0223C],
"TildeEqual" => [0x02243],
"TildeFullEqual" => [0x02245],
"TildeTilde" => [0x02248],
"Topf" => [0x1D54B],
"TripleDot" => [0x020DB],
"Tscr" => [0x1D4AF],
"Tstrok" => [0x00166],
"Uacute" => [0x000DA],
"Uarr" => [0x0219F],
"Uarrocir" => [0x02949],
"Ubrcy" => [0x0040E],
"Ubreve" => [0x0016C],
"Ucirc" => [0x000DB],
"Ucy" => [0x00423],
"Udblac" => [0x00170],
"Ufr" => [0x1D518],
"Ugrave" => [0x000D9],
"Umacr" => [0x0016A],
"UnderBar" => [0x0005F],
"UnderBrace" => [0x023DF],
"UnderBracket" => [0x023B5],
"UnderParenthesis" => [0x023DD],
"Union" => [0x022C3],
"UnionPlus" => [0x0228E],
"Uogon" => [0x00172],
"Uopf" => [0x1D54C],
"UpArrow" => [0x02191],
"UpArrowBar" => [0x02912],
"UpArrowDownArrow" => [0x021C5],
"UpDownArrow" => [0x02195],
"UpEquilibrium" => [0x0296E],
"UpTee" => [0x022A5],
"UpTeeArrow" => [0x021A5],
"Uparrow" => [0x021D1],
"Updownarrow" => [0x021D5],
"UpperLeftArrow" => [0x02196],
"UpperRightArrow" => [0x02197],
"Upsi" => [0x003D2],
"Upsilon" => [0x003A5],
"Uring" => [0x0016E],
"Uscr" => [0x1D4B0],
"Utilde" => [0x00168],
"Uuml" => [0x000DC],
"VDash" => [0x022AB],
"Vbar" => [0x02AEB],
"Vcy" => [0x00412],
"Vdash" => [0x022A9],
"Vdashl" => [0x02AE6],
"Vee" => [0x022C1],
"Verbar" => [0x02016],
"Vert" => [0x02016],
"VerticalBar" => [0x02223],
"VerticalLine" => [0x0007C],
"VerticalSeparator" => [0x02758],
"VerticalTilde" => [0x02240],
"VeryThinSpace" => [0x0200A],
"Vfr" => [0x1D519],
"Vopf" => [0x1D54D],
"Vscr" => [0x1D4B1],
"Vvdash" => [0x022AA],
"Wcirc" => [0x00174],
"Wedge" => [0x022C0],
"Wfr" => [0x1D51A],
"Wopf" => [0x1D54E],
"Wscr" => [0x1D4B2],
"Xfr" => [0x1D51B],
"Xi" => [0x0039E],
"Xopf" => [0x1D54F],
"Xscr" => [0x1D4B3],
"YAcy" => [0x0042F],
"YIcy" => [0x00407],
"YUcy" => [0x0042E],
"Yacute" => [0x000DD],
"Ycirc" => [0x00176],
"Ycy" => [0x0042B],
"Yfr" => [0x1D51C],
"Yopf" => [0x1D550],
"Yscr" => [0x1D4B4],
"Yuml" => [0x00178],
"ZHcy" => [0x00416],
"Zacute" => [0x00179],
"Zcaron" => [0x0017D],
"Zcy" => [0x00417],
"Zdot" => [0x0017B],
"ZeroWidthSpace" => [0x0200B],
"Zeta" => [0x00396],
"Zfr" => [0x02128],
"Zopf" => [0x02124],
"Zscr" => [0x1D4B5],
"aacute" => [0x000E1],
"abreve" => [0x00103],
"ac" => [0x0223E],
"acE" => [0x0223E, 0x00333],
"acd" => [0x0223F],
"acirc" => [0x000E2],
"acute" => [0x000B4],
"acy" => [0x00430],
"aelig" => [0x000E6],
"af" => [0x02061],
"afr" => [0x1D51E],
"agrave" => [0x000E0],
"alefsym" => [0x02135],
"aleph" => [0x02135],
"alpha" => [0x003B1],
"amacr" => [0x00101],
"amalg" => [0x02A3F],
"amp" => [0x00026],
"and" => [0x02227],
"andand" => [0x02A55],
"andd" => [0x02A5C],
"andslope" => [0x02A58],
"andv" => [0x02A5A],
"ang" => [0x02220],
"ange" => [0x029A4],
"angle" => [0x02220],
"angmsd" => [0x02221],
"angmsdaa" => [0x029A8],
"angmsdab" => [0x029A9],
"angmsdac" => [0x029AA],
"angmsdad" => [0x029AB],
"angmsdae" => [0x029AC],
"angmsdaf" => [0x029AD],
"angmsdag" => [0x029AE],
"angmsdah" => [0x029AF],
"angrt" => [0x0221F],
"angrtvb" => [0x022BE],
"angrtvbd" => [0x0299D],
"angsph" => [0x02222],
"angst" => [0x000C5],
"angzarr" => [0x0237C],
"aogon" => [0x00105],
"aopf" => [0x1D552],
"ap" => [0x02248],
"apE" => [0x02A70],
"apacir" => [0x02A6F],
"ape" => [0x0224A],
"apid" => [0x0224B],
"apos" => [0x00027],
"approx" => [0x02248],
"approxeq" => [0x0224A],
"aring" => [0x000E5],
"ascr" => [0x1D4B6],
"ast" => [0x0002A],
"asymp" => [0x02248],
"asympeq" => [0x0224D],
"atilde" => [0x000E3],
"auml" => [0x000E4],
"awconint" => [0x02233],
"awint" => [0x02A11],
"bNot" => [0x02AED],
"backcong" => [0x0224C],
"backepsilon" => [0x003F6],
"backprime" => [0x02035],
"backsim" => [0x0223D],
"backsimeq" => [0x022CD],
"barvee" => [0x022BD],
"barwed" => [0x02305],
"barwedge" => [0x02305],
"bbrk" => [0x023B5],
"bbrktbrk" => [0x023B6],
"bcong" => [0x0224C],
"bcy" => [0x00431],
"bdquo" => [0x0201E],
"becaus" => [0x02235],
"because" => [0x02235],
"bemptyv" => [0x029B0],
"bepsi" => [0x003F6],
"bernou" => [0x0212C],
"beta" => [0x003B2],
"beth" => [0x02136],
"between" => [0x0226C],
"bfr" => [0x1D51F],
"bigcap" => [0x022C2],
"bigcirc" => [0x025EF],
"bigcup" => [0x022C3],
"bigodot" => [0x02A00],
"bigoplus" => [0x02A01],
"bigotimes" => [0x02A02],
"bigsqcup" => [0x02A06],
"bigstar" => [0x02605],
"bigtriangledown" => [0x025BD],
"bigtriangleup" => [0x025B3],
"biguplus" => [0x02A04],
"bigvee" => [0x022C1],
"bigwedge" => [0x022C0],
"bkarow" => [0x0290D],
"blacklozenge" => [0x029EB],
"blacksquare" => [0x025AA],
"blacktriangle" => [0x025B4],
"blacktriangledown" => [0x025BE],
"blacktriangleleft" => [0x025C2],
"blacktriangleright" => [0x025B8],
"blank" => [0x02423],
"blk12" => [0x02592],
"blk14" => [0x02591],
"blk34" => [0x02593],
"block" => [0x02588],
"bne" => [0x0003D, 0x020E5],
"bnequiv" => [0x02261, 0x020E5],
"bnot" => [0x02310],
"bopf" => [0x1D553],
"bot" => [0x022A5],
"bottom" => [0x022A5],
"bowtie" => [0x022C8],
"boxDL" => [0x02557],
"boxDR" => [0x02554],
"boxDl" => [0x02556],
"boxDr" => [0x02553],
"boxH" => [0x02550],
"boxHD" => [0x02566],
"boxHU" => [0x02569],
"boxHd" => [0x02564],
"boxHu" => [0x02567],
"boxUL" => [0x0255D],
"boxUR" => [0x0255A],
"boxUl" => [0x0255C],
"boxUr" => [0x02559],
"boxV" => [0x02551],
"boxVH" => [0x0256C],
"boxVL" => [0x02563],
"boxVR" => [0x02560],
"boxVh" => [0x0256B],
"boxVl" => [0x02562],
"boxVr" => [0x0255F],
"boxbox" => [0x029C9],
"boxdL" => [0x02555],
"boxdR" => [0x02552],
"boxdl" => [0x02510],
"boxdr" => [0x0250C],
"boxh" => [0x02500],
"boxhD" => [0x02565],
"boxhU" => [0x02568],
"boxhd" => [0x0252C],
"boxhu" => [0x02534],
"boxminus" => [0x0229F],
"boxplus" => [0x0229E],
"boxtimes" => [0x022A0],
"boxuL" => [0x0255B],
"boxuR" => [0x02558],
"boxul" => [0x02518],
"boxur" => [0x02514],
"boxv" => [0x02502],
"boxvH" => [0x0256A],
"boxvL" => [0x02561],
"boxvR" => [0x0255E],
"boxvh" => [0x0253C],
"boxvl" => [0x02524],
"boxvr" => [0x0251C],
"bprime" => [0x02035],
"breve" => [0x002D8],
"brvbar" => [0x000A6],
"bscr" => [0x1D4B7],
"bsemi" => [0x0204F],
"bsim" => [0x0223D],
"bsime" => [0x022CD],
"bsol" => [0x0005C],
"bsolb" => [0x029C5],
"bsolhsub" => [0x027C8],
"bull" => [0x02022],
"bullet" => [0x02022],
"bump" => [0x0224E],
"bumpE" => [0x02AAE],
"bumpe" => [0x0224F],
"bumpeq" => [0x0224F],
"cacute" => [0x00107],
"cap" => [0x02229],
"capand" => [0x02A44],
"capbrcup" => [0x02A49],
"capcap" => [0x02A4B],
"capcup" => [0x02A47],
"capdot" => [0x02A40],
"caps" => [0x02229, 0x0FE00],
"caret" => [0x02041],
"caron" => [0x002C7],
"ccaps" => [0x02A4D],
"ccaron" => [0x0010D],
"ccedil" => [0x000E7],
"ccirc" => [0x00109],
"ccups" => [0x02A4C],
"ccupssm" => [0x02A50],
"cdot" => [0x0010B],
"cedil" => [0x000B8],
"cemptyv" => [0x029B2],
"cent" => [0x000A2],
"centerdot" => [0x000B7],
"cfr" => [0x1D520],
"chcy" => [0x00447],
"check" => [0x02713],
"checkmark" => [0x02713],
"chi" => [0x003C7],
"cir" => [0x025CB],
"cirE" => [0x029C3],
"circ" => [0x002C6],
"circeq" => [0x02257],
"circlearrowleft" => [0x021BA],
"circlearrowright" => [0x021BB],
"circledR" => [0x000AE],
"circledS" => [0x024C8],
"circledast" => [0x0229B],
"circledcirc" => [0x0229A],
"circleddash" => [0x0229D],
"cire" => [0x02257],
"cirfnint" => [0x02A10],
"cirmid" => [0x02AEF],
"cirscir" => [0x029C2],
"clubs" => [0x02663],
"clubsuit" => [0x02663],
"colon" => [0x0003A],
"colone" => [0x02254],
"coloneq" => [0x02254],
"comma" => [0x0002C],
"commat" => [0x00040],
"comp" => [0x02201],
"compfn" => [0x02218],
"complement" => [0x02201],
"complexes" => [0x02102],
"cong" => [0x02245],
"congdot" => [0x02A6D],
"conint" => [0x0222E],
"copf" => [0x1D554],
"coprod" => [0x02210],
"copy" => [0x000A9],
"copysr" => [0x02117],
"crarr" => [0x021B5],
"cross" => [0x02717],
"cscr" => [0x1D4B8],
"csub" => [0x02ACF],
"csube" => [0x02AD1],
"csup" => [0x02AD0],
"csupe" => [0x02AD2],
"ctdot" => [0x022EF],
"cudarrl" => [0x02938],
"cudarrr" => [0x02935],
"cuepr" => [0x022DE],
"cuesc" => [0x022DF],
"cularr" => [0x021B6],
"cularrp" => [0x0293D],
"cup" => [0x0222A],
"cupbrcap" => [0x02A48],
"cupcap" => [0x02A46],
"cupcup" => [0x02A4A],
"cupdot" => [0x0228D],
"cupor" => [0x02A45],
"cups" => [0x0222A, 0x0FE00],
"curarr" => [0x021B7],
"curarrm" => [0x0293C],
"curlyeqprec" => [0x022DE],
"curlyeqsucc" => [0x022DF],
"curlyvee" => [0x022CE],
"curlywedge" => [0x022CF],
"curren" => [0x000A4],
"curvearrowleft" => [0x021B6],
"curvearrowright" => [0x021B7],
"cuvee" => [0x022CE],
"cuwed" => [0x022CF],
"cwconint" => [0x02232],
"cwint" => [0x02231],
"cylcty" => [0x0232D],
"dArr" => [0x021D3],
"dHar" => [0x02965],
"dagger" => [0x02020],
"daleth" => [0x02138],
"darr" => [0x02193],
"dash" => [0x02010],
"dashv" => [0x022A3],
"dbkarow" => [0x0290F],
"dblac" => [0x002DD],
"dcaron" => [0x0010F],
"dcy" => [0x00434],
"dd" => [0x02146],
"ddagger" => [0x02021],
"ddarr" => [0x021CA],
"ddotseq" => [0x02A77],
"deg" => [0x000B0],
"delta" => [0x003B4],
"demptyv" => [0x029B1],
"dfisht" => [0x0297F],
"dfr" => [0x1D521],
"dharl" => [0x021C3],
"dharr" => [0x021C2],
"diam" => [0x022C4],
"diamond" => [0x022C4],
"diamondsuit" => [0x02666],
"diams" => [0x02666],
"die" => [0x000A8],
"digamma" => [0x003DD],
"disin" => [0x022F2],
"div" => [0x000F7],
"divide" => [0x000F7],
"divideontimes" => [0x022C7],
"divonx" => [0x022C7],
"djcy" => [0x00452],
"dlcorn" => [0x0231E],
"dlcrop" => [0x0230D],
"dollar" => [0x00024],
"dopf" => [0x1D555],
"dot" => [0x002D9],
"doteq" => [0x02250],
"doteqdot" => [0x02251],
"dotminus" => [0x02238],
"dotplus" => [0x02214],
"dotsquare" => [0x022A1],
"doublebarwedge" => [0x02306],
"downarrow" => [0x02193],
"downdownarrows" => [0x021CA],
"downharpoonleft" => [0x021C3],
"downharpoonright" => [0x021C2],
"drbkarow" => [0x02910],
"drcorn" => [0x0231F],
"drcrop" => [0x0230C],
"dscr" => [0x1D4B9],
"dscy" => [0x00455],
"dsol" => [0x029F6],
"dstrok" => [0x00111],
"dtdot" => [0x022F1],
"dtri" => [0x025BF],
"dtrif" => [0x025BE],
"duarr" => [0x021F5],
"duhar" => [0x0296F],
"dwangle" => [0x029A6],
"dzcy" => [0x0045F],
"dzigrarr" => [0x027FF],
"eDDot" => [0x02A77],
"eDot" => [0x02251],
"eacute" => [0x000E9],
"easter" => [0x02A6E],
"ecaron" => [0x0011B],
"ecir" => [0x02256],
"ecirc" => [0x000EA],
"ecolon" => [0x02255],
"ecy" => [0x0044D],
"edot" => [0x00117],
"ee" => [0x02147],
"efDot" => [0x02252],
"efr" => [0x1D522],
"eg" => [0x02A9A],
"egrave" => [0x000E8],
"egs" => [0x02A96],
"egsdot" => [0x02A98],
"el" => [0x02A99],
"elinters" => [0x023E7],
"ell" => [0x02113],
"els" => [0x02A95],
"elsdot" => [0x02A97],
"emacr" => [0x00113],
"empty" => [0x02205],
"emptyset" => [0x02205],
"emptyv" => [0x02205],
"emsp" => [0x02003],
"emsp13" => [0x02004],
"emsp14" => [0x02005],
"eng" => [0x0014B],
"ensp" => [0x02002],
"eogon" => [0x00119],
"eopf" => [0x1D556],
"epar" => [0x022D5],
"eparsl" => [0x029E3],
"eplus" => [0x02A71],
"epsi" => [0x003B5],
"epsilon" => [0x003B5],
"epsiv" => [0x003F5],
"eqcirc" => [0x02256],
"eqcolon" => [0x02255],
"eqsim" => [0x02242],
"eqslantgtr" => [0x02A96],
"eqslantless" => [0x02A95],
"equals" => [0x0003D],
"equest" => [0x0225F],
"equiv" => [0x02261],
"equivDD" => [0x02A78],
"eqvparsl" => [0x029E5],
"erDot" => [0x02253],
"erarr" => [0x02971],
"escr" => [0x0212F],
"esdot" => [0x02250],
"esim" => [0x02242],
"eta" => [0x003B7],
"eth" => [0x000F0],
"euml" => [0x000EB],
"euro" => [0x020AC],
"excl" => [0x00021],
"exist" => [0x02203],
"expectation" => [0x02130],
"exponentiale" => [0x02147],
"fallingdotseq" => [0x02252],
"fcy" => [0x00444],
"female" => [0x02640],
"ffilig" => [0x0FB03],
"fflig" => [0x0FB00],
"ffllig" => [0x0FB04],
"ffr" => [0x1D523],
"filig" => [0x0FB01],
"fjlig" => [0x00066, 0x0006A],
"flat" => [0x0266D],
"fllig" => [0x0FB02],
"fltns" => [0x025B1],
"fnof" => [0x00192],
"fopf" => [0x1D557],
"forall" => [0x02200],
"fork" => [0x022D4],
"forkv" => [0x02AD9],
"fpartint" => [0x02A0D],
"frac12" => [0x000BD],
"frac13" => [0x02153],
"frac14" => [0x000BC],
"frac15" => [0x02155],
"frac16" => [0x02159],
"frac18" => [0x0215B],
"frac23" => [0x02154],
"frac25" => [0x02156],
"frac34" => [0x000BE],
"frac35" => [0x02157],
"frac38" => [0x0215C],
"frac45" => [0x02158],
"frac56" => [0x0215A],
"frac58" => [0x0215D],
"frac78" => [0x0215E],
"frasl" => [0x02044],
"frown" => [0x02322],
"fscr" => [0x1D4BB],
"gE" => [0x02267],
"gEl" => [0x02A8C],
"gacute" => [0x001F5],
"gamma" => [0x003B3],
"gammad" => [0x003DD],
"gap" => [0x02A86],
"gbreve" => [0x0011F],
"gcirc" => [0x0011D],
"gcy" => [0x00433],
"gdot" => [0x00121],
"ge" => [0x02265],
"gel" => [0x022DB],
"geq" => [0x02265],
"geqq" => [0x02267],
"geqslant" => [0x02A7E],
"ges" => [0x02A7E],
"gescc" => [0x02AA9],
"gesdot" => [0x02A80],
"gesdoto" => [0x02A82],
"gesdotol" => [0x02A84],
"gesl" => [0x022DB, 0x0FE00],
"gesles" => [0x02A94],
"gfr" => [0x1D524],
"gg" => [0x0226B],
"ggg" => [0x022D9],
"gimel" => [0x02137],
"gjcy" => [0x00453],
"gl" => [0x02277],
"glE" => [0x02A92],
"gla" => [0x02AA5],
"glj" => [0x02AA4],
"gnE" => [0x02269],
"gnap" => [0x02A8A],
"gnapprox" => [0x02A8A],
"gne" => [0x02A88],
"gneq" => [0x02A88],
"gneqq" => [0x02269],
"gnsim" => [0x022E7],
"gopf" => [0x1D558],
"grave" => [0x00060],
"gscr" => [0x0210A],
"gsim" => [0x02273],
"gsime" => [0x02A8E],
"gsiml" => [0x02A90],
"gt" => [0x0003E],
"gtcc" => [0x02AA7],
"gtcir" => [0x02A7A],
"gtdot" => [0x022D7],
"gtlPar" => [0x02995],
"gtquest" => [0x02A7C],
"gtrapprox" => [0x02A86],
"gtrarr" => [0x02978],
"gtrdot" => [0x022D7],
"gtreqless" => [0x022DB],
"gtreqqless" => [0x02A8C],
"gtrless" => [0x02277],
"gtrsim" => [0x02273],
"gvertneqq" => [0x02269, 0x0FE00],
"gvnE" => [0x02269, 0x0FE00],
"hArr" => [0x021D4],
"hairsp" => [0x0200A],
"half" => [0x000BD],
"hamilt" => [0x0210B],
"hardcy" => [0x0044A],
"harr" => [0x02194],
"harrcir" => [0x02948],
"harrw" => [0x021AD],
"hbar" => [0x0210F],
"hcirc" => [0x00125],
"hearts" => [0x02665],
"heartsuit" => [0x02665],
"hellip" => [0x02026],
"hercon" => [0x022B9],
"hfr" => [0x1D525],
"hksearow" => [0x02925],
"hkswarow" => [0x02926],
"hoarr" => [0x021FF],
"homtht" => [0x0223B],
"hookleftarrow" => [0x021A9],
"hookrightarrow" => [0x021AA],
"hopf" => [0x1D559],
"horbar" => [0x02015],
"hscr" => [0x1D4BD],
"hslash" => [0x0210F],
"hstrok" => [0x00127],
"hybull" => [0x02043],
"hyphen" => [0x02010],
"iacute" => [0x000ED],
"ic" => [0x02063],
"icirc" => [0x000EE],
"icy" => [0x00438],
"iecy" => [0x00435],
"iexcl" => [0x000A1],
"iff" => [0x021D4],
"ifr" => [0x1D526],
"igrave" => [0x000EC],
"ii" => [0x02148],
"iiiint" => [0x02A0C],
"iiint" => [0x0222D],
"iinfin" => [0x029DC],
"iiota" => [0x02129],
"ijlig" => [0x00133],
"imacr" => [0x0012B],
"image" => [0x02111],
"imagline" => [0x02110],
"imagpart" => [0x02111],
"imath" => [0x00131],
"imof" => [0x022B7],
"imped" => [0x001B5],
"in" => [0x02208],
"incare" => [0x02105],
"infin" => [0x0221E],
"infintie" => [0x029DD],
"inodot" => [0x00131],
"int" => [0x0222B],
"intcal" => [0x022BA],
"integers" => [0x02124],
"intercal" => [0x022BA],
"intlarhk" => [0x02A17],
"intprod" => [0x02A3C],
"iocy" => [0x00451],
"iogon" => [0x0012F],
"iopf" => [0x1D55A],
"iota" => [0x003B9],
"iprod" => [0x02A3C],
"iquest" => [0x000BF],
"iscr" => [0x1D4BE],
"isin" => [0x02208],
"isinE" => [0x022F9],
"isindot" => [0x022F5],
"isins" => [0x022F4],
"isinsv" => [0x022F3],
"isinv" => [0x02208],
"it" => [0x02062],
"itilde" => [0x00129],
"iukcy" => [0x00456],
"iuml" => [0x000EF],
"jcirc" => [0x00135],
"jcy" => [0x00439],
"jfr" => [0x1D527],
"jmath" => [0x00237],
"jopf" => [0x1D55B],
"jscr" => [0x1D4BF],
"jsercy" => [0x00458],
"jukcy" => [0x00454],
"kappa" => [0x003BA],
"kappav" => [0x003F0],
"kcedil" => [0x00137],
"kcy" => [0x0043A],
"kfr" => [0x1D528],
"kgreen" => [0x00138],
"khcy" => [0x00445],
"kjcy" => [0x0045C],
"kopf" => [0x1D55C],
"kscr" => [0x1D4C0],
"lAarr" => [0x021DA],
"lArr" => [0x021D0],
"lAtail" => [0x0291B],
"lBarr" => [0x0290E],
"lE" => [0x02266],
"lEg" => [0x02A8B],
"lHar" => [0x02962],
"lacute" => [0x0013A],
"laemptyv" => [0x029B4],
"lagran" => [0x02112],
"lambda" => [0x003BB],
"lang" => [0x027E8],
"langd" => [0x02991],
"langle" => [0x027E8],
"lap" => [0x02A85],
"laquo" => [0x000AB],
"larr" => [0x02190],
"larrb" => [0x021E4],
"larrbfs" => [0x0291F],
"larrfs" => [0x0291D],
"larrhk" => [0x021A9],
"larrlp" => [0x021AB],
"larrpl" => [0x02939],
"larrsim" => [0x02973],
"larrtl" => [0x021A2],
"lat" => [0x02AAB],
"latail" => [0x02919],
"late" => [0x02AAD],
"lates" => [0x02AAD, 0x0FE00],
"lbarr" => [0x0290C],
"lbbrk" => [0x02772],
"lbrace" => [0x0007B],
"lbrack" => [0x0005B],
"lbrke" => [0x0298B],
"lbrksld" => [0x0298F],
"lbrkslu" => [0x0298D],
"lcaron" => [0x0013E],
"lcedil" => [0x0013C],
"lceil" => [0x02308],
"lcub" => [0x0007B],
"lcy" => [0x0043B],
"ldca" => [0x02936],
"ldquo" => [0x0201C],
"ldquor" => [0x0201E],
"ldrdhar" => [0x02967],
"ldrushar" => [0x0294B],
"ldsh" => [0x021B2],
"le" => [0x02264],
"leftarrow" => [0x02190],
"leftarrowtail" => [0x021A2],
"leftharpoondown" => [0x021BD],
"leftharpoonup" => [0x021BC],
"leftleftarrows" => [0x021C7],
"leftrightarrow" => [0x02194],
"leftrightarrows" => [0x021C6],
"leftrightharpoons" => [0x021CB],
"leftrightsquigarrow" => [0x021AD],
"leftthreetimes" => [0x022CB],
"leg" => [0x022DA],
"leq" => [0x02264],
"leqq" => [0x02266],
"leqslant" => [0x02A7D],
"les" => [0x02A7D],
"lescc" => [0x02AA8],
"lesdot" => [0x02A7F],
"lesdoto" => [0x02A81],
"lesdotor" => [0x02A83],
"lesg" => [0x022DA, 0x0FE00],
"lesges" => [0x02A93],
"lessapprox" => [0x02A85],
"lessdot" => [0x022D6],
"lesseqgtr" => [0x022DA],
"lesseqqgtr" => [0x02A8B],
"lessgtr" => [0x02276],
"lesssim" => [0x02272],
"lfisht" => [0x0297C],
"lfloor" => [0x0230A],
"lfr" => [0x1D529],
"lg" => [0x02276],
"lgE" => [0x02A91],
"lhard" => [0x021BD],
"lharu" => [0x021BC],
"lharul" => [0x0296A],
"lhblk" => [0x02584],
"ljcy" => [0x00459],
"ll" => [0x0226A],
"llarr" => [0x021C7],
"llcorner" => [0x0231E],
"llhard" => [0x0296B],
"lltri" => [0x025FA],
"lmidot" => [0x00140],
"lmoust" => [0x023B0],
"lmoustache" => [0x023B0],
"lnE" => [0x02268],
"lnap" => [0x02A89],
"lnapprox" => [0x02A89],
"lne" => [0x02A87],
"lneq" => [0x02A87],
"lneqq" => [0x02268],
"lnsim" => [0x022E6],
"loang" => [0x027EC],
"loarr" => [0x021FD],
"lobrk" => [0x027E6],
"longleftarrow" => [0x027F5],
"longleftrightarrow" => [0x027F7],
"longmapsto" => [0x027FC],
"longrightarrow" => [0x027F6],
"looparrowleft" => [0x021AB],
"looparrowright" => [0x021AC],
"lopar" => [0x02985],
"lopf" => [0x1D55D],
"loplus" => [0x02A2D],
"lotimes" => [0x02A34],
"lowast" => [0x02217],
"lowbar" => [0x0005F],
"loz" => [0x025CA],
"lozenge" => [0x025CA],
"lozf" => [0x029EB],
"lpar" => [0x00028],
"lparlt" => [0x02993],
"lrarr" => [0x021C6],
"lrcorner" => [0x0231F],
"lrhar" => [0x021CB],
"lrhard" => [0x0296D],
"lrm" => [0x0200E],
"lrtri" => [0x022BF],
"lsaquo" => [0x02039],
"lscr" => [0x1D4C1],
"lsh" => [0x021B0],
"lsim" => [0x02272],
"lsime" => [0x02A8D],
"lsimg" => [0x02A8F],
"lsqb" => [0x0005B],
"lsquo" => [0x02018],
"lsquor" => [0x0201A],
"lstrok" => [0x00142],
"lt" => [0x0003C],
"ltcc" => [0x02AA6],
"ltcir" => [0x02A79],
"ltdot" => [0x022D6],
"lthree" => [0x022CB],
"ltimes" => [0x022C9],
"ltlarr" => [0x02976],
"ltquest" => [0x02A7B],
"ltrPar" => [0x02996],
"ltri" => [0x025C3],
"ltrie" => [0x022B4],
"ltrif" => [0x025C2],
"lurdshar" => [0x0294A],
"luruhar" => [0x02966],
"lvertneqq" => [0x02268, 0x0FE00],
"lvnE" => [0x02268, 0x0FE00],
"mDDot" => [0x0223A],
"macr" => [0x000AF],
"male" => [0x02642],
"malt" => [0x02720],
"maltese" => [0x02720],
"map" => [0x021A6],
"mapsto" => [0x021A6],
"mapstodown" => [0x021A7],
"mapstoleft" => [0x021A4],
"mapstoup" => [0x021A5],
"marker" => [0x025AE],
"mcomma" => [0x02A29],
"mcy" => [0x0043C],
"mdash" => [0x02014],
"measuredangle" => [0x02221],
"mfr" => [0x1D52A],
"mho" => [0x02127],
"micro" => [0x000B5],
"mid" => [0x02223],
"midast" => [0x0002A],
"midcir" => [0x02AF0],
"middot" => [0x000B7],
"minus" => [0x02212],
"minusb" => [0x0229F],
"minusd" => [0x02238],
"minusdu" => [0x02A2A],
"mlcp" => [0x02ADB],
"mldr" => [0x02026],
"mnplus" => [0x02213],
"models" => [0x022A7],
"mopf" => [0x1D55E],
"mp" => [0x02213],
"mscr" => [0x1D4C2],
"mstpos" => [0x0223E],
"mu" => [0x003BC],
"multimap" => [0x022B8],
"mumap" => [0x022B8],
"nGg" => [0x022D9, 0x00338],
"nGt" => [0x0226B, 0x020D2],
"nGtv" => [0x0226B, 0x00338],
"nLeftarrow" => [0x021CD],
"nLeftrightarrow" => [0x021CE],
"nLl" => [0x022D8, 0x00338],
"nLt" => [0x0226A, 0x020D2],
"nLtv" => [0x0226A, 0x00338],
"nRightarrow" => [0x021CF],
"nVDash" => [0x022AF],
"nVdash" => [0x022AE],
"nabla" => [0x02207],
"nacute" => [0x00144],
"nang" => [0x02220, 0x020D2],
"nap" => [0x02249],
"napE" => [0x02A70, 0x00338],
"napid" => [0x0224B, 0x00338],
"napos" => [0x00149],
"napprox" => [0x02249],
"natur" => [0x0266E],
"natural" => [0x0266E],
"naturals" => [0x02115],
"nbsp" => [0x000A0],
"nbump" => [0x0224E, 0x00338],
"nbumpe" => [0x0224F, 0x00338],
"ncap" => [0x02A43],
"ncaron" => [0x00148],
"ncedil" => [0x00146],
"ncong" => [0x02247],
"ncongdot" => [0x02A6D, 0x00338],
"ncup" => [0x02A42],
"ncy" => [0x0043D],
"ndash" => [0x02013],
"ne" => [0x02260],
"neArr" => [0x021D7],
"nearhk" => [0x02924],
"nearr" => [0x02197],
"nearrow" => [0x02197],
"nedot" => [0x02250, 0x00338],
"nequiv" => [0x02262],
"nesear" => [0x02928],
"nesim" => [0x02242, 0x00338],
"nexist" => [0x02204],
"nexists" => [0x02204],
"nfr" => [0x1D52B],
"ngE" => [0x02267, 0x00338],
"nge" => [0x02271],
"ngeq" => [0x02271],
"ngeqq" => [0x02267, 0x00338],
"ngeqslant" => [0x02A7E, 0x00338],
"nges" => [0x02A7E, 0x00338],
"ngsim" => [0x02275],
"ngt" => [0x0226F],
"ngtr" => [0x0226F],
"nhArr" => [0x021CE],
"nharr" => [0x021AE],
"nhpar" => [0x02AF2],
"ni" => [0x0220B],
"nis" => [0x022FC],
"nisd" => [0x022FA],
"niv" => [0x0220B],
"njcy" => [0x0045A],
"nlArr" => [0x021CD],
"nlE" => [0x02266, 0x00338],
"nlarr" => [0x0219A],
"nldr" => [0x02025],
"nle" => [0x02270],
"nleftarrow" => [0x0219A],
"nleftrightarrow" => [0x021AE],
"nleq" => [0x02270],
"nleqq" => [0x02266, 0x00338],
"nleqslant" => [0x02A7D, 0x00338],
"nles" => [0x02A7D, 0x00338],
"nless" => [0x0226E],
"nlsim" => [0x02274],
"nlt" => [0x0226E],
"nltri" => [0x022EA],
"nltrie" => [0x022EC],
"nmid" => [0x02224],
"nopf" => [0x1D55F],
"not" => [0x000AC],
"notin" => [0x02209],
"notinE" => [0x022F9, 0x00338],
"notindot" => [0x022F5, 0x00338],
"notinva" => [0x02209],
"notinvb" => [0x022F7],
"notinvc" => [0x022F6],
"notni" => [0x0220C],
"notniva" => [0x0220C],
"notnivb" => [0x022FE],
"notnivc" => [0x022FD],
"npar" => [0x02226],
"nparallel" => [0x02226],
"nparsl" => [0x02AFD, 0x020E5],
"npart" => [0x02202, 0x00338],
"npolint" => [0x02A14],
"npr" => [0x02280],
"nprcue" => [0x022E0],
"npre" => [0x02AAF, 0x00338],
"nprec" => [0x02280],
"npreceq" => [0x02AAF, 0x00338],
"nrArr" => [0x021CF],
"nrarr" => [0x0219B],
"nrarrc" => [0x02933, 0x00338],
"nrarrw" => [0x0219D, 0x00338],
"nrightarrow" => [0x0219B],
"nrtri" => [0x022EB],
"nrtrie" => [0x022ED],
"nsc" => [0x02281],
"nsccue" => [0x022E1],
"nsce" => [0x02AB0, 0x00338],
"nscr" => [0x1D4C3],
"nshortmid" => [0x02224],
"nshortparallel" => [0x02226],
"nsim" => [0x02241],
"nsime" => [0x02244],
"nsimeq" => [0x02244],
"nsmid" => [0x02224],
"nspar" => [0x02226],
"nsqsube" => [0x022E2],
"nsqsupe" => [0x022E3],
"nsub" => [0x02284],
"nsubE" => [0x02AC5, 0x00338],
"nsube" => [0x02288],
"nsubset" => [0x02282, 0x020D2],
"nsubseteq" => [0x02288],
"nsubseteqq" => [0x02AC5, 0x00338],
"nsucc" => [0x02281],
"nsucceq" => [0x02AB0, 0x00338],
"nsup" => [0x02285],
"nsupE" => [0x02AC6, 0x00338],
"nsupe" => [0x02289],
"nsupset" => [0x02283, 0x020D2],
"nsupseteq" => [0x02289],
"nsupseteqq" => [0x02AC6, 0x00338],
"ntgl" => [0x02279],
"ntilde" => [0x000F1],
"ntlg" => [0x02278],
"ntriangleleft" => [0x022EA],
"ntrianglelefteq" => [0x022EC],
"ntriangleright" => [0x022EB],
"ntrianglerighteq" => [0x022ED],
"nu" => [0x003BD],
"num" => [0x00023],
"numero" => [0x02116],
"numsp" => [0x02007],
"nvDash" => [0x022AD],
"nvHarr" => [0x02904],
"nvap" => [0x0224D, 0x020D2],
"nvdash" => [0x022AC],
"nvge" => [0x02265, 0x020D2],
"nvgt" => [0x0003E, 0x020D2],
"nvinfin" => [0x029DE],
"nvlArr" => [0x02902],
"nvle" => [0x02264, 0x020D2],
"nvlt" => [0x0003C, 0x020D2],
"nvltrie" => [0x022B4, 0x020D2],
"nvrArr" => [0x02903],
"nvrtrie" => [0x022B5, 0x020D2],
"nvsim" => [0x0223C, 0x020D2],
"nwArr" => [0x021D6],
"nwarhk" => [0x02923],
"nwarr" => [0x02196],
"nwarrow" => [0x02196],
"nwnear" => [0x02927],
"oS" => [0x024C8],
"oacute" => [0x000F3],
"oast" => [0x0229B],
"ocir" => [0x0229A],
"ocirc" => [0x000F4],
"ocy" => [0x0043E],
"odash" => [0x0229D],
"odblac" => [0x00151],
"odiv" => [0x02A38],
"odot" => [0x02299],
"odsold" => [0x029BC],
"oelig" => [0x00153],
"ofcir" => [0x029BF],
"ofr" => [0x1D52C],
"ogon" => [0x002DB],
"ograve" => [0x000F2],
"ogt" => [0x029C1],
"ohbar" => [0x029B5],
"ohm" => [0x003A9],
"oint" => [0x0222E],
"olarr" => [0x021BA],
"olcir" => [0x029BE],
"olcross" => [0x029BB],
"oline" => [0x0203E],
"olt" => [0x029C0],
"omacr" => [0x0014D],
"omega" => [0x003C9],
"omicron" => [0x003BF],
"omid" => [0x029B6],
"ominus" => [0x02296],
"oopf" => [0x1D560],
"opar" => [0x029B7],
"operp" => [0x029B9],
"oplus" => [0x02295],
"or" => [0x02228],
"orarr" => [0x021BB],
"ord" => [0x02A5D],
"order" => [0x02134],
"orderof" => [0x02134],
"ordf" => [0x000AA],
"ordm" => [0x000BA],
"origof" => [0x022B6],
"oror" => [0x02A56],
"orslope" => [0x02A57],
"orv" => [0x02A5B],
"oscr" => [0x02134],
"oslash" => [0x000F8],
"osol" => [0x02298],
"otilde" => [0x000F5],
"otimes" => [0x02297],
"otimesas" => [0x02A36],
"ouml" => [0x000F6],
"ovbar" => [0x0233D],
"par" => [0x02225],
"para" => [0x000B6],
"parallel" => [0x02225],
"parsim" => [0x02AF3],
"parsl" => [0x02AFD],
"part" => [0x02202],
"pcy" => [0x0043F],
"percnt" => [0x00025],
"period" => [0x0002E],
"permil" => [0x02030],
"perp" => [0x022A5],
"pertenk" => [0x02031],
"pfr" => [0x1D52D],
"phi" => [0x003C6],
"phiv" => [0x003D5],
"phmmat" => [0x02133],
"phone" => [0x0260E],
"pi" => [0x003C0],
"pitchfork" => [0x022D4],
"piv" => [0x003D6],
"planck" => [0x0210F],
"planckh" => [0x0210E],
"plankv" => [0x0210F],
"plus" => [0x0002B],
"plusacir" => [0x02A23],
"plusb" => [0x0229E],
"pluscir" => [0x02A22],
"plusdo" => [0x02214],
"plusdu" => [0x02A25],
"pluse" => [0x02A72],
"plusmn" => [0x000B1],
"plussim" => [0x02A26],
"plustwo" => [0x02A27],
"pm" => [0x000B1],
"pointint" => [0x02A15],
"popf" => [0x1D561],
"pound" => [0x000A3],
"pr" => [0x0227A],
"prE" => [0x02AB3],
"prap" => [0x02AB7],
"prcue" => [0x0227C],
"pre" => [0x02AAF],
"prec" => [0x0227A],
"precapprox" => [0x02AB7],
"preccurlyeq" => [0x0227C],
"preceq" => [0x02AAF],
"precnapprox" => [0x02AB9],
"precneqq" => [0x02AB5],
"precnsim" => [0x022E8],
"precsim" => [0x0227E],
"prime" => [0x02032],
"primes" => [0x02119],
"prnE" => [0x02AB5],
"prnap" => [0x02AB9],
"prnsim" => [0x022E8],
"prod" => [0x0220F],
"profalar" => [0x0232E],
"profline" => [0x02312],
"profsurf" => [0x02313],
"prop" => [0x0221D],
"propto" => [0x0221D],
"prsim" => [0x0227E],
"prurel" => [0x022B0],
"pscr" => [0x1D4C5],
"psi" => [0x003C8],
"puncsp" => [0x02008],
"qfr" => [0x1D52E],
"qint" => [0x02A0C],
"qopf" => [0x1D562],
"qprime" => [0x02057],
"qscr" => [0x1D4C6],
"quaternions" => [0x0210D],
"quatint" => [0x02A16],
"quest" => [0x0003F],
"questeq" => [0x0225F],
"quot" => [0x00022],
"rAarr" => [0x021DB],
"rArr" => [0x021D2],
"rAtail" => [0x0291C],
"rBarr" => [0x0290F],
"rHar" => [0x02964],
"race" => [0x0223D, 0x00331],
"racute" => [0x00155],
"radic" => [0x0221A],
"raemptyv" => [0x029B3],
"rang" => [0x027E9],
"rangd" => [0x02992],
"range" => [0x029A5],
"rangle" => [0x027E9],
"raquo" => [0x000BB],
"rarr" => [0x02192],
"rarrap" => [0x02975],
"rarrb" => [0x021E5],
"rarrbfs" => [0x02920],
"rarrc" => [0x02933],
"rarrfs" => [0x0291E],
"rarrhk" => [0x021AA],
"rarrlp" => [0x021AC],
"rarrpl" => [0x02945],
"rarrsim" => [0x02974],
"rarrtl" => [0x021A3],
"rarrw" => [0x0219D],
"ratail" => [0x0291A],
"ratio" => [0x02236],
"rationals" => [0x0211A],
"rbarr" => [0x0290D],
"rbbrk" => [0x02773],
"rbrace" => [0x0007D],
"rbrack" => [0x0005D],
"rbrke" => [0x0298C],
"rbrksld" => [0x0298E],
"rbrkslu" => [0x02990],
"rcaron" => [0x00159],
"rcedil" => [0x00157],
"rceil" => [0x02309],
"rcub" => [0x0007D],
"rcy" => [0x00440],
"rdca" => [0x02937],
"rdldhar" => [0x02969],
"rdquo" => [0x0201D],
"rdquor" => [0x0201D],
"rdsh" => [0x021B3],
"real" => [0x0211C],
"realine" => [0x0211B],
"realpart" => [0x0211C],
"reals" => [0x0211D],
"rect" => [0x025AD],
"reg" => [0x000AE],
"rfisht" => [0x0297D],
"rfloor" => [0x0230B],
"rfr" => [0x1D52F],
"rhard" => [0x021C1],
"rharu" => [0x021C0],
"rharul" => [0x0296C],
"rho" => [0x003C1],
"rhov" => [0x003F1],
"rightarrow" => [0x02192],
"rightarrowtail" => [0x021A3],
"rightharpoondown" => [0x021C1],
"rightharpoonup" => [0x021C0],
"rightleftarrows" => [0x021C4],
"rightleftharpoons" => [0x021CC],
"rightrightarrows" => [0x021C9],
"rightsquigarrow" => [0x0219D],
"rightthreetimes" => [0x022CC],
"ring" => [0x002DA],
"risingdotseq" => [0x02253],
"rlarr" => [0x021C4],
"rlhar" => [0x021CC],
"rlm" => [0x0200F],
"rmoust" => [0x023B1],
"rmoustache" => [0x023B1],
"rnmid" => [0x02AEE],
"roang" => [0x027ED],
"roarr" => [0x021FE],
"robrk" => [0x027E7],
"ropar" => [0x02986],
"ropf" => [0x1D563],
"roplus" => [0x02A2E],
"rotimes" => [0x02A35],
"rpar" => [0x00029],
"rpargt" => [0x02994],
"rppolint" => [0x02A12],
"rrarr" => [0x021C9],
"rsaquo" => [0x0203A],
"rscr" => [0x1D4C7],
"rsh" => [0x021B1],
"rsqb" => [0x0005D],
"rsquo" => [0x02019],
"rsquor" => [0x02019],
"rthree" => [0x022CC],
"rtimes" => [0x022CA],
"rtri" => [0x025B9],
"rtrie" => [0x022B5],
"rtrif" => [0x025B8],
"rtriltri" => [0x029CE],
"ruluhar" => [0x02968],
"rx" => [0x0211E],
"sacute" => [0x0015B],
"sbquo" => [0x0201A],
"sc" => [0x0227B],
"scE" => [0x02AB4],
"scap" => [0x02AB8],
"scaron" => [0x00161],
"sccue" => [0x0227D],
"sce" => [0x02AB0],
"scedil" => [0x0015F],
"scirc" => [0x0015D],
"scnE" => [0x02AB6],
"scnap" => [0x02ABA],
"scnsim" => [0x022E9],
"scpolint" => [0x02A13],
"scsim" => [0x0227F],
"scy" => [0x00441],
"sdot" => [0x022C5],
"sdotb" => [0x022A1],
"sdote" => [0x02A66],
"seArr" => [0x021D8],
"searhk" => [0x02925],
"searr" => [0x02198],
"searrow" => [0x02198],
"sect" => [0x000A7],
"semi" => [0x0003B],
"seswar" => [0x02929],
"setminus" => [0x02216],
"setmn" => [0x02216],
"sext" => [0x02736],
"sfr" => [0x1D530],
"sfrown" => [0x02322],
"sharp" => [0x0266F],
"shchcy" => [0x00449],
"shcy" => [0x00448],
"shortmid" => [0x02223],
"shortparallel" => [0x02225],
"shy" => [0x000AD],
"sigma" => [0x003C3],
"sigmaf" => [0x003C2],
"sigmav" => [0x003C2],
"sim" => [0x0223C],
"simdot" => [0x02A6A],
"sime" => [0x02243],
"simeq" => [0x02243],
"simg" => [0x02A9E],
"simgE" => [0x02AA0],
"siml" => [0x02A9D],
"simlE" => [0x02A9F],
"simne" => [0x02246],
"simplus" => [0x02A24],
"simrarr" => [0x02972],
"slarr" => [0x02190],
"smallsetminus" => [0x02216],
"smashp" => [0x02A33],
"smeparsl" => [0x029E4],
"smid" => [0x02223],
"smile" => [0x02323],
"smt" => [0x02AAA],
"smte" => [0x02AAC],
"smtes" => [0x02AAC, 0x0FE00],
"softcy" => [0x0044C],
"sol" => [0x0002F],
"solb" => [0x029C4],
"solbar" => [0x0233F],
"sopf" => [0x1D564],
"spades" => [0x02660],
"spadesuit" => [0x02660],
"spar" => [0x02225],
"sqcap" => [0x02293],
"sqcaps" => [0x02293, 0x0FE00],
"sqcup" => [0x02294],
"sqcups" => [0x02294, 0x0FE00],
"sqsub" => [0x0228F],
"sqsube" => [0x02291],
"sqsubset" => [0x0228F],
"sqsubseteq" => [0x02291],
"sqsup" => [0x02290],
"sqsupe" => [0x02292],
"sqsupset" => [0x02290],
"sqsupseteq" => [0x02292],
"squ" => [0x025A1],
"square" => [0x025A1],
"squarf" => [0x025AA],
"squf" => [0x025AA],
"srarr" => [0x02192],
"sscr" => [0x1D4C8],
"ssetmn" => [0x02216],
"ssmile" => [0x02323],
"sstarf" => [0x022C6],
"star" => [0x02606],
"starf" => [0x02605],
"straightepsilon" => [0x003F5],
"straightphi" => [0x003D5],
"strns" => [0x000AF],
"sub" => [0x02282],
"subE" => [0x02AC5],
"subdot" => [0x02ABD],
"sube" => [0x02286],
"subedot" => [0x02AC3],
"submult" => [0x02AC1],
"subnE" => [0x02ACB],
"subne" => [0x0228A],
"subplus" => [0x02ABF],
"subrarr" => [0x02979],
"subset" => [0x02282],
"subseteq" => [0x02286],
"subseteqq" => [0x02AC5],
"subsetneq" => [0x0228A],
"subsetneqq" => [0x02ACB],
"subsim" => [0x02AC7],
"subsub" => [0x02AD5],
"subsup" => [0x02AD3],
"succ" => [0x0227B],
"succapprox" => [0x02AB8],
"succcurlyeq" => [0x0227D],
"succeq" => [0x02AB0],
"succnapprox" => [0x02ABA],
"succneqq" => [0x02AB6],
"succnsim" => [0x022E9],
"succsim" => [0x0227F],
"sum" => [0x02211],
"sung" => [0x0266A],
"sup" => [0x02283],
"sup1" => [0x000B9],
"sup2" => [0x000B2],
"sup3" => [0x000B3],
"supE" => [0x02AC6],
"supdot" => [0x02ABE],
"supdsub" => [0x02AD8],
"supe" => [0x02287],
"supedot" => [0x02AC4],
"suphsol" => [0x027C9],
"suphsub" => [0x02AD7],
"suplarr" => [0x0297B],
"supmult" => [0x02AC2],
"supnE" => [0x02ACC],
"supne" => [0x0228B],
"supplus" => [0x02AC0],
"supset" => [0x02283],
"supseteq" => [0x02287],
"supseteqq" => [0x02AC6],
"supsetneq" => [0x0228B],
"supsetneqq" => [0x02ACC],
"supsim" => [0x02AC8],
"supsub" => [0x02AD4],
"supsup" => [0x02AD6],
"swArr" => [0x021D9],
"swarhk" => [0x02926],
"swarr" => [0x02199],
"swarrow" => [0x02199],
"swnwar" => [0x0292A],
"szlig" => [0x000DF],
"target" => [0x02316],
"tau" => [0x003C4],
"tbrk" => [0x023B4],
"tcaron" => [0x00165],
"tcedil" => [0x00163],
"tcy" => [0x00442],
"tdot" => [0x020DB],
"telrec" => [0x02315],
"tfr" => [0x1D531],
"there4" => [0x02234],
"therefore" => [0x02234],
"theta" => [0x003B8],
"thetasym" => [0x003D1],
"thetav" => [0x003D1],
"thickapprox" => [0x02248],
"thicksim" => [0x0223C],
"thinsp" => [0x02009],
"thkap" => [0x02248],
"thksim" => [0x0223C],
"thorn" => [0x000FE],
"tilde" => [0x002DC],
"times" => [0x000D7],
"timesb" => [0x022A0],
"timesbar" => [0x02A31],
"timesd" => [0x02A30],
"tint" => [0x0222D],
"toea" => [0x02928],
"top" => [0x022A4],
"topbot" => [0x02336],
"topcir" => [0x02AF1],
"topf" => [0x1D565],
"topfork" => [0x02ADA],
"tosa" => [0x02929],
"tprime" => [0x02034],
"trade" => [0x02122],
"triangle" => [0x025B5],
"triangledown" => [0x025BF],
"triangleleft" => [0x025C3],
"trianglelefteq" => [0x022B4],
"triangleq" => [0x0225C],
"triangleright" => [0x025B9],
"trianglerighteq" => [0x022B5],
"tridot" => [0x025EC],
"trie" => [0x0225C],
"triminus" => [0x02A3A],
"triplus" => [0x02A39],
"trisb" => [0x029CD],
"tritime" => [0x02A3B],
"trpezium" => [0x023E2],
"tscr" => [0x1D4C9],
"tscy" => [0x00446],
"tshcy" => [0x0045B],
"tstrok" => [0x00167],
"twixt" => [0x0226C],
"twoheadleftarrow" => [0x0219E],
"twoheadrightarrow" => [0x021A0],
"uArr" => [0x021D1],
"uHar" => [0x02963],
"uacute" => [0x000FA],
"uarr" => [0x02191],
"ubrcy" => [0x0045E],
"ubreve" => [0x0016D],
"ucirc" => [0x000FB],
"ucy" => [0x00443],
"udarr" => [0x021C5],
"udblac" => [0x00171],
"udhar" => [0x0296E],
"ufisht" => [0x0297E],
"ufr" => [0x1D532],
"ugrave" => [0x000F9],
"uharl" => [0x021BF],
"uharr" => [0x021BE],
"uhblk" => [0x02580],
"ulcorn" => [0x0231C],
"ulcorner" => [0x0231C],
"ulcrop" => [0x0230F],
"ultri" => [0x025F8],
"umacr" => [0x0016B],
"uml" => [0x000A8],
"uogon" => [0x00173],
"uopf" => [0x1D566],
"uparrow" => [0x02191],
"updownarrow" => [0x02195],
"upharpoonleft" => [0x021BF],
"upharpoonright" => [0x021BE],
"uplus" => [0x0228E],
"upsi" => [0x003C5],
"upsih" => [0x003D2],
"upsilon" => [0x003C5],
"upuparrows" => [0x021C8],
"urcorn" => [0x0231D],
"urcorner" => [0x0231D],
"urcrop" => [0x0230E],
"uring" => [0x0016F],
"urtri" => [0x025F9],
"uscr" => [0x1D4CA],
"utdot" => [0x022F0],
"utilde" => [0x00169],
"utri" => [0x025B5],
"utrif" => [0x025B4],
"uuarr" => [0x021C8],
"uuml" => [0x000FC],
"uwangle" => [0x029A7],
"vArr" => [0x021D5],
"vBar" => [0x02AE8],
"vBarv" => [0x02AE9],
"vDash" => [0x022A8],
"vangrt" => [0x0299C],
"varepsilon" => [0x003F5],
"varkappa" => [0x003F0],
"varnothing" => [0x02205],
"varphi" => [0x003D5],
"varpi" => [0x003D6],
"varpropto" => [0x0221D],
"varr" => [0x02195],
"varrho" => [0x003F1],
"varsigma" => [0x003C2],
"varsubsetneq" => [0x0228A, 0x0FE00],
"varsubsetneqq" => [0x02ACB, 0x0FE00],
"varsupsetneq" => [0x0228B, 0x0FE00],
"varsupsetneqq" => [0x02ACC, 0x0FE00],
"vartheta" => [0x003D1],
"vartriangleleft" => [0x022B2],
"vartriangleright" => [0x022B3],
"vcy" => [0x00432],
"vdash" => [0x022A2],
"vee" => [0x02228],
"veebar" => [0x022BB],
"veeeq" => [0x0225A],
"vellip" => [0x022EE],
"verbar" => [0x0007C],
"vert" => [0x0007C],
"vfr" => [0x1D533],
"vltri" => [0x022B2],
"vnsub" => [0x02282, 0x020D2],
"vnsup" => [0x02283, 0x020D2],
"vopf" => [0x1D567],
"vprop" => [0x0221D],
"vrtri" => [0x022B3],
"vscr" => [0x1D4CB],
"vsubnE" => [0x02ACB, 0x0FE00],
"vsubne" => [0x0228A, 0x0FE00],
"vsupnE" => [0x02ACC, 0x0FE00],
"vsupne" => [0x0228B, 0x0FE00],
"vzigzag" => [0x0299A],
"wcirc" => [0x00175],
"wedbar" => [0x02A5F],
"wedge" => [0x02227],
"wedgeq" => [0x02259],
"weierp" => [0x02118],
"wfr" => [0x1D534],
"wopf" => [0x1D568],
"wp" => [0x02118],
"wr" => [0x02240],
"wreath" => [0x02240],
"wscr" => [0x1D4CC],
"xcap" => [0x022C2],
"xcirc" => [0x025EF],
"xcup" => [0x022C3],
"xdtri" => [0x025BD],
"xfr" => [0x1D535],
"xhArr" => [0x027FA],
"xharr" => [0x027F7],
"xi" => [0x003BE],
"xlArr" => [0x027F8],
"xlarr" => [0x027F5],
"xmap" => [0x027FC],
"xnis" => [0x022FB],
"xodot" => [0x02A00],
"xopf" => [0x1D569],
"xoplus" => [0x02A01],
"xotime" => [0x02A02],
"xrArr" => [0x027F9],
"xrarr" => [0x027F6],
"xscr" => [0x1D4CD],
"xsqcup" => [0x02A06],
"xuplus" => [0x02A04],
"xutri" => [0x025B3],
"xvee" => [0x022C1],
"xwedge" => [0x022C0],
"yacute" => [0x000FD],
"yacy" => [0x0044F],
"ycirc" => [0x00177],
"ycy" => [0x0044B],
"yen" => [0x000A5],
"yfr" => [0x1D536],
"yicy" => [0x00457],
"yopf" => [0x1D56A],
"yscr" => [0x1D4CE],
"yucy" => [0x0044E],
"yuml" => [0x000FF],
"zacute" => [0x0017A],
"zcaron" => [0x0017E],
"zcy" => [0x00437],
"zdot" => [0x0017C],
"zeetrf" => [0x02128],
"zeta" => [0x003B6],
"zfr" => [0x1D537],
"zhcy" => [0x00436],
"zigrarr" => [0x021DD],
"zopf" => [0x1D56B],
"zscr" => [0x1D4CF],
"zwj" => [0x0200D],
"zwnj" => [0x0200C],
}
extend.rb 0000644 00000005032 14763537411 0006373 0 ustar 00 ##
# A Module extension in a class with \#extend
class RDoc::Extend < RDoc::CodeObject
##
# Name of extension module
attr_accessor :name
##
# Creates a new Extend for +name+ with +comment+
def initialize(name, comment)
super()
@name = name
self.comment = comment
@module = nil # cache for module if found
end
##
# Extends are sorted by name
def <=> other
return unless self.class === other
name <=> other.name
end
def == other # :nodoc:
self.class === other and @name == other.name
end
alias eql? ==
##
# Full name based on #module
def full_name
m = self.module
RDoc::ClassModule === m ? m.full_name : @name
end
def hash # :nodoc:
[@name, self.module].hash
end
def inspect # :nodoc:
"#<%s:0x%x %s.extend %s>" % [
self.class,
object_id,
parent_name, @name,
]
end
##
# Attempts to locate the extend module object. Returns the name if not
# known.
#
# The scoping rules of Ruby to resolve the name of an extension module are:
# - first look into the children of the current context;
# - if not found, look into the children of extension modules,
# in reverse extend order;
# - if still not found, go up the hierarchy of names.
#
# This method has O(n!) behavior when the module calling
# extend is referencing nonexistent modules. Avoid calling #module until
# after all the files are parsed. This behavior is due to ruby's constant
# lookup behavior.
def module
return @module if @module
# search the current context
return @name unless parent
full_name = parent.child_name(@name)
@module = @store.modules_hash[full_name]
return @module if @module
return @name if @name =~ /^::/
# search the includes before this one, in reverse order
searched = parent.extends.take_while { |i| i != self }.reverse
searched.each do |i|
ext = i.module
next if String === ext
full_name = ext.child_name(@name)
@module = @store.modules_hash[full_name]
return @module if @module
end
# go up the hierarchy of names
up = parent.parent
while up
full_name = up.child_name(@name)
@module = @store.modules_hash[full_name]
return @module if @module
up = up.parent
end
@name
end
##
# Sets the store for this class or module and its contained code objects.
def store= store
super
@file = @store.add_file @file.full_name if @file
end
def to_s # :nodoc:
"extend #@name in: #{parent}"
end
end
stats.rb 0000644 00000023443 14763537411 0006250 0 ustar 00 ##
# RDoc statistics collector which prints a summary and report of a project's
# documentation totals.
class RDoc::Stats
##
# Output level for the coverage report
attr_reader :coverage_level
##
# Count of files parsed during parsing
attr_reader :files_so_far
##
# Total number of files found
attr_reader :num_files
##
# Creates a new Stats that will have +num_files+. +verbosity+ defaults to 1
# which will create an RDoc::Stats::Normal outputter.
def initialize store, num_files, verbosity = 1
@num_files = num_files
@store = store
@coverage_level = 0
@doc_items = nil
@files_so_far = 0
@fully_documented = false
@num_params = 0
@percent_doc = nil
@start = Time.now
@undoc_params = 0
@display = case verbosity
when 0 then Quiet.new num_files
when 1 then Normal.new num_files
else Verbose.new num_files
end
end
##
# Records the parsing of an alias +as+.
def add_alias as
@display.print_alias as
end
##
# Records the parsing of an attribute +attribute+
def add_attribute attribute
@display.print_attribute attribute
end
##
# Records the parsing of a class +klass+
def add_class klass
@display.print_class klass
end
##
# Records the parsing of +constant+
def add_constant constant
@display.print_constant constant
end
##
# Records the parsing of +file+
def add_file(file)
@files_so_far += 1
@display.print_file @files_so_far, file
end
##
# Records the parsing of +method+
def add_method(method)
@display.print_method method
end
##
# Records the parsing of a module +mod+
def add_module(mod)
@display.print_module mod
end
##
# Call this to mark the beginning of parsing for display purposes
def begin_adding
@display.begin_adding
end
##
# Calculates documentation totals and percentages for classes, modules,
# constants, attributes and methods.
def calculate
return if @doc_items
ucm = @store.unique_classes_and_modules
classes = @store.unique_classes.reject { |cm| cm.full_name == 'Object' }
constants = []
ucm.each { |cm| constants.concat cm.constants }
methods = []
ucm.each { |cm| methods.concat cm.method_list }
attributes = []
ucm.each { |cm| attributes.concat cm.attributes }
@num_attributes, @undoc_attributes = doc_stats attributes
@num_classes, @undoc_classes = doc_stats classes
@num_constants, @undoc_constants = doc_stats constants
@num_methods, @undoc_methods = doc_stats methods
@num_modules, @undoc_modules = doc_stats @store.unique_modules
@num_items =
@num_attributes +
@num_classes +
@num_constants +
@num_methods +
@num_modules +
@num_params
@undoc_items =
@undoc_attributes +
@undoc_classes +
@undoc_constants +
@undoc_methods +
@undoc_modules +
@undoc_params
@doc_items = @num_items - @undoc_items
end
##
# Sets coverage report level. Accepted values are:
#
# false or nil:: No report
# 0:: Classes, modules, constants, attributes, methods
# 1:: Level 0 + method parameters
def coverage_level= level
level = -1 unless level
@coverage_level = level
end
##
# Returns the length and number of undocumented items in +collection+.
def doc_stats collection
visible = collection.select { |item| item.display? }
[visible.length, visible.count { |item| not item.documented? }]
end
##
# Call this to mark the end of parsing for display purposes
def done_adding
@display.done_adding
end
##
# The documentation status of this project. +true+ when 100%, +false+ when
# less than 100% and +nil+ when unknown.
#
# Set by calling #calculate
def fully_documented?
@fully_documented
end
##
# A report that says you did a great job!
def great_job
report = []
report << '100% documentation!'
report << nil
report << 'Great Job!'
report.join "\n"
end
##
# Calculates the percentage of items documented.
def percent_doc
return @percent_doc if @percent_doc
@fully_documented = (@num_items - @doc_items) == 0
@percent_doc = @doc_items.to_f / @num_items * 100 if @num_items.nonzero?
@percent_doc ||= 0
@percent_doc
end
##
# Returns a report on which items are not documented
def report
if @coverage_level > 0 then
extend RDoc::Text
end
report = []
if @coverage_level.zero? then
calculate
return great_job if @num_items == @doc_items
end
ucm = @store.unique_classes_and_modules
ucm.sort.each do |cm|
report << report_class_module(cm) {
[
report_constants(cm),
report_attributes(cm),
report_methods(cm),
].compact
}
end
if @coverage_level > 0 then
calculate
return great_job if @num_items == @doc_items
end
report.unshift nil
report.unshift 'The following items are not documented:'
report.join "\n"
end
##
# Returns a report on undocumented attributes in ClassModule +cm+
def report_attributes cm
return if cm.attributes.empty?
report = []
cm.each_attribute do |attr|
next if attr.documented?
line = attr.line ? ":#{attr.line}" : nil
report << " #{attr.definition} :#{attr.name} # in file #{attr.file.full_name}#{line}"
end
report
end
##
# Returns a report on undocumented items in ClassModule +cm+
def report_class_module cm
return if cm.fully_documented? and @coverage_level.zero?
return unless cm.display?
report = []
if cm.in_files.empty? then
report << "# #{cm.definition} is referenced but empty."
report << "#"
report << "# It probably came from another project. I'm sorry I'm holding it against you."
report << nil
return report
elsif cm.documented? then
documented = true
report << "#{cm.definition} # is documented"
else
report << '# in files:'
cm.in_files.each do |file|
report << "# #{file.full_name}"
end
report << nil
report << "#{cm.definition}"
end
body = yield.flatten # HACK remove #flatten
return if body.empty? and documented
report << nil << body unless body.empty?
report << 'end'
report << nil
report
end
##
# Returns a report on undocumented constants in ClassModule +cm+
def report_constants cm
return if cm.constants.empty?
report = []
cm.each_constant do |constant|
# TODO constant aliases are listed in the summary but not reported
# figure out what to do here
next if constant.documented? || constant.is_alias_for
line = constant.line ? ":#{constant.line}" : line
report << " # in file #{constant.file.full_name}#{line}"
report << " #{constant.name} = nil"
end
report
end
##
# Returns a report on undocumented methods in ClassModule +cm+
def report_methods cm
return if cm.method_list.empty?
report = []
cm.each_method do |method|
next if method.documented? and @coverage_level.zero?
if @coverage_level > 0 then
params, undoc = undoc_params method
@num_params += params
unless undoc.empty? then
@undoc_params += undoc.length
undoc = undoc.map do |param| "+#{param}+" end
param_report = " # #{undoc.join ', '} is not documented"
end
end
next if method.documented? and not param_report
line = method.line ? ":#{method.line}" : nil
scope = method.singleton ? 'self.' : nil
report << " # in file #{method.file.full_name}#{line}"
report << param_report if param_report
report << " def #{scope}#{method.name}#{method.params}; end"
report << nil
end
report
end
##
# Returns a summary of the collected statistics.
def summary
calculate
num_width = [@num_files, @num_items].max.to_s.length
undoc_width = [
@undoc_attributes,
@undoc_classes,
@undoc_constants,
@undoc_items,
@undoc_methods,
@undoc_modules,
@undoc_params,
].max.to_s.length
report = []
report << 'Files: %*d' % [num_width, @num_files]
report << nil
report << 'Classes: %*d (%*d undocumented)' % [
num_width, @num_classes, undoc_width, @undoc_classes]
report << 'Modules: %*d (%*d undocumented)' % [
num_width, @num_modules, undoc_width, @undoc_modules]
report << 'Constants: %*d (%*d undocumented)' % [
num_width, @num_constants, undoc_width, @undoc_constants]
report << 'Attributes: %*d (%*d undocumented)' % [
num_width, @num_attributes, undoc_width, @undoc_attributes]
report << 'Methods: %*d (%*d undocumented)' % [
num_width, @num_methods, undoc_width, @undoc_methods]
report << 'Parameters: %*d (%*d undocumented)' % [
num_width, @num_params, undoc_width, @undoc_params] if
@coverage_level > 0
report << nil
report << 'Total: %*d (%*d undocumented)' % [
num_width, @num_items, undoc_width, @undoc_items]
report << '%6.2f%% documented' % percent_doc
report << nil
report << 'Elapsed: %0.1fs' % (Time.now - @start)
report.join "\n"
end
##
# Determines which parameters in +method+ were not documented. Returns a
# total parameter count and an Array of undocumented methods.
def undoc_params method
@formatter ||= RDoc::Markup::ToTtOnly.new
params = method.param_list
return 0, [] if params.empty?
document = parse method.comment
tts = document.accept @formatter
undoc = params - tts
[params.length, undoc]
end
autoload :Quiet, 'rdoc/stats/quiet'
autoload :Normal, 'rdoc/stats/normal'
autoload :Verbose, 'rdoc/stats/verbose'
end
erb_partial.rb 0000644 00000000562 14763537411 0007373 0 ustar 00 ##
# Allows an ERB template to be rendered in the context (binding) of an
# existing ERB template evaluation.
class RDoc::ERBPartial < ERB
##
# Overrides +compiler+ startup to set the +eoutvar+ to an empty string only
# if it isn't already set.
def set_eoutvar compiler, eoutvar = '_erbout'
super
compiler.pre_cmd = ["#{eoutvar} ||= ''"]
end
end
include.rb 0000644 00000005165 14763537411 0006536 0 ustar 00 ##
# A Module include in a class with \#include
class RDoc::Include < RDoc::CodeObject
##
# Name of included module
attr_accessor :name
##
# Creates a new Include for +name+ with +comment+
def initialize(name, comment)
super()
@name = name
self.comment = comment
@module = nil # cache for module if found
end
##
# Includes are sorted by name
def <=> other
return unless self.class === other
name <=> other.name
end
def == other # :nodoc:
self.class === other and @name == other.name
end
alias eql? ==
##
# Full name based on #module
def full_name
m = self.module
RDoc::ClassModule === m ? m.full_name : @name
end
def hash # :nodoc:
[@name, self.module].hash
end
def inspect # :nodoc:
"#<%s:0x%x %s.include %s>" % [
self.class,
object_id,
parent_name, @name,
]
end
##
# Attempts to locate the included module object. Returns the name if not
# known.
#
# The scoping rules of Ruby to resolve the name of an included module are:
# - first look into the children of the current context;
# - if not found, look into the children of included modules,
# in reverse inclusion order;
# - if still not found, go up the hierarchy of names.
#
# This method has O(n!) behavior when the module calling
# include is referencing nonexistent modules. Avoid calling #module until
# after all the files are parsed. This behavior is due to ruby's constant
# lookup behavior.
#
# As of the beginning of October, 2011, no gem includes nonexistent modules.
def module
return @module if @module
# search the current context
return @name unless parent
full_name = parent.child_name(@name)
@module = @store.modules_hash[full_name]
return @module if @module
return @name if @name =~ /^::/
# search the includes before this one, in reverse order
searched = parent.includes.take_while { |i| i != self }.reverse
searched.each do |i|
inc = i.module
next if String === inc
full_name = inc.child_name(@name)
@module = @store.modules_hash[full_name]
return @module if @module
end
# go up the hierarchy of names
up = parent.parent
while up
full_name = up.child_name(@name)
@module = @store.modules_hash[full_name]
return @module if @module
up = up.parent
end
@name
end
##
# Sets the store for this class or module and its contained code objects.
def store= store
super
@file = @store.add_file @file.full_name if @file
end
def to_s # :nodoc:
"include #@name in: #{parent}"
end
end
usr/share/gems/gems/rdoc-4.0.0/bin/rdoc 0000755 00000001652 14763544702 0013376 0 ustar 00 #!/usr/bin/env ruby
#
# RDoc: Documentation tool for source code
# (see lib/rdoc/rdoc.rb for more information)
#
# Copyright (c) 2003 Dave Thomas
# Released under the same terms as Ruby
begin
gem 'rdoc'
rescue NameError => e # --disable-gems
raise unless e.name == :gem
rescue Gem::LoadError
end
require 'rdoc/rdoc'
begin
r = RDoc::RDoc.new
r.document ARGV
rescue Errno::ENOSPC
$stderr.puts 'Ran out of space creating documentation'
$stderr.puts
$stderr.puts 'Please free up some space and try again'
rescue SystemExit
raise
rescue Exception => e
if $DEBUG_RDOC then
$stderr.puts e.message
$stderr.puts "#{e.backtrace.join "\n\t"}"
$stderr.puts
elsif Interrupt === e then
$stderr.puts
$stderr.puts 'Interrupted'
else
$stderr.puts "uh-oh! RDoc had a problem:"
$stderr.puts e.message
$stderr.puts
$stderr.puts "run with --debug for full backtrace"
end
exit 1
end