Class: RDoc::Markdown

Relationships & Source Files
Namespace Children
Classes: `KpegPosInfo`, `Literals`, `MemoEntry`, `RuleInfo`
Exceptions: `ParseError`
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 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. 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[^1] 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

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 = StrChunk: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

.parse(markdown)

Parses the markdown document into an RDoc::Document using the default extensions.
.new(str, debug = false) ⇒ Markdown constructor 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.
.rule_info(name, rendered) Internal use only

Instance Attribute Summary

#failed_rule readonly Internal use only
#failing_rule_offset readonly Internal use only
#pos rw Internal use only
#result rw Internal use only
#string readonly Internal use only

Instance Method Summary

#emphasis(text)

Wraps text in emphasis for rdoc inline formatting.
#initialize(extensions = DEFAULT_EXTENSIONS, debug = false) ⇒ Markdown constructor

Creates a new markdown parser that enables the given extensions.
#apply(rule) Internal use only
#apply_with_args(rule, *args) Internal use only
#current_character(target = pos) Internal use only
#current_column(target = pos) Internal use only
#current_line(target = pos) Internal use only

See additional method definition at line 234.
#current_pos_info(target = pos) Internal use only
#external_invoke(other, rule, *args) Internal use only
#failure_caret Internal use only
#failure_character Internal use only
#failure_info Internal use only
#failure_oneline Internal use only
#get_byte Internal use only

See additional method definition at line 393.
#get_line(no) Internal use only
#get_text(start) Internal use only
#grow_lr(rule, args, start_pos, m) Internal use only
#lines Internal use only
#match_string(str) Internal use only
#orig_initialize Internal use only

TODO remove when kpeg 0.10 is released.
#position_line_offsets Internal use only
#raise_error Internal use only
#scan(reg) Internal use only
#set_failed_rule(name) Internal use only
#set_string(string, pos) Internal use only

Sets the string and current parsing position for the parser.
#setup_parser(str, debug = false) Internal use only

Prepares for parsing str.
#show_error(io = STDOUT) Internal use only
#show_pos Internal use only

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

#_AutoLink

This method is for internal use only.

AutoLink = (AutoLinkUrl | AutoLinkEmail)

[ GitHub ]

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


def _AutoLink

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

  set_failed_rule :_AutoLink 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.

[ 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 = StrChunk:label @Sp @Newline { label }

[ GitHub ]

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


def _DefinitionListLabel

  _save = self.pos
  while true # sequence
    _tmp = apply(:_StrChunk)
    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

#_ExplicitLink

This method is for internal use only.

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

[ GitHub ]

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


def _ExplicitLink

  _save = self.pos
  while true # sequence
    _tmp = apply(:_Label)
    l = @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 = apply(:_Source)
    s = @result
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Spnl)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = apply(:_Title)
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = _Sp()
    unless _tmp
      self.pos = _save
      break
    end
    _tmp = match_string(")")
    unless _tmp
      self.pos = _save
      break
    end
    @result = begin;  "{#{l}}[#{s}]" ; end
    _tmp = true
    unless _tmp
      self.pos = _save
    end
    break
  end # end sequence

  set_failed_rule :_ExplicitLink 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.

[ 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 { “ RDoc::Markdown#pos (method) 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.

[ 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

#_Link

This method is for internal use only.

Link = (ExplicitLink | ReferenceLink | AutoLink)

[ GitHub ]

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


def _Link

  _save = self.pos
  while true # choice
    _tmp = apply(:_ExplicitLink)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_ReferenceLink)
    break if _tmp
    self.pos = _save
    _tmp = apply(:_AutoLink)
    break if _tmp
    self.pos = _save
    break
  end # end choice

  set_failed_rule :_Link 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

#_ReferenceLink

This method is for internal use only.

ReferenceLink = (ReferenceLinkDouble | ReferenceLinkSingle)

[ GitHub ]

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


def _ReferenceLink

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

  set_failed_rule :_ReferenceLink 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

#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. If label was not encountered in the reference-gathering parser pass the label and content are reconstructed with the linking text (usually whitespace).

Raises:

(ParseError)

[ GitHub ]

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


def link_to content, label = content, text = nil
  raise ParseError, 'enable notes extension' if
    content.start_with? '^' and label.equal? content

  if ref = @references[label] then
    "{#{content}}[#{ref}]"
  elsif label.equal? content then
    "[#{content}]#{text}"
  else
    "[#{content}]#{text}[#{label}]"
  end
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:

(ParseError)

[ 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

Class: RDoc::Markdown

Overview

Usage

Extensions

RDoc

Break on Newline

CSS

Definition Lists

Strike

Github

Fenced code blocks

Syntax highlighting

HTML

Notes

Limitations

Author

Constant Summary

Extensions

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(str, debug = false) ⇒ Markdown

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

Class Method Details

.extension(name)

.parse(markdown)

.rule_info(name, rendered)

Instance Attribute Details

#failed_rule (readonly)

#failing_rule_offset (readonly)

#pos (rw)

#result (rw)

#string (readonly)

Instance Method Details

#_Alphanumeric

#_AlphanumericAscii

#_AtxHeading

#_AtxInline

#_AtxStart

#_AutoLink

#_AutoLinkEmail

#_AutoLinkUrl

#_BlankLine

#_Block

#_BlockQuote

#_BlockQuoteRaw

#_BOM

#_Bullet

#_BulletList

#_CharEntity

#_Code

#_CodeFence

#_DecEntity

#_DefinitionList

#_DefinitionListDefinition

#_DefinitionListItem

#_DefinitionListLabel

#_Digit

#_Doc

#_Emph

#_EmphStar

#_EmphUl

#_EmptyTitle

#_Endline

#_Entity

#_Enumerator

#_Eof

#_EscapedChar

#_ExplicitLink

#_ExtendedSpecialChar

#_Heading

#_HexEntity

#_HorizontalRule

#_HtmlAnchor

#_HtmlAttribute

#_HtmlBlock

#_HtmlBlockAddress

#_HtmlBlockBlockquote

#_HtmlBlockCenter

.new(str, debug = false) ⇒ `Markdown`

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