123456789_123456789_123456789_123456789_123456789_

Class: RDoc::Markdown

Relationships & Source Files
Namespace Children
Classes:
Exceptions:
Inherits: Object
Defined in: lib/rdoc/markdown.rb

Overview

Markdown as described by the [markdown syntax].

To choose Markdown as your only default format see RDoc::Options@Saved+Options for instructions on setting up a .doc_options file to store your project default.

Usage

Here is a brief example of using this parse to read a markdown file by hand.

data = File.read("README.md")
formatter = RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
html = RDoc::Markdown.parse(data).accept(formatter)

# do something with html

Extensions

The following markdown extensions are supported by the parser, but not all are used in RDoc output by default.

RDoc

The RDoc Markdown parser has the following built-in behaviors that cannot be disabled.

Underscores embedded in words are never interpreted as emphasis. (While the

markdown dingus][dingus

emphasizes in-word underscores, neither the

Markdown syntax nor MarkdownTest mention this behavior.)

For HTML output, RDoc always auto-links bare URLs.

Break on Newline

The break_on_newline extension converts all newlines into hard line breaks as in [Github Flavored Markdown]. This extension is disabled by default.

CSS

The #css extension enables CSS blocks to be included in the output, but they are not used for any built-in RDoc output format. This extension is disabled by default.

Example:

<style type="text/css">
h1 { font-size: 3em }
</style>

Definition Lists

The definition_lists extension allows definition lists using the [PHP Markdown Extra syntax], but only one label and definition are supported at this time. This extension is enabled by default.

Example:

“‘ cat : A small furry mammal that seems to sleep a lot

ant : A little insect that is known to enjoy picnics

“‘

Produces:

cat : A small furry mammal that seems to sleep a lot

ant : A little insect that is known to enjoy picnics

Strike

Example:

“‘ This is ~~striked~~. “`

Produces:

This is ~~striked~~.

Github

The #github extension enables a partial set of [Github Flavored Markdown] [GFM]. This extension is enabled by default.

Supported github extensions include:

Fenced code blocks

Use ‘ “` ` around a block of code instead of indenting it four spaces.

Syntax highlighting

Use ‘ “` ruby ` as the start of a code fence to add syntax highlighting. (Currently only ruby syntax is supported).

HTML

Enables raw HTML to be included in the output. This extension is enabled by default.

Example:

<table>
...
</table>

Notes

The #notes extension enables footnote support. This extension is enabled by default.

Example:

Here is some text[^1] including an inline footnote ^[for short footnotes]

#...

[^1]: With the footnote text down at the bottom

Produces:

Here is some text including an inline footnote ^[for short footnotes]

[^1]: With the footnote text down at the bottom

Limitations

  • Link titles are not used

  • Footnotes are collapsed into a single paragraph

Author

This markdown parser is a port to kpeg from [peg-markdown] by John MacFarlane.

It is used under the MIT license:

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.

The port to kpeg was performed by Eric Hodel and Evan Phoenix

[dingus]: daringfireball.net/projects/markdown/dingus [GFM]: github.github.com/gfm/ [pegmarkdown]: github.com/jgm/peg-markdown [PHPE]: michelf.ca/projects/php-markdown/extra/#def-list [syntax]: daringfireball.net/projects/markdown/syntax

Constant Summary

  • DEFAULT_EXTENSIONS =

    Extensions enabled by default

    # File 'lib/rdoc/markdown.rb', line 589
    [
      :definition_lists,
      :github,
      :html,
      :notes,
      :strike,
    ]
  • EXTENSIONS =

    Supported extensions

    # File 'lib/rdoc/markdown.rb', line 584
    []
  • HTML_ENTITIES =

    HTML entity name map for Markdown

    # File 'lib/rdoc/markdown/entities.rb', line 5
    {
      "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],
    }
  • Rules = Internal use only
    # File 'lib/rdoc/markdown.rb', line 16534
    {}

Extensions

  • #_Alphanumeric Internal use only

    Alphanumeric = %literals.Alphanumeric.

  • #_AlphanumericAscii Internal use only

    AlphanumericAscii = %literals.AlphanumericAscii.

  • #_AtxHeading Internal use only

    AtxHeading = AtxStart:s @Sp AtxInline+:a (@Sp /#*/ @Sp)? @Newline { RDoc::Markup::Heading.new(s, a.join) }

  • #_AtxInline Internal use only

    AtxInline = !@Newline !(@Sp /#*/ @Sp @Newline) Inline.

  • #_AtxStart Internal use only

    AtxStart = < /#1,6/ > { text.length }

  • #_AutoLink Internal use only

    AutoLink = (AutoLinkUrl | AutoLinkEmail).

  • #_AutoLinkEmail Internal use only

    AutoLinkEmail = “<” “mailto:”? < /[w+./!%~$-]+/i “@” (!@Newline !“>” .)+ > “>” { “mailto:#text” }

  • #_AutoLinkUrl Internal use only

    AutoLinkUrl = “<” < /[A-Za-z]+/ “://” (!@Newline !“>” .)+ > “>” { text }

  • #_BOM Internal use only

    BOM = %literals.BOM.

  • #_BlankLine Internal use only

    BlankLine = @Sp @Newline { “n” }

  • #_Block Internal use only

    Block = @BlankLine* (BlockQuote | Verbatim | CodeFence | Table | Note | Reference | HorizontalRule | Heading | OrderedList | BulletList | DefinitionList | HtmlBlock | StyleBlock | Para | Plain).

  • #_BlockQuote Internal use only

    BlockQuote = BlockQuoteRaw:a { Markup::BlockQuote.new(*a) }

  • #_BlockQuoteRaw Internal use only

    BlockQuoteRaw = @StartList:a (“>” “ ”? Line:l { a << l } (!“>” !@BlankLine Line:c { a << c })* (@BlankLine:n { a << n })*)+ { inner_parse a.join }

  • #_Bullet Internal use only

    Bullet = !HorizontalRule @NonindentSpace /[+*-]/ @Spacechar+.

  • #_BulletList Internal use only

    BulletList = &Bullet (ListTight | ListLoose):a { Markup::List.new(:BULLET, *a) }

  • #_CharEntity Internal use only

    CharEntity = “&” < /[A-Za-z0-9]+/ > “;” { if entity = HTML_ENTITIES then entity.pack ‘U*’ else “&#text;” end }

  • #_Code Internal use only

    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}” }

  • #_CodeFence Internal use only

    CodeFence = &{ github? } Ticks3 (@Sp StrChunk:format)? Spnl < ((!“‘” Nonspacechar)+ | !Ticks3 /`+/ | Spacechar | @Newline)+ > Ticks3 @Sp @Newline* { verbatim = Markup::Verbatim.new text verbatim.format = format.intern if format.instance_of?(String) verbatim }

  • #_DecEntity Internal use only

    DecEntity = “&#” < /[0-9]+/ > “;” { [text.to_i].pack ‘U’ }

  • #_DefinitionList Internal use only

    DefinitionList = &{ definition_lists? } DefinitionListItem+:list { Markup::List.new :NOTE, *list.flatten }

  • #_DefinitionListDefinition Internal use only

    DefinitionListDefinition = @NonindentSpace “:” @Space Inlines:a @BlankLine+ { paragraph a }

  • #_DefinitionListItem Internal use only

    DefinitionListItem = DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| Markup::ListItem.new nil, defn } unless list_items.empty? list_items }

  • #_DefinitionListLabel Internal use only

    DefinitionListLabel = Inline:label @Sp @Newline { label }

  • #_Digit Internal use only

    Digit = [0-9].

  • #_Doc Internal use only

    Doc = BOM? Block*:a { Markup::Document.new(*a.compact) }

  • #_Emph Internal use only

    Emph = (EmphStar | EmphUl).

  • #_EmphStar Internal use only

    EmphStar = “*” !@Whitespace @StartList:a (!“*” Inline:b { a << b } | StrongStar:b { a << b })+ “*” { emphasis a.join }

  • #_EmphUl Internal use only

    EmphUl = “_” !@Whitespace @StartList:a (!“_” Inline:b { a << b } | StrongUl:b { a << b })+ “_” { emphasis a.join }

  • #_EmptyTitle Internal use only

    EmptyTitle = “”.

  • #_Endline Internal use only

    Endline = (@LineBreak | @TerminalEndline | @NormalEndline).

  • #_Entity Internal use only

    Entity = (HexEntity | DecEntity | CharEntity):a { a }

  • #_Enumerator Internal use only

    Enumerator = @NonindentSpace [0-9]+ “.” @Spacechar+.

  • #_Eof Internal use only

    Eof = !.

  • #_EscapedChar Internal use only

    EscapedChar = “\” !@Newline < /[:\‘|*_{}[]()#+.!><-]/ > { text }

  • #_ExplicitLink Internal use only

    ExplicitLink = Label:l “(” @Sp Source:s Spnl Title @Sp “)” { “#{l}[#s]” }

  • #_ExtendedSpecialChar Internal use only

    ExtendedSpecialChar = &{ notes? } “^”.

  • #_Heading Internal use only

    Heading = (SetextHeading | AtxHeading).

  • #_HexEntity Internal use only

    HexEntity = /&#x/i < /[0-9a-fA-F]+/ > “;” { [text.to_i(16)].pack ‘U’ }

  • #_HorizontalRule Internal use only

    HorizontalRule = @NonindentSpace (“*” @Sp “*” @Sp “*” (@Sp “*”)* | “-” @Sp “-” @Sp “-” (@Sp “-”)* | “_” @Sp “_” @Sp “_” (@Sp “_”)*) @Sp @Newline @BlankLine+ { RDoc::Markup::Rule.new 1 }

  • #_HtmlAnchor Internal use only

    HtmlAnchor = HtmlOpenAnchor (HtmlAnchor | !HtmlCloseAnchor .)* HtmlCloseAnchor.

  • #_HtmlAttribute Internal use only

    HtmlAttribute = (AlphanumericAscii | “-”)+ Spnl (“=” Spnl (Quoted | (!“>” Nonspacechar)+))? Spnl.

  • #_HtmlBlock Internal use only

    HtmlBlock = < (HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) > @BlankLine+ { if html? then Markup::Raw.new text end }

  • #_HtmlBlockAddress Internal use only

    HtmlBlockAddress = HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress.

  • #_HtmlBlockBlockquote Internal use only

    HtmlBlockBlockquote = HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote.

  • #_HtmlBlockCenter Internal use only

    HtmlBlockCenter = HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter.

  • #_HtmlBlockCloseAddress Internal use only

    HtmlBlockCloseAddress = “<” Spnl “/” (“address” | “ADDRESS”) Spnl “>”.

  • #_HtmlBlockCloseBlockquote Internal use only

    HtmlBlockCloseBlockquote = “<” Spnl “/” (“blockquote” | “BLOCKQUOTE”) Spnl “>”.

  • #_HtmlBlockCloseCenter Internal use only

    HtmlBlockCloseCenter = “<” Spnl “/” (“center” | “CENTER”) Spnl “>”.

  • #_HtmlBlockCloseDd Internal use only

    HtmlBlockCloseDd = “<” Spnl “/” (“dd” | “DD”) Spnl “>”.

  • #_HtmlBlockCloseDir Internal use only

    HtmlBlockCloseDir = “<” Spnl “/” (“dir” | “DIR”) Spnl “>”.

  • #_HtmlBlockCloseDiv Internal use only

    HtmlBlockCloseDiv = “<” Spnl “/” (“div” | “DIV”) Spnl “>”.

  • #_HtmlBlockCloseDl Internal use only

    HtmlBlockCloseDl = “<” Spnl “/” (“dl” | “DL”) Spnl “>”.

  • #_HtmlBlockCloseDt Internal use only

    HtmlBlockCloseDt = “<” Spnl “/” (“dt” | “DT”) Spnl “>”.

  • #_HtmlBlockCloseFieldset Internal use only

    HtmlBlockCloseFieldset = “<” Spnl “/” (“fieldset” | “FIELDSET”) Spnl “>”.

  • #_HtmlBlockCloseForm Internal use only

    HtmlBlockCloseForm = “<” Spnl “/” (“form” | “FORM”) Spnl “>”.

  • #_HtmlBlockCloseFrameset Internal use only

    HtmlBlockCloseFrameset = “<” Spnl “/” (“frameset” | “FRAMESET”) Spnl “>”.

  • #_HtmlBlockCloseH1 Internal use only

    HtmlBlockCloseH1 = “<” Spnl “/” (“h1” | “H1”) Spnl “>”.

  • #_HtmlBlockCloseH2 Internal use only

    HtmlBlockCloseH2 = “<” Spnl “/” (“h2” | “H2”) Spnl “>”.

  • #_HtmlBlockCloseH3 Internal use only

    HtmlBlockCloseH3 = “<” Spnl “/” (“h3” | “H3”) Spnl “>”.

  • #_HtmlBlockCloseH4 Internal use only

    HtmlBlockCloseH4 = “<” Spnl “/” (“h4” | “H4”) Spnl “>”.

  • #_HtmlBlockCloseH5 Internal use only

    HtmlBlockCloseH5 = “<” Spnl “/” (“h5” | “H5”) Spnl “>”.

  • #_HtmlBlockCloseH6 Internal use only

    HtmlBlockCloseH6 = “<” Spnl “/” (“h6” | “H6”) Spnl “>”.

  • #_HtmlBlockCloseHead Internal use only

    HtmlBlockCloseHead = “<” Spnl “/” (“head” | “HEAD”) Spnl “>”.

  • #_HtmlBlockCloseLi Internal use only

    HtmlBlockCloseLi = “<” Spnl “/” (“li” | “LI”) Spnl “>”.

  • #_HtmlBlockCloseMenu Internal use only

    HtmlBlockCloseMenu = “<” Spnl “/” (“menu” | “MENU”) Spnl “>”.

  • #_HtmlBlockCloseNoframes Internal use only

    HtmlBlockCloseNoframes = “<” Spnl “/” (“noframes” | “NOFRAMES”) Spnl “>”.

  • #_HtmlBlockCloseNoscript Internal use only

    HtmlBlockCloseNoscript = “<” Spnl “/” (“noscript” | “NOSCRIPT”) Spnl “>”.

  • #_HtmlBlockCloseOl Internal use only

    HtmlBlockCloseOl = “<” Spnl “/” (“ol” | “OL”) Spnl “>”.

  • #_HtmlBlockCloseP Internal use only

    HtmlBlockCloseP = “<” Spnl “/” (“p” | “P”) Spnl “>”.

  • #_HtmlBlockClosePre Internal use only

    HtmlBlockClosePre = “<” Spnl “/” (“pre” | “PRE”) Spnl “>”.

  • #_HtmlBlockCloseScript Internal use only

    HtmlBlockCloseScript = “<” Spnl “/” (“script” | “SCRIPT”) Spnl “>”.

  • #_HtmlBlockCloseTable Internal use only

    HtmlBlockCloseTable = “<” Spnl “/” (“table” | “TABLE”) Spnl “>”.

  • #_HtmlBlockCloseTbody Internal use only

    HtmlBlockCloseTbody = “<” Spnl “/” (“tbody” | “TBODY”) Spnl “>”.

  • #_HtmlBlockCloseTd Internal use only

    HtmlBlockCloseTd = “<” Spnl “/” (“td” | “TD”) Spnl “>”.

  • #_HtmlBlockCloseTfoot Internal use only

    HtmlBlockCloseTfoot = “<” Spnl “/” (“tfoot” | “TFOOT”) Spnl “>”.

  • #_HtmlBlockCloseTh Internal use only

    HtmlBlockCloseTh = “<” Spnl “/” (“th” | “TH”) Spnl “>”.

  • #_HtmlBlockCloseThead Internal use only

    HtmlBlockCloseThead = “<” Spnl “/” (“thead” | “THEAD”) Spnl “>”.

  • #_HtmlBlockCloseTr Internal use only

    HtmlBlockCloseTr = “<” Spnl “/” (“tr” | “TR”) Spnl “>”.

  • #_HtmlBlockCloseUl Internal use only

    HtmlBlockCloseUl = “<” Spnl “/” (“ul” | “UL”) Spnl “>”.

  • #_HtmlBlockDd Internal use only

    HtmlBlockDd = HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd.

  • #_HtmlBlockDir Internal use only

    HtmlBlockDir = HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir.

  • #_HtmlBlockDiv Internal use only

    HtmlBlockDiv = HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv.

  • #_HtmlBlockDl Internal use only

    HtmlBlockDl = HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl.

  • #_HtmlBlockDt Internal use only

    HtmlBlockDt = HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt.

  • #_HtmlBlockFieldset Internal use only

    HtmlBlockFieldset = HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset.

  • #_HtmlBlockForm Internal use only

    HtmlBlockForm = HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm.

  • #_HtmlBlockFrameset Internal use only

    HtmlBlockFrameset = HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset.

  • #_HtmlBlockH1 Internal use only

    HtmlBlockH1 = HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1.

  • #_HtmlBlockH2 Internal use only

    HtmlBlockH2 = HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2.

  • #_HtmlBlockH3 Internal use only

    HtmlBlockH3 = HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3.

  • #_HtmlBlockH4 Internal use only

    HtmlBlockH4 = HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4.

  • #_HtmlBlockH5 Internal use only

    HtmlBlockH5 = HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5.

  • #_HtmlBlockH6 Internal use only

    HtmlBlockH6 = HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6.

  • #_HtmlBlockHead Internal use only

    HtmlBlockHead = HtmlBlockOpenHead (!HtmlBlockCloseHead .)* HtmlBlockCloseHead.

  • #_HtmlBlockInTags Internal use only

    HtmlBlockInTags = (HtmlAnchor | 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 | HtmlBlockHead).

  • #_HtmlBlockLi Internal use only

    HtmlBlockLi = HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi.

  • #_HtmlBlockMenu Internal use only

    HtmlBlockMenu = HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu.

  • #_HtmlBlockNoframes Internal use only

    HtmlBlockNoframes = HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes.

  • #_HtmlBlockNoscript Internal use only

    HtmlBlockNoscript = HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript.

  • #_HtmlBlockOl Internal use only

    HtmlBlockOl = HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl.

  • #_HtmlBlockOpenAddress Internal use only

    HtmlBlockOpenAddress = “<” Spnl (“address” | “ADDRESS”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenBlockquote Internal use only

    HtmlBlockOpenBlockquote = “<” Spnl (“blockquote” | “BLOCKQUOTE”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenCenter Internal use only

    HtmlBlockOpenCenter = “<” Spnl (“center” | “CENTER”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenDd Internal use only

    HtmlBlockOpenDd = “<” Spnl (“dd” | “DD”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenDir Internal use only

    HtmlBlockOpenDir = “<” Spnl (“dir” | “DIR”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenDiv Internal use only

    HtmlBlockOpenDiv = “<” Spnl (“div” | “DIV”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenDl Internal use only

    HtmlBlockOpenDl = “<” Spnl (“dl” | “DL”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenDt Internal use only

    HtmlBlockOpenDt = “<” Spnl (“dt” | “DT”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenFieldset Internal use only

    HtmlBlockOpenFieldset = “<” Spnl (“fieldset” | “FIELDSET”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenForm Internal use only

    HtmlBlockOpenForm = “<” Spnl (“form” | “FORM”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenFrameset Internal use only

    HtmlBlockOpenFrameset = “<” Spnl (“frameset” | “FRAMESET”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenH1 Internal use only

    HtmlBlockOpenH1 = “<” Spnl (“h1” | “H1”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenH2 Internal use only

    HtmlBlockOpenH2 = “<” Spnl (“h2” | “H2”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenH3 Internal use only

    HtmlBlockOpenH3 = “<” Spnl (“h3” | “H3”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenH4 Internal use only

    HtmlBlockOpenH4 = “<” Spnl (“h4” | “H4”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenH5 Internal use only

    HtmlBlockOpenH5 = “<” Spnl (“h5” | “H5”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenH6 Internal use only

    HtmlBlockOpenH6 = “<” Spnl (“h6” | “H6”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenHead Internal use only

    HtmlBlockOpenHead = “<” Spnl (“head” | “HEAD”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenLi Internal use only

    HtmlBlockOpenLi = “<” Spnl (“li” | “LI”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenMenu Internal use only

    HtmlBlockOpenMenu = “<” Spnl (“menu” | “MENU”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenNoframes Internal use only

    HtmlBlockOpenNoframes = “<” Spnl (“noframes” | “NOFRAMES”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenNoscript Internal use only

    HtmlBlockOpenNoscript = “<” Spnl (“noscript” | “NOSCRIPT”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenOl Internal use only

    HtmlBlockOpenOl = “<” Spnl (“ol” | “OL”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenP Internal use only

    HtmlBlockOpenP = “<” Spnl (“p” | “P”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenPre Internal use only

    HtmlBlockOpenPre = “<” Spnl (“pre” | “PRE”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenScript Internal use only

    HtmlBlockOpenScript = “<” Spnl (“script” | “SCRIPT”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenTable Internal use only

    HtmlBlockOpenTable = “<” Spnl (“table” | “TABLE”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenTbody Internal use only

    HtmlBlockOpenTbody = “<” Spnl (“tbody” | “TBODY”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenTd Internal use only

    HtmlBlockOpenTd = “<” Spnl (“td” | “TD”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenTfoot Internal use only

    HtmlBlockOpenTfoot = “<” Spnl (“tfoot” | “TFOOT”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenTh Internal use only

    HtmlBlockOpenTh = “<” Spnl (“th” | “TH”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenThead Internal use only

    HtmlBlockOpenThead = “<” Spnl (“thead” | “THEAD”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenTr Internal use only

    HtmlBlockOpenTr = “<” Spnl (“tr” | “TR”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockOpenUl Internal use only

    HtmlBlockOpenUl = “<” Spnl (“ul” | “UL”) Spnl HtmlAttribute* “>”.

  • #_HtmlBlockP Internal use only

    HtmlBlockP = HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP.

  • #_HtmlBlockPre Internal use only

    HtmlBlockPre = HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre.

  • #_HtmlBlockScript Internal use only

    HtmlBlockScript = HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript.

  • #_HtmlBlockSelfClosing Internal use only

    HtmlBlockSelfClosing = “<” Spnl HtmlBlockType Spnl HtmlAttribute* “/” Spnl “>”.

  • #_HtmlBlockTable Internal use only

    HtmlBlockTable = HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable.

  • #_HtmlBlockTbody Internal use only

    HtmlBlockTbody = HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody.

  • #_HtmlBlockTd Internal use only

    HtmlBlockTd = HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd.

  • #_HtmlBlockTfoot Internal use only

    HtmlBlockTfoot = HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot.

  • #_HtmlBlockTh Internal use only

    HtmlBlockTh = HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh.

  • #_HtmlBlockThead Internal use only

    HtmlBlockThead = HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead.

  • #_HtmlBlockTr Internal use only

    HtmlBlockTr = HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr.

  • #_HtmlBlockType Internal use only

    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”).

  • #_HtmlBlockUl Internal use only

    HtmlBlockUl = HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl.

  • #_HtmlCloseAnchor Internal use only

    HtmlCloseAnchor = “<” Spnl “/” (“a” | “A”) Spnl “>”.

  • #_HtmlComment Internal use only

    HtmlComment = “<!–” (!“–>” .)* “–>”.

  • #_HtmlOpenAnchor Internal use only

    HtmlOpenAnchor = “<” Spnl (“a” | “A”) Spnl HtmlAttribute* “>”.

  • #_HtmlTag Internal use only

    HtmlTag = “<” Spnl “/”? AlphanumericAscii+ Spnl HtmlAttribute* “/”? Spnl “>”.

  • #_HtmlUnclosed Internal use only

    HtmlUnclosed = “<” Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl “>”.

  • #_HtmlUnclosedType Internal use only

    HtmlUnclosedType = (“HR” | “hr”).

  • #_Image Internal use only

    Image = “!” (ExplicitLink | ReferenceLink):a { “#_InStyleTags Internal use only

    InStyleTags = StyleOpen (!StyleClose .)* StyleClose.

  • #_Indent Internal use only

    Indent = /t| /.

  • #_IndentedLine Internal use only

    IndentedLine = Indent Line.

  • #_Inline Internal use only

    Inline = (Str | @Endline | UlOrStarLine | @Space | Strong | Emph | Strike | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol).

  • #_InlineNote Internal use only

    InlineNote = &{ notes? } “^[” @StartList:a (!“]” Inline:l { a << l })+ “]” { ref = [:inline, @note_order.length] @footnotes = paragraph a note_for ref }

  • #_Inlines Internal use only

    Inlines = (!@Endline Inline:i { i } | @Endline:c !(&{ github? } Ticks3 /[^‘n]*$/) &Inline { c })+:chunks @Endline? { chunks }

  • #_Label Internal use only

    Label = “[” (!“^” &{ notes? } | &.

  • #_Line Internal use only

    Line = @RawLine:a { a }

  • #_LineBreak Internal use only

    LineBreak = “ ” @NormalEndline { Markup::HardBreak.new }

  • #_Link Internal use only

    Link = (ExplicitLink | ReferenceLink | AutoLink).

  • #_ListBlock Internal use only

    ListBlock = !@BlankLine Line:a ListBlockLine*:c { [a, *c] }

  • #_ListBlockLine Internal use only

    ListBlockLine = !@BlankLine !(Indent? (Bullet | Enumerator)) !HorizontalRule OptionallyIndentedLine.

  • #_ListContinuationBlock Internal use only

    ListContinuationBlock = @StartList:a @BlankLine* { a << “n” } (Indent ListBlock:b { a.concat b })+ { a }

  • #_ListItem Internal use only

    ListItem = (Bullet | Enumerator) @StartList:a ListBlock:b { a << b } (ListContinuationBlock:c { a.push(*c) })* { list_item_from a }

  • #_ListItemTight Internal use only

    ListItemTight = (Bullet | Enumerator) ListBlock:a (!@BlankLine ListContinuationBlock:b { a.push(*b) })* !ListContinuationBlock { list_item_from a }

  • #_ListLoose Internal use only

    ListLoose = @StartList:a (ListItem:b @BlankLine* { a << b })+ { a }

  • #_ListTight Internal use only

    ListTight = ListItemTight+:a @BlankLine* !(Bullet | Enumerator) { a }

  • #_Newline Internal use only

    Newline = %literals.Newline.

  • #_NonblankIndentedLine Internal use only

    NonblankIndentedLine = !@BlankLine IndentedLine.

  • #_NonindentSpace Internal use only

    NonindentSpace = / 0,3/.

  • #_Nonspacechar Internal use only

    Nonspacechar = !@Spacechar !@Newline .

  • #_NormalChar Internal use only

    NormalChar = !(@SpecialChar | @Spacechar | @Newline) .

  • #_NormalEndline Internal use only

    NormalEndline = @Sp @Newline !@BlankLine !“>” !AtxStart !(Line /=1,|-1,/ @Newline) { “n” }

  • #_Note Internal use only

    Note = &{ notes? } @NonindentSpace RawNoteReference:ref “:” @Sp @StartList:a RawNoteBlock:i { a.concat i } (&Indent RawNoteBlock:i { a.concat i })* { @footnotes = paragraph a nil }

  • #_NoteReference Internal use only

    NoteReference = &{ notes? } RawNoteReference:ref { note_for ref }

  • #_Notes Internal use only

    Notes = (Note | SkipBlock)*.

  • #_OptionallyIndentedLine Internal use only

    OptionallyIndentedLine = Indent? Line.

  • #_OrderedList Internal use only

    OrderedList = &Enumerator (ListTight | ListLoose):a { Markup::List.new(:NUMBER, *a) }

  • #_Para Internal use only

    Para = @NonindentSpace Inlines:a @BlankLine+ { paragraph a }

  • #_Plain Internal use only

    Plain = Inlines:a { paragraph a }

  • #_Quoted Internal use only

    Quoted = (“"” (!“"” .)* “"” | “‘” (!“’” .)* “‘”).

  • #_RawHtml Internal use only

    RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else ” end }

  • #_RawLine Internal use only

    RawLine = (< /[^rn]*/ @Newline > | < .+ > @Eof) { text }

  • #_RawNoteBlock Internal use only

    RawNoteBlock = @StartList:a (!@BlankLine !RawNoteReference OptionallyIndentedLine:l { a << l })+ < @BlankLine* > { a << text } { a }

  • #_RawNoteReference Internal use only

    RawNoteReference = “[^” < (!@Newline !“]” .)+ > “]” { text }

  • #_RefSrc Internal use only

    RefSrc = < Nonspacechar+ > { text }

  • #_RefTitle Internal use only

    RefTitle = (RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle).

  • #_RefTitleDouble Internal use only

    RefTitleDouble = Spnl “"” < (!(“"” @Sp @Newline | @Newline) .)* > “"” { text }

  • #_RefTitleParens Internal use only

    RefTitleParens = Spnl “(” < (!(“)” @Sp @Newline | @Newline) .)* > “)” { text }

  • #_RefTitleSingle Internal use only

    RefTitleSingle = Spnl “‘” < (!(“’” @Sp @Newline | @Newline) .)* > “‘” { text }

  • #_Reference Internal use only

    Reference = @NonindentSpace !“[]” Label:label “:” Spnl RefSrc:link RefTitle @BlankLine+ { # TODO use title reference label, link nil }

  • #_ReferenceLink Internal use only

    ReferenceLink = (ReferenceLinkDouble | ReferenceLinkSingle).

  • #_ReferenceLinkDouble Internal use only

    ReferenceLinkDouble = Label:content < Spnl > !“[]” Label:label { link_to content, label, text }

  • #_ReferenceLinkSingle Internal use only

    ReferenceLinkSingle = Label:content < (Spnl “[]”)? > { link_to content, content, text }

  • #_References Internal use only

    References = (Reference | SkipBlock)*.

  • #_SetextBottom1 Internal use only

    SetextBottom1 = /=1,/ @Newline.

  • #_SetextBottom2 Internal use only

    SetextBottom2 = /-1,/ @Newline.

  • #_SetextHeading Internal use only

    SetextHeading = (SetextHeading1 | SetextHeading2).

  • #_SetextHeading1 Internal use only

    SetextHeading1 = &(@RawLine SetextBottom1) @StartList:a (!@Endline Inline:b { a << b })+ @Sp @Newline SetextBottom1 { RDoc::Markup::Heading.new(1, a.join) }

  • #_SetextHeading2 Internal use only

    SetextHeading2 = &(@RawLine SetextBottom2) @StartList:a (!@Endline Inline:b { a << b })+ @Sp @Newline SetextBottom2 { RDoc::Markup::Heading.new(2, a.join) }

  • #_SkipBlock Internal use only

    SkipBlock = (HtmlBlock | (!“#” !SetextBottom1 !SetextBottom2 !@BlankLine @RawLine)+ @BlankLine* | @BlankLine+ | @RawLine).

  • #_Source Internal use only

    Source = (“<” < SourceContents > “>” | < SourceContents >) { text }

  • #_SourceContents Internal use only

    SourceContents = ((!“(” !“)” !“>” Nonspacechar)+ | “(” SourceContents “)”)*.

  • #_Sp Internal use only

    Sp = @Spacechar*.

  • #_Space Internal use only

    Space = @Spacechar+ { “ ” }

  • #_Spacechar Internal use only

    Spacechar = %literals.Spacechar.

  • #_SpecialChar Internal use only

    SpecialChar = (/[~*_`&()<!#\‘“]/ | @ExtendedSpecialChar).

  • #_Spnl Internal use only

    Spnl = @Sp (@Newline @Sp)?

  • #_StarLine Internal use only

    StarLine = (< /*4,/ > { text } | < @Spacechar /*+/ &@Spacechar > { text }).

  • #_StartList Internal use only

    StartList = &.

  • #_Str Internal use only

    Str = @StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { a }

  • #_StrChunk Internal use only

    StrChunk = < (@NormalChar | /_+/ &Alphanumeric)+ > { text }

  • #_Strike Internal use only

    Strike = &{ strike? } “~~” !@Whitespace @StartList:a (!“~~” Inline:b { a << b })+ “~~” { strike a.join }

  • #_Strong Internal use only

    Strong = (StrongStar | StrongUl).

  • #_StrongStar Internal use only

    StrongStar = “**” !@Whitespace @StartList:a (!“**” Inline:b { a << b })+ “**” { strong a.join }

  • #_StrongUl Internal use only

    StrongUl = “__” !@Whitespace @StartList:a (!“__” Inline:b { a << b })+ “__” { strong a.join }

  • #_StyleBlock Internal use only

    StyleBlock = < InStyleTags > @BlankLine* { if css? then Markup::Raw.new text end }

  • #_StyleClose Internal use only

    StyleClose = “<” Spnl “/” (“style” | “STYLE”) Spnl “>”.

  • #_StyleOpen Internal use only

    StyleOpen = “<” Spnl (“style” | “STYLE”) Spnl HtmlAttribute* “>”.

  • #_Symbol Internal use only

    Symbol = < @SpecialChar > { text }

  • #_Table Internal use only

    Table = &{ github? } TableHead:header TableLine:line TableRow+:body { table = Markup::Table.new(header, line, body) }

  • #_TableAlign Internal use only

    TableAlign = < /:?-+:?/ > @Sp { text.start_with?(“:”) ? (text.end_with?(“:”) ? :center : :left) : (text.end_with?(“:”) ? :right : nil) }

  • #_TableAlign2 Internal use only

    TableAlign2 = “|” @Sp TableAlign.

  • #_TableHead Internal use only

    TableHead = TableItem2+:items “|”? @Newline { items }

  • #_TableItem Internal use only

    TableItem = < /(?:\.|[^|n])+/ > { text.strip.gsub(/\(.)/, ‘1’) }

  • #_TableItem2 Internal use only

    TableItem2 = “|” TableItem.

  • #_TableLine Internal use only

    TableLine = ((TableAlign:align1 TableAlign2*:aligns {[align1, *aligns] }):line | TableAlign2+:line) “|”? @Newline { line }

  • #_TableRow Internal use only

    TableRow = ((TableItem:item1 TableItem2*:items { [item1, *items] }):row | TableItem2+:row) “|”? @Newline { row }

  • #_TerminalEndline Internal use only

    TerminalEndline = @Sp @Newline @Eof.

  • #_Ticks1 Internal use only

    Ticks1 = “‘” !“`”.

  • #_Ticks2 Internal use only

    Ticks2 = ““” !“‘”.

  • #_Ticks3 Internal use only

    Ticks3 = “.

  • #_Ticks4 Internal use only

    Ticks4 = “.

  • #_Ticks5 Internal use only

    Ticks5 = “.

  • #_Title Internal use only

    Title = (TitleSingle | TitleDouble | “”):a { a }

  • #_TitleDouble Internal use only

    TitleDouble = “"” (!(“"” @Sp (“)” | @Newline)) .)* “"”.

  • #_TitleSingle Internal use only

    TitleSingle = “‘” (!(“’” @Sp (“)” | @Newline)) .)* “‘”.

  • #_UlLine Internal use only

    UlLine = (< /_4,/ > { text } | < @Spacechar /_+/ &@Spacechar > { text }).

  • #_UlOrStarLine Internal use only

    UlOrStarLine = (UlLine | StarLine):a { a }

  • #_Verbatim Internal use only

    Verbatim = VerbatimChunk+:a { Markup::Verbatim.new(*a.flatten) }

  • #_VerbatimChunk Internal use only

    VerbatimChunk = @BlankLine*:a NonblankIndentedLine+:b { a.concat b }

  • #_Whitespace Internal use only

    Whitespace = (@Spacechar | @Newline).

  • #_root Internal use only

    root = Doc.

  • #break_on_newline

    Converts all newlines into hard breaks.

  • #css

    Allow style blocks.

  • #definition_lists

    Allow PHP Markdown Extras style definition lists.

  • .extension(name)

    Creates extension methods for the name extension to enable and disable the extension and to query if they are active.

  • #extension(name, enable)

    Enables or disables the extension with name

  • #extension?(name) ⇒ Boolean

    Is the extension name enabled?

  • #github

    Allow Github Flavored Markdown.

  • #html

    Allow HTML.

  • #inner_parse(text) Internal use only

    Parses text in a clone of this parser.

  • #link_to(content, label = content, text = nil)

    Finds a link reference for label and creates a new link to it with content as the link text.

  • #list_item_from(unparsed)

    Creates an Markup::ListItem by parsing the unparsed content from the first parsing pass.

  • #note(label)

    Stores label as a note and fills in previously unknown note references.

  • #note_for(ref)

    Creates a new link for the footnote #reference and adds the reference to the note order list for proper display at the end of the document.

  • #notes

    Enables the notes extension.

  • #paragraph(parts)

    Creates an Markup::Paragraph from parts and including extension-specific behavior.

  • #parse(markdown) (also: #peg_parse) Internal use only

    Parses markdown into an RDoc::Document

  • #peg_parse(rule = nil) Internal use only

    The internal kpeg parse method.

  • #reference(label, link)

    Stores label as a reference to link and fills in previously unknown link references.

  • #setup_foreign_grammar Internal use only
  • #strike(text)

    Enables the strike extension.

  • #strong(text)

    Wraps text in strong markup for rdoc inline formatting.

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(str, debug = false) ⇒ Markdown

This method is for internal use only.

This is distinct from setup_parser so that a standalone parser can redefine #initialize and still have access to the proper parser setup code.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 188

def initialize(str, debug=false)
  setup_parser(str, debug)
end

#initialize(extensions = DEFAULT_EXTENSIONS, debug = false) ⇒ Markdown

Creates a new markdown parser that enables the given extensions.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 668

def initialize extensions = DEFAULT_EXTENSIONS, debug = false
  @debug      = debug
  @formatter  = RDoc::Markup::ToJoinedParagraph.new
  @extensions = extensions

  @references          = nil
  @unlinked_references = nil

  @footnotes       = nil
  @note_order      = nil
end

Class Method Details

.extension(name)

Creates extension methods for the name extension to enable and disable the extension and to query if they are active.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 603

def self.extension name
  EXTENSIONS << name

  define_method "#{name}?" do
    extension? name
  end

  define_method "#{name}=" do |enable|
    extension name, enable
  end
end

.parse(markdown)

Parses the markdown document into an RDoc::Document using the default extensions.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 656

def self.parse markdown
  parser = new

  parser.parse markdown
end

.rule_info(name, rendered)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 566

def self.rule_info(name, rendered)
  RuleInfo.new(name, rendered)
end

Instance Attribute Details

#failed_rule (readonly)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 371

attr_reader :failed_rule

#failing_rule_offset (readonly)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 208

attr_reader :failing_rule_offset

#pos (rw)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 209

attr_accessor :result, :pos

#result (rw)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 209

attr_accessor :result, :pos

#string (readonly)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 207

attr_reader :string

Instance Method Details

#_Alphanumeric

This method is for internal use only.

Alphanumeric = %literals.Alphanumeric

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14705

def _Alphanumeric
  _tmp = @_grammar_literals.external_invoke(self, :_Alphanumeric)
  set_failed_rule :_Alphanumeric unless _tmp
  return _tmp
end

#_AlphanumericAscii

This method is for internal use only.

AlphanumericAscii = %literals.AlphanumericAscii

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14712

def _AlphanumericAscii
  _tmp = @_grammar_literals.external_invoke(self, :_AlphanumericAscii)
  set_failed_rule :_AlphanumericAscii unless _tmp
  return _tmp
end

#_AtxHeading

This method is for internal use only.

AtxHeading = AtxStart:s @Sp AtxInline+:a (@Sp /#*/ @Sp)? @Newline { RDoc::Markup::Heading.new(s, a.join) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1162

def _AtxHeading

  _save = self.pos
  while true # sequence
    _tmp = apply(:_AtxStart)
    s = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _ary = []
    _tmp = apply(:_AtxInline)
    if _tmp
      _ary << @result
      while true
        _tmp = apply(:_AtxInline)
        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save1
    end
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos

    _save3 = self.pos
    while true # sequence
      _tmp = _Sp()
      unless _tmp
        self.pos = _save3
        break
      end
      _tmp = scan(/\G(?-mix:#*)/)
      unless _tmp
        self.pos = _save3
        break
      end
      _tmp = _Sp()
      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 = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::Heading.new(s, a.join) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_AtxHeading unless _tmp
  return _tmp
end

#_AtxInline

This method is for internal use only.

AtxInline = !@Newline !(@Sp /#*/ @Sp @Newline) Inline

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1080

def _AtxInline

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = _Newline()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos

    _save3 = self.pos
    while true # sequence
      _tmp = _Sp()
      unless _tmp
        self.pos = _save3
        break
      end
      _tmp = scan(/\G(?-mix:#*)/)
      unless _tmp
        self.pos = _save3
        break
      end
      _tmp = _Sp()
      unless _tmp
        self.pos = _save3
        break
      end
      _tmp = _Newline()
      unless _tmp
        self.pos = _save3
      end
      break
    end # end sequence

    _tmp = _tmp ? nil : true
    self.pos = _save2
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Inline)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_AtxInline unless _tmp
  return _tmp
end

#_AtxStart

This method is for internal use only.

AtxStart = < /#1,6/ > { text.length }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1136

def _AtxStart

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _tmp = scan(/\G(?-mix:\#{1,6})/)
    if _tmp
      text = get_text(_text_start)
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  text.length ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_AtxStart unless _tmp
  return _tmp
end

#_AutoLinkEmail

This method is for internal use only.

AutoLinkEmail = “<” “mailto:”? < /[w+./!%~$-]+/i “@” (!@Newline !“>” .)+ > “>” { “mailto:#text” }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11707

def _AutoLinkEmail

  _save = self.pos
  while true # sequence
    _tmp = match_string("<")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("mailto:")
    unless _tmp
      _tmp = true
      self.pos = _save1
    end
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = scan(/\G(?i-mx:[\w.\/!%~$-])/)
      unless _tmp
        self.pos = _save2
        break
      end
      _tmp = match_string("@")
      unless _tmp
        self.pos = _save2
        break
      end
      _save3 = self.pos

      _save4 = self.pos
      while true # sequence
        _save5 = self.pos
        _tmp = _Newline()
        _tmp = _tmp ? nil : true
        self.pos = _save5
        unless _tmp
          self.pos = _save4
          break
        end
        _save6 = self.pos
        _tmp = match_string(">")
        _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

      if _tmp
        while true

          _save7 = self.pos
          while true # sequence
            _save8 = self.pos
            _tmp = _Newline()
            _tmp = _tmp ? nil : true
            self.pos = _save8
            unless _tmp
              self.pos = _save7
              break
            end
            _save9 = self.pos
            _tmp = match_string(">")
            _tmp = _tmp ? nil : true
            self.pos = _save9
            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
      else
        self.pos = _save3
      end
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    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;  "mailto:#{text}" ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_AutoLinkEmail unless _tmp
  return _tmp
end

#_AutoLinkUrl

This method is for internal use only.

AutoLinkUrl = “<” < /[A-Za-z]+/ “://” (!@Newline !“>” .)+ > “>” { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11592

def _AutoLinkUrl

  _save = self.pos
  while true # sequence
    _tmp = match_string("<")
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos

    _save1 = self.pos
    while true # sequence
      _tmp = scan(/\G(?-mix:[A-Za-z]+)/)
      unless _tmp
        self.pos = _save1
        break
      end
      _tmp = match_string("://")
      unless _tmp
        self.pos = _save1
        break
      end
      _save2 = self.pos

      _save3 = self.pos
      while true # sequence
        _save4 = self.pos
        _tmp = _Newline()
        _tmp = _tmp ? nil : true
        self.pos = _save4
        unless _tmp
          self.pos = _save3
          break
        end
        _save5 = self.pos
        _tmp = match_string(">")
        _tmp = _tmp ? nil : true
        self.pos = _save5
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = get_byte
        unless _tmp
          self.pos = _save3
        end
        break
      end # end sequence

      if _tmp
        while true

          _save6 = self.pos
          while true # sequence
            _save7 = self.pos
            _tmp = _Newline()
            _tmp = _tmp ? nil : true
            self.pos = _save7
            unless _tmp
              self.pos = _save6
              break
            end
            _save8 = self.pos
            _tmp = match_string(">")
            _tmp = _tmp ? nil : true
            self.pos = _save8
            unless _tmp
              self.pos = _save6
              break
            end
            _tmp = get_byte
            unless _tmp
              self.pos = _save6
            end
            break
          end # end sequence

          break unless _tmp
        end
        _tmp = true
      else
        self.pos = _save2
      end
      unless _tmp
        self.pos = _save1
      end
      break
    end # end sequence

    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 :_AutoLinkUrl unless _tmp
  return _tmp
end

#_BlankLine

This method is for internal use only.

BlankLine = @Sp @Newline { “n” }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14148

def _BlankLine

  _save = self.pos
  while true # sequence
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _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

#_Block

This method is for internal use only.

Block = @BlankLine* (BlockQuote | Verbatim | CodeFence | Table | Note | Reference | HorizontalRule | Heading | OrderedList | BulletList | DefinitionList | HtmlBlock | StyleBlock | Para | Plain)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 939

def _Block

  _save = self.pos
  while true # sequence
    while true
      _tmp = _BlankLine()
      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end

    _save2 = self.pos
    while true # choice
      _tmp = apply(:_BlockQuote)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Verbatim)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_CodeFence)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Table)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Note)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Reference)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_HorizontalRule)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Heading)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_OrderedList)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_BulletList)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_DefinitionList)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_HtmlBlock)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_StyleBlock)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Para)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_Plain)
      break if _tmp
      self.pos = _save2
      break
    end # end choice

    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Block unless _tmp
  return _tmp
end

#_BlockQuote

This method is for internal use only.

BlockQuote = BlockQuoteRaw:a { Markup::BlockQuote.new(*a) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1566

def _BlockQuote

  _save = self.pos
  while true # sequence
    _tmp = apply(:_BlockQuoteRaw)
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::BlockQuote.new(*a) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_BlockQuote unless _tmp
  return _tmp
end

#_BlockQuoteRaw

This method is for internal use only.

BlockQuoteRaw = @StartList:a (“>” “ ”? Line:l { a << l } (!“>” !@BlankLine Line:c { a << c })* (@BlankLine:n { a << n })*)+ { inner_parse a.join }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1589

def _BlockQuoteRaw

  _save = self.pos
  while true # sequence
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = match_string(">")
      unless _tmp
        self.pos = _save2
        break
      end
      _save3 = self.pos
      _tmp = match_string(" ")
      unless _tmp
        _tmp = true
        self.pos = _save3
      end
      unless _tmp
        self.pos = _save2
        break
      end
      _tmp = apply(:_Line)
      l = @result
      unless _tmp
        self.pos = _save2
        break
      end
      @result = begin;  a << l ; end
      _tmp = true
      unless _tmp
        self.pos = _save2
        break
      end
      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
          _save7 = self.pos
          _tmp = _BlankLine()
          _tmp = _tmp ? nil : true
          self.pos = _save7
          unless _tmp
            self.pos = _save5
            break
          end
          _tmp = apply(:_Line)
          c = @result
          unless _tmp
            self.pos = _save5
            break
          end
          @result = begin;  a << c ; end
          _tmp = true
          unless _tmp
            self.pos = _save5
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
      unless _tmp
        self.pos = _save2
        break
      end
      while true

        _save9 = self.pos
        while true # sequence
          _tmp = _BlankLine()
          n = @result
          unless _tmp
            self.pos = _save9
            break
          end
          @result = begin;  a << n ; end
          _tmp = true
          unless _tmp
            self.pos = _save9
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    if _tmp
      while true

        _save10 = self.pos
        while true # sequence
          _tmp = match_string(">")
          unless _tmp
            self.pos = _save10
            break
          end
          _save11 = self.pos
          _tmp = match_string(" ")
          unless _tmp
            _tmp = true
            self.pos = _save11
          end
          unless _tmp
            self.pos = _save10
            break
          end
          _tmp = apply(:_Line)
          l = @result
          unless _tmp
            self.pos = _save10
            break
          end
          @result = begin;  a << l ; end
          _tmp = true
          unless _tmp
            self.pos = _save10
            break
          end
          while true

            _save13 = self.pos
            while true # sequence
              _save14 = self.pos
              _tmp = match_string(">")
              _tmp = _tmp ? nil : true
              self.pos = _save14
              unless _tmp
                self.pos = _save13
                break
              end
              _save15 = self.pos
              _tmp = _BlankLine()
              _tmp = _tmp ? nil : true
              self.pos = _save15
              unless _tmp
                self.pos = _save13
                break
              end
              _tmp = apply(:_Line)
              c = @result
              unless _tmp
                self.pos = _save13
                break
              end
              @result = begin;  a << c ; end
              _tmp = true
              unless _tmp
                self.pos = _save13
              end
              break
            end # end sequence

            break unless _tmp
          end
          _tmp = true
          unless _tmp
            self.pos = _save10
            break
          end
          while true

            _save17 = self.pos
            while true # sequence
              _tmp = _BlankLine()
              n = @result
              unless _tmp
                self.pos = _save17
                break
              end
              @result = begin;  a << n ; end
              _tmp = true
              unless _tmp
                self.pos = _save17
              end
              break
            end # end sequence

            break unless _tmp
          end
          _tmp = true
          unless _tmp
            self.pos = _save10
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save1
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  inner_parse a.join ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_BlockQuoteRaw unless _tmp
  return _tmp
end

#_BOM

This method is for internal use only.

BOM = %literals.BOM

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14719

def _BOM
  _tmp = @_grammar_literals.external_invoke(self, :_BOM)
  set_failed_rule :_BOM unless _tmp
  return _tmp
end

#_Bullet

This method is for internal use only.

Bullet = !HorizontalRule @NonindentSpace /[+*-]/ @Spacechar+

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2154

def _Bullet

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = apply(:_HorizontalRule)
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _NonindentSpace()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = scan(/\G(?-mix:[+*-])/)
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _tmp = _Spacechar()
    if _tmp
      while true
        _tmp = _Spacechar()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save2
    end
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Bullet unless _tmp
  return _tmp
end

#_BulletList

This method is for internal use only.

BulletList = &Bullet (ListTight | ListLoose):a { Markup::List.new(:BULLET, *a) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2198

def _BulletList

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = apply(:_Bullet)
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end

    _save2 = self.pos
    while true # choice
      _tmp = apply(:_ListTight)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_ListLoose)
      break if _tmp
      self.pos = _save2
      break
    end # end choice

    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::List.new(:BULLET, *a) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_BulletList unless _tmp
  return _tmp
end

#_CharEntity

This method is for internal use only.

CharEntity = “&” < /[A-Za-z0-9]+/ > “;” { if entity = HTML_ENTITIES then entity.pack ‘U*’ else “&#text;” end }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14812

def _CharEntity

  _save = self.pos
  while true # sequence
    _tmp = match_string("&")
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _tmp = scan(/\G(?-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

#_Code

This method is for internal use only.

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}” }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12511

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 = _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
            _tmp = scan(/\G(?-mix:`+)/)
            unless _tmp
              self.pos = _save10
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save4

          _save12 = self.pos
          while true # sequence
            _save13 = self.pos

            _save14 = self.pos
            while true # sequence
              _tmp = _Sp()
              unless _tmp
                self.pos = _save14
                break
              end
              _tmp = apply(:_Ticks1)
              unless _tmp
                self.pos = _save14
              end
              break
            end # end sequence

            _tmp = _tmp ? nil : true
            self.pos = _save13
            unless _tmp
              self.pos = _save12
              break
            end

            _save15 = self.pos
            while true # choice
              _tmp = _Spacechar()
              break if _tmp
              self.pos = _save15

              _save16 = self.pos
              while true # sequence
                _tmp = _Newline()
                unless _tmp
                  self.pos = _save16
                  break
                end
                _save17 = self.pos
                _tmp = _BlankLine()
                _tmp = _tmp ? nil : true
                self.pos = _save17
                unless _tmp
                  self.pos = _save16
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save15
              break
            end # end choice

            unless _tmp
              self.pos = _save12
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save4
          break
        end # end choice

        if _tmp
          while true

            _save18 = self.pos
            while true # choice
              _save19 = self.pos

              _save20 = self.pos
              while true # sequence
                _save21 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save21
                unless _tmp
                  self.pos = _save20
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save20
                end
                break
              end # end sequence

              if _tmp
                while true

                  _save22 = self.pos
                  while true # sequence
                    _save23 = self.pos
                    _tmp = match_string("`")
                    _tmp = _tmp ? nil : true
                    self.pos = _save23
                    unless _tmp
                      self.pos = _save22
                      break
                    end
                    _tmp = apply(:_Nonspacechar)
                    unless _tmp
                      self.pos = _save22
                    end
                    break
                  end # end sequence

                  break unless _tmp
                end
                _tmp = true
              else
                self.pos = _save19
              end
              break if _tmp
              self.pos = _save18

              _save24 = self.pos
              while true # sequence
                _save25 = self.pos
                _tmp = apply(:_Ticks1)
                _tmp = _tmp ? nil : true
                self.pos = _save25
                unless _tmp
                  self.pos = _save24
                  break
                end
                _tmp = scan(/\G(?-mix:`+)/)
                unless _tmp
                  self.pos = _save24
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save18

              _save26 = self.pos
              while true # sequence
                _save27 = self.pos

                _save28 = self.pos
                while true # sequence
                  _tmp = _Sp()
                  unless _tmp
                    self.pos = _save28
                    break
                  end
                  _tmp = apply(:_Ticks1)
                  unless _tmp
                    self.pos = _save28
                  end
                  break
                end # end sequence

                _tmp = _tmp ? nil : true
                self.pos = _save27
                unless _tmp
                  self.pos = _save26
                  break
                end

                _save29 = self.pos
                while true # choice
                  _tmp = _Spacechar()
                  break if _tmp
                  self.pos = _save29

                  _save30 = self.pos
                  while true # sequence
                    _tmp = _Newline()
                    unless _tmp
                      self.pos = _save30
                      break
                    end
                    _save31 = self.pos
                    _tmp = _BlankLine()
                    _tmp = _tmp ? nil : true
                    self.pos = _save31
                    unless _tmp
                      self.pos = _save30
                    end
                    break
                  end # end sequence

                  break if _tmp
                  self.pos = _save29
                  break
                end # end choice

                unless _tmp
                  self.pos = _save26
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save18
              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 = _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

      _save32 = self.pos
      while true # sequence
        _tmp = apply(:_Ticks2)
        unless _tmp
          self.pos = _save32
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save32
          break
        end
        _text_start = self.pos
        _save33 = self.pos

        _save34 = self.pos
        while true # choice
          _save35 = self.pos

          _save36 = self.pos
          while true # sequence
            _save37 = self.pos
            _tmp = match_string("`")
            _tmp = _tmp ? nil : true
            self.pos = _save37
            unless _tmp
              self.pos = _save36
              break
            end
            _tmp = apply(:_Nonspacechar)
            unless _tmp
              self.pos = _save36
            end
            break
          end # end sequence

          if _tmp
            while true

              _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

              break unless _tmp
            end
            _tmp = true
          else
            self.pos = _save35
          end
          break if _tmp
          self.pos = _save34

          _save40 = self.pos
          while true # sequence
            _save41 = self.pos
            _tmp = apply(:_Ticks2)
            _tmp = _tmp ? nil : true
            self.pos = _save41
            unless _tmp
              self.pos = _save40
              break
            end
            _tmp = scan(/\G(?-mix:`+)/)
            unless _tmp
              self.pos = _save40
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save34

          _save42 = self.pos
          while true # sequence
            _save43 = self.pos

            _save44 = self.pos
            while true # sequence
              _tmp = _Sp()
              unless _tmp
                self.pos = _save44
                break
              end
              _tmp = apply(:_Ticks2)
              unless _tmp
                self.pos = _save44
              end
              break
            end # end sequence

            _tmp = _tmp ? nil : true
            self.pos = _save43
            unless _tmp
              self.pos = _save42
              break
            end

            _save45 = self.pos
            while true # choice
              _tmp = _Spacechar()
              break if _tmp
              self.pos = _save45

              _save46 = self.pos
              while true # sequence
                _tmp = _Newline()
                unless _tmp
                  self.pos = _save46
                  break
                end
                _save47 = self.pos
                _tmp = _BlankLine()
                _tmp = _tmp ? nil : true
                self.pos = _save47
                unless _tmp
                  self.pos = _save46
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save45
              break
            end # end choice

            unless _tmp
              self.pos = _save42
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save34
          break
        end # end choice

        if _tmp
          while true

            _save48 = self.pos
            while true # choice
              _save49 = self.pos

              _save50 = self.pos
              while true # sequence
                _save51 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save51
                unless _tmp
                  self.pos = _save50
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save50
                end
                break
              end # end sequence

              if _tmp
                while true

                  _save52 = self.pos
                  while true # sequence
                    _save53 = self.pos
                    _tmp = match_string("`")
                    _tmp = _tmp ? nil : true
                    self.pos = _save53
                    unless _tmp
                      self.pos = _save52
                      break
                    end
                    _tmp = apply(:_Nonspacechar)
                    unless _tmp
                      self.pos = _save52
                    end
                    break
                  end # end sequence

                  break unless _tmp
                end
                _tmp = true
              else
                self.pos = _save49
              end
              break if _tmp
              self.pos = _save48

              _save54 = self.pos
              while true # sequence
                _save55 = self.pos
                _tmp = apply(:_Ticks2)
                _tmp = _tmp ? nil : true
                self.pos = _save55
                unless _tmp
                  self.pos = _save54
                  break
                end
                _tmp = scan(/\G(?-mix:`+)/)
                unless _tmp
                  self.pos = _save54
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save48

              _save56 = self.pos
              while true # sequence
                _save57 = self.pos

                _save58 = self.pos
                while true # sequence
                  _tmp = _Sp()
                  unless _tmp
                    self.pos = _save58
                    break
                  end
                  _tmp = apply(:_Ticks2)
                  unless _tmp
                    self.pos = _save58
                  end
                  break
                end # end sequence

                _tmp = _tmp ? nil : true
                self.pos = _save57
                unless _tmp
                  self.pos = _save56
                  break
                end

                _save59 = self.pos
                while true # choice
                  _tmp = _Spacechar()
                  break if _tmp
                  self.pos = _save59

                  _save60 = self.pos
                  while true # sequence
                    _tmp = _Newline()
                    unless _tmp
                      self.pos = _save60
                      break
                    end
                    _save61 = self.pos
                    _tmp = _BlankLine()
                    _tmp = _tmp ? nil : true
                    self.pos = _save61
                    unless _tmp
                      self.pos = _save60
                    end
                    break
                  end # end sequence

                  break if _tmp
                  self.pos = _save59
                  break
                end # end choice

                unless _tmp
                  self.pos = _save56
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save48
              break
            end # end choice

            break unless _tmp
          end
          _tmp = true
        else
          self.pos = _save33
        end
        if _tmp
          text = get_text(_text_start)
        end
        unless _tmp
          self.pos = _save32
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save32
          break
        end
        _tmp = apply(:_Ticks2)
        unless _tmp
          self.pos = _save32
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1

      _save62 = self.pos
      while true # sequence
        _tmp = apply(:_Ticks3)
        unless _tmp
          self.pos = _save62
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save62
          break
        end
        _text_start = self.pos
        _save63 = self.pos

        _save64 = self.pos
        while true # choice
          _save65 = self.pos

          _save66 = self.pos
          while true # sequence
            _save67 = self.pos
            _tmp = match_string("`")
            _tmp = _tmp ? nil : true
            self.pos = _save67
            unless _tmp
              self.pos = _save66
              break
            end
            _tmp = apply(:_Nonspacechar)
            unless _tmp
              self.pos = _save66
            end
            break
          end # end sequence

          if _tmp
            while true

              _save68 = self.pos
              while true # sequence
                _save69 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save69
                unless _tmp
                  self.pos = _save68
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save68
                end
                break
              end # end sequence

              break unless _tmp
            end
            _tmp = true
          else
            self.pos = _save65
          end
          break if _tmp
          self.pos = _save64

          _save70 = self.pos
          while true # sequence
            _save71 = self.pos
            _tmp = apply(:_Ticks3)
            _tmp = _tmp ? nil : true
            self.pos = _save71
            unless _tmp
              self.pos = _save70
              break
            end
            _tmp = scan(/\G(?-mix:`+)/)
            unless _tmp
              self.pos = _save70
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save64

          _save72 = self.pos
          while true # sequence
            _save73 = self.pos

            _save74 = self.pos
            while true # sequence
              _tmp = _Sp()
              unless _tmp
                self.pos = _save74
                break
              end
              _tmp = apply(:_Ticks3)
              unless _tmp
                self.pos = _save74
              end
              break
            end # end sequence

            _tmp = _tmp ? nil : true
            self.pos = _save73
            unless _tmp
              self.pos = _save72
              break
            end

            _save75 = self.pos
            while true # choice
              _tmp = _Spacechar()
              break if _tmp
              self.pos = _save75

              _save76 = self.pos
              while true # sequence
                _tmp = _Newline()
                unless _tmp
                  self.pos = _save76
                  break
                end
                _save77 = self.pos
                _tmp = _BlankLine()
                _tmp = _tmp ? nil : true
                self.pos = _save77
                unless _tmp
                  self.pos = _save76
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save75
              break
            end # end choice

            unless _tmp
              self.pos = _save72
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save64
          break
        end # end choice

        if _tmp
          while true

            _save78 = self.pos
            while true # choice
              _save79 = self.pos

              _save80 = self.pos
              while true # sequence
                _save81 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save81
                unless _tmp
                  self.pos = _save80
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save80
                end
                break
              end # end sequence

              if _tmp
                while true

                  _save82 = self.pos
                  while true # sequence
                    _save83 = self.pos
                    _tmp = match_string("`")
                    _tmp = _tmp ? nil : true
                    self.pos = _save83
                    unless _tmp
                      self.pos = _save82
                      break
                    end
                    _tmp = apply(:_Nonspacechar)
                    unless _tmp
                      self.pos = _save82
                    end
                    break
                  end # end sequence

                  break unless _tmp
                end
                _tmp = true
              else
                self.pos = _save79
              end
              break if _tmp
              self.pos = _save78

              _save84 = self.pos
              while true # sequence
                _save85 = self.pos
                _tmp = apply(:_Ticks3)
                _tmp = _tmp ? nil : true
                self.pos = _save85
                unless _tmp
                  self.pos = _save84
                  break
                end
                _tmp = scan(/\G(?-mix:`+)/)
                unless _tmp
                  self.pos = _save84
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save78

              _save86 = self.pos
              while true # sequence
                _save87 = self.pos

                _save88 = self.pos
                while true # sequence
                  _tmp = _Sp()
                  unless _tmp
                    self.pos = _save88
                    break
                  end
                  _tmp = apply(:_Ticks3)
                  unless _tmp
                    self.pos = _save88
                  end
                  break
                end # end sequence

                _tmp = _tmp ? nil : true
                self.pos = _save87
                unless _tmp
                  self.pos = _save86
                  break
                end

                _save89 = self.pos
                while true # choice
                  _tmp = _Spacechar()
                  break if _tmp
                  self.pos = _save89

                  _save90 = self.pos
                  while true # sequence
                    _tmp = _Newline()
                    unless _tmp
                      self.pos = _save90
                      break
                    end
                    _save91 = self.pos
                    _tmp = _BlankLine()
                    _tmp = _tmp ? nil : true
                    self.pos = _save91
                    unless _tmp
                      self.pos = _save90
                    end
                    break
                  end # end sequence

                  break if _tmp
                  self.pos = _save89
                  break
                end # end choice

                unless _tmp
                  self.pos = _save86
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save78
              break
            end # end choice

            break unless _tmp
          end
          _tmp = true
        else
          self.pos = _save63
        end
        if _tmp
          text = get_text(_text_start)
        end
        unless _tmp
          self.pos = _save62
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save62
          break
        end
        _tmp = apply(:_Ticks3)
        unless _tmp
          self.pos = _save62
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1

      _save92 = self.pos
      while true # sequence
        _tmp = apply(:_Ticks4)
        unless _tmp
          self.pos = _save92
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save92
          break
        end
        _text_start = self.pos
        _save93 = self.pos

        _save94 = self.pos
        while true # choice
          _save95 = self.pos

          _save96 = self.pos
          while true # sequence
            _save97 = self.pos
            _tmp = match_string("`")
            _tmp = _tmp ? nil : true
            self.pos = _save97
            unless _tmp
              self.pos = _save96
              break
            end
            _tmp = apply(:_Nonspacechar)
            unless _tmp
              self.pos = _save96
            end
            break
          end # end sequence

          if _tmp
            while true

              _save98 = self.pos
              while true # sequence
                _save99 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save99
                unless _tmp
                  self.pos = _save98
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save98
                end
                break
              end # end sequence

              break unless _tmp
            end
            _tmp = true
          else
            self.pos = _save95
          end
          break if _tmp
          self.pos = _save94

          _save100 = self.pos
          while true # sequence
            _save101 = self.pos
            _tmp = apply(:_Ticks4)
            _tmp = _tmp ? nil : true
            self.pos = _save101
            unless _tmp
              self.pos = _save100
              break
            end
            _tmp = scan(/\G(?-mix:`+)/)
            unless _tmp
              self.pos = _save100
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save94

          _save102 = self.pos
          while true # sequence
            _save103 = self.pos

            _save104 = self.pos
            while true # sequence
              _tmp = _Sp()
              unless _tmp
                self.pos = _save104
                break
              end
              _tmp = apply(:_Ticks4)
              unless _tmp
                self.pos = _save104
              end
              break
            end # end sequence

            _tmp = _tmp ? nil : true
            self.pos = _save103
            unless _tmp
              self.pos = _save102
              break
            end

            _save105 = self.pos
            while true # choice
              _tmp = _Spacechar()
              break if _tmp
              self.pos = _save105

              _save106 = self.pos
              while true # sequence
                _tmp = _Newline()
                unless _tmp
                  self.pos = _save106
                  break
                end
                _save107 = self.pos
                _tmp = _BlankLine()
                _tmp = _tmp ? nil : true
                self.pos = _save107
                unless _tmp
                  self.pos = _save106
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save105
              break
            end # end choice

            unless _tmp
              self.pos = _save102
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save94
          break
        end # end choice

        if _tmp
          while true

            _save108 = self.pos
            while true # choice
              _save109 = self.pos

              _save110 = self.pos
              while true # sequence
                _save111 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save111
                unless _tmp
                  self.pos = _save110
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save110
                end
                break
              end # end sequence

              if _tmp
                while true

                  _save112 = self.pos
                  while true # sequence
                    _save113 = self.pos
                    _tmp = match_string("`")
                    _tmp = _tmp ? nil : true
                    self.pos = _save113
                    unless _tmp
                      self.pos = _save112
                      break
                    end
                    _tmp = apply(:_Nonspacechar)
                    unless _tmp
                      self.pos = _save112
                    end
                    break
                  end # end sequence

                  break unless _tmp
                end
                _tmp = true
              else
                self.pos = _save109
              end
              break if _tmp
              self.pos = _save108

              _save114 = self.pos
              while true # sequence
                _save115 = self.pos
                _tmp = apply(:_Ticks4)
                _tmp = _tmp ? nil : true
                self.pos = _save115
                unless _tmp
                  self.pos = _save114
                  break
                end
                _tmp = scan(/\G(?-mix:`+)/)
                unless _tmp
                  self.pos = _save114
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save108

              _save116 = self.pos
              while true # sequence
                _save117 = self.pos

                _save118 = self.pos
                while true # sequence
                  _tmp = _Sp()
                  unless _tmp
                    self.pos = _save118
                    break
                  end
                  _tmp = apply(:_Ticks4)
                  unless _tmp
                    self.pos = _save118
                  end
                  break
                end # end sequence

                _tmp = _tmp ? nil : true
                self.pos = _save117
                unless _tmp
                  self.pos = _save116
                  break
                end

                _save119 = self.pos
                while true # choice
                  _tmp = _Spacechar()
                  break if _tmp
                  self.pos = _save119

                  _save120 = self.pos
                  while true # sequence
                    _tmp = _Newline()
                    unless _tmp
                      self.pos = _save120
                      break
                    end
                    _save121 = self.pos
                    _tmp = _BlankLine()
                    _tmp = _tmp ? nil : true
                    self.pos = _save121
                    unless _tmp
                      self.pos = _save120
                    end
                    break
                  end # end sequence

                  break if _tmp
                  self.pos = _save119
                  break
                end # end choice

                unless _tmp
                  self.pos = _save116
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save108
              break
            end # end choice

            break unless _tmp
          end
          _tmp = true
        else
          self.pos = _save93
        end
        if _tmp
          text = get_text(_text_start)
        end
        unless _tmp
          self.pos = _save92
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save92
          break
        end
        _tmp = apply(:_Ticks4)
        unless _tmp
          self.pos = _save92
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1

      _save122 = self.pos
      while true # sequence
        _tmp = apply(:_Ticks5)
        unless _tmp
          self.pos = _save122
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save122
          break
        end
        _text_start = self.pos
        _save123 = self.pos

        _save124 = self.pos
        while true # choice
          _save125 = self.pos

          _save126 = self.pos
          while true # sequence
            _save127 = self.pos
            _tmp = match_string("`")
            _tmp = _tmp ? nil : true
            self.pos = _save127
            unless _tmp
              self.pos = _save126
              break
            end
            _tmp = apply(:_Nonspacechar)
            unless _tmp
              self.pos = _save126
            end
            break
          end # end sequence

          if _tmp
            while true

              _save128 = self.pos
              while true # sequence
                _save129 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save129
                unless _tmp
                  self.pos = _save128
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save128
                end
                break
              end # end sequence

              break unless _tmp
            end
            _tmp = true
          else
            self.pos = _save125
          end
          break if _tmp
          self.pos = _save124

          _save130 = self.pos
          while true # sequence
            _save131 = self.pos
            _tmp = apply(:_Ticks5)
            _tmp = _tmp ? nil : true
            self.pos = _save131
            unless _tmp
              self.pos = _save130
              break
            end
            _tmp = scan(/\G(?-mix:`+)/)
            unless _tmp
              self.pos = _save130
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save124

          _save132 = self.pos
          while true # sequence
            _save133 = self.pos

            _save134 = self.pos
            while true # sequence
              _tmp = _Sp()
              unless _tmp
                self.pos = _save134
                break
              end
              _tmp = apply(:_Ticks5)
              unless _tmp
                self.pos = _save134
              end
              break
            end # end sequence

            _tmp = _tmp ? nil : true
            self.pos = _save133
            unless _tmp
              self.pos = _save132
              break
            end

            _save135 = self.pos
            while true # choice
              _tmp = _Spacechar()
              break if _tmp
              self.pos = _save135

              _save136 = self.pos
              while true # sequence
                _tmp = _Newline()
                unless _tmp
                  self.pos = _save136
                  break
                end
                _save137 = self.pos
                _tmp = _BlankLine()
                _tmp = _tmp ? nil : true
                self.pos = _save137
                unless _tmp
                  self.pos = _save136
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save135
              break
            end # end choice

            unless _tmp
              self.pos = _save132
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save124
          break
        end # end choice

        if _tmp
          while true

            _save138 = self.pos
            while true # choice
              _save139 = self.pos

              _save140 = self.pos
              while true # sequence
                _save141 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save141
                unless _tmp
                  self.pos = _save140
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save140
                end
                break
              end # end sequence

              if _tmp
                while true

                  _save142 = self.pos
                  while true # sequence
                    _save143 = self.pos
                    _tmp = match_string("`")
                    _tmp = _tmp ? nil : true
                    self.pos = _save143
                    unless _tmp
                      self.pos = _save142
                      break
                    end
                    _tmp = apply(:_Nonspacechar)
                    unless _tmp
                      self.pos = _save142
                    end
                    break
                  end # end sequence

                  break unless _tmp
                end
                _tmp = true
              else
                self.pos = _save139
              end
              break if _tmp
              self.pos = _save138

              _save144 = self.pos
              while true # sequence
                _save145 = self.pos
                _tmp = apply(:_Ticks5)
                _tmp = _tmp ? nil : true
                self.pos = _save145
                unless _tmp
                  self.pos = _save144
                  break
                end
                _tmp = scan(/\G(?-mix:`+)/)
                unless _tmp
                  self.pos = _save144
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save138

              _save146 = self.pos
              while true # sequence
                _save147 = self.pos

                _save148 = self.pos
                while true # sequence
                  _tmp = _Sp()
                  unless _tmp
                    self.pos = _save148
                    break
                  end
                  _tmp = apply(:_Ticks5)
                  unless _tmp
                    self.pos = _save148
                  end
                  break
                end # end sequence

                _tmp = _tmp ? nil : true
                self.pos = _save147
                unless _tmp
                  self.pos = _save146
                  break
                end

                _save149 = self.pos
                while true # choice
                  _tmp = _Spacechar()
                  break if _tmp
                  self.pos = _save149

                  _save150 = self.pos
                  while true # sequence
                    _tmp = _Newline()
                    unless _tmp
                      self.pos = _save150
                      break
                    end
                    _save151 = self.pos
                    _tmp = _BlankLine()
                    _tmp = _tmp ? nil : true
                    self.pos = _save151
                    unless _tmp
                      self.pos = _save150
                    end
                    break
                  end # end sequence

                  break if _tmp
                  self.pos = _save149
                  break
                end # end choice

                unless _tmp
                  self.pos = _save146
                end
                break
              end # end sequence

              break if _tmp
              self.pos = _save138
              break
            end # end choice

            break unless _tmp
          end
          _tmp = true
        else
          self.pos = _save123
        end
        if _tmp
          text = get_text(_text_start)
        end
        unless _tmp
          self.pos = _save122
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save122
          break
        end
        _tmp = apply(:_Ticks5)
        unless _tmp
          self.pos = _save122
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  "<code>#{text}</code>" ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Code unless _tmp
  return _tmp
end

#_CodeFence

This method is for internal use only.

CodeFence = &{ github? } Ticks3 (@Sp StrChunk:format)? Spnl < ((!“‘” Nonspacechar)+ | !Ticks3 /`+/ | Spacechar | @Newline)+ > Ticks3 @Sp @Newline* { verbatim = Markup::Verbatim.new text verbatim.format = format.intern if format.instance_of?(String) verbatim }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15681

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 = _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
        _tmp = scan(/\G(?-mix:`+)/)
        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 = _Newline()
      break if _tmp
      self.pos = _save5
      break
    end # end choice

    if _tmp
      while true

        _save13 = self.pos
        while true # choice
          _save14 = self.pos

          _save15 = self.pos
          while true # sequence
            _save16 = self.pos
            _tmp = match_string("`")
            _tmp = _tmp ? nil : true
            self.pos = _save16
            unless _tmp
              self.pos = _save15
              break
            end
            _tmp = apply(:_Nonspacechar)
            unless _tmp
              self.pos = _save15
            end
            break
          end # end sequence

          if _tmp
            while true

              _save17 = self.pos
              while true # sequence
                _save18 = self.pos
                _tmp = match_string("`")
                _tmp = _tmp ? nil : true
                self.pos = _save18
                unless _tmp
                  self.pos = _save17
                  break
                end
                _tmp = apply(:_Nonspacechar)
                unless _tmp
                  self.pos = _save17
                end
                break
              end # end sequence

              break unless _tmp
            end
            _tmp = true
          else
            self.pos = _save14
          end
          break if _tmp
          self.pos = _save13

          _save19 = self.pos
          while true # sequence
            _save20 = self.pos
            _tmp = apply(:_Ticks3)
            _tmp = _tmp ? nil : true
            self.pos = _save20
            unless _tmp
              self.pos = _save19
              break
            end
            _tmp = scan(/\G(?-mix:`+)/)
            unless _tmp
              self.pos = _save19
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save13
          _tmp = apply(:_Spacechar)
          break if _tmp
          self.pos = _save13
          _tmp = _Newline()
          break if _tmp
          self.pos = _save13
          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 = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    while true
      _tmp = _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.instance_of?(String)
            verbatim
          ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_CodeFence unless _tmp
  return _tmp
end

#_DecEntity

This method is for internal use only.

DecEntity = “&#” < /[0-9]+/ > “;” { [text.to_i].pack ‘U’ }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14776

def _DecEntity

  _save = self.pos
  while true # sequence
    _tmp = match_string("&#")
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _tmp = scan(/\G(?-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

#_DefinitionList

This method is for internal use only.

DefinitionList = &{ definition_lists? } DefinitionListItem+:list { Markup::List.new :NOTE, *list.flatten }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16339

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

#_DefinitionListDefinition

This method is for internal use only.

DefinitionListDefinition = @NonindentSpace “:” @Space Inlines:a @BlankLine+ { paragraph a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16482

def _DefinitionListDefinition

  _save = self.pos
  while true # sequence
    _tmp = _NonindentSpace()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string(":")
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Space()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Inlines)
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _BlankLine()
    if _tmp
      while true
        _tmp = _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

#_DefinitionListItem

This method is for internal use only.

DefinitionListItem = DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| Markup::ListItem.new nil, defn } unless list_items.empty? list_items }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16383

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

This method is for internal use only.

DefinitionListLabel = Inline:label @Sp @Newline { label }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16449

def _DefinitionListLabel

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Inline)
    label = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _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

#_Digit

This method is for internal use only.

Digit = [0-9]

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14691

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

#_Doc

This method is for internal use only.

Doc = BOM? Block*:a { Markup::Document.new(*a.compact) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 899

def _Doc

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = apply(:_BOM)
    unless _tmp
      _tmp = true
      self.pos = _save1
    end
    unless _tmp
      self.pos = _save
      break
    end
    _ary = []
    while true
      _tmp = apply(:_Block)
      _ary << @result if _tmp
      break unless _tmp
    end
    _tmp = true
    @result = _ary
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::Document.new(*a.compact) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Doc unless _tmp
  return _tmp
end

#_Emph

This method is for internal use only.

Emph = (EmphStar | EmphUl)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10283

def _Emph

  _save = self.pos
  while true # choice
    _tmp = apply(:_EmphStar)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_EmphUl)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Emph unless _tmp
  return _tmp
end

#_EmphStar

This method is for internal use only.

EmphStar = “*” !@Whitespace @StartList:a (!“*” Inline:b { a << b } | StrongStar:b { a << b })+ “*” { emphasis a.join }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10319

def _EmphStar

  _save = self.pos
  while true # sequence
    _tmp = match_string("*")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _Whitespace()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos

    _save3 = self.pos
    while true # choice

      _save4 = self.pos
      while true # sequence
        _save5 = self.pos
        _tmp = match_string("*")
        _tmp = _tmp ? nil : true
        self.pos = _save5
        unless _tmp
          self.pos = _save4
          break
        end
        _tmp = apply(:_Inline)
        b = @result
        unless _tmp
          self.pos = _save4
          break
        end
        @result = begin;  a << b ; end
        _tmp = true
        unless _tmp
          self.pos = _save4
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save3

      _save6 = self.pos
      while true # sequence
        _tmp = apply(:_StrongStar)
        b = @result
        unless _tmp
          self.pos = _save6
          break
        end
        @result = begin;  a << b ; end
        _tmp = true
        unless _tmp
          self.pos = _save6
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save3
      break
    end # end choice

    if _tmp
      while true

        _save7 = self.pos
        while true # choice

          _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(:_Inline)
            b = @result
            unless _tmp
              self.pos = _save8
              break
            end
            @result = begin;  a << b ; end
            _tmp = true
            unless _tmp
              self.pos = _save8
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save7

          _save10 = self.pos
          while true # sequence
            _tmp = apply(:_StrongStar)
            b = @result
            unless _tmp
              self.pos = _save10
              break
            end
            @result = begin;  a << b ; end
            _tmp = true
            unless _tmp
              self.pos = _save10
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save7
          break
        end # end choice

        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;  emphasis a.join ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_EmphStar unless _tmp
  return _tmp
end

#_EmphUl

This method is for internal use only.

EmphUl = “_” !@Whitespace @StartList:a (!“_” Inline:b { a << b } | StrongUl:b { a << b })+ “_” { emphasis a.join }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10477

def _EmphUl

  _save = self.pos
  while true # sequence
    _tmp = match_string("_")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _Whitespace()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos

    _save3 = self.pos
    while true # choice

      _save4 = self.pos
      while true # sequence
        _save5 = self.pos
        _tmp = match_string("_")
        _tmp = _tmp ? nil : true
        self.pos = _save5
        unless _tmp
          self.pos = _save4
          break
        end
        _tmp = apply(:_Inline)
        b = @result
        unless _tmp
          self.pos = _save4
          break
        end
        @result = begin;  a << b ; end
        _tmp = true
        unless _tmp
          self.pos = _save4
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save3

      _save6 = self.pos
      while true # sequence
        _tmp = apply(:_StrongUl)
        b = @result
        unless _tmp
          self.pos = _save6
          break
        end
        @result = begin;  a << b ; end
        _tmp = true
        unless _tmp
          self.pos = _save6
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save3
      break
    end # end choice

    if _tmp
      while true

        _save7 = self.pos
        while true # choice

          _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(:_Inline)
            b = @result
            unless _tmp
              self.pos = _save8
              break
            end
            @result = begin;  a << b ; end
            _tmp = true
            unless _tmp
              self.pos = _save8
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save7

          _save10 = self.pos
          while true # sequence
            _tmp = apply(:_StrongUl)
            b = @result
            unless _tmp
              self.pos = _save10
              break
            end
            @result = begin;  a << b ; end
            _tmp = true
            unless _tmp
              self.pos = _save10
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save7
          break
        end # end choice

        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;  emphasis a.join ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_EmphUl unless _tmp
  return _tmp
end

#_EmptyTitle

This method is for internal use only.

EmptyTitle = “”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12086

def _EmptyTitle
  _tmp = match_string("")
  set_failed_rule :_EmptyTitle unless _tmp
  return _tmp
end

#_Endline

This method is for internal use only.

Endline = (@LineBreak | @TerminalEndline | @NormalEndline)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9917

def _Endline

  _save = self.pos
  while true # choice
    _tmp = _LineBreak()
    break if _tmp
    self.pos = _save
    _tmp = _TerminalEndline()
    break if _tmp
    self.pos = _save
    _tmp = _NormalEndline()
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Endline unless _tmp
  return _tmp
end

#_Entity

This method is for internal use only.

Entity = (HexEntity | DecEntity | CharEntity):a { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9880

def _Entity

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_HexEntity)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_DecEntity)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_CharEntity)
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_Entity unless _tmp
  return _tmp
end

#_Enumerator

This method is for internal use only.

Enumerator = @NonindentSpace [0-9]+ “.” @Spacechar+

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2687

def _Enumerator

  _save = self.pos
  while true # sequence
    _tmp = _NonindentSpace()
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _save2 = self.pos
    _tmp = get_byte
    if _tmp
      unless _tmp >= 48 and _tmp <= 57
        self.pos = _save2
        _tmp = nil
      end
    end
    if _tmp
      while true
        _save3 = self.pos
        _tmp = get_byte
        if _tmp
          unless _tmp >= 48 and _tmp <= 57
            self.pos = _save3
            _tmp = nil
          end
        end
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save1
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string(".")
    unless _tmp
      self.pos = _save
      break
    end
    _save4 = self.pos
    _tmp = _Spacechar()
    if _tmp
      while true
        _tmp = _Spacechar()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save4
    end
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Enumerator unless _tmp
  return _tmp
end

#_Eof

This method is for internal use only.

Eof = !.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14542

def _Eof
  _save = self.pos
  _tmp = get_byte
  _tmp = _tmp ? nil : true
  self.pos = _save
  set_failed_rule :_Eof unless _tmp
  return _tmp
end

#_EscapedChar

This method is for internal use only.

EscapedChar = “\” !@Newline < /[:\‘|*_{}[]()#+.!><-]/ > { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9841

def _EscapedChar

  _save = self.pos
  while true # sequence
    _tmp = match_string("\\")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _Newline()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _tmp = scan(/\G(?-mix:[:\\`|*_{}\[\]()#+.!><-])/)
    if _tmp
      text = get_text(_text_start)
    end
    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 :_EscapedChar unless _tmp
  return _tmp
end

#_ExtendedSpecialChar

This method is for internal use only.

ExtendedSpecialChar = &{ notes? } “^”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15184

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

#_Heading

This method is for internal use only.

Heading = (SetextHeading | AtxHeading)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1548

def _Heading

  _save = self.pos
  while true # choice
    _tmp = apply(:_SetextHeading)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_AtxHeading)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Heading unless _tmp
  return _tmp
end

#_HexEntity

This method is for internal use only.

HexEntity = /&#x/i < /[0-9a-fA-F]+/ > “;” { [text.to_i(16)].pack ‘U’ }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14740

def _HexEntity

  _save = self.pos
  while true # sequence
    _tmp = scan(/\G(?i-mx:&#x)/)
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _tmp = scan(/\G(?-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

#_HorizontalRule

This method is for internal use only.

HorizontalRule = @NonindentSpace (“*” @Sp “*” @Sp “*” (@Sp “*”)* | “-” @Sp “-” @Sp “-” (@Sp “-”)* | “_” @Sp “_” @Sp “_” (@Sp “_”)*) @Sp @Newline @BlankLine+ { RDoc::Markup::Rule.new 1 }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1932

def _HorizontalRule

  _save = self.pos
  while true # sequence
    _tmp = _NonindentSpace()
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice

      _save2 = self.pos
      while true # sequence
        _tmp = match_string("*")
        unless _tmp
          self.pos = _save2
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save2
          break
        end
        _tmp = match_string("*")
        unless _tmp
          self.pos = _save2
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save2
          break
        end
        _tmp = match_string("*")
        unless _tmp
          self.pos = _save2
          break
        end
        while true

          _save4 = self.pos
          while true # sequence
            _tmp = _Sp()
            unless _tmp
              self.pos = _save4
              break
            end
            _tmp = match_string("*")
            unless _tmp
              self.pos = _save4
            end
            break
          end # end sequence

          break unless _tmp
        end
        _tmp = true
        unless _tmp
          self.pos = _save2
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1

      _save5 = self.pos
      while true # sequence
        _tmp = match_string("-")
        unless _tmp
          self.pos = _save5
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save5
          break
        end
        _tmp = match_string("-")
        unless _tmp
          self.pos = _save5
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save5
          break
        end
        _tmp = match_string("-")
        unless _tmp
          self.pos = _save5
          break
        end
        while true

          _save7 = self.pos
          while true # sequence
            _tmp = _Sp()
            unless _tmp
              self.pos = _save7
              break
            end
            _tmp = match_string("-")
            unless _tmp
              self.pos = _save7
            end
            break
          end # end sequence

          break unless _tmp
        end
        _tmp = true
        unless _tmp
          self.pos = _save5
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1

      _save8 = self.pos
      while true # sequence
        _tmp = match_string("_")
        unless _tmp
          self.pos = _save8
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save8
          break
        end
        _tmp = match_string("_")
        unless _tmp
          self.pos = _save8
          break
        end
        _tmp = _Sp()
        unless _tmp
          self.pos = _save8
          break
        end
        _tmp = match_string("_")
        unless _tmp
          self.pos = _save8
          break
        end
        while true

          _save10 = self.pos
          while true # sequence
            _tmp = _Sp()
            unless _tmp
              self.pos = _save10
              break
            end
            _tmp = match_string("_")
            unless _tmp
              self.pos = _save10
            end
            break
          end # end sequence

          break unless _tmp
        end
        _tmp = true
        unless _tmp
          self.pos = _save8
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    _save11 = self.pos
    _tmp = _BlankLine()
    if _tmp
      while true
        _tmp = _BlankLine()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save11
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::Rule.new 1 ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HorizontalRule unless _tmp
  return _tmp
end

#_HtmlAnchor

This method is for internal use only.

HtmlAnchor = HtmlOpenAnchor (HtmlAnchor | !HtmlCloseAnchor .)* HtmlCloseAnchor

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2971

def _HtmlAnchor

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlOpenAnchor)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlAnchor)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlCloseAnchor)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlCloseAnchor)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlAnchor unless _tmp
  return _tmp
end

#_HtmlAttribute

This method is for internal use only.

HtmlAttribute = (AlphanumericAscii | “-”)+ Spnl (“=” Spnl (Quoted | (!“>” Nonspacechar)+))? Spnl

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14273

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

#_HtmlBlock

This method is for internal use only.

HtmlBlock = < (HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) > @BlankLine+ { if html? then Markup::Raw.new text end }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8768

def _HtmlBlock

  _save = self.pos
  while true # sequence
    _text_start = self.pos

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_HtmlBlockInTags)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_HtmlComment)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_HtmlBlockSelfClosing)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_HtmlUnclosed)
      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
    _save2 = self.pos
    _tmp = _BlankLine()
    if _tmp
      while true
        _tmp = _BlankLine()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save2
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  if html? then
              RDoc::Markup::Raw.new text
            end ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlock unless _tmp
  return _tmp
end

#_HtmlBlockAddress

This method is for internal use only.

HtmlBlockAddress = HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3137

def _HtmlBlockAddress

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenAddress)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockAddress)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseAddress)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseAddress)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockAddress unless _tmp
  return _tmp
end

#_HtmlBlockBlockquote

This method is for internal use only.

HtmlBlockBlockquote = HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3303

def _HtmlBlockBlockquote

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenBlockquote)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockBlockquote)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseBlockquote)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseBlockquote)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockBlockquote unless _tmp
  return _tmp
end

#_HtmlBlockCenter

This method is for internal use only.

HtmlBlockCenter = HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3469

def _HtmlBlockCenter

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenCenter)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockCenter)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseCenter)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseCenter)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockCenter unless _tmp
  return _tmp
end

#_HtmlBlockCloseAddress

This method is for internal use only.

HtmlBlockCloseAddress = “<” Spnl “/” (“address” | “ADDRESS”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3085

def _HtmlBlockCloseAddress

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("address")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("ADDRESS")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseAddress unless _tmp
  return _tmp
end

#_HtmlBlockCloseBlockquote

This method is for internal use only.

HtmlBlockCloseBlockquote = “<” Spnl “/” (“blockquote” | “BLOCKQUOTE”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3251

def _HtmlBlockCloseBlockquote

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("blockquote")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("BLOCKQUOTE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseBlockquote unless _tmp
  return _tmp
end

#_HtmlBlockCloseCenter

This method is for internal use only.

HtmlBlockCloseCenter = “<” Spnl “/” (“center” | “CENTER”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3417

def _HtmlBlockCloseCenter

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("center")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("CENTER")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseCenter unless _tmp
  return _tmp
end

#_HtmlBlockCloseDd

This method is for internal use only.

HtmlBlockCloseDd = “<” Spnl “/” (“dd” | “DD”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6737

def _HtmlBlockCloseDd

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("dd")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseDd unless _tmp
  return _tmp
end

#_HtmlBlockCloseDir

This method is for internal use only.

HtmlBlockCloseDir = “<” Spnl “/” (“dir” | “DIR”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3583

def _HtmlBlockCloseDir

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("dir")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DIR")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseDir unless _tmp
  return _tmp
end

#_HtmlBlockCloseDiv

This method is for internal use only.

HtmlBlockCloseDiv = “<” Spnl “/” (“div” | “DIV”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3749

def _HtmlBlockCloseDiv

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("div")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DIV")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseDiv unless _tmp
  return _tmp
end

#_HtmlBlockCloseDl

This method is for internal use only.

HtmlBlockCloseDl = “<” Spnl “/” (“dl” | “DL”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3915

def _HtmlBlockCloseDl

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("dl")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DL")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseDl unless _tmp
  return _tmp
end

#_HtmlBlockCloseDt

This method is for internal use only.

HtmlBlockCloseDt = “<” Spnl “/” (“dt” | “DT”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6903

def _HtmlBlockCloseDt

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("dt")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseDt unless _tmp
  return _tmp
end

#_HtmlBlockCloseFieldset

This method is for internal use only.

HtmlBlockCloseFieldset = “<” Spnl “/” (“fieldset” | “FIELDSET”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4081

def _HtmlBlockCloseFieldset

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("fieldset")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("FIELDSET")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseFieldset unless _tmp
  return _tmp
end

#_HtmlBlockCloseForm

This method is for internal use only.

HtmlBlockCloseForm = “<” Spnl “/” (“form” | “FORM”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4247

def _HtmlBlockCloseForm

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("form")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("FORM")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseForm unless _tmp
  return _tmp
end

#_HtmlBlockCloseFrameset

This method is for internal use only.

HtmlBlockCloseFrameset = “<” Spnl “/” (“frameset” | “FRAMESET”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7069

def _HtmlBlockCloseFrameset

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("frameset")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("FRAMESET")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseFrameset unless _tmp
  return _tmp
end

#_HtmlBlockCloseH1

This method is for internal use only.

HtmlBlockCloseH1 = “<” Spnl “/” (“h1” | “H1”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4413

def _HtmlBlockCloseH1

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("h1")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H1")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseH1 unless _tmp
  return _tmp
end

#_HtmlBlockCloseH2

This method is for internal use only.

HtmlBlockCloseH2 = “<” Spnl “/” (“h2” | “H2”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4579

def _HtmlBlockCloseH2

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("h2")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H2")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseH2 unless _tmp
  return _tmp
end

#_HtmlBlockCloseH3

This method is for internal use only.

HtmlBlockCloseH3 = “<” Spnl “/” (“h3” | “H3”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4745

def _HtmlBlockCloseH3

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("h3")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H3")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseH3 unless _tmp
  return _tmp
end

#_HtmlBlockCloseH4

This method is for internal use only.

HtmlBlockCloseH4 = “<” Spnl “/” (“h4” | “H4”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4911

def _HtmlBlockCloseH4

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("h4")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H4")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseH4 unless _tmp
  return _tmp
end

#_HtmlBlockCloseH5

This method is for internal use only.

HtmlBlockCloseH5 = “<” Spnl “/” (“h5” | “H5”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5077

def _HtmlBlockCloseH5

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("h5")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H5")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseH5 unless _tmp
  return _tmp
end

#_HtmlBlockCloseH6

This method is for internal use only.

HtmlBlockCloseH6 = “<” Spnl “/” (“h6” | “H6”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5243

def _HtmlBlockCloseH6

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("h6")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H6")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseH6 unless _tmp
  return _tmp
end

#_HtmlBlockCloseHead

This method is for internal use only.

HtmlBlockCloseHead = “<” Spnl “/” (“head” | “HEAD”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8552

def _HtmlBlockCloseHead

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("head")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("HEAD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseHead unless _tmp
  return _tmp
end

#_HtmlBlockCloseLi

This method is for internal use only.

HtmlBlockCloseLi = “<” Spnl “/” (“li” | “LI”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7235

def _HtmlBlockCloseLi

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("li")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("LI")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseLi unless _tmp
  return _tmp
end

#_HtmlBlockCloseMenu

This method is for internal use only.

HtmlBlockCloseMenu = “<” Spnl “/” (“menu” | “MENU”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5409

def _HtmlBlockCloseMenu

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("menu")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("MENU")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseMenu unless _tmp
  return _tmp
end

#_HtmlBlockCloseNoframes

This method is for internal use only.

HtmlBlockCloseNoframes = “<” Spnl “/” (“noframes” | “NOFRAMES”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5575

def _HtmlBlockCloseNoframes

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("noframes")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("NOFRAMES")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseNoframes unless _tmp
  return _tmp
end

#_HtmlBlockCloseNoscript

This method is for internal use only.

HtmlBlockCloseNoscript = “<” Spnl “/” (“noscript” | “NOSCRIPT”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5741

def _HtmlBlockCloseNoscript

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("noscript")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("NOSCRIPT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseNoscript unless _tmp
  return _tmp
end

#_HtmlBlockCloseOl

This method is for internal use only.

HtmlBlockCloseOl = “<” Spnl “/” (“ol” | “OL”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5907

def _HtmlBlockCloseOl

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("ol")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("OL")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseOl unless _tmp
  return _tmp
end

#_HtmlBlockCloseP

This method is for internal use only.

HtmlBlockCloseP = “<” Spnl “/” (“p” | “P”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6073

def _HtmlBlockCloseP

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("p")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("P")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseP unless _tmp
  return _tmp
end

#_HtmlBlockClosePre

This method is for internal use only.

HtmlBlockClosePre = “<” Spnl “/” (“pre” | “PRE”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6239

def _HtmlBlockClosePre

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("pre")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("PRE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockClosePre unless _tmp
  return _tmp
end

#_HtmlBlockCloseScript

This method is for internal use only.

HtmlBlockCloseScript = “<” Spnl “/” (“script” | “SCRIPT”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8397

def _HtmlBlockCloseScript

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("script")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("SCRIPT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseScript unless _tmp
  return _tmp
end

#_HtmlBlockCloseTable

This method is for internal use only.

HtmlBlockCloseTable = “<” Spnl “/” (“table” | “TABLE”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6405

def _HtmlBlockCloseTable

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("table")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TABLE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseTable unless _tmp
  return _tmp
end

#_HtmlBlockCloseTbody

This method is for internal use only.

HtmlBlockCloseTbody = “<” Spnl “/” (“tbody” | “TBODY”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7401

def _HtmlBlockCloseTbody

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("tbody")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TBODY")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseTbody unless _tmp
  return _tmp
end

#_HtmlBlockCloseTd

This method is for internal use only.

HtmlBlockCloseTd = “<” Spnl “/” (“td” | “TD”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7567

def _HtmlBlockCloseTd

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("td")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseTd unless _tmp
  return _tmp
end

#_HtmlBlockCloseTfoot

This method is for internal use only.

HtmlBlockCloseTfoot = “<” Spnl “/” (“tfoot” | “TFOOT”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7733

def _HtmlBlockCloseTfoot

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("tfoot")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TFOOT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseTfoot unless _tmp
  return _tmp
end

#_HtmlBlockCloseTh

This method is for internal use only.

HtmlBlockCloseTh = “<” Spnl “/” (“th” | “TH”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7899

def _HtmlBlockCloseTh

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("th")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TH")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseTh unless _tmp
  return _tmp
end

#_HtmlBlockCloseThead

This method is for internal use only.

HtmlBlockCloseThead = “<” Spnl “/” (“thead” | “THEAD”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8065

def _HtmlBlockCloseThead

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("thead")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("THEAD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseThead unless _tmp
  return _tmp
end

#_HtmlBlockCloseTr

This method is for internal use only.

HtmlBlockCloseTr = “<” Spnl “/” (“tr” | “TR”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8231

def _HtmlBlockCloseTr

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("tr")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TR")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseTr unless _tmp
  return _tmp
end

#_HtmlBlockCloseUl

This method is for internal use only.

HtmlBlockCloseUl = “<” Spnl “/” (“ul” | “UL”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6571

def _HtmlBlockCloseUl

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("ul")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("UL")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlBlockCloseUl unless _tmp
  return _tmp
end

#_HtmlBlockDd

This method is for internal use only.

HtmlBlockDd = HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6789

def _HtmlBlockDd

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenDd)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockDd)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseDd)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseDd)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockDd unless _tmp
  return _tmp
end

#_HtmlBlockDir

This method is for internal use only.

HtmlBlockDir = HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3635

def _HtmlBlockDir

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenDir)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockDir)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseDir)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseDir)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockDir unless _tmp
  return _tmp
end

#_HtmlBlockDiv

This method is for internal use only.

HtmlBlockDiv = HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3801

def _HtmlBlockDiv

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenDiv)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockDiv)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseDiv)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseDiv)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockDiv unless _tmp
  return _tmp
end

#_HtmlBlockDl

This method is for internal use only.

HtmlBlockDl = HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3967

def _HtmlBlockDl

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenDl)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockDl)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseDl)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseDl)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockDl unless _tmp
  return _tmp
end

#_HtmlBlockDt

This method is for internal use only.

HtmlBlockDt = HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6955

def _HtmlBlockDt

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenDt)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockDt)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseDt)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseDt)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockDt unless _tmp
  return _tmp
end

#_HtmlBlockFieldset

This method is for internal use only.

HtmlBlockFieldset = HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4133

def _HtmlBlockFieldset

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenFieldset)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockFieldset)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseFieldset)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseFieldset)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockFieldset unless _tmp
  return _tmp
end

#_HtmlBlockForm

This method is for internal use only.

HtmlBlockForm = HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4299

def _HtmlBlockForm

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenForm)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockForm)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseForm)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseForm)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockForm unless _tmp
  return _tmp
end

#_HtmlBlockFrameset

This method is for internal use only.

HtmlBlockFrameset = HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7121

def _HtmlBlockFrameset

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenFrameset)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockFrameset)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseFrameset)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseFrameset)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockFrameset unless _tmp
  return _tmp
end

#_HtmlBlockH1

This method is for internal use only.

HtmlBlockH1 = HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4465

def _HtmlBlockH1

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenH1)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockH1)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseH1)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseH1)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockH1 unless _tmp
  return _tmp
end

#_HtmlBlockH2

This method is for internal use only.

HtmlBlockH2 = HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4631

def _HtmlBlockH2

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenH2)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockH2)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseH2)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseH2)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockH2 unless _tmp
  return _tmp
end

#_HtmlBlockH3

This method is for internal use only.

HtmlBlockH3 = HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4797

def _HtmlBlockH3

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenH3)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockH3)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseH3)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseH3)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockH3 unless _tmp
  return _tmp
end

#_HtmlBlockH4

This method is for internal use only.

HtmlBlockH4 = HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4963

def _HtmlBlockH4

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenH4)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockH4)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseH4)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseH4)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockH4 unless _tmp
  return _tmp
end

#_HtmlBlockH5

This method is for internal use only.

HtmlBlockH5 = HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5129

def _HtmlBlockH5

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenH5)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockH5)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseH5)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseH5)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockH5 unless _tmp
  return _tmp
end

#_HtmlBlockH6

This method is for internal use only.

HtmlBlockH6 = HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5295

def _HtmlBlockH6

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenH6)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockH6)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseH6)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseH6)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockH6 unless _tmp
  return _tmp
end

#_HtmlBlockHead

This method is for internal use only.

HtmlBlockHead = HtmlBlockOpenHead (!HtmlBlockCloseHead .)* HtmlBlockCloseHead

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8604

def _HtmlBlockHead

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenHead)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos
        _tmp = apply(:_HtmlBlockCloseHead)
        _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 = apply(:_HtmlBlockCloseHead)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockHead unless _tmp
  return _tmp
end

#_HtmlBlockInTags

This method is for internal use only.

HtmlBlockInTags = (HtmlAnchor | 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 | HtmlBlockHead)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8651

def _HtmlBlockInTags

  _save = self.pos
  while true # choice
    _tmp = apply(:_HtmlAnchor)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockAddress)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockBlockquote)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockCenter)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockDir)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockDiv)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockDl)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockFieldset)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockForm)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockH1)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockH2)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockH3)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockH4)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockH5)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockH6)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockMenu)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockNoframes)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockNoscript)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockOl)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockP)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockPre)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockTable)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockUl)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockDd)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockDt)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockFrameset)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockLi)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockTbody)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockTd)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockTfoot)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockTh)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockThead)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockTr)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockScript)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_HtmlBlockHead)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_HtmlBlockInTags unless _tmp
  return _tmp
end

#_HtmlBlockLi

This method is for internal use only.

HtmlBlockLi = HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7287

def _HtmlBlockLi

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenLi)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockLi)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseLi)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseLi)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockLi unless _tmp
  return _tmp
end

#_HtmlBlockMenu

This method is for internal use only.

HtmlBlockMenu = HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5461

def _HtmlBlockMenu

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenMenu)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockMenu)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseMenu)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseMenu)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockMenu unless _tmp
  return _tmp
end

#_HtmlBlockNoframes

This method is for internal use only.

HtmlBlockNoframes = HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5627

def _HtmlBlockNoframes

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenNoframes)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockNoframes)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseNoframes)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseNoframes)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockNoframes unless _tmp
  return _tmp
end

#_HtmlBlockNoscript

This method is for internal use only.

HtmlBlockNoscript = HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5793

def _HtmlBlockNoscript

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenNoscript)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockNoscript)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseNoscript)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseNoscript)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockNoscript unless _tmp
  return _tmp
end

#_HtmlBlockOl

This method is for internal use only.

HtmlBlockOl = HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5959

def _HtmlBlockOl

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenOl)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockOl)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseOl)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseOl)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOl unless _tmp
  return _tmp
end

#_HtmlBlockOpenAddress

This method is for internal use only.

HtmlBlockOpenAddress = “<” Spnl (“address” | “ADDRESS”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3029

def _HtmlBlockOpenAddress

  _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
    while true # choice
      _tmp = match_string("address")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("ADDRESS")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenAddress unless _tmp
  return _tmp
end

#_HtmlBlockOpenBlockquote

This method is for internal use only.

HtmlBlockOpenBlockquote = “<” Spnl (“blockquote” | “BLOCKQUOTE”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3195

def _HtmlBlockOpenBlockquote

  _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
    while true # choice
      _tmp = match_string("blockquote")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("BLOCKQUOTE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenBlockquote unless _tmp
  return _tmp
end

#_HtmlBlockOpenCenter

This method is for internal use only.

HtmlBlockOpenCenter = “<” Spnl (“center” | “CENTER”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3361

def _HtmlBlockOpenCenter

  _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
    while true # choice
      _tmp = match_string("center")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("CENTER")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenCenter unless _tmp
  return _tmp
end

#_HtmlBlockOpenDd

This method is for internal use only.

HtmlBlockOpenDd = “<” Spnl (“dd” | “DD”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6681

def _HtmlBlockOpenDd

  _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
    while true # choice
      _tmp = match_string("dd")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenDd unless _tmp
  return _tmp
end

#_HtmlBlockOpenDir

This method is for internal use only.

HtmlBlockOpenDir = “<” Spnl (“dir” | “DIR”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3527

def _HtmlBlockOpenDir

  _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
    while true # choice
      _tmp = match_string("dir")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DIR")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenDir unless _tmp
  return _tmp
end

#_HtmlBlockOpenDiv

This method is for internal use only.

HtmlBlockOpenDiv = “<” Spnl (“div” | “DIV”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3693

def _HtmlBlockOpenDiv

  _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
    while true # choice
      _tmp = match_string("div")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DIV")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenDiv unless _tmp
  return _tmp
end

#_HtmlBlockOpenDl

This method is for internal use only.

HtmlBlockOpenDl = “<” Spnl (“dl” | “DL”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 3859

def _HtmlBlockOpenDl

  _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
    while true # choice
      _tmp = match_string("dl")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DL")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenDl unless _tmp
  return _tmp
end

#_HtmlBlockOpenDt

This method is for internal use only.

HtmlBlockOpenDt = “<” Spnl (“dt” | “DT”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6847

def _HtmlBlockOpenDt

  _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
    while true # choice
      _tmp = match_string("dt")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("DT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenDt unless _tmp
  return _tmp
end

#_HtmlBlockOpenFieldset

This method is for internal use only.

HtmlBlockOpenFieldset = “<” Spnl (“fieldset” | “FIELDSET”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4025

def _HtmlBlockOpenFieldset

  _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
    while true # choice
      _tmp = match_string("fieldset")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("FIELDSET")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenFieldset unless _tmp
  return _tmp
end

#_HtmlBlockOpenForm

This method is for internal use only.

HtmlBlockOpenForm = “<” Spnl (“form” | “FORM”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4191

def _HtmlBlockOpenForm

  _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
    while true # choice
      _tmp = match_string("form")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("FORM")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenForm unless _tmp
  return _tmp
end

#_HtmlBlockOpenFrameset

This method is for internal use only.

HtmlBlockOpenFrameset = “<” Spnl (“frameset” | “FRAMESET”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7013

def _HtmlBlockOpenFrameset

  _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
    while true # choice
      _tmp = match_string("frameset")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("FRAMESET")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenFrameset unless _tmp
  return _tmp
end

#_HtmlBlockOpenH1

This method is for internal use only.

HtmlBlockOpenH1 = “<” Spnl (“h1” | “H1”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4357

def _HtmlBlockOpenH1

  _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
    while true # choice
      _tmp = match_string("h1")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H1")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenH1 unless _tmp
  return _tmp
end

#_HtmlBlockOpenH2

This method is for internal use only.

HtmlBlockOpenH2 = “<” Spnl (“h2” | “H2”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4523

def _HtmlBlockOpenH2

  _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
    while true # choice
      _tmp = match_string("h2")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H2")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenH2 unless _tmp
  return _tmp
end

#_HtmlBlockOpenH3

This method is for internal use only.

HtmlBlockOpenH3 = “<” Spnl (“h3” | “H3”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4689

def _HtmlBlockOpenH3

  _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
    while true # choice
      _tmp = match_string("h3")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H3")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenH3 unless _tmp
  return _tmp
end

#_HtmlBlockOpenH4

This method is for internal use only.

HtmlBlockOpenH4 = “<” Spnl (“h4” | “H4”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 4855

def _HtmlBlockOpenH4

  _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
    while true # choice
      _tmp = match_string("h4")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H4")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenH4 unless _tmp
  return _tmp
end

#_HtmlBlockOpenH5

This method is for internal use only.

HtmlBlockOpenH5 = “<” Spnl (“h5” | “H5”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5021

def _HtmlBlockOpenH5

  _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
    while true # choice
      _tmp = match_string("h5")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H5")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenH5 unless _tmp
  return _tmp
end

#_HtmlBlockOpenH6

This method is for internal use only.

HtmlBlockOpenH6 = “<” Spnl (“h6” | “H6”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5187

def _HtmlBlockOpenH6

  _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
    while true # choice
      _tmp = match_string("h6")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("H6")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenH6 unless _tmp
  return _tmp
end

#_HtmlBlockOpenHead

This method is for internal use only.

HtmlBlockOpenHead = “<” Spnl (“head” | “HEAD”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8496

def _HtmlBlockOpenHead

  _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
    while true # choice
      _tmp = match_string("head")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("HEAD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenHead unless _tmp
  return _tmp
end

#_HtmlBlockOpenLi

This method is for internal use only.

HtmlBlockOpenLi = “<” Spnl (“li” | “LI”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7179

def _HtmlBlockOpenLi

  _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
    while true # choice
      _tmp = match_string("li")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("LI")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenLi unless _tmp
  return _tmp
end

#_HtmlBlockOpenMenu

This method is for internal use only.

HtmlBlockOpenMenu = “<” Spnl (“menu” | “MENU”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5353

def _HtmlBlockOpenMenu

  _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
    while true # choice
      _tmp = match_string("menu")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("MENU")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenMenu unless _tmp
  return _tmp
end

#_HtmlBlockOpenNoframes

This method is for internal use only.

HtmlBlockOpenNoframes = “<” Spnl (“noframes” | “NOFRAMES”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5519

def _HtmlBlockOpenNoframes

  _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
    while true # choice
      _tmp = match_string("noframes")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("NOFRAMES")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenNoframes unless _tmp
  return _tmp
end

#_HtmlBlockOpenNoscript

This method is for internal use only.

HtmlBlockOpenNoscript = “<” Spnl (“noscript” | “NOSCRIPT”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5685

def _HtmlBlockOpenNoscript

  _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
    while true # choice
      _tmp = match_string("noscript")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("NOSCRIPT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenNoscript unless _tmp
  return _tmp
end

#_HtmlBlockOpenOl

This method is for internal use only.

HtmlBlockOpenOl = “<” Spnl (“ol” | “OL”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 5851

def _HtmlBlockOpenOl

  _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
    while true # choice
      _tmp = match_string("ol")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("OL")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenOl unless _tmp
  return _tmp
end

#_HtmlBlockOpenP

This method is for internal use only.

HtmlBlockOpenP = “<” Spnl (“p” | “P”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6017

def _HtmlBlockOpenP

  _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
    while true # choice
      _tmp = match_string("p")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("P")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenP unless _tmp
  return _tmp
end

#_HtmlBlockOpenPre

This method is for internal use only.

HtmlBlockOpenPre = “<” Spnl (“pre” | “PRE”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6183

def _HtmlBlockOpenPre

  _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
    while true # choice
      _tmp = match_string("pre")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("PRE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenPre unless _tmp
  return _tmp
end

#_HtmlBlockOpenScript

This method is for internal use only.

HtmlBlockOpenScript = “<” Spnl (“script” | “SCRIPT”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8341

def _HtmlBlockOpenScript

  _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
    while true # choice
      _tmp = match_string("script")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("SCRIPT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenScript unless _tmp
  return _tmp
end

#_HtmlBlockOpenTable

This method is for internal use only.

HtmlBlockOpenTable = “<” Spnl (“table” | “TABLE”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6349

def _HtmlBlockOpenTable

  _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
    while true # choice
      _tmp = match_string("table")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TABLE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenTable unless _tmp
  return _tmp
end

#_HtmlBlockOpenTbody

This method is for internal use only.

HtmlBlockOpenTbody = “<” Spnl (“tbody” | “TBODY”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7345

def _HtmlBlockOpenTbody

  _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
    while true # choice
      _tmp = match_string("tbody")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TBODY")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenTbody unless _tmp
  return _tmp
end

#_HtmlBlockOpenTd

This method is for internal use only.

HtmlBlockOpenTd = “<” Spnl (“td” | “TD”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7511

def _HtmlBlockOpenTd

  _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
    while true # choice
      _tmp = match_string("td")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenTd unless _tmp
  return _tmp
end

#_HtmlBlockOpenTfoot

This method is for internal use only.

HtmlBlockOpenTfoot = “<” Spnl (“tfoot” | “TFOOT”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7677

def _HtmlBlockOpenTfoot

  _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
    while true # choice
      _tmp = match_string("tfoot")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TFOOT")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenTfoot unless _tmp
  return _tmp
end

#_HtmlBlockOpenTh

This method is for internal use only.

HtmlBlockOpenTh = “<” Spnl (“th” | “TH”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7843

def _HtmlBlockOpenTh

  _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
    while true # choice
      _tmp = match_string("th")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TH")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenTh unless _tmp
  return _tmp
end

#_HtmlBlockOpenThead

This method is for internal use only.

HtmlBlockOpenThead = “<” Spnl (“thead” | “THEAD”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8009

def _HtmlBlockOpenThead

  _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
    while true # choice
      _tmp = match_string("thead")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("THEAD")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenThead unless _tmp
  return _tmp
end

#_HtmlBlockOpenTr

This method is for internal use only.

HtmlBlockOpenTr = “<” Spnl (“tr” | “TR”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8175

def _HtmlBlockOpenTr

  _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
    while true # choice
      _tmp = match_string("tr")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("TR")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenTr unless _tmp
  return _tmp
end

#_HtmlBlockOpenUl

This method is for internal use only.

HtmlBlockOpenUl = “<” Spnl (“ul” | “UL”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6515

def _HtmlBlockOpenUl

  _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
    while true # choice
      _tmp = match_string("ul")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("UL")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockOpenUl unless _tmp
  return _tmp
end

#_HtmlBlockP

This method is for internal use only.

HtmlBlockP = HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6125

def _HtmlBlockP

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenP)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockP)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseP)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseP)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockP unless _tmp
  return _tmp
end

#_HtmlBlockPre

This method is for internal use only.

HtmlBlockPre = HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6291

def _HtmlBlockPre

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenPre)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockPre)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockClosePre)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockClosePre)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockPre unless _tmp
  return _tmp
end

#_HtmlBlockScript

This method is for internal use only.

HtmlBlockScript = HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8449

def _HtmlBlockScript

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenScript)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos
        _tmp = apply(:_HtmlBlockCloseScript)
        _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 = apply(:_HtmlBlockCloseScript)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockScript unless _tmp
  return _tmp
end

#_HtmlBlockSelfClosing

This method is for internal use only.

HtmlBlockSelfClosing = “<” Spnl HtmlBlockType Spnl HtmlAttribute* “/” Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8896

def _HtmlBlockSelfClosing

  _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
    _tmp = apply(:_HtmlBlockType)
    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
    _tmp = match_string("/")
    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 :_HtmlBlockSelfClosing unless _tmp
  return _tmp
end

#_HtmlBlockTable

This method is for internal use only.

HtmlBlockTable = HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6457

def _HtmlBlockTable

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenTable)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockTable)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseTable)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseTable)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockTable unless _tmp
  return _tmp
end

#_HtmlBlockTbody

This method is for internal use only.

HtmlBlockTbody = HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7453

def _HtmlBlockTbody

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenTbody)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockTbody)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseTbody)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseTbody)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockTbody unless _tmp
  return _tmp
end

#_HtmlBlockTd

This method is for internal use only.

HtmlBlockTd = HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7619

def _HtmlBlockTd

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenTd)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockTd)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseTd)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseTd)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockTd unless _tmp
  return _tmp
end

#_HtmlBlockTfoot

This method is for internal use only.

HtmlBlockTfoot = HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7785

def _HtmlBlockTfoot

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenTfoot)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockTfoot)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseTfoot)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseTfoot)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockTfoot unless _tmp
  return _tmp
end

#_HtmlBlockTh

This method is for internal use only.

HtmlBlockTh = HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 7951

def _HtmlBlockTh

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenTh)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockTh)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseTh)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseTh)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockTh unless _tmp
  return _tmp
end

#_HtmlBlockThead

This method is for internal use only.

HtmlBlockThead = HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8117

def _HtmlBlockThead

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenThead)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockThead)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseThead)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseThead)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockThead unless _tmp
  return _tmp
end

#_HtmlBlockTr

This method is for internal use only.

HtmlBlockTr = HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8283

def _HtmlBlockTr

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenTr)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockTr)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseTr)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseTr)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockTr unless _tmp
  return _tmp
end

#_HtmlBlockType

This method is for internal use only.

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”)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8951

def _HtmlBlockType

  _save = self.pos
  while true # choice
    _tmp = match_string("ADDRESS")
    break if _tmp
    self.pos = _save
    _tmp = match_string("BLOCKQUOTE")
    break if _tmp
    self.pos = _save
    _tmp = match_string("CENTER")
    break if _tmp
    self.pos = _save
    _tmp = match_string("DD")
    break if _tmp
    self.pos = _save
    _tmp = match_string("DIR")
    break if _tmp
    self.pos = _save
    _tmp = match_string("DIV")
    break if _tmp
    self.pos = _save
    _tmp = match_string("DL")
    break if _tmp
    self.pos = _save
    _tmp = match_string("DT")
    break if _tmp
    self.pos = _save
    _tmp = match_string("FIELDSET")
    break if _tmp
    self.pos = _save
    _tmp = match_string("FORM")
    break if _tmp
    self.pos = _save
    _tmp = match_string("FRAMESET")
    break if _tmp
    self.pos = _save
    _tmp = match_string("H1")
    break if _tmp
    self.pos = _save
    _tmp = match_string("H2")
    break if _tmp
    self.pos = _save
    _tmp = match_string("H3")
    break if _tmp
    self.pos = _save
    _tmp = match_string("H4")
    break if _tmp
    self.pos = _save
    _tmp = match_string("H5")
    break if _tmp
    self.pos = _save
    _tmp = match_string("H6")
    break if _tmp
    self.pos = _save
    _tmp = match_string("HR")
    break if _tmp
    self.pos = _save
    _tmp = match_string("ISINDEX")
    break if _tmp
    self.pos = _save
    _tmp = match_string("LI")
    break if _tmp
    self.pos = _save
    _tmp = match_string("MENU")
    break if _tmp
    self.pos = _save
    _tmp = match_string("NOFRAMES")
    break if _tmp
    self.pos = _save
    _tmp = match_string("NOSCRIPT")
    break if _tmp
    self.pos = _save
    _tmp = match_string("OL")
    break if _tmp
    self.pos = _save
    _tmp = match_string("P")
    break if _tmp
    self.pos = _save
    _tmp = match_string("PRE")
    break if _tmp
    self.pos = _save
    _tmp = match_string("SCRIPT")
    break if _tmp
    self.pos = _save
    _tmp = match_string("TABLE")
    break if _tmp
    self.pos = _save
    _tmp = match_string("TBODY")
    break if _tmp
    self.pos = _save
    _tmp = match_string("TD")
    break if _tmp
    self.pos = _save
    _tmp = match_string("TFOOT")
    break if _tmp
    self.pos = _save
    _tmp = match_string("TH")
    break if _tmp
    self.pos = _save
    _tmp = match_string("THEAD")
    break if _tmp
    self.pos = _save
    _tmp = match_string("TR")
    break if _tmp
    self.pos = _save
    _tmp = match_string("UL")
    break if _tmp
    self.pos = _save
    _tmp = match_string("address")
    break if _tmp
    self.pos = _save
    _tmp = match_string("blockquote")
    break if _tmp
    self.pos = _save
    _tmp = match_string("center")
    break if _tmp
    self.pos = _save
    _tmp = match_string("dd")
    break if _tmp
    self.pos = _save
    _tmp = match_string("dir")
    break if _tmp
    self.pos = _save
    _tmp = match_string("div")
    break if _tmp
    self.pos = _save
    _tmp = match_string("dl")
    break if _tmp
    self.pos = _save
    _tmp = match_string("dt")
    break if _tmp
    self.pos = _save
    _tmp = match_string("fieldset")
    break if _tmp
    self.pos = _save
    _tmp = match_string("form")
    break if _tmp
    self.pos = _save
    _tmp = match_string("frameset")
    break if _tmp
    self.pos = _save
    _tmp = match_string("h1")
    break if _tmp
    self.pos = _save
    _tmp = match_string("h2")
    break if _tmp
    self.pos = _save
    _tmp = match_string("h3")
    break if _tmp
    self.pos = _save
    _tmp = match_string("h4")
    break if _tmp
    self.pos = _save
    _tmp = match_string("h5")
    break if _tmp
    self.pos = _save
    _tmp = match_string("h6")
    break if _tmp
    self.pos = _save
    _tmp = match_string("hr")
    break if _tmp
    self.pos = _save
    _tmp = match_string("isindex")
    break if _tmp
    self.pos = _save
    _tmp = match_string("li")
    break if _tmp
    self.pos = _save
    _tmp = match_string("menu")
    break if _tmp
    self.pos = _save
    _tmp = match_string("noframes")
    break if _tmp
    self.pos = _save
    _tmp = match_string("noscript")
    break if _tmp
    self.pos = _save
    _tmp = match_string("ol")
    break if _tmp
    self.pos = _save
    _tmp = match_string("p")
    break if _tmp
    self.pos = _save
    _tmp = match_string("pre")
    break if _tmp
    self.pos = _save
    _tmp = match_string("script")
    break if _tmp
    self.pos = _save
    _tmp = match_string("table")
    break if _tmp
    self.pos = _save
    _tmp = match_string("tbody")
    break if _tmp
    self.pos = _save
    _tmp = match_string("td")
    break if _tmp
    self.pos = _save
    _tmp = match_string("tfoot")
    break if _tmp
    self.pos = _save
    _tmp = match_string("th")
    break if _tmp
    self.pos = _save
    _tmp = match_string("thead")
    break if _tmp
    self.pos = _save
    _tmp = match_string("tr")
    break if _tmp
    self.pos = _save
    _tmp = match_string("ul")
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_HtmlBlockType unless _tmp
  return _tmp
end

#_HtmlBlockUl

This method is for internal use only.

HtmlBlockUl = HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 6623

def _HtmlBlockUl

  _save = self.pos
  while true # sequence
    _tmp = apply(:_HtmlBlockOpenUl)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # choice
        _tmp = apply(:_HtmlBlockUl)
        break if _tmp
        self.pos = _save2

        _save3 = self.pos
        while true # sequence
          _save4 = self.pos
          _tmp = apply(:_HtmlBlockCloseUl)
          _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 if _tmp
        self.pos = _save2
        break
      end # end choice

      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_HtmlBlockCloseUl)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlBlockUl unless _tmp
  return _tmp
end

#_HtmlCloseAnchor

This method is for internal use only.

HtmlCloseAnchor = “<” Spnl “/” (“a” | “A”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2919

def _HtmlCloseAnchor

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("a")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("A")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_HtmlCloseAnchor unless _tmp
  return _tmp
end

#_HtmlComment

This method is for internal use only.

HtmlComment = “<!–” (!“–>” .)* “–>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14415

def _HtmlComment

  _save = self.pos
  while true # sequence
    _tmp = match_string("<!--")
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos
        _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

#_HtmlOpenAnchor

This method is for internal use only.

HtmlOpenAnchor = “<” Spnl (“a” | “A”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2863

def _HtmlOpenAnchor

  _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
    while true # choice
      _tmp = match_string("a")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("A")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_HtmlOpenAnchor unless _tmp
  return _tmp
end

#_HtmlTag

This method is for internal use only.

HtmlTag = “<” Spnl “/”? AlphanumericAscii+ Spnl HtmlAttribute* “/”? Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14462

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

#_HtmlUnclosed

This method is for internal use only.

HtmlUnclosed = “<” Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8828

def _HtmlUnclosed

  _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
    _tmp = apply(:_HtmlUnclosedType)
    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
    _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 :_HtmlUnclosed unless _tmp
  return _tmp
end

#_HtmlUnclosedType

This method is for internal use only.

HtmlUnclosedType = (“HR” | “hr”)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 8878

def _HtmlUnclosedType

  _save = self.pos
  while true # choice
    _tmp = match_string("HR")
    break if _tmp
    self.pos = _save
    _tmp = match_string("hr")
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_HtmlUnclosedType unless _tmp
  return _tmp
end

#_Image

This method is for internal use only.

Image = “!” (ExplicitLink | ReferenceLink):a { “pos while true # sequence _tmp = match_string("!") unless _tmp self.pos = _save break end _save1 = self.pos while true # choice _tmp = apply(:_ExplicitLink) break if _tmp self.pos = _save1 _tmp = apply(:_ReferenceLink) break if _tmp self.pos = _save1 break end # end choice a = @result unless _tmp self.pos = _save break end @result = begin; "rdoc-image:#{a[/\[(.*)\]/, 1]}" ; end _tmp = true unless _tmp self.pos = _save end break end # end sequence set_failed_rule :_Image unless _tmp return _tmp end

#_Indent

This method is for internal use only.

Indent = /t| /

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14860

def _Indent
  _tmp = scan(/\G(?-mix:\t|    )/)
  set_failed_rule :_Indent unless _tmp
  return _tmp
end

#_IndentedLine

This method is for internal use only.

IndentedLine = Indent Line

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14867

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

#_Inline

This method is for internal use only.

Inline = (Str | @Endline | UlOrStarLine | @Space | Strong | Emph | Strike | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9586

def _Inline

  _save = self.pos
  while true # choice
    _tmp = apply(:_Str)
    break if _tmp
    self.pos = _save
    _tmp = _Endline()
    break if _tmp
    self.pos = _save
    _tmp = apply(:_UlOrStarLine)
    break if _tmp
    self.pos = _save
    _tmp = _Space()
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Strong)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Emph)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Strike)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Image)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Link)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_NoteReference)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_InlineNote)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Code)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_RawHtml)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Entity)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_EscapedChar)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_Symbol)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Inline unless _tmp
  return _tmp
end

#_InlineNote

This method is for internal use only.

InlineNote = &{ notes? } “^[” @StartList:a (!“]” Inline:l { a << l })+ “]” { ref = [:inline, @note_order.length] @footnotes = paragraph a note_for ref }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15431

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 = _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

#_Inlines

This method is for internal use only.

Inlines = (!@Endline Inline:i { i } | @Endline:c !(&{ github? } Ticks3 /[^‘n]*$/) &Inline { c })+:chunks @Endline? { chunks }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9365

def _Inlines

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _ary = []

    _save2 = self.pos
    while true # choice

      _save3 = self.pos
      while true # sequence
        _save4 = self.pos
        _tmp = _Endline()
        _tmp = _tmp ? nil : true
        self.pos = _save4
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = apply(:_Inline)
        i = @result
        unless _tmp
          self.pos = _save3
          break
        end
        @result = begin;  i ; end
        _tmp = true
        unless _tmp
          self.pos = _save3
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save2

      _save5 = self.pos
      while true # sequence
        _tmp = _Endline()
        c = @result
        unless _tmp
          self.pos = _save5
          break
        end
        _save6 = self.pos

        _save7 = self.pos
        while true # sequence
          _save8 = self.pos
          _tmp = begin;  github? ; end
          self.pos = _save8
          unless _tmp
            self.pos = _save7
            break
          end
          _tmp = apply(:_Ticks3)
          unless _tmp
            self.pos = _save7
            break
          end
          _tmp = scan(/\G(?-mix:[^`\n]*$)/)
          unless _tmp
            self.pos = _save7
          end
          break
        end # end sequence

        _tmp = _tmp ? nil : true
        self.pos = _save6
        unless _tmp
          self.pos = _save5
          break
        end
        _save9 = self.pos
        _tmp = apply(:_Inline)
        self.pos = _save9
        unless _tmp
          self.pos = _save5
          break
        end
        @result = begin;  c ; end
        _tmp = true
        unless _tmp
          self.pos = _save5
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save2
      break
    end # end choice

    if _tmp
      _ary << @result
      while true

        _save10 = self.pos
        while true # choice

          _save11 = self.pos
          while true # sequence
            _save12 = self.pos
            _tmp = _Endline()
            _tmp = _tmp ? nil : true
            self.pos = _save12
            unless _tmp
              self.pos = _save11
              break
            end
            _tmp = apply(:_Inline)
            i = @result
            unless _tmp
              self.pos = _save11
              break
            end
            @result = begin;  i ; end
            _tmp = true
            unless _tmp
              self.pos = _save11
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save10

          _save13 = self.pos
          while true # sequence
            _tmp = _Endline()
            c = @result
            unless _tmp
              self.pos = _save13
              break
            end
            _save14 = self.pos

            _save15 = self.pos
            while true # sequence
              _save16 = self.pos
              _tmp = begin;  github? ; end
              self.pos = _save16
              unless _tmp
                self.pos = _save15
                break
              end
              _tmp = apply(:_Ticks3)
              unless _tmp
                self.pos = _save15
                break
              end
              _tmp = scan(/\G(?-mix:[^`\n]*$)/)
              unless _tmp
                self.pos = _save15
              end
              break
            end # end sequence

            _tmp = _tmp ? nil : true
            self.pos = _save14
            unless _tmp
              self.pos = _save13
              break
            end
            _save17 = self.pos
            _tmp = apply(:_Inline)
            self.pos = _save17
            unless _tmp
              self.pos = _save13
              break
            end
            @result = begin;  c ; end
            _tmp = true
            unless _tmp
              self.pos = _save13
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save10
          break
        end # end choice

        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save1
    end
    chunks = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save18 = self.pos
    _tmp = _Endline()
    unless _tmp
      _tmp = true
      self.pos = _save18
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  chunks ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Inlines unless _tmp
  return _tmp
end

#_InStyleTags

This method is for internal use only.

InStyleTags = StyleOpen (!StyleClose .)* StyleClose

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9281

def _InStyleTags

  _save = self.pos
  while true # sequence
    _tmp = apply(:_StyleOpen)
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos
        _tmp = apply(:_StyleClose)
        _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 = apply(:_StyleClose)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_InStyleTags unless _tmp
  return _tmp
end

#_Label

This method is for internal use only.

Label = “[” (!“^” &{ notes? } | &. &{ !notes? }) @StartList:a (!“]” Inline:l { a << l })* “]” { a.join.gsub(/s+/, ‘ ’) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11907

def _Label

  _save = self.pos
  while true # sequence
    _tmp = match_string("[")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos
        _tmp = match_string("^")
        _tmp = _tmp ? nil : true
        self.pos = _save3
        unless _tmp
          self.pos = _save2
          break
        end
        _save4 = self.pos
        _tmp = begin;  notes? ; end
        self.pos = _save4
        unless _tmp
          self.pos = _save2
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1

      _save5 = self.pos
      while true # sequence
        _save6 = self.pos
        _tmp = get_byte
        self.pos = _save6
        unless _tmp
          self.pos = _save5
          break
        end
        _save7 = self.pos
        _tmp = begin;  !notes? ; end
        self.pos = _save7
        unless _tmp
          self.pos = _save5
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    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(:_Inline)
        l = @result
        unless _tmp
          self.pos = _save9
          break
        end
        @result = begin;  a << l ; end
        _tmp = true
        unless _tmp
          self.pos = _save9
        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
      break
    end
    @result = begin;  a.join.gsub(/\s+/, ' ') ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Label unless _tmp
  return _tmp
end

#_Line

This method is for internal use only.

Line = @RawLine:a { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14938

def _Line

  _save = self.pos
  while true # sequence
    _tmp = _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

#_LineBreak

This method is for internal use only.

LineBreak = “ ” @NormalEndline { Markup::HardBreak.new }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10042

def _LineBreak

  _save = self.pos
  while true # sequence
    _tmp = match_string("  ")
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _NormalEndline()
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::HardBreak.new ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_LineBreak unless _tmp
  return _tmp
end

#_ListBlock

This method is for internal use only.

ListBlock = !@BlankLine Line:a ListBlockLine*:c { [a, *c] }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2548

def _ListBlock

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = _BlankLine()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Line)
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _ary = []
    while true
      _tmp = apply(:_ListBlockLine)
      _ary << @result if _tmp
      break unless _tmp
    end
    _tmp = true
    @result = _ary
    c = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  [a, *c] ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ListBlock unless _tmp
  return _tmp
end

#_ListBlockLine

This method is for internal use only.

ListBlockLine = !@BlankLine !(Indent? (Bullet | Enumerator)) !HorizontalRule OptionallyIndentedLine

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2793

def _ListBlockLine

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = _BlankLine()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos

    _save3 = self.pos
    while true # sequence
      _save4 = self.pos
      _tmp = apply(:_Indent)
      unless _tmp
        _tmp = true
        self.pos = _save4
      end
      unless _tmp
        self.pos = _save3
        break
      end

      _save5 = self.pos
      while true # choice
        _tmp = apply(:_Bullet)
        break if _tmp
        self.pos = _save5
        _tmp = apply(:_Enumerator)
        break if _tmp
        self.pos = _save5
        break
      end # end choice

      unless _tmp
        self.pos = _save3
      end
      break
    end # end sequence

    _tmp = _tmp ? nil : true
    self.pos = _save2
    unless _tmp
      self.pos = _save
      break
    end
    _save6 = self.pos
    _tmp = apply(:_HorizontalRule)
    _tmp = _tmp ? nil : true
    self.pos = _save6
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_OptionallyIndentedLine)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ListBlockLine unless _tmp
  return _tmp
end

#_ListContinuationBlock

This method is for internal use only.

ListContinuationBlock = @StartList:a @BlankLine* { a << “n” } (Indent ListBlock:b { a.concat b })+ { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2592

def _ListContinuationBlock

  _save = self.pos
  while true # sequence
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    while true
      _tmp = _BlankLine()
      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  a << "\n" ; end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos

    _save3 = self.pos
    while true # sequence
      _tmp = apply(:_Indent)
      unless _tmp
        self.pos = _save3
        break
      end
      _tmp = apply(:_ListBlock)
      b = @result
      unless _tmp
        self.pos = _save3
        break
      end
      @result = begin;  a.concat b ; end
      _tmp = true
      unless _tmp
        self.pos = _save3
      end
      break
    end # end sequence

    if _tmp
      while true

        _save4 = self.pos
        while true # sequence
          _tmp = apply(:_Indent)
          unless _tmp
            self.pos = _save4
            break
          end
          _tmp = apply(:_ListBlock)
          b = @result
          unless _tmp
            self.pos = _save4
            break
          end
          @result = begin;  a.concat b ; end
          _tmp = true
          unless _tmp
            self.pos = _save4
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save2
    end
    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 :_ListContinuationBlock unless _tmp
  return _tmp
end

#_ListItem

This method is for internal use only.

ListItem = (Bullet | Enumerator) @StartList:a ListBlock:b { a << b } (ListContinuationBlock:c { a.push(*c) })* { list_item_from a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2392

def _ListItem

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_Bullet)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_Enumerator)
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_ListBlock)
    b = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  a << b ; end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save3 = self.pos
      while true # sequence
        _tmp = apply(:_ListContinuationBlock)
        c = @result
        unless _tmp
          self.pos = _save3
          break
        end
        @result = begin;  a.push(*c) ; 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;  list_item_from a ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ListItem unless _tmp
  return _tmp
end

#_ListItemTight

This method is for internal use only.

ListItemTight = (Bullet | Enumerator) ListBlock:a (!@BlankLine ListContinuationBlock:b { a.push(*b) })* !ListContinuationBlock { list_item_from a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2468

def _ListItemTight

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_Bullet)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_Enumerator)
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_ListBlock)
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save3 = self.pos
      while true # sequence
        _save4 = self.pos
        _tmp = _BlankLine()
        _tmp = _tmp ? nil : true
        self.pos = _save4
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = apply(:_ListContinuationBlock)
        b = @result
        unless _tmp
          self.pos = _save3
          break
        end
        @result = begin;  a.push(*b) ; 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
    _save5 = self.pos
    _tmp = apply(:_ListContinuationBlock)
    _tmp = _tmp ? nil : true
    self.pos = _save5
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  list_item_from a ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ListItemTight unless _tmp
  return _tmp
end

#_ListLoose

This method is for internal use only.

ListLoose = @StartList:a (ListItem:b @BlankLine* { a << b })+ { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2304

def _ListLoose

  _save = self.pos
  while true # sequence
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = apply(:_ListItem)
      b = @result
      unless _tmp
        self.pos = _save2
        break
      end
      while true
        _tmp = _BlankLine()
        break unless _tmp
      end
      _tmp = true
      unless _tmp
        self.pos = _save2
        break
      end
      @result = begin;  a << b ; end
      _tmp = true
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    if _tmp
      while true

        _save4 = self.pos
        while true # sequence
          _tmp = apply(:_ListItem)
          b = @result
          unless _tmp
            self.pos = _save4
            break
          end
          while true
            _tmp = _BlankLine()
            break unless _tmp
          end
          _tmp = true
          unless _tmp
            self.pos = _save4
            break
          end
          @result = begin;  a << b ; 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
    @result = begin;  a ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ListLoose unless _tmp
  return _tmp
end

#_ListTight

This method is for internal use only.

ListTight = ListItemTight+:a @BlankLine* !(Bullet | Enumerator) { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2239

def _ListTight

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _ary = []
    _tmp = apply(:_ListItemTight)
    if _tmp
      _ary << @result
      while true
        _tmp = apply(:_ListItemTight)
        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save1
    end
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    while true
      _tmp = _BlankLine()
      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    _save3 = self.pos

    _save4 = self.pos
    while true # choice
      _tmp = apply(:_Bullet)
      break if _tmp
      self.pos = _save4
      _tmp = apply(:_Enumerator)
      break if _tmp
      self.pos = _save4
      break
    end # end choice

    _tmp = _tmp ? nil : true
    self.pos = _save3
    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 :_ListTight unless _tmp
  return _tmp
end

#_Newline

This method is for internal use only.

Newline = %literals.Newline

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14726

def _Newline
  _tmp = @_grammar_literals.external_invoke(self, :_Newline)
  set_failed_rule :_Newline unless _tmp
  return _tmp
end

#_NonblankIndentedLine

This method is for internal use only.

NonblankIndentedLine = !@BlankLine IndentedLine

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1821

def _NonblankIndentedLine

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = _BlankLine()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_IndentedLine)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_NonblankIndentedLine unless _tmp
  return _tmp
end

#_NonindentSpace

This method is for internal use only.

NonindentSpace = / 0,3/

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14853

def _NonindentSpace
  _tmp = scan(/\G(?-mix: {0,3})/)
  set_failed_rule :_NonindentSpace unless _tmp
  return _tmp
end

#_Nonspacechar

This method is for internal use only.

Nonspacechar = !@Spacechar !@Newline .

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14552

def _Nonspacechar

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = _Spacechar()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _tmp = _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

#_NormalChar

This method is for internal use only.

NormalChar = !(@SpecialChar | @Spacechar | @Newline) .

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14653

def _NormalChar

  _save = self.pos
  while true # sequence
    _save1 = self.pos

    _save2 = self.pos
    while true # choice
      _tmp = _SpecialChar()
      break if _tmp
      self.pos = _save2
      _tmp = _Spacechar()
      break if _tmp
      self.pos = _save2
      _tmp = _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

#_NormalEndline

This method is for internal use only.

NormalEndline = @Sp @Newline !@BlankLine !“>” !AtxStart !(Line /=1,|-1,/ @Newline) { “n” }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9938

def _NormalEndline

  _save = self.pos
  while true # sequence
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _BlankLine()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _tmp = match_string(">")
    _tmp = _tmp ? nil : true
    self.pos = _save2
    unless _tmp
      self.pos = _save
      break
    end
    _save3 = self.pos
    _tmp = apply(:_AtxStart)
    _tmp = _tmp ? nil : true
    self.pos = _save3
    unless _tmp
      self.pos = _save
      break
    end
    _save4 = self.pos

    _save5 = self.pos
    while true # sequence
      _tmp = apply(:_Line)
      unless _tmp
        self.pos = _save5
        break
      end
      _tmp = scan(/\G(?-mix:={1,}|-{1,})/)
      unless _tmp
        self.pos = _save5
        break
      end
      _tmp = _Newline()
      unless _tmp
        self.pos = _save5
      end
      break
    end # end sequence

    _tmp = _tmp ? nil : true
    self.pos = _save4
    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 :_NormalEndline unless _tmp
  return _tmp
end

#_Note

This method is for internal use only.

Note = &{ notes? } @NonindentSpace RawNoteReference:ref “:” @Sp @StartList:a RawNoteBlock:i { a.concat i } (&Indent RawNoteBlock:i { a.concat i })* { @footnotes = paragraph a nil }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15333

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 = _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 = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_RawNoteBlock)
    i = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  a.concat i ; end
    _tmp = true
    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

#_NoteReference

This method is for internal use only.

NoteReference = &{ notes? } RawNoteReference:ref { note_for ref }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15207

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

#_Notes

This method is for internal use only.

Notes = (Note | SkipBlock)*

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15538

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

#_OptionallyIndentedLine

This method is for internal use only.

OptionallyIndentedLine = Indent? Line

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14888

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

#_OrderedList

This method is for internal use only.

OrderedList = &Enumerator (ListTight | ListLoose):a { Markup::List.new(:NUMBER, *a) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 2752

def _OrderedList

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = apply(:_Enumerator)
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end

    _save2 = self.pos
    while true # choice
      _tmp = apply(:_ListTight)
      break if _tmp
      self.pos = _save2
      _tmp = apply(:_ListLoose)
      break if _tmp
      self.pos = _save2
      break
    end # end choice

    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::List.new(:NUMBER, *a) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_OrderedList unless _tmp
  return _tmp
end

#_Para

This method is for internal use only.

Para = @NonindentSpace Inlines:a @BlankLine+ { paragraph a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1014

def _Para

  _save = self.pos
  while true # sequence
    _tmp = _NonindentSpace()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Inlines)
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _BlankLine()
    if _tmp
      while true
        _tmp = _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 :_Para unless _tmp
  return _tmp
end

#_Plain

This method is for internal use only.

Plain = Inlines:a { paragraph a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1057

def _Plain

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Inlines)
    a = @result
    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 :_Plain unless _tmp
  return _tmp
end

#_Quoted

This method is for internal use only.

Quoted = (“"” (!“"” .)* “"” | “‘” (!“’” .)* “‘”)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14175

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

#_RawHtml

This method is for internal use only.

RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else ” end }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14108

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

#_RawLine

This method is for internal use only.

RawLine = (< /[^rn]*/ @Newline > | < .+ > @Eof) { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14961

def _RawLine

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice
      _text_start = self.pos

      _save2 = self.pos
      while true # sequence
        _tmp = scan(/\G(?-mix:[^\r\n]*)/)
        unless _tmp
          self.pos = _save2
          break
        end
        _tmp = _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

      _save3 = self.pos
      while true # sequence
        _text_start = self.pos
        _save4 = self.pos
        _tmp = get_byte
        if _tmp
          while true
            _tmp = get_byte
            break unless _tmp
          end
          _tmp = true
        else
          self.pos = _save4
        end
        if _tmp
          text = get_text(_text_start)
        end
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = _Eof()
        unless _tmp
          self.pos = _save3
        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

#_RawNoteBlock

This method is for internal use only.

RawNoteBlock = @StartList:a (!@BlankLine !RawNoteReference OptionallyIndentedLine:l { a << l })+ < @BlankLine* > { a << text } { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15560

def _RawNoteBlock

  _save = self.pos
  while true # sequence
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _save3 = self.pos
      _tmp = _BlankLine()
      _tmp = _tmp ? nil : true
      self.pos = _save3
      unless _tmp
        self.pos = _save2
        break
      end
      _save4 = self.pos
      _tmp = apply(:_RawNoteReference)
      _tmp = _tmp ? nil : true
      self.pos = _save4
      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

        _save5 = self.pos
        while true # sequence
          _save6 = self.pos
          _tmp = _BlankLine()
          _tmp = _tmp ? nil : true
          self.pos = _save6
          unless _tmp
            self.pos = _save5
            break
          end
          _save7 = self.pos
          _tmp = apply(:_RawNoteReference)
          _tmp = _tmp ? nil : true
          self.pos = _save7
          unless _tmp
            self.pos = _save5
            break
          end
          _tmp = apply(:_OptionallyIndentedLine)
          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 = _save1
    end
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    while true
      _tmp = _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

#_RawNoteReference

This method is for internal use only.

RawNoteReference = “[^” < (!@Newline !“]” .)+ > “]” { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15237

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 = _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 = _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

#_Reference

This method is for internal use only.

Reference = @NonindentSpace !“[]” Label:label “:” Spnl RefSrc:link RefTitle @BlankLine+ { # TODO use title reference label, link nil }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11832

def _Reference

  _save = self.pos
  while true # sequence
    _tmp = _NonindentSpace()
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("[]")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Label)
    label = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string(":")
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Spnl)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_RefSrc)
    link = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_RefTitle)
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _tmp = _BlankLine()
    if _tmp
      while true
        _tmp = _BlankLine()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save2
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  # TODO use title
            reference label, link
            nil
          ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Reference unless _tmp
  return _tmp
end

#_ReferenceLinkDouble

This method is for internal use only.

ReferenceLinkDouble = Label:content < Spnl > !“[]” Label:label { link_to content, label, text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11050

def _ReferenceLinkDouble

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Label)
    content = @result
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _tmp = apply(:_Spnl)
    if _tmp
      text = get_text(_text_start)
    end
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("[]")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Label)
    label = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  link_to content, label, text ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ReferenceLinkDouble unless _tmp
  return _tmp
end

#_ReferenceLinkSingle

This method is for internal use only.

ReferenceLinkSingle = Label:content < (Spnl “[]”)? > { link_to content, content, text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11096

def _ReferenceLinkSingle

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Label)
    content = @result
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = apply(:_Spnl)
      unless _tmp
        self.pos = _save2
        break
      end
      _tmp = match_string("[]")
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    unless _tmp
      _tmp = true
      self.pos = _save1
    end
    if _tmp
      text = get_text(_text_start)
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  link_to content, content, text ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ReferenceLinkSingle unless _tmp
  return _tmp
end

#_References

This method is for internal use only.

References = (Reference | SkipBlock)*

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12369

def _References
  while true

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_Reference)
      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 :_References unless _tmp
  return _tmp
end

#_RefSrc

This method is for internal use only.

RefSrc = < Nonspacechar+ > { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12026

def _RefSrc

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _save1 = self.pos
    _tmp = apply(:_Nonspacechar)
    if _tmp
      while true
        _tmp = apply(:_Nonspacechar)
        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
    @result = begin;  text ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_RefSrc unless _tmp
  return _tmp
end

#_RefTitle

This method is for internal use only.

RefTitle = (RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12062

def _RefTitle

  _save = self.pos
  while true # choice
    _tmp = apply(:_RefTitleSingle)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_RefTitleDouble)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_RefTitleParens)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_EmptyTitle)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_RefTitle unless _tmp
  return _tmp
end

#_RefTitleDouble

This method is for internal use only.

RefTitleDouble = Spnl “"” < (!(“"” @Sp @Newline | @Newline) .)* > “"” { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12185

def _RefTitleDouble

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Spnl)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string("\"")
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos

        _save4 = self.pos
        while true # choice

          _save5 = self.pos
          while true # sequence
            _tmp = match_string("\"")
            unless _tmp
              self.pos = _save5
              break
            end
            _tmp = _Sp()
            unless _tmp
              self.pos = _save5
              break
            end
            _tmp = _Newline()
            unless _tmp
              self.pos = _save5
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save4
          _tmp = _Newline()
          break if _tmp
          self.pos = _save4
          break
        end # end choice

        _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
    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 :_RefTitleDouble unless _tmp
  return _tmp
end

#_RefTitleParens

This method is for internal use only.

RefTitleParens = Spnl “(” < (!(“)” @Sp @Newline | @Newline) .)* > “)” { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12277

def _RefTitleParens

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Spnl)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string("(")
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos

        _save4 = self.pos
        while true # choice

          _save5 = self.pos
          while true # sequence
            _tmp = match_string(")")
            unless _tmp
              self.pos = _save5
              break
            end
            _tmp = _Sp()
            unless _tmp
              self.pos = _save5
              break
            end
            _tmp = _Newline()
            unless _tmp
              self.pos = _save5
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save4
          _tmp = _Newline()
          break if _tmp
          self.pos = _save4
          break
        end # end choice

        _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
    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 :_RefTitleParens unless _tmp
  return _tmp
end

#_RefTitleSingle

This method is for internal use only.

RefTitleSingle = Spnl “‘” < (!(“’” @Sp @Newline | @Newline) .)* > “‘” { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12093

def _RefTitleSingle

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Spnl)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string("'")
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos

        _save4 = self.pos
        while true # choice

          _save5 = self.pos
          while true # sequence
            _tmp = match_string("'")
            unless _tmp
              self.pos = _save5
              break
            end
            _tmp = _Sp()
            unless _tmp
              self.pos = _save5
              break
            end
            _tmp = _Newline()
            unless _tmp
              self.pos = _save5
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save4
          _tmp = _Newline()
          break if _tmp
          self.pos = _save4
          break
        end # end choice

        _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
    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 :_RefTitleSingle unless _tmp
  return _tmp
end

#_root

This method is for internal use only.

root = Doc

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 892

def _root
  _tmp = apply(:_Doc)
  set_failed_rule :_root unless _tmp
  return _tmp
end

#_SetextBottom1

This method is for internal use only.

SetextBottom1 = /=1,/ @Newline

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1262

def _SetextBottom1

  _save = self.pos
  while true # sequence
    _tmp = scan(/\G(?-mix:={1,})/)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_SetextBottom1 unless _tmp
  return _tmp
end

#_SetextBottom2

This method is for internal use only.

SetextBottom2 = /-1,/ @Newline

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1283

def _SetextBottom2

  _save = self.pos
  while true # sequence
    _tmp = scan(/\G(?-mix:-{1,})/)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_SetextBottom2 unless _tmp
  return _tmp
end

#_SetextHeading

This method is for internal use only.

SetextHeading = (SetextHeading1 | SetextHeading2)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1244

def _SetextHeading

  _save = self.pos
  while true # choice
    _tmp = apply(:_SetextHeading1)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_SetextHeading2)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_SetextHeading unless _tmp
  return _tmp
end

#_SetextHeading1

This method is for internal use only.

SetextHeading1 = &(@RawLine SetextBottom1) @StartList:a (!@Endline Inline:b { a << b })+ @Sp @Newline SetextBottom1 { RDoc::Markup::Heading.new(1, a.join) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1304

def _SetextHeading1

  _save = self.pos
  while true # sequence
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = _RawLine()
      unless _tmp
        self.pos = _save2
        break
      end
      _tmp = apply(:_SetextBottom1)
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save3 = self.pos

    _save4 = self.pos
    while true # sequence
      _save5 = self.pos
      _tmp = _Endline()
      _tmp = _tmp ? nil : true
      self.pos = _save5
      unless _tmp
        self.pos = _save4
        break
      end
      _tmp = apply(:_Inline)
      b = @result
      unless _tmp
        self.pos = _save4
        break
      end
      @result = begin;  a << b ; end
      _tmp = true
      unless _tmp
        self.pos = _save4
      end
      break
    end # end sequence

    if _tmp
      while true

        _save6 = self.pos
        while true # sequence
          _save7 = self.pos
          _tmp = _Endline()
          _tmp = _tmp ? nil : true
          self.pos = _save7
          unless _tmp
            self.pos = _save6
            break
          end
          _tmp = apply(:_Inline)
          b = @result
          unless _tmp
            self.pos = _save6
            break
          end
          @result = begin;  a << b ; end
          _tmp = true
          unless _tmp
            self.pos = _save6
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save3
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_SetextBottom1)
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::Heading.new(1, a.join) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_SetextHeading1 unless _tmp
  return _tmp
end

#_SetextHeading2

This method is for internal use only.

SetextHeading2 = &(@RawLine SetextBottom2) @StartList:a (!@Endline Inline:b { a << b })+ @Sp @Newline SetextBottom2 { RDoc::Markup::Heading.new(2, a.join) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1426

def _SetextHeading2

  _save = self.pos
  while true # sequence
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = _RawLine()
      unless _tmp
        self.pos = _save2
        break
      end
      _tmp = apply(:_SetextBottom2)
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save3 = self.pos

    _save4 = self.pos
    while true # sequence
      _save5 = self.pos
      _tmp = _Endline()
      _tmp = _tmp ? nil : true
      self.pos = _save5
      unless _tmp
        self.pos = _save4
        break
      end
      _tmp = apply(:_Inline)
      b = @result
      unless _tmp
        self.pos = _save4
        break
      end
      @result = begin;  a << b ; end
      _tmp = true
      unless _tmp
        self.pos = _save4
      end
      break
    end # end sequence

    if _tmp
      while true

        _save6 = self.pos
        while true # sequence
          _save7 = self.pos
          _tmp = _Endline()
          _tmp = _tmp ? nil : true
          self.pos = _save7
          unless _tmp
            self.pos = _save6
            break
          end
          _tmp = apply(:_Inline)
          b = @result
          unless _tmp
            self.pos = _save6
            break
          end
          @result = begin;  a << b ; end
          _tmp = true
          unless _tmp
            self.pos = _save6
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save3
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_SetextBottom2)
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::Heading.new(2, a.join) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_SetextHeading2 unless _tmp
  return _tmp
end

#_SkipBlock

This method is for internal use only.

SkipBlock = (HtmlBlock | (!“#” !SetextBottom1 !SetextBottom2 !@BlankLine @RawLine)+ @BlankLine* | @BlankLine+ | @RawLine)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15040

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 = _BlankLine()
        _tmp = _tmp ? nil : true
        self.pos = _save7
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = _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 = _BlankLine()
            _tmp = _tmp ? nil : true
            self.pos = _save12
            unless _tmp
              self.pos = _save8
              break
            end
            _tmp = _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 = _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 = _BlankLine()
    if _tmp
      while true
        _tmp = _BlankLine()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save14
    end
    break if _tmp
    self.pos = _save
    _tmp = _RawLine()
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_SkipBlock unless _tmp
  return _tmp
end

#_Source

This method is for internal use only.

Source = (“<” < SourceContents > “>” | < SourceContents >) { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11206

def _Source

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice

      _save2 = self.pos
      while true # sequence
        _tmp = match_string("<")
        unless _tmp
          self.pos = _save2
          break
        end
        _text_start = self.pos
        _tmp = apply(:_SourceContents)
        if _tmp
          text = get_text(_text_start)
        end
        unless _tmp
          self.pos = _save2
          break
        end
        _tmp = match_string(">")
        unless _tmp
          self.pos = _save2
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1
      _text_start = self.pos
      _tmp = apply(:_SourceContents)
      if _tmp
        text = get_text(_text_start)
      end
      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 :_Source unless _tmp
  return _tmp
end

#_SourceContents

This method is for internal use only.

SourceContents = ((!“(” !“)” !“>” Nonspacechar)+ | “(” SourceContents “)”)*

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11266

def _SourceContents
  while true

    _save1 = self.pos
    while true # choice
      _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 = match_string(")")
        _tmp = _tmp ? nil : true
        self.pos = _save5
        unless _tmp
          self.pos = _save3
          break
        end
        _save6 = self.pos
        _tmp = match_string(">")
        _tmp = _tmp ? nil : true
        self.pos = _save6
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = apply(:_Nonspacechar)
        unless _tmp
          self.pos = _save3
        end
        break
      end # end sequence

      if _tmp
        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
            _save9 = self.pos
            _tmp = match_string(")")
            _tmp = _tmp ? nil : true
            self.pos = _save9
            unless _tmp
              self.pos = _save7
              break
            end
            _save10 = self.pos
            _tmp = match_string(">")
            _tmp = _tmp ? nil : true
            self.pos = _save10
            unless _tmp
              self.pos = _save7
              break
            end
            _tmp = apply(:_Nonspacechar)
            unless _tmp
              self.pos = _save7
            end
            break
          end # end sequence

          break unless _tmp
        end
        _tmp = true
      else
        self.pos = _save2
      end
      break if _tmp
      self.pos = _save1

      _save11 = self.pos
      while true # sequence
        _tmp = match_string("(")
        unless _tmp
          self.pos = _save11
          break
        end
        _tmp = apply(:_SourceContents)
        unless _tmp
          self.pos = _save11
          break
        end
        _tmp = match_string(")")
        unless _tmp
          self.pos = _save11
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save1
      break
    end # end choice

    break unless _tmp
  end
  _tmp = true
  set_failed_rule :_SourceContents unless _tmp
  return _tmp
end

#_Sp

This method is for internal use only.

Sp = @Spacechar*

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14584

def _Sp
  while true
    _tmp = _Spacechar()
    break unless _tmp
  end
  _tmp = true
  set_failed_rule :_Sp unless _tmp
  return _tmp
end

#_Space

This method is for internal use only.

Space = @Spacechar+ { “ ” }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9646

def _Space

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = _Spacechar()
    if _tmp
      while true
        _tmp = _Spacechar()
        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save1
    end
    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 :_Space unless _tmp
  return _tmp
end

#_Spacechar

This method is for internal use only.

Spacechar = %literals.Spacechar

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14733

def _Spacechar
  _tmp = @_grammar_literals.external_invoke(self, :_Spacechar)
  set_failed_rule :_Spacechar unless _tmp
  return _tmp
end

#_SpecialChar

This method is for internal use only.

SpecialChar = (/[~*_`&()<!#\‘“]/ | @ExtendedSpecialChar)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14635

def _SpecialChar

  _save = self.pos
  while true # choice
    _tmp = scan(/\G(?-mix:[~*_`&\[\]()<!#\\'"])/)
    break if _tmp
    self.pos = _save
    _tmp = _ExtendedSpecialChar()
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_SpecialChar unless _tmp
  return _tmp
end

#_Spnl

This method is for internal use only.

Spnl = @Sp (@Newline @Sp)?

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14595

def _Spnl

  _save = self.pos
  while true # sequence
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos

    _save2 = self.pos
    while true # sequence
      _tmp = _Newline()
      unless _tmp
        self.pos = _save2
        break
      end
      _tmp = _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

#_StarLine

This method is for internal use only.

StarLine = (< /*4,/ > { text } | < @Spacechar /*+/ &@Spacechar > { text })

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10129

def _StarLine

  _save = self.pos
  while true # choice

    _save1 = self.pos
    while true # sequence
      _text_start = self.pos
      _tmp = scan(/\G(?-mix:\*{4,})/)
      if _tmp
        text = get_text(_text_start)
      end
      unless _tmp
        self.pos = _save1
        break
      end
      @result = begin;  text ; end
      _tmp = true
      unless _tmp
        self.pos = _save1
      end
      break
    end # end sequence

    break if _tmp
    self.pos = _save

    _save2 = self.pos
    while true # sequence
      _text_start = self.pos

      _save3 = self.pos
      while true # sequence
        _tmp = _Spacechar()
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = scan(/\G(?-mix:\*+)/)
        unless _tmp
          self.pos = _save3
          break
        end
        _save4 = self.pos
        _tmp = _Spacechar()
        self.pos = _save4
        unless _tmp
          self.pos = _save3
        end
        break
      end # end sequence

      if _tmp
        text = get_text(_text_start)
      end
      unless _tmp
        self.pos = _save2
        break
      end
      @result = begin;  text ; end
      _tmp = true
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_StarLine unless _tmp
  return _tmp
end

#_StartList

This method is for internal use only.

StartList = &. { [] }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 14914

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

#_Str

This method is for internal use only.

Str = @StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9678

def _Str

  _save = self.pos
  while true # sequence
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _text_start = self.pos
    _save1 = self.pos
    _tmp = _NormalChar()
    if _tmp
      while true
        _tmp = _NormalChar()
        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
    @result = begin;  a = text ; end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save3 = self.pos
      while true # sequence
        _tmp = apply(:_StrChunk)
        c = @result
        unless _tmp
          self.pos = _save3
          break
        end
        @result = begin;  a << c ; 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;  a ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Str unless _tmp
  return _tmp
end

#_StrChunk

This method is for internal use only.

StrChunk = < (@NormalChar | /_+/ &Alphanumeric)+ > { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9751

def _StrChunk

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _save1 = self.pos

    _save2 = self.pos
    while true # choice
      _tmp = _NormalChar()
      break if _tmp
      self.pos = _save2

      _save3 = self.pos
      while true # sequence
        _tmp = scan(/\G(?-mix:_+)/)
        unless _tmp
          self.pos = _save3
          break
        end
        _save4 = self.pos
        _tmp = apply(:_Alphanumeric)
        self.pos = _save4
        unless _tmp
          self.pos = _save3
        end
        break
      end # end sequence

      break if _tmp
      self.pos = _save2
      break
    end # end choice

    if _tmp
      while true

        _save5 = self.pos
        while true # choice
          _tmp = _NormalChar()
          break if _tmp
          self.pos = _save5

          _save6 = self.pos
          while true # sequence
            _tmp = scan(/\G(?-mix:_+)/)
            unless _tmp
              self.pos = _save6
              break
            end
            _save7 = self.pos
            _tmp = apply(:_Alphanumeric)
            self.pos = _save7
            unless _tmp
              self.pos = _save6
            end
            break
          end # end sequence

          break if _tmp
          self.pos = _save5
          break
        end # end choice

        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
    @result = begin;  text ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_StrChunk unless _tmp
  return _tmp
end

#_Strike

This method is for internal use only.

Strike = &{ strike? } “~~” !@Whitespace @StartList:a (!“~~” Inline:b { a << b })+ “~~” { strike a.join }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10861

def _Strike

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _tmp = begin;  strike? ; end
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string("~~")
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _tmp = _Whitespace()
    _tmp = _tmp ? nil : true
    self.pos = _save2
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _StartList()
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save3 = self.pos

    _save4 = self.pos
    while true # sequence
      _save5 = self.pos
      _tmp = match_string("~~")
      _tmp = _tmp ? nil : true
      self.pos = _save5
      unless _tmp
        self.pos = _save4
        break
      end
      _tmp = apply(:_Inline)
      b = @result
      unless _tmp
        self.pos = _save4
        break
      end
      @result = begin;  a << b ; end
      _tmp = true
      unless _tmp
        self.pos = _save4
      end
      break
    end # end sequence

    if _tmp
      while true

        _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(:_Inline)
          b = @result
          unless _tmp
            self.pos = _save6
            break
          end
          @result = begin;  a << b ; end
          _tmp = true
          unless _tmp
            self.pos = _save6
          end
          break
        end # end sequence

        break unless _tmp
      end
      _tmp = true
    else
      self.pos = _save3
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string("~~")
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  strike a.join ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Strike unless _tmp
  return _tmp
end

#_Strong

This method is for internal use only.

Strong = (StrongStar | StrongUl)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10635

def _Strong

  _save = self.pos
  while true # choice
    _tmp = apply(:_StrongStar)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_StrongUl)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Strong unless _tmp
  return _tmp
end

#_StrongStar

This method is for internal use only.

StrongStar = “**” !@Whitespace @StartList:a (!“**” Inline:b { a << b })+ “**” { strong a.join }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10653

def _StrongStar

  _save = self.pos
  while true # sequence
    _tmp = match_string("**")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _Whitespace()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _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)
      b = @result
      unless _tmp
        self.pos = _save3
        break
      end
      @result = begin;  a << b ; 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)
          b = @result
          unless _tmp
            self.pos = _save5
            break
          end
          @result = begin;  a << b ; 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;  strong a.join ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_StrongStar unless _tmp
  return _tmp
end

#_StrongUl

This method is for internal use only.

StrongUl = “__” !@Whitespace @StartList:a (!“__” Inline:b { a << b })+ “__” { strong a.join }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10757

def _StrongUl

  _save = self.pos
  while true # sequence
    _tmp = match_string("__")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = _Whitespace()
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _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)
      b = @result
      unless _tmp
        self.pos = _save3
        break
      end
      @result = begin;  a << b ; 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)
          b = @result
          unless _tmp
            self.pos = _save5
            break
          end
          @result = begin;  a << b ; 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;  strong a.join ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_StrongUl unless _tmp
  return _tmp
end

#_StyleBlock

This method is for internal use only.

StyleBlock = < InStyleTags > @BlankLine* { if css? then Markup::Raw.new text end }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9328

def _StyleBlock

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _tmp = apply(:_InStyleTags)
    if _tmp
      text = get_text(_text_start)
    end
    unless _tmp
      self.pos = _save
      break
    end
    while true
      _tmp = _BlankLine()
      break unless _tmp
    end
    _tmp = true
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  if css? then
                  RDoc::Markup::Raw.new text
                end ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_StyleBlock unless _tmp
  return _tmp
end

#_StyleClose

This method is for internal use only.

StyleClose = “<” Spnl “/” (“style” | “STYLE”) Spnl “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9229

def _StyleClose

  _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
    _tmp = match_string("/")
    unless _tmp
      self.pos = _save
      break
    end

    _save1 = self.pos
    while true # choice
      _tmp = match_string("style")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("STYLE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_StyleClose unless _tmp
  return _tmp
end

#_StyleOpen

This method is for internal use only.

StyleOpen = “<” Spnl (“style” | “STYLE”) Spnl HtmlAttribute* “>”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 9173

def _StyleOpen

  _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
    while true # choice
      _tmp = match_string("style")
      break if _tmp
      self.pos = _save1
      _tmp = match_string("STYLE")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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
    _tmp = match_string(">")
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_StyleOpen unless _tmp
  return _tmp
end

#_Symbol

This method is for internal use only.

Symbol = < @SpecialChar > { text }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10069

def _Symbol

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _tmp = _SpecialChar()
    if _tmp
      text = get_text(_text_start)
    end
    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 :_Symbol unless _tmp
  return _tmp
end

#_Table

This method is for internal use only.

Table = &{ github? } TableHead:header TableLine:line TableRow+:body { table = Markup::Table.new(header, line, body) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15937

def _Table

  _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(:_TableHead)
    header = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_TableLine)
    line = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _ary = []
    _tmp = apply(:_TableRow)
    if _tmp
      _ary << @result
      while true
        _tmp = apply(:_TableRow)
        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save2
    end
    body = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  table = RDoc::Markup::Table.new(header, line, body) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Table unless _tmp
  return _tmp
end

#_TableAlign

This method is for internal use only.

TableAlign = < /:?-+:?/ > @Sp { text.start_with?(“:”) ? (text.end_with?(“:”) ? :center : :left) : (text.end_with?(“:”) ? :right : nil) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16304

def _TableAlign

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _tmp = scan(/\G(?-mix::?-+:?)/)
    if _tmp
      text = get_text(_text_start)
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;
              text.start_with?(":") ?
              (text.end_with?(":") ? :center : :left) :
              (text.end_with?(":") ? :right : nil)
            ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableAlign unless _tmp
  return _tmp
end

#_TableAlign2

This method is for internal use only.

TableAlign2 = “|” @Sp TableAlign

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16278

def _TableAlign2

  _save = self.pos
  while true # sequence
    _tmp = match_string("|")
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_TableAlign)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableAlign2 unless _tmp
  return _tmp
end

#_TableHead

This method is for internal use only.

TableHead = TableItem2+:items “|”? @Newline { items }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 15993

def _TableHead

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _ary = []
    _tmp = apply(:_TableItem2)
    if _tmp
      _ary << @result
      while true
        _tmp = apply(:_TableItem2)
        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save1
    end
    items = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _tmp = match_string("|")
    unless _tmp
      _tmp = true
      self.pos = _save2
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  items ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableHead unless _tmp
  return _tmp
end

#_TableItem

This method is for internal use only.

TableItem = < /(?:\.|[^|n])+/ > { text.strip.gsub(/\(.)/, ‘1’) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16159

def _TableItem

  _save = self.pos
  while true # sequence
    _text_start = self.pos
    _tmp = scan(/\G(?-mix:(?:\\.|[^|\n])+)/)
    if _tmp
      text = get_text(_text_start)
    end
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  text.strip.gsub(/\\(.)/, '\1')  ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableItem unless _tmp
  return _tmp
end

#_TableItem2

This method is for internal use only.

TableItem2 = “|” TableItem

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16138

def _TableItem2

  _save = self.pos
  while true # sequence
    _tmp = match_string("|")
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_TableItem)
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableItem2 unless _tmp
  return _tmp
end

#_TableLine

This method is for internal use only.

TableLine = ((TableAlign:align1 TableAlign2*:aligns {[align1, *aligns] }):line | TableAlign2+:line) “|”? @Newline { line }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16185

def _TableLine

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice

      _save2 = self.pos
      while true # sequence
        _tmp = apply(:_TableAlign)
        align1 = @result
        unless _tmp
          self.pos = _save2
          break
        end
        _ary = []
        while true
          _tmp = apply(:_TableAlign2)
          _ary << @result if _tmp
          break unless _tmp
        end
        _tmp = true
        @result = _ary
        aligns = @result
        unless _tmp
          self.pos = _save2
          break
        end
        @result = begin; [align1, *aligns] ; end
        _tmp = true
        unless _tmp
          self.pos = _save2
        end
        break
      end # end sequence

      line = @result
      break if _tmp
      self.pos = _save1
      _save4 = self.pos
      _ary = []
      _tmp = apply(:_TableAlign2)
      if _tmp
        _ary << @result
        while true
          _tmp = apply(:_TableAlign2)
          _ary << @result if _tmp
          break unless _tmp
        end
        _tmp = true
        @result = _ary
      else
        self.pos = _save4
      end
      line = @result
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    _save5 = self.pos
    _tmp = match_string("|")
    unless _tmp
      _tmp = true
      self.pos = _save5
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  line ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableLine unless _tmp
  return _tmp
end

#_TableRow

This method is for internal use only.

TableRow = ((TableItem:item1 TableItem2*:items { [item1, *items] }):row | TableItem2+:row) “|”? @Newline { row }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 16045

def _TableRow

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice

      _save2 = self.pos
      while true # sequence
        _tmp = apply(:_TableItem)
        item1 = @result
        unless _tmp
          self.pos = _save2
          break
        end
        _ary = []
        while true
          _tmp = apply(:_TableItem2)
          _ary << @result if _tmp
          break unless _tmp
        end
        _tmp = true
        @result = _ary
        items = @result
        unless _tmp
          self.pos = _save2
          break
        end
        @result = begin;  [item1, *items] ; end
        _tmp = true
        unless _tmp
          self.pos = _save2
        end
        break
      end # end sequence

      row = @result
      break if _tmp
      self.pos = _save1
      _save4 = self.pos
      _ary = []
      _tmp = apply(:_TableItem2)
      if _tmp
        _ary << @result
        while true
          _tmp = apply(:_TableItem2)
          _ary << @result if _tmp
          break unless _tmp
        end
        _tmp = true
        @result = _ary
      else
        self.pos = _save4
      end
      row = @result
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    unless _tmp
      self.pos = _save
      break
    end
    _save5 = self.pos
    _tmp = match_string("|")
    unless _tmp
      _tmp = true
      self.pos = _save5
    end
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  row ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TableRow unless _tmp
  return _tmp
end

#_TerminalEndline

This method is for internal use only.

TerminalEndline = @Sp @Newline @Eof

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10016

def _TerminalEndline

  _save = self.pos
  while true # sequence
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Newline()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Eof()
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_TerminalEndline unless _tmp
  return _tmp
end

#_Ticks1

This method is for internal use only.

Ticks1 = “‘” !“`”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12391

def _Ticks1

  _save = self.pos
  while true # sequence
    _tmp = match_string("`")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("`")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Ticks1 unless _tmp
  return _tmp
end

#_Ticks2

This method is for internal use only.

Ticks2 = ““” !“‘”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12415

def _Ticks2

  _save = self.pos
  while true # sequence
    _tmp = match_string("``")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("`")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Ticks2 unless _tmp
  return _tmp
end

#_Ticks3

This method is for internal use only.

Ticks3 = ““‘” !“`”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12439

def _Ticks3

  _save = self.pos
  while true # sequence
    _tmp = match_string("```")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("`")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Ticks3 unless _tmp
  return _tmp
end

#_Ticks4

This method is for internal use only.

Ticks4 = “““” !“‘”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12463

def _Ticks4

  _save = self.pos
  while true # sequence
    _tmp = match_string("````")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("`")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Ticks4 unless _tmp
  return _tmp
end

#_Ticks5

This method is for internal use only.

Ticks5 = “““‘” !“`”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 12487

def _Ticks5

  _save = self.pos
  while true # sequence
    _tmp = match_string("`````")
    unless _tmp
      self.pos = _save
      break
    end
    _save1 = self.pos
    _tmp = match_string("`")
    _tmp = _tmp ? nil : true
    self.pos = _save1
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Ticks5 unless _tmp
  return _tmp
end

#_Title

This method is for internal use only.

Title = (TitleSingle | TitleDouble | “”):a { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11383

def _Title

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_TitleSingle)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_TitleDouble)
      break if _tmp
      self.pos = _save1
      _tmp = match_string("")
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_Title unless _tmp
  return _tmp
end

#_TitleDouble

This method is for internal use only.

TitleDouble = “"” (!(“"” @Sp (“)” | @Newline)) .)* “"”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11497

def _TitleDouble

  _save = self.pos
  while true # sequence
    _tmp = match_string("\"")
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos

        _save4 = self.pos
        while true # sequence
          _tmp = match_string("\"")
          unless _tmp
            self.pos = _save4
            break
          end
          _tmp = _Sp()
          unless _tmp
            self.pos = _save4
            break
          end

          _save5 = self.pos
          while true # choice
            _tmp = match_string(")")
            break if _tmp
            self.pos = _save5
            _tmp = _Newline()
            break if _tmp
            self.pos = _save5
            break
          end # end choice

          unless _tmp
            self.pos = _save4
          end
          break
        end # end sequence

        _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 :_TitleDouble unless _tmp
  return _tmp
end

#_TitleSingle

This method is for internal use only.

TitleSingle = “‘” (!(“’” @Sp (“)” | @Newline)) .)* “‘”

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 11420

def _TitleSingle

  _save = self.pos
  while true # sequence
    _tmp = match_string("'")
    unless _tmp
      self.pos = _save
      break
    end
    while true

      _save2 = self.pos
      while true # sequence
        _save3 = self.pos

        _save4 = self.pos
        while true # sequence
          _tmp = match_string("'")
          unless _tmp
            self.pos = _save4
            break
          end
          _tmp = _Sp()
          unless _tmp
            self.pos = _save4
            break
          end

          _save5 = self.pos
          while true # choice
            _tmp = match_string(")")
            break if _tmp
            self.pos = _save5
            _tmp = _Newline()
            break if _tmp
            self.pos = _save5
            break
          end # end choice

          unless _tmp
            self.pos = _save4
          end
          break
        end # end sequence

        _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 :_TitleSingle unless _tmp
  return _tmp
end

#_UlLine

This method is for internal use only.

UlLine = (< /_4,/ > { text } | < @Spacechar /_+/ &@Spacechar > { text })

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10206

def _UlLine

  _save = self.pos
  while true # choice

    _save1 = self.pos
    while true # sequence
      _text_start = self.pos
      _tmp = scan(/\G(?-mix:_{4,})/)
      if _tmp
        text = get_text(_text_start)
      end
      unless _tmp
        self.pos = _save1
        break
      end
      @result = begin;  text ; end
      _tmp = true
      unless _tmp
        self.pos = _save1
      end
      break
    end # end sequence

    break if _tmp
    self.pos = _save

    _save2 = self.pos
    while true # sequence
      _text_start = self.pos

      _save3 = self.pos
      while true # sequence
        _tmp = _Spacechar()
        unless _tmp
          self.pos = _save3
          break
        end
        _tmp = scan(/\G(?-mix:_+)/)
        unless _tmp
          self.pos = _save3
          break
        end
        _save4 = self.pos
        _tmp = _Spacechar()
        self.pos = _save4
        unless _tmp
          self.pos = _save3
        end
        break
      end # end sequence

      if _tmp
        text = get_text(_text_start)
      end
      unless _tmp
        self.pos = _save2
        break
      end
      @result = begin;  text ; end
      _tmp = true
      unless _tmp
        self.pos = _save2
      end
      break
    end # end sequence

    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_UlLine unless _tmp
  return _tmp
end

#_UlOrStarLine

This method is for internal use only.

UlOrStarLine = (UlLine | StarLine):a { a }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10095

def _UlOrStarLine

  _save = self.pos
  while true # sequence

    _save1 = self.pos
    while true # choice
      _tmp = apply(:_UlLine)
      break if _tmp
      self.pos = _save1
      _tmp = apply(:_StarLine)
      break if _tmp
      self.pos = _save1
      break
    end # end choice

    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 :_UlOrStarLine unless _tmp
  return _tmp
end

#_Verbatim

This method is for internal use only.

Verbatim = VerbatimChunk+:a { Markup::Verbatim.new(*a.flatten) }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1895

def _Verbatim

  _save = self.pos
  while true # sequence
    _save1 = self.pos
    _ary = []
    _tmp = apply(:_VerbatimChunk)
    if _tmp
      _ary << @result
      while true
        _tmp = apply(:_VerbatimChunk)
        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save1
    end
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  RDoc::Markup::Verbatim.new(*a.flatten) ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_Verbatim unless _tmp
  return _tmp
end

#_VerbatimChunk

This method is for internal use only.

VerbatimChunk = @BlankLine*:a NonblankIndentedLine+:b { a.concat b }

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 1845

def _VerbatimChunk

  _save = self.pos
  while true # sequence
    _ary = []
    while true
      _tmp = _BlankLine()
      _ary << @result if _tmp
      break unless _tmp
    end
    _tmp = true
    @result = _ary
    a = @result
    unless _tmp
      self.pos = _save
      break
    end
    _save2 = self.pos
    _ary = []
    _tmp = apply(:_NonblankIndentedLine)
    if _tmp
      _ary << @result
      while true
        _tmp = apply(:_NonblankIndentedLine)
        _ary << @result if _tmp
        break unless _tmp
      end
      _tmp = true
      @result = _ary
    else
      self.pos = _save2
    end
    b = @result
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  a.concat b ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_VerbatimChunk unless _tmp
  return _tmp
end

#_Whitespace

This method is for internal use only.

Whitespace = (@Spacechar | @Newline)

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 10301

def _Whitespace

  _save = self.pos
  while true # choice
    _tmp = _Spacechar()
    break if _tmp
    self.pos = _save
    _tmp = _Newline()
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Whitespace unless _tmp
  return _tmp
end

#apply(rule)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 502

def apply(rule)
  @result = nil
  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
  end
end

#apply_with_args(rule, *args)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 468

def apply_with_args(rule, *args)
  @result = nil
  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
  end
end

#break_on_newline

Converts all newlines into hard breaks

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 618

extension :break_on_newline

#css

Allow style blocks

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 623

extension :css

#current_character(target = pos)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 250

def current_character(target=pos)
  if target < 0 || target >= string.size
    raise "Target position #{target} is outside of string"
  end
  string[target, 1]
end

#current_column(target = pos)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 211

def current_column(target=pos)
  if string[target] == "\n" && (c = string.rindex("\n", target-1) || -1)
    return target - c
  elsif c = string.rindex("\n", target)
    return target - c
  end

  target + 1
end

#current_line(target = pos)

This method is for internal use only.

See additional method definition at line 234.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 241

def current_line(target=pos)
  if line = position_line_offsets.bsearch_index {|x| x > target }
    return line + 1
  end
  raise "Target position #{target} is outside of string"
end

#current_pos_info(target = pos)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 259

def current_pos_info(target=pos)
  l = current_line target
  c = current_column target
  ln = get_line(l-1)
  chr = string[target,1]
  KpegPosInfo.new(target, l, c, ln, chr)
end

#definition_lists

Allow PHP Markdown Extras style definition lists

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 628

extension :definition_lists

#emphasis(text)

Wraps text in emphasis for rdoc inline formatting

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 683

def emphasis text
  if text =~ /\A[a-z\d.\/]+\z/i then
    "_#{text}_"
  else
    "<em>#{text}</em>"
  end
end

#extension(name, enable)

Enables or disables the extension with name

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 705

def extension name, enable
  if enable then
    @extensions |= [name]
  else
    @extensions -= [name]
  end
end

#extension?(name) ⇒ Boolean

Is the extension name enabled?

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 696

def extension? name
  @extensions.include? name
end

#external_invoke(other, rule, *args)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 449

def external_invoke(other, rule, *args)
  old_pos = @pos
  old_string = @string

  set_string other.string, other.pos

  begin
    if val = __send__(rule, *args)
      other.pos = @pos
      other.result = @result
    else
      other.set_failed_rule "#{self.class}##{rule}"
    end
    val
  ensure
    set_string old_string, old_pos
  end
end

#failure_caret

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 318

def failure_caret
  p = current_pos_info @failing_rule_offset
  "#{p.line.chomp}\n#{' ' * (p.col - 1)}^"
end

#failure_character

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 323

def failure_character
  current_character @failing_rule_offset
end

#failure_info

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 306

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

#failure_oneline

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 327

def failure_oneline
  p = current_pos_info @failing_rule_offset

  if @failed_rule.kind_of? Symbol
    info = self.class::Rules[@failed_rule]
    "@#{p.lno}:#{p.col} failed rule '#{info.name}', got '#{p.char}'"
  else
    "@#{p.lno}:#{p.col} failed rule '#{@failed_rule}', got '#{p.char}'"
  end
end

#get_byte

This method is for internal use only.

See additional method definition at line 393.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 403

def get_byte
  if @pos >= @string_size
    return nil
  end

  s = @string[@pos].ord
  @pos += 1
  s
end

#get_line(no)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 271

def get_line(no)
  loff = position_line_offsets
  if no < 0
    raise "Line No is out of range: #{no} < 0"
  elsif no >= loff.size
    raise "Line No is out of range: #{no} >= #{loff.size}"
  end
  lend = loff[no]-1
  lstart = no > 0 ? loff[no-1] : 0
  string[lstart..lend]
end

#get_text(start)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 285

def get_text(start)
  @string[start..@pos-1]
end

#github

Allow Github Flavored Markdown

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 633

extension :github

#grow_lr(rule, args, start_pos, m)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 535

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

#html

Allow HTML

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 638

extension :html

#inner_parse(text)

This method is for internal use only.

Parses text in a clone of this parser. This is used for handling nested lists the same way as markdown_parser.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 717

def inner_parse text # :nodoc:
  parser = clone

  parser.setup_parser text, @debug

  parser.peg_parse

  doc = parser.result

  doc.accept @formatter

  doc.parts
end

#lines

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 267

def lines
  string.lines
end

#list_item_from(unparsed)

Creates an Markup::ListItem by parsing the unparsed content from the first parsing pass.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 754

def list_item_from unparsed
  parsed = inner_parse unparsed.join
  RDoc::Markup::ListItem.new nil, *parsed
end

#match_string(str)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 373

def match_string(str)
  len = str.size
  if @string[pos,len] == str
    @pos += len
    return str
  end

  return nil
end

#note(label)

Stores label as a note and fills in previously unknown note references.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 762

def note label
  #foottext = "rdoc-label:foottext-#{label}:footmark-#{label}"

  #ref.replace foottext if ref = @unlinked_notes.delete(label)

  @notes[label] = foottext

  #"{^1}[rdoc-label:footmark-#{label}:foottext-#{label}] "
end

#note_for(ref)

Creates a new link for the footnote #reference and adds the reference to the note order list for proper display at the end of the document.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 776

def note_for ref
  @note_order << ref

  label = @note_order.length

  "{*#{label}}[rdoc-label:foottext-#{label}:footmark-#{label}]"
end

#notes

Enables the notes extension

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 643

extension :notes

#orig_initialize

This method is for internal use only.

TODO remove when kpeg 0.10 is released

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 663

alias orig_initialize initialize # :nodoc:

#paragraph(parts)

Creates an Markup::Paragraph from parts and including extension-specific behavior

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 793

def paragraph parts
  parts = parts.map do |part|
    if "\n" == part then
      RDoc::Markup::HardBreak.new
    else
      part
    end
  end if break_on_newline?

  RDoc::Markup::Paragraph.new(*parts)
end

#parse(markdown) Also known as: #peg_parse

This method is for internal use only.

Parses markdown into an RDoc::Document

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 808

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

#peg_parse(rule = nil)

This method is for internal use only.

The internal kpeg parse method

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 787

alias peg_parse parse # :nodoc:

#position_line_offsets

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 221

def position_line_offsets
  unless @position_line_offsets
    @position_line_offsets = []
    total = 0
    string.each_line do |line|
      total += line.size
      @position_line_offsets << total
    end
  end
  @position_line_offsets
end

#raise_error

This method is for internal use only.

Raises:

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 341

def raise_error
  raise ParseError, failure_oneline
end

#reference(label, link)

Stores label as a reference to link and fills in previously unknown link references.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 855

def reference label, link
  if ref = @unlinked_references.delete(label) then
    ref.replace link
  end

  @references[label] = link
end

#scan(reg)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 383

def scan(reg)
  if m = reg.match(@string, @pos)
    @pos = m.end(0)
    return true
  end

  return nil
end

#set_failed_rule(name)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 364

def set_failed_rule(name)
  if @pos > @failing_rule_offset
    @failed_rule = name
    @failing_rule_offset = @pos
  end
end

#set_string(string, pos)

This method is for internal use only.

Sets the string and current parsing position for the parser.

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 290

def set_string string, pos
  @string = string
  @string_size = string ? string.size : 0
  @pos = pos
  @position_line_offsets = nil
end

#setup_foreign_grammar

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 887

def setup_foreign_grammar
  @_grammar_literals = RDoc::Markdown::Literals.new(nil)
end

#setup_parser(str, debug = false)

This method is for internal use only.

Prepares for parsing str. If you define a custom initialize you must call this method before #parse

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 196

def setup_parser(str, debug=false)
  set_string str, 0
  @memoizations = Hash.new { |h,k| h[k] = {} }
  @result = nil
  @failed_rule = nil
  @failing_rule_offset = -1
  @line_offsets = nil

  setup_foreign_grammar
end

#show_error(io = STDOUT)

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 345

def show_error(io=STDOUT)
  error_pos = @failing_rule_offset
  p = current_pos_info(error_pos)

  io.puts "On line #{p.lno}, column #{p.col}:"

  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: #{p.char.inspect}"
  io.puts "=> #{p.line}"
  io.print(" " * (p.col + 2))
  io.puts "^"
end

#show_pos

This method is for internal use only.
[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 297

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

#strike(text)

Enables the strike extension

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 877

extension :strike

#strong(text)

Wraps text in strong markup for rdoc inline formatting

[ GitHub ]

  
# File 'lib/rdoc/markdown.rb', line 866

def strong text
  if text =~ /\A[a-z\d.\/-]+\z/i then
    "*#{text}*"
  else
    "<b>#{text}</b>"
  end
end