12834 lines
239 KiB
Go
12834 lines
239 KiB
Go
|
|
/* Original C version https://github.com/jgm/peg-markdown/
|
|
* Copyright 2008 John MacFarlane (jgm at berkeley dot edu).
|
|
*
|
|
* Modifications and translation from C into Go
|
|
* based on markdown_parser.leg and utility_functions.c
|
|
* Copyright 2010 Michael Teichgräber (mt at wmipf dot de)
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License or the MIT
|
|
* license. See LICENSE for details.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*/
|
|
|
|
package markdown
|
|
|
|
// PEG grammar and parser actions for markdown syntax.
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"log"
|
|
)
|
|
|
|
const (
|
|
parserIfaceVersion_16 = iota
|
|
)
|
|
|
|
// Semantic value of a parsing action.
|
|
type element struct {
|
|
key int
|
|
contents
|
|
children *element
|
|
next *element
|
|
}
|
|
|
|
// Information (label, URL and title) for a link.
|
|
type link struct {
|
|
label *element
|
|
url string
|
|
title string
|
|
}
|
|
|
|
// Union for contents of an Element (string, list, or link).
|
|
type contents struct {
|
|
str string
|
|
*link
|
|
}
|
|
|
|
// Types of semantic values returned by parsers.
|
|
const (
|
|
LIST = iota /* A generic list of values. For ordered and bullet lists, see below. */
|
|
RAW /* Raw markdown to be processed further */
|
|
SPACE
|
|
LINEBREAK
|
|
ELLIPSIS
|
|
EMDASH
|
|
ENDASH
|
|
APOSTROPHE
|
|
SINGLEQUOTED
|
|
DOUBLEQUOTED
|
|
STR
|
|
LINK
|
|
IMAGE
|
|
CODE
|
|
HTML
|
|
EMPH
|
|
STRONG
|
|
PLAIN
|
|
PARA
|
|
LISTITEM
|
|
BULLETLIST
|
|
ORDEREDLIST
|
|
H1 /* Code assumes that H1..6 are in order. */
|
|
H2
|
|
H3
|
|
H4
|
|
H5
|
|
H6
|
|
BLOCKQUOTE
|
|
VERBATIM
|
|
HTMLBLOCK
|
|
HRULE
|
|
REFERENCE
|
|
NOTE
|
|
DEFINITIONLIST
|
|
DEFTITLE
|
|
DEFDATA
|
|
numVAL
|
|
)
|
|
|
|
type state struct {
|
|
extension Extensions
|
|
heap elemHeap
|
|
tree *element /* Results of parse. */
|
|
references *element /* List of link references found. */
|
|
notes *element /* List of footnotes found. */
|
|
}
|
|
|
|
|
|
const (
|
|
ruleDoc = iota
|
|
ruleDocblock
|
|
ruleBlock
|
|
rulePara
|
|
rulePlain
|
|
ruleAtxInline
|
|
ruleAtxStart
|
|
ruleAtxHeading
|
|
ruleSetextHeading
|
|
ruleSetextBottom1
|
|
ruleSetextBottom2
|
|
ruleSetextHeading1
|
|
ruleSetextHeading2
|
|
ruleHeading
|
|
ruleBlockQuote
|
|
ruleBlockQuoteRaw
|
|
ruleNonblankIndentedLine
|
|
ruleVerbatimChunk
|
|
ruleVerbatim
|
|
ruleHorizontalRule
|
|
ruleBullet
|
|
ruleBulletList
|
|
ruleListTight
|
|
ruleListLoose
|
|
ruleListItem
|
|
ruleListItemTight
|
|
ruleListBlock
|
|
ruleListContinuationBlock
|
|
ruleEnumerator
|
|
ruleOrderedList
|
|
ruleListBlockLine
|
|
ruleHtmlBlockOpenAddress
|
|
ruleHtmlBlockCloseAddress
|
|
ruleHtmlBlockAddress
|
|
ruleHtmlBlockOpenBlockquote
|
|
ruleHtmlBlockCloseBlockquote
|
|
ruleHtmlBlockBlockquote
|
|
ruleHtmlBlockOpenCenter
|
|
ruleHtmlBlockCloseCenter
|
|
ruleHtmlBlockCenter
|
|
ruleHtmlBlockOpenDir
|
|
ruleHtmlBlockCloseDir
|
|
ruleHtmlBlockDir
|
|
ruleHtmlBlockOpenDiv
|
|
ruleHtmlBlockCloseDiv
|
|
ruleHtmlBlockDiv
|
|
ruleHtmlBlockOpenDl
|
|
ruleHtmlBlockCloseDl
|
|
ruleHtmlBlockDl
|
|
ruleHtmlBlockOpenFieldset
|
|
ruleHtmlBlockCloseFieldset
|
|
ruleHtmlBlockFieldset
|
|
ruleHtmlBlockOpenForm
|
|
ruleHtmlBlockCloseForm
|
|
ruleHtmlBlockForm
|
|
ruleHtmlBlockOpenH1
|
|
ruleHtmlBlockCloseH1
|
|
ruleHtmlBlockH1
|
|
ruleHtmlBlockOpenH2
|
|
ruleHtmlBlockCloseH2
|
|
ruleHtmlBlockH2
|
|
ruleHtmlBlockOpenH3
|
|
ruleHtmlBlockCloseH3
|
|
ruleHtmlBlockH3
|
|
ruleHtmlBlockOpenH4
|
|
ruleHtmlBlockCloseH4
|
|
ruleHtmlBlockH4
|
|
ruleHtmlBlockOpenH5
|
|
ruleHtmlBlockCloseH5
|
|
ruleHtmlBlockH5
|
|
ruleHtmlBlockOpenH6
|
|
ruleHtmlBlockCloseH6
|
|
ruleHtmlBlockH6
|
|
ruleHtmlBlockOpenMenu
|
|
ruleHtmlBlockCloseMenu
|
|
ruleHtmlBlockMenu
|
|
ruleHtmlBlockOpenNoframes
|
|
ruleHtmlBlockCloseNoframes
|
|
ruleHtmlBlockNoframes
|
|
ruleHtmlBlockOpenNoscript
|
|
ruleHtmlBlockCloseNoscript
|
|
ruleHtmlBlockNoscript
|
|
ruleHtmlBlockOpenOl
|
|
ruleHtmlBlockCloseOl
|
|
ruleHtmlBlockOl
|
|
ruleHtmlBlockOpenP
|
|
ruleHtmlBlockCloseP
|
|
ruleHtmlBlockP
|
|
ruleHtmlBlockOpenPre
|
|
ruleHtmlBlockClosePre
|
|
ruleHtmlBlockPre
|
|
ruleHtmlBlockOpenTable
|
|
ruleHtmlBlockCloseTable
|
|
ruleHtmlBlockTable
|
|
ruleHtmlBlockOpenUl
|
|
ruleHtmlBlockCloseUl
|
|
ruleHtmlBlockUl
|
|
ruleHtmlBlockOpenDd
|
|
ruleHtmlBlockCloseDd
|
|
ruleHtmlBlockDd
|
|
ruleHtmlBlockOpenDt
|
|
ruleHtmlBlockCloseDt
|
|
ruleHtmlBlockDt
|
|
ruleHtmlBlockOpenFrameset
|
|
ruleHtmlBlockCloseFrameset
|
|
ruleHtmlBlockFrameset
|
|
ruleHtmlBlockOpenLi
|
|
ruleHtmlBlockCloseLi
|
|
ruleHtmlBlockLi
|
|
ruleHtmlBlockOpenTbody
|
|
ruleHtmlBlockCloseTbody
|
|
ruleHtmlBlockTbody
|
|
ruleHtmlBlockOpenTd
|
|
ruleHtmlBlockCloseTd
|
|
ruleHtmlBlockTd
|
|
ruleHtmlBlockOpenTfoot
|
|
ruleHtmlBlockCloseTfoot
|
|
ruleHtmlBlockTfoot
|
|
ruleHtmlBlockOpenTh
|
|
ruleHtmlBlockCloseTh
|
|
ruleHtmlBlockTh
|
|
ruleHtmlBlockOpenThead
|
|
ruleHtmlBlockCloseThead
|
|
ruleHtmlBlockThead
|
|
ruleHtmlBlockOpenTr
|
|
ruleHtmlBlockCloseTr
|
|
ruleHtmlBlockTr
|
|
ruleHtmlBlockOpenScript
|
|
ruleHtmlBlockCloseScript
|
|
ruleHtmlBlockScript
|
|
ruleHtmlBlockInTags
|
|
ruleHtmlBlock
|
|
ruleHtmlBlockSelfClosing
|
|
ruleHtmlBlockType
|
|
ruleStyleOpen
|
|
ruleStyleClose
|
|
ruleInStyleTags
|
|
ruleStyleBlock
|
|
ruleInlines
|
|
ruleInline
|
|
ruleSpace
|
|
ruleStr
|
|
ruleStrChunk
|
|
ruleAposChunk
|
|
ruleEscapedChar
|
|
ruleEntity
|
|
ruleEndline
|
|
ruleNormalEndline
|
|
ruleTerminalEndline
|
|
ruleLineBreak
|
|
ruleSymbol
|
|
ruleUlOrStarLine
|
|
ruleStarLine
|
|
ruleUlLine
|
|
ruleEmph
|
|
ruleOneStarOpen
|
|
ruleOneStarClose
|
|
ruleEmphStar
|
|
ruleOneUlOpen
|
|
ruleOneUlClose
|
|
ruleEmphUl
|
|
ruleStrong
|
|
ruleTwoStarOpen
|
|
ruleTwoStarClose
|
|
ruleStrongStar
|
|
ruleTwoUlOpen
|
|
ruleTwoUlClose
|
|
ruleStrongUl
|
|
ruleImage
|
|
ruleLink
|
|
ruleReferenceLink
|
|
ruleReferenceLinkDouble
|
|
ruleReferenceLinkSingle
|
|
ruleExplicitLink
|
|
ruleSource
|
|
ruleSourceContents
|
|
ruleTitle
|
|
ruleTitleSingle
|
|
ruleTitleDouble
|
|
ruleAutoLink
|
|
ruleAutoLinkUrl
|
|
ruleAutoLinkEmail
|
|
ruleReference
|
|
ruleLabel
|
|
ruleRefSrc
|
|
ruleRefTitle
|
|
ruleEmptyTitle
|
|
ruleRefTitleSingle
|
|
ruleRefTitleDouble
|
|
ruleRefTitleParens
|
|
ruleReferences
|
|
ruleTicks1
|
|
ruleTicks2
|
|
ruleTicks3
|
|
ruleTicks4
|
|
ruleTicks5
|
|
ruleCode
|
|
ruleRawHtml
|
|
ruleBlankLine
|
|
ruleQuoted
|
|
ruleHtmlAttribute
|
|
ruleHtmlComment
|
|
ruleHtmlTag
|
|
ruleEof
|
|
ruleSpacechar
|
|
ruleNonspacechar
|
|
ruleNewline
|
|
ruleSp
|
|
ruleSpnl
|
|
ruleSpecialChar
|
|
ruleNormalChar
|
|
ruleNonAlphanumeric
|
|
ruleAlphanumeric
|
|
ruleAlphanumericAscii
|
|
ruleDigit
|
|
ruleHexEntity
|
|
ruleDecEntity
|
|
ruleCharEntity
|
|
ruleNonindentSpace
|
|
ruleIndent
|
|
ruleIndentedLine
|
|
ruleOptionallyIndentedLine
|
|
ruleStartList
|
|
ruleLine
|
|
ruleRawLine
|
|
ruleSkipBlock
|
|
ruleExtendedSpecialChar
|
|
ruleSmart
|
|
ruleApostrophe
|
|
ruleEllipsis
|
|
ruleDash
|
|
ruleEnDash
|
|
ruleEmDash
|
|
ruleSingleQuoteStart
|
|
ruleSingleQuoteEnd
|
|
ruleSingleQuoted
|
|
ruleDoubleQuoteStart
|
|
ruleDoubleQuoteEnd
|
|
ruleDoubleQuoted
|
|
ruleNoteReference
|
|
ruleRawNoteReference
|
|
ruleNote
|
|
ruleInlineNote
|
|
ruleNotes
|
|
ruleRawNoteBlock
|
|
ruleDefinitionList
|
|
ruleDefinition
|
|
ruleDListTitle
|
|
ruleDefTight
|
|
ruleDefLoose
|
|
ruleDefmark
|
|
ruleDefMarker
|
|
)
|
|
|
|
type yyParser struct {
|
|
state
|
|
Buffer string
|
|
Min, Max int
|
|
rules [252]func() bool
|
|
ResetBuffer func(string) string
|
|
}
|
|
|
|
func (p *yyParser) Parse(ruleId int) (err error) {
|
|
if p.rules[ruleId]() {
|
|
return
|
|
}
|
|
return p.parseErr()
|
|
}
|
|
|
|
type errPos struct {
|
|
Line, Pos int
|
|
}
|
|
|
|
func (e *errPos) String() string {
|
|
return fmt.Sprintf("%d:%d", e.Line, e.Pos)
|
|
}
|
|
|
|
type unexpectedCharError struct {
|
|
After, At errPos
|
|
Char byte
|
|
}
|
|
|
|
func (e *unexpectedCharError) Error() string {
|
|
return fmt.Sprintf("%v: unexpected character '%c'", &e.At, e.Char)
|
|
}
|
|
|
|
type unexpectedEOFError struct {
|
|
After errPos
|
|
}
|
|
|
|
func (e *unexpectedEOFError) Error() string {
|
|
return fmt.Sprintf("%v: unexpected end of file", &e.After)
|
|
}
|
|
|
|
func (p *yyParser) parseErr() (err error) {
|
|
var pos, after errPos
|
|
pos.Line = 1
|
|
for i, c := range p.Buffer[0:] {
|
|
if c == '\n' {
|
|
pos.Line++
|
|
pos.Pos = 0
|
|
} else {
|
|
pos.Pos++
|
|
}
|
|
if i == p.Min {
|
|
if p.Min != p.Max {
|
|
after = pos
|
|
} else {
|
|
break
|
|
}
|
|
} else if i == p.Max {
|
|
break
|
|
}
|
|
}
|
|
if p.Max >= len(p.Buffer) {
|
|
err = &unexpectedEOFError{after}
|
|
} else {
|
|
err = &unexpectedCharError{after, pos, p.Buffer[p.Max]}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (p *yyParser) Init() {
|
|
var position int
|
|
var yyp int
|
|
var yy *element
|
|
var yyval = make([]*element, 256)
|
|
|
|
actions := [...]func(string, int){
|
|
/* 0 Doc */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 1 Doc */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
p.tree = reverse(a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 2 Docblock */
|
|
func(yytext string, _ int) {
|
|
p.tree = yy
|
|
},
|
|
/* 3 Para */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = a; yy.key = PARA
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 4 Plain */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = a; yy.key = PLAIN
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 5 AtxStart */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(H1 + (len(yytext) - 1))
|
|
},
|
|
/* 6 AtxHeading */
|
|
func(yytext string, _ int) {
|
|
s := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = s
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 7 AtxHeading */
|
|
func(yytext string, _ int) {
|
|
s := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
yy = p.mkList(s.key, a)
|
|
s = nil
|
|
yyval[yyp-1] = s
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 8 SetextHeading1 */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 9 SetextHeading1 */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(H1, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 10 SetextHeading2 */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 11 SetextHeading2 */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(H2, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 12 BlockQuote */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkElem(BLOCKQUOTE)
|
|
yy.children = a
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 13 BlockQuoteRaw */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 14 BlockQuoteRaw */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 15 BlockQuoteRaw */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(p.mkString("\n"), a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 16 BlockQuoteRaw */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkStringFromList(a, true)
|
|
yy.key = RAW
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 17 VerbatimChunk */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(p.mkString("\n"), a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 18 VerbatimChunk */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 19 VerbatimChunk */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkStringFromList(a, false)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 20 Verbatim */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 21 Verbatim */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkStringFromList(a, false)
|
|
yy.key = VERBATIM
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 22 HorizontalRule */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(HRULE)
|
|
},
|
|
/* 23 BulletList */
|
|
func(yytext string, _ int) {
|
|
yy.key = BULLETLIST
|
|
},
|
|
/* 24 ListTight */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 25 ListTight */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(LIST, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 26 ListLoose */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
b := yyval[yyp-2]
|
|
|
|
li := b.children
|
|
li.contents.str += "\n\n"
|
|
a = cons(b, a)
|
|
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = b
|
|
},
|
|
/* 27 ListLoose */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
b := yyval[yyp-2]
|
|
yy = p.mkList(LIST, a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = b
|
|
},
|
|
/* 28 ListItem */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 29 ListItem */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 30 ListItem */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
|
|
raw := p.mkStringFromList(a, false)
|
|
raw.key = RAW
|
|
yy = p.mkElem(LISTITEM)
|
|
yy.children = raw
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 31 ListItemTight */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 32 ListItemTight */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 33 ListItemTight */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
|
|
raw := p.mkStringFromList(a, false)
|
|
raw.key = RAW
|
|
yy = p.mkElem(LISTITEM)
|
|
yy.children = raw
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 34 ListBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 35 ListBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 36 ListBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkStringFromList(a, false)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 37 ListContinuationBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
if len(yytext) == 0 {
|
|
a = cons(p.mkString("\001"), a) // block separator
|
|
} else {
|
|
a = cons(p.mkString(yytext), a)
|
|
}
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 38 ListContinuationBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 39 ListContinuationBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkStringFromList(a, false)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 40 OrderedList */
|
|
func(yytext string, _ int) {
|
|
yy.key = ORDEREDLIST
|
|
},
|
|
/* 41 HtmlBlock */
|
|
func(yytext string, _ int) {
|
|
if p.extension.FilterHTML {
|
|
yy = p.mkList(LIST, nil)
|
|
} else {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTMLBLOCK
|
|
}
|
|
|
|
},
|
|
/* 42 StyleBlock */
|
|
func(yytext string, _ int) {
|
|
if p.extension.FilterStyles {
|
|
yy = p.mkList(LIST, nil)
|
|
} else {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTMLBLOCK
|
|
}
|
|
|
|
},
|
|
/* 43 Inlines */
|
|
func(yytext string, _ int) {
|
|
c := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = c
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 44 Inlines */
|
|
func(yytext string, _ int) {
|
|
c := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
a = cons(c, a)
|
|
yyval[yyp-1] = c
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 45 Inlines */
|
|
func(yytext string, _ int) {
|
|
c := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
yy = p.mkList(LIST, a)
|
|
yyval[yyp-1] = c
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 46 Space */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(" ")
|
|
yy.key = SPACE
|
|
},
|
|
/* 47 Str */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(p.mkString(yytext), a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 48 Str */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 49 Str */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
if a.next == nil { yy = a; } else { yy = p.mkList(LIST, a) }
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 50 StrChunk */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 51 AposChunk */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(APOSTROPHE)
|
|
},
|
|
/* 52 EscapedChar */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 53 Entity */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext); yy.key = HTML
|
|
},
|
|
/* 54 NormalEndline */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString("\n")
|
|
yy.key = SPACE
|
|
},
|
|
/* 55 TerminalEndline */
|
|
func(yytext string, _ int) {
|
|
yy = nil
|
|
},
|
|
/* 56 LineBreak */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(LINEBREAK)
|
|
},
|
|
/* 57 Symbol */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 58 UlOrStarLine */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 59 OneStarClose */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = a
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 60 EmphStar */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 61 EmphStar */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 62 EmphStar */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(EMPH, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 63 OneUlClose */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = a
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 64 EmphUl */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 65 EmphUl */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 66 EmphUl */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(EMPH, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 67 TwoStarClose */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = a
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 68 StrongStar */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 69 StrongStar */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 70 StrongStar */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(STRONG, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 71 TwoUlClose */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = a
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 72 StrongUl */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 73 StrongUl */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 74 StrongUl */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(STRONG, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 75 Image */
|
|
func(yytext string, _ int) {
|
|
if yy.key == LINK {
|
|
yy.key = IMAGE
|
|
} else {
|
|
result := yy
|
|
yy.children = cons(p.mkString("!"), result.children)
|
|
}
|
|
|
|
},
|
|
/* 76 ReferenceLinkDouble */
|
|
func(yytext string, _ int) {
|
|
b := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
|
|
if match, found := p.findReference(b.children); found {
|
|
yy = p.mkLink(a.children, match.url, match.title);
|
|
a = nil
|
|
b = nil
|
|
} else {
|
|
result := p.mkElem(LIST)
|
|
result.children = cons(p.mkString("["), cons(a, cons(p.mkString("]"), cons(p.mkString(yytext),
|
|
cons(p.mkString("["), cons(b, p.mkString("]")))))))
|
|
yy = result
|
|
}
|
|
|
|
yyval[yyp-1] = b
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 77 ReferenceLinkSingle */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
|
|
if match, found := p.findReference(a.children); found {
|
|
yy = p.mkLink(a.children, match.url, match.title)
|
|
a = nil
|
|
} else {
|
|
result := p.mkElem(LIST)
|
|
result.children = cons(p.mkString("["), cons(a, cons(p.mkString("]"), p.mkString(yytext))));
|
|
yy = result
|
|
}
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 78 ExplicitLink */
|
|
func(yytext string, _ int) {
|
|
s := yyval[yyp-1]
|
|
l := yyval[yyp-2]
|
|
t := yyval[yyp-3]
|
|
yy = p.mkLink(l.children, s.contents.str, t.contents.str)
|
|
s = nil
|
|
t = nil
|
|
l = nil
|
|
yyval[yyp-1] = s
|
|
yyval[yyp-2] = l
|
|
yyval[yyp-3] = t
|
|
},
|
|
/* 79 Source */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 80 Title */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 81 AutoLinkUrl */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkLink(p.mkString(yytext), yytext, "")
|
|
},
|
|
/* 82 AutoLinkEmail */
|
|
func(yytext string, _ int) {
|
|
|
|
yy = p.mkLink(p.mkString(yytext), "mailto:"+yytext, "")
|
|
|
|
},
|
|
/* 83 Reference */
|
|
func(yytext string, _ int) {
|
|
l := yyval[yyp-1]
|
|
s := yyval[yyp-2]
|
|
t := yyval[yyp-3]
|
|
yy = p.mkLink(l.children, s.contents.str, t.contents.str)
|
|
s = nil
|
|
t = nil
|
|
l = nil
|
|
yy.key = REFERENCE
|
|
yyval[yyp-3] = t
|
|
yyval[yyp-1] = l
|
|
yyval[yyp-2] = s
|
|
},
|
|
/* 84 Label */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 85 Label */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(LIST, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 86 RefSrc */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTML
|
|
},
|
|
/* 87 RefTitle */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 88 References */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
b := yyval[yyp-2]
|
|
a = cons(b, a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = b
|
|
},
|
|
/* 89 References */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
b := yyval[yyp-2]
|
|
p.references = reverse(a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = b
|
|
},
|
|
/* 90 Code */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext); yy.key = CODE
|
|
},
|
|
/* 91 RawHtml */
|
|
func(yytext string, _ int) {
|
|
if p.extension.FilterHTML {
|
|
yy = p.mkList(LIST, nil)
|
|
} else {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTML
|
|
}
|
|
|
|
},
|
|
/* 92 StartList */
|
|
func(yytext string, _ int) {
|
|
yy = nil
|
|
},
|
|
/* 93 Line */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 94 Apostrophe */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(APOSTROPHE)
|
|
},
|
|
/* 95 Ellipsis */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(ELLIPSIS)
|
|
},
|
|
/* 96 EnDash */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(ENDASH)
|
|
},
|
|
/* 97 EmDash */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkElem(EMDASH)
|
|
},
|
|
/* 98 SingleQuoted */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
b := yyval[yyp-2]
|
|
a = cons(b, a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = b
|
|
},
|
|
/* 99 SingleQuoted */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
b := yyval[yyp-2]
|
|
yy = p.mkList(SINGLEQUOTED, a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = b
|
|
},
|
|
/* 100 DoubleQuoted */
|
|
func(yytext string, _ int) {
|
|
b := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
a = cons(b, a)
|
|
yyval[yyp-1] = b
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 101 DoubleQuoted */
|
|
func(yytext string, _ int) {
|
|
b := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
yy = p.mkList(DOUBLEQUOTED, a)
|
|
yyval[yyp-1] = b
|
|
yyval[yyp-2] = a
|
|
},
|
|
/* 102 NoteReference */
|
|
func(yytext string, _ int) {
|
|
ref := yyval[yyp-1]
|
|
|
|
if match, ok := p.find_note(ref.contents.str); ok {
|
|
yy = p.mkElem(NOTE)
|
|
yy.children = match.children
|
|
yy.contents.str = ""
|
|
} else {
|
|
yy = p.mkString("[^"+ref.contents.str+"]")
|
|
}
|
|
|
|
yyval[yyp-1] = ref
|
|
},
|
|
/* 103 RawNoteReference */
|
|
func(yytext string, _ int) {
|
|
yy = p.mkString(yytext)
|
|
},
|
|
/* 104 Note */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
ref := yyval[yyp-2]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = ref
|
|
},
|
|
/* 105 Note */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
ref := yyval[yyp-2]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
yyval[yyp-2] = ref
|
|
},
|
|
/* 106 Note */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
ref := yyval[yyp-2]
|
|
yy = p.mkList(NOTE, a)
|
|
yy.contents.str = ref.contents.str
|
|
|
|
yyval[yyp-2] = ref
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 107 InlineNote */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 108 InlineNote */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(NOTE, a)
|
|
yy.contents.str = ""
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 109 Notes */
|
|
func(yytext string, _ int) {
|
|
b := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
a = cons(b, a)
|
|
yyval[yyp-2] = a
|
|
yyval[yyp-1] = b
|
|
},
|
|
/* 110 Notes */
|
|
func(yytext string, _ int) {
|
|
b := yyval[yyp-1]
|
|
a := yyval[yyp-2]
|
|
p.notes = reverse(a)
|
|
yyval[yyp-2] = a
|
|
yyval[yyp-1] = b
|
|
},
|
|
/* 111 RawNoteBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 112 RawNoteBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(p.mkString(yytext), a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 113 RawNoteBlock */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkStringFromList(a, true)
|
|
yy.key = RAW
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 114 DefinitionList */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 115 DefinitionList */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(DEFINITIONLIST, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 116 Definition */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 117 Definition */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
|
|
for e := yy.children; e != nil; e = e.next {
|
|
e.key = DEFDATA
|
|
}
|
|
a = cons(yy, a)
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 118 Definition */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(LIST, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 119 DListTitle */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
a = cons(yy, a)
|
|
yyval[yyp-1] = a
|
|
},
|
|
/* 120 DListTitle */
|
|
func(yytext string, _ int) {
|
|
a := yyval[yyp-1]
|
|
yy = p.mkList(LIST, a)
|
|
yy.key = DEFTITLE
|
|
|
|
yyval[yyp-1] = a
|
|
},
|
|
|
|
/* yyPush */
|
|
func(_ string, count int) {
|
|
yyp += count
|
|
if yyp >= len(yyval) {
|
|
s := make([]*element, cap(yyval)+256)
|
|
copy(s, yyval)
|
|
yyval = s
|
|
}
|
|
},
|
|
/* yyPop */
|
|
func(_ string, count int) {
|
|
yyp -= count
|
|
},
|
|
/* yySet */
|
|
func(_ string, count int) {
|
|
yyval[yyp+count] = yy
|
|
},
|
|
}
|
|
const (
|
|
yyPush = 121 + iota
|
|
yyPop
|
|
yySet
|
|
)
|
|
|
|
type thunk struct {
|
|
action uint8
|
|
begin, end int
|
|
}
|
|
var thunkPosition, begin, end int
|
|
thunks := make([]thunk, 32)
|
|
doarg := func(action uint8, arg int) {
|
|
if thunkPosition == len(thunks) {
|
|
newThunks := make([]thunk, 2*len(thunks))
|
|
copy(newThunks, thunks)
|
|
thunks = newThunks
|
|
}
|
|
t := &thunks[thunkPosition]
|
|
thunkPosition++
|
|
t.action = action
|
|
if arg != 0 {
|
|
t.begin = arg // use begin to store an argument
|
|
} else {
|
|
t.begin = begin
|
|
}
|
|
t.end = end
|
|
}
|
|
do := func(action uint8) {
|
|
doarg(action, 0)
|
|
}
|
|
|
|
p.ResetBuffer = func(s string) (old string) {
|
|
if position < len(p.Buffer) {
|
|
old = p.Buffer[position:]
|
|
}
|
|
p.Buffer = s
|
|
thunkPosition = 0
|
|
position = 0
|
|
p.Min = 0
|
|
p.Max = 0
|
|
end = 0
|
|
return
|
|
}
|
|
|
|
commit := func(thunkPosition0 int) bool {
|
|
if thunkPosition0 == 0 {
|
|
s := ""
|
|
for _, t := range thunks[:thunkPosition] {
|
|
b := t.begin
|
|
if b >= 0 && b <= t.end {
|
|
s = p.Buffer[b:t.end]
|
|
}
|
|
magic := b
|
|
actions[t.action](s, magic)
|
|
}
|
|
p.Min = position
|
|
thunkPosition = 0
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
matchDot := func() bool {
|
|
if position < len(p.Buffer) {
|
|
position++
|
|
return true
|
|
} else if position >= p.Max {
|
|
p.Max = position
|
|
}
|
|
return false
|
|
}
|
|
|
|
matchChar := func(c byte) bool {
|
|
if (position < len(p.Buffer)) && (p.Buffer[position] == c) {
|
|
position++
|
|
return true
|
|
} else if position >= p.Max {
|
|
p.Max = position
|
|
}
|
|
return false
|
|
}
|
|
|
|
peekChar := func(c byte) bool {
|
|
return position < len(p.Buffer) && p.Buffer[position] == c
|
|
}
|
|
|
|
matchString := func(s string) bool {
|
|
length := len(s)
|
|
next := position + length
|
|
if (next <= len(p.Buffer)) && p.Buffer[position] == s[0] && (p.Buffer[position:next] == s) {
|
|
position = next
|
|
return true
|
|
} else if position >= p.Max {
|
|
p.Max = position
|
|
}
|
|
return false
|
|
}
|
|
|
|
classes := [...][32]uint8{
|
|
3: {0, 0, 0, 0, 50, 232, 255, 3, 254, 255, 255, 135, 254, 255, 255, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
1: {0, 0, 0, 0, 10, 111, 0, 80, 0, 0, 0, 184, 1, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
0: {0, 0, 0, 0, 0, 0, 255, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
5: {0, 0, 0, 0, 0, 0, 255, 3, 254, 255, 255, 7, 254, 255, 255, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
8: {0, 0, 0, 0, 0, 0, 255, 3, 126, 0, 0, 0, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
2: {0, 0, 0, 0, 0, 0, 0, 0, 254, 255, 255, 7, 254, 255, 255, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
6: {0, 0, 0, 0, 0, 0, 255, 3, 254, 255, 255, 7, 254, 255, 255, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
7: {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
4: {0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
|
|
}
|
|
matchClass := func(class uint) bool {
|
|
if (position < len(p.Buffer)) &&
|
|
((classes[class][p.Buffer[position]>>3] & (1 << (p.Buffer[position] & 7))) != 0) {
|
|
position++
|
|
return true
|
|
} else if position >= p.Max {
|
|
p.Max = position
|
|
}
|
|
return false
|
|
}
|
|
peekClass := func(class uint) bool {
|
|
if (position < len(p.Buffer)) &&
|
|
((classes[class][p.Buffer[position]>>3] & (1 << (p.Buffer[position] & 7))) != 0) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
|
|
p.rules = [...]func() bool{
|
|
|
|
/* 0 Doc <- (StartList (Block { a = cons(yy, a) })* { p.tree = reverse(a) } commit) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l0
|
|
}
|
|
doarg(yySet, -1)
|
|
l1:
|
|
{
|
|
position2 := position
|
|
if !p.rules[ruleBlock]() {
|
|
goto l2
|
|
}
|
|
do(0)
|
|
goto l1
|
|
l2:
|
|
position = position2
|
|
}
|
|
do(1)
|
|
if !(commit(thunkPosition0)) {
|
|
goto l0
|
|
}
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l0:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 1 Docblock <- (Block { p.tree = yy } commit) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
if !p.rules[ruleBlock]() {
|
|
goto l3
|
|
}
|
|
do(2)
|
|
if !(commit(thunkPosition0)) {
|
|
goto l3
|
|
}
|
|
return true
|
|
l3:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 2 Block <- (BlankLine* (BlockQuote / Verbatim / Note / Reference / HorizontalRule / Heading / DefinitionList / OrderedList / BulletList / HtmlBlock / StyleBlock / Para / Plain)) */
|
|
func() bool {
|
|
position0 := position
|
|
l5:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l6
|
|
}
|
|
goto l5
|
|
l6:
|
|
if !p.rules[ruleBlockQuote]() {
|
|
goto l8
|
|
}
|
|
goto l7
|
|
l8:
|
|
if !p.rules[ruleVerbatim]() {
|
|
goto l9
|
|
}
|
|
goto l7
|
|
l9:
|
|
if !p.rules[ruleNote]() {
|
|
goto l10
|
|
}
|
|
goto l7
|
|
l10:
|
|
if !p.rules[ruleReference]() {
|
|
goto l11
|
|
}
|
|
goto l7
|
|
l11:
|
|
if !p.rules[ruleHorizontalRule]() {
|
|
goto l12
|
|
}
|
|
goto l7
|
|
l12:
|
|
if !p.rules[ruleHeading]() {
|
|
goto l13
|
|
}
|
|
goto l7
|
|
l13:
|
|
if !p.rules[ruleDefinitionList]() {
|
|
goto l14
|
|
}
|
|
goto l7
|
|
l14:
|
|
if !p.rules[ruleOrderedList]() {
|
|
goto l15
|
|
}
|
|
goto l7
|
|
l15:
|
|
if !p.rules[ruleBulletList]() {
|
|
goto l16
|
|
}
|
|
goto l7
|
|
l16:
|
|
if !p.rules[ruleHtmlBlock]() {
|
|
goto l17
|
|
}
|
|
goto l7
|
|
l17:
|
|
if !p.rules[ruleStyleBlock]() {
|
|
goto l18
|
|
}
|
|
goto l7
|
|
l18:
|
|
if !p.rules[rulePara]() {
|
|
goto l19
|
|
}
|
|
goto l7
|
|
l19:
|
|
if !p.rules[rulePlain]() {
|
|
goto l4
|
|
}
|
|
l7:
|
|
return true
|
|
l4:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 3 Para <- (NonindentSpace Inlines BlankLine+ { yy = a; yy.key = PARA }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l20
|
|
}
|
|
if !p.rules[ruleInlines]() {
|
|
goto l20
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l20
|
|
}
|
|
l21:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l22
|
|
}
|
|
goto l21
|
|
l22:
|
|
do(3)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l20:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 4 Plain <- (Inlines { yy = a; yy.key = PLAIN }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleInlines]() {
|
|
goto l23
|
|
}
|
|
doarg(yySet, -1)
|
|
do(4)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l23:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 5 AtxInline <- (!Newline !(Sp? '#'* Sp Newline) Inline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleNewline]() {
|
|
goto l25
|
|
}
|
|
goto l24
|
|
l25:
|
|
{
|
|
position26 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l27
|
|
}
|
|
l27:
|
|
l29:
|
|
if !matchChar('#') {
|
|
goto l30
|
|
}
|
|
goto l29
|
|
l30:
|
|
if !p.rules[ruleSp]() {
|
|
goto l26
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l26
|
|
}
|
|
goto l24
|
|
l26:
|
|
position = position26
|
|
}
|
|
if !p.rules[ruleInline]() {
|
|
goto l24
|
|
}
|
|
return true
|
|
l24:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 6 AtxStart <- (&'#' < ('######' / '#####' / '####' / '###' / '##' / '#') > { yy = p.mkElem(H1 + (len(yytext) - 1)) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !peekChar('#') {
|
|
goto l31
|
|
}
|
|
begin = position
|
|
if !matchString("######") {
|
|
goto l33
|
|
}
|
|
goto l32
|
|
l33:
|
|
if !matchString("#####") {
|
|
goto l34
|
|
}
|
|
goto l32
|
|
l34:
|
|
if !matchString("####") {
|
|
goto l35
|
|
}
|
|
goto l32
|
|
l35:
|
|
if !matchString("###") {
|
|
goto l36
|
|
}
|
|
goto l32
|
|
l36:
|
|
if !matchString("##") {
|
|
goto l37
|
|
}
|
|
goto l32
|
|
l37:
|
|
if !matchChar('#') {
|
|
goto l31
|
|
}
|
|
l32:
|
|
end = position
|
|
do(5)
|
|
return true
|
|
l31:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 7 AtxHeading <- (AtxStart Sp? StartList (AtxInline { a = cons(yy, a) })+ (Sp? '#'* Sp)? Newline { yy = p.mkList(s.key, a)
|
|
s = nil }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleAtxStart]() {
|
|
goto l38
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleSp]() {
|
|
goto l39
|
|
}
|
|
l39:
|
|
if !p.rules[ruleStartList]() {
|
|
goto l38
|
|
}
|
|
doarg(yySet, -2)
|
|
if !p.rules[ruleAtxInline]() {
|
|
goto l38
|
|
}
|
|
do(6)
|
|
l41:
|
|
{
|
|
position42 := position
|
|
if !p.rules[ruleAtxInline]() {
|
|
goto l42
|
|
}
|
|
do(6)
|
|
goto l41
|
|
l42:
|
|
position = position42
|
|
}
|
|
{
|
|
position43 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l45
|
|
}
|
|
l45:
|
|
l47:
|
|
if !matchChar('#') {
|
|
goto l48
|
|
}
|
|
goto l47
|
|
l48:
|
|
if !p.rules[ruleSp]() {
|
|
goto l43
|
|
}
|
|
goto l44
|
|
l43:
|
|
position = position43
|
|
}
|
|
l44:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l38
|
|
}
|
|
do(7)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l38:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 8 SetextHeading <- (SetextHeading1 / SetextHeading2) */
|
|
func() bool {
|
|
if !p.rules[ruleSetextHeading1]() {
|
|
goto l51
|
|
}
|
|
goto l50
|
|
l51:
|
|
if !p.rules[ruleSetextHeading2]() {
|
|
goto l49
|
|
}
|
|
l50:
|
|
return true
|
|
l49:
|
|
return false
|
|
},
|
|
/* 9 SetextBottom1 <- ('===' '='* Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("===") {
|
|
goto l52
|
|
}
|
|
l53:
|
|
if !matchChar('=') {
|
|
goto l54
|
|
}
|
|
goto l53
|
|
l54:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l52
|
|
}
|
|
return true
|
|
l52:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 10 SetextBottom2 <- ('---' '-'* Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("---") {
|
|
goto l55
|
|
}
|
|
l56:
|
|
if !matchChar('-') {
|
|
goto l57
|
|
}
|
|
goto l56
|
|
l57:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l55
|
|
}
|
|
return true
|
|
l55:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 11 SetextHeading1 <- (&(RawLine SetextBottom1) StartList (!Endline Inline { a = cons(yy, a) })+ Sp? Newline SetextBottom1 { yy = p.mkList(H1, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
{
|
|
position59 := position
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l58
|
|
}
|
|
if !p.rules[ruleSetextBottom1]() {
|
|
goto l58
|
|
}
|
|
position = position59
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l58
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleEndline]() {
|
|
goto l62
|
|
}
|
|
goto l58
|
|
l62:
|
|
if !p.rules[ruleInline]() {
|
|
goto l58
|
|
}
|
|
do(8)
|
|
l60:
|
|
{
|
|
position61 := position
|
|
if !p.rules[ruleEndline]() {
|
|
goto l63
|
|
}
|
|
goto l61
|
|
l63:
|
|
if !p.rules[ruleInline]() {
|
|
goto l61
|
|
}
|
|
do(8)
|
|
goto l60
|
|
l61:
|
|
position = position61
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l64
|
|
}
|
|
l64:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l58
|
|
}
|
|
if !p.rules[ruleSetextBottom1]() {
|
|
goto l58
|
|
}
|
|
do(9)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l58:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 12 SetextHeading2 <- (&(RawLine SetextBottom2) StartList (!Endline Inline { a = cons(yy, a) })+ Sp? Newline SetextBottom2 { yy = p.mkList(H2, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
{
|
|
position67 := position
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l66
|
|
}
|
|
if !p.rules[ruleSetextBottom2]() {
|
|
goto l66
|
|
}
|
|
position = position67
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l66
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleEndline]() {
|
|
goto l70
|
|
}
|
|
goto l66
|
|
l70:
|
|
if !p.rules[ruleInline]() {
|
|
goto l66
|
|
}
|
|
do(10)
|
|
l68:
|
|
{
|
|
position69 := position
|
|
if !p.rules[ruleEndline]() {
|
|
goto l71
|
|
}
|
|
goto l69
|
|
l71:
|
|
if !p.rules[ruleInline]() {
|
|
goto l69
|
|
}
|
|
do(10)
|
|
goto l68
|
|
l69:
|
|
position = position69
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l72
|
|
}
|
|
l72:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l66
|
|
}
|
|
if !p.rules[ruleSetextBottom2]() {
|
|
goto l66
|
|
}
|
|
do(11)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l66:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 13 Heading <- (SetextHeading / AtxHeading) */
|
|
func() bool {
|
|
if !p.rules[ruleSetextHeading]() {
|
|
goto l76
|
|
}
|
|
goto l75
|
|
l76:
|
|
if !p.rules[ruleAtxHeading]() {
|
|
goto l74
|
|
}
|
|
l75:
|
|
return true
|
|
l74:
|
|
return false
|
|
},
|
|
/* 14 BlockQuote <- (BlockQuoteRaw { yy = p.mkElem(BLOCKQUOTE)
|
|
yy.children = a
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleBlockQuoteRaw]() {
|
|
goto l77
|
|
}
|
|
doarg(yySet, -1)
|
|
do(12)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l77:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 15 BlockQuoteRaw <- (StartList ('>' ' '? Line { a = cons(yy, a) } (!'>' !BlankLine Line { a = cons(yy, a) })* (BlankLine { a = cons(p.mkString("\n"), a) })*)+ { yy = p.mkStringFromList(a, true)
|
|
yy.key = RAW
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l78
|
|
}
|
|
doarg(yySet, -1)
|
|
if !matchChar('>') {
|
|
goto l78
|
|
}
|
|
matchChar(' ')
|
|
if !p.rules[ruleLine]() {
|
|
goto l78
|
|
}
|
|
do(13)
|
|
l81:
|
|
{
|
|
position82, thunkPosition82 := position, thunkPosition
|
|
if peekChar('>') {
|
|
goto l82
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l83
|
|
}
|
|
goto l82
|
|
l83:
|
|
if !p.rules[ruleLine]() {
|
|
goto l82
|
|
}
|
|
do(14)
|
|
goto l81
|
|
l82:
|
|
position, thunkPosition = position82, thunkPosition82
|
|
}
|
|
l84:
|
|
{
|
|
position85 := position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l85
|
|
}
|
|
do(15)
|
|
goto l84
|
|
l85:
|
|
position = position85
|
|
}
|
|
l79:
|
|
{
|
|
position80, thunkPosition80 := position, thunkPosition
|
|
if !matchChar('>') {
|
|
goto l80
|
|
}
|
|
matchChar(' ')
|
|
if !p.rules[ruleLine]() {
|
|
goto l80
|
|
}
|
|
do(13)
|
|
l86:
|
|
{
|
|
position87, thunkPosition87 := position, thunkPosition
|
|
if peekChar('>') {
|
|
goto l87
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l88
|
|
}
|
|
goto l87
|
|
l88:
|
|
if !p.rules[ruleLine]() {
|
|
goto l87
|
|
}
|
|
do(14)
|
|
goto l86
|
|
l87:
|
|
position, thunkPosition = position87, thunkPosition87
|
|
}
|
|
l89:
|
|
{
|
|
position90 := position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l90
|
|
}
|
|
do(15)
|
|
goto l89
|
|
l90:
|
|
position = position90
|
|
}
|
|
goto l79
|
|
l80:
|
|
position, thunkPosition = position80, thunkPosition80
|
|
}
|
|
do(16)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l78:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 16 NonblankIndentedLine <- (!BlankLine IndentedLine) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l92
|
|
}
|
|
goto l91
|
|
l92:
|
|
if !p.rules[ruleIndentedLine]() {
|
|
goto l91
|
|
}
|
|
return true
|
|
l91:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 17 VerbatimChunk <- (StartList (BlankLine { a = cons(p.mkString("\n"), a) })* (NonblankIndentedLine { a = cons(yy, a) })+ { yy = p.mkStringFromList(a, false) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l93
|
|
}
|
|
doarg(yySet, -1)
|
|
l94:
|
|
{
|
|
position95 := position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l95
|
|
}
|
|
do(17)
|
|
goto l94
|
|
l95:
|
|
position = position95
|
|
}
|
|
if !p.rules[ruleNonblankIndentedLine]() {
|
|
goto l93
|
|
}
|
|
do(18)
|
|
l96:
|
|
{
|
|
position97 := position
|
|
if !p.rules[ruleNonblankIndentedLine]() {
|
|
goto l97
|
|
}
|
|
do(18)
|
|
goto l96
|
|
l97:
|
|
position = position97
|
|
}
|
|
do(19)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l93:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 18 Verbatim <- (StartList (VerbatimChunk { a = cons(yy, a) })+ { yy = p.mkStringFromList(a, false)
|
|
yy.key = VERBATIM }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l98
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleVerbatimChunk]() {
|
|
goto l98
|
|
}
|
|
do(20)
|
|
l99:
|
|
{
|
|
position100, thunkPosition100 := position, thunkPosition
|
|
if !p.rules[ruleVerbatimChunk]() {
|
|
goto l100
|
|
}
|
|
do(20)
|
|
goto l99
|
|
l100:
|
|
position, thunkPosition = position100, thunkPosition100
|
|
}
|
|
do(21)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l98:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 19 HorizontalRule <- (NonindentSpace ((&[_] ('_' Sp '_' Sp '_' (Sp '_')*)) | (&[\-] ('-' Sp '-' Sp '-' (Sp '-')*)) | (&[*] ('*' Sp '*' Sp '*' (Sp '*')*))) Sp Newline BlankLine+ { yy = p.mkElem(HRULE) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l101
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l101
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '_':
|
|
position++ // matchChar
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !matchChar('_') {
|
|
goto l101
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !matchChar('_') {
|
|
goto l101
|
|
}
|
|
l103:
|
|
{
|
|
position104 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l104
|
|
}
|
|
if !matchChar('_') {
|
|
goto l104
|
|
}
|
|
goto l103
|
|
l104:
|
|
position = position104
|
|
}
|
|
break
|
|
case '-':
|
|
position++ // matchChar
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !matchChar('-') {
|
|
goto l101
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !matchChar('-') {
|
|
goto l101
|
|
}
|
|
l105:
|
|
{
|
|
position106 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l106
|
|
}
|
|
if !matchChar('-') {
|
|
goto l106
|
|
}
|
|
goto l105
|
|
l106:
|
|
position = position106
|
|
}
|
|
break
|
|
case '*':
|
|
position++ // matchChar
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !matchChar('*') {
|
|
goto l101
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !matchChar('*') {
|
|
goto l101
|
|
}
|
|
l107:
|
|
{
|
|
position108 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l108
|
|
}
|
|
if !matchChar('*') {
|
|
goto l108
|
|
}
|
|
goto l107
|
|
l108:
|
|
position = position108
|
|
}
|
|
break
|
|
default:
|
|
goto l101
|
|
}
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l101
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l101
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l101
|
|
}
|
|
l109:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l110
|
|
}
|
|
goto l109
|
|
l110:
|
|
do(22)
|
|
return true
|
|
l101:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 20 Bullet <- (!HorizontalRule NonindentSpace ((&[\-] '-') | (&[*] '*') | (&[+] '+')) Spacechar+) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
if !p.rules[ruleHorizontalRule]() {
|
|
goto l112
|
|
}
|
|
goto l111
|
|
l112:
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l111
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l111
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '-':
|
|
position++ // matchChar
|
|
break
|
|
case '*':
|
|
position++ // matchChar
|
|
break
|
|
case '+':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l111
|
|
}
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l111
|
|
}
|
|
l114:
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l115
|
|
}
|
|
goto l114
|
|
l115:
|
|
return true
|
|
l111:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 21 BulletList <- (&Bullet (ListTight / ListLoose) { yy.key = BULLETLIST }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
{
|
|
position117 := position
|
|
if !p.rules[ruleBullet]() {
|
|
goto l116
|
|
}
|
|
position = position117
|
|
}
|
|
if !p.rules[ruleListTight]() {
|
|
goto l119
|
|
}
|
|
goto l118
|
|
l119:
|
|
if !p.rules[ruleListLoose]() {
|
|
goto l116
|
|
}
|
|
l118:
|
|
do(23)
|
|
return true
|
|
l116:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 22 ListTight <- (StartList (ListItemTight { a = cons(yy, a) })+ BlankLine* !((&[:~] DefMarker) | (&[*+\-] Bullet) | (&[0-9] Enumerator)) { yy = p.mkList(LIST, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l120
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleListItemTight]() {
|
|
goto l120
|
|
}
|
|
do(24)
|
|
l121:
|
|
{
|
|
position122, thunkPosition122 := position, thunkPosition
|
|
if !p.rules[ruleListItemTight]() {
|
|
goto l122
|
|
}
|
|
do(24)
|
|
goto l121
|
|
l122:
|
|
position, thunkPosition = position122, thunkPosition122
|
|
}
|
|
l123:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l124
|
|
}
|
|
goto l123
|
|
l124:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l125
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ':', '~':
|
|
if !p.rules[ruleDefMarker]() {
|
|
goto l125
|
|
}
|
|
break
|
|
case '*', '+', '-':
|
|
if !p.rules[ruleBullet]() {
|
|
goto l125
|
|
}
|
|
break
|
|
default:
|
|
if !p.rules[ruleEnumerator]() {
|
|
goto l125
|
|
}
|
|
}
|
|
}
|
|
goto l120
|
|
l125:
|
|
do(25)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l120:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 23 ListLoose <- (StartList (ListItem BlankLine* {
|
|
li := b.children
|
|
li.contents.str += "\n\n"
|
|
a = cons(b, a)
|
|
})+ { yy = p.mkList(LIST, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l127
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleListItem]() {
|
|
goto l127
|
|
}
|
|
doarg(yySet, -2)
|
|
l130:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l131
|
|
}
|
|
goto l130
|
|
l131:
|
|
do(26)
|
|
l128:
|
|
{
|
|
position129, thunkPosition129 := position, thunkPosition
|
|
if !p.rules[ruleListItem]() {
|
|
goto l129
|
|
}
|
|
doarg(yySet, -2)
|
|
l132:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l133
|
|
}
|
|
goto l132
|
|
l133:
|
|
do(26)
|
|
goto l128
|
|
l129:
|
|
position, thunkPosition = position129, thunkPosition129
|
|
}
|
|
do(27)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l127:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 24 ListItem <- (((&[:~] DefMarker) | (&[*+\-] Bullet) | (&[0-9] Enumerator)) StartList ListBlock { a = cons(yy, a) } (ListContinuationBlock { a = cons(yy, a) })* {
|
|
raw := p.mkStringFromList(a, false)
|
|
raw.key = RAW
|
|
yy = p.mkElem(LISTITEM)
|
|
yy.children = raw
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l134
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ':', '~':
|
|
if !p.rules[ruleDefMarker]() {
|
|
goto l134
|
|
}
|
|
break
|
|
case '*', '+', '-':
|
|
if !p.rules[ruleBullet]() {
|
|
goto l134
|
|
}
|
|
break
|
|
default:
|
|
if !p.rules[ruleEnumerator]() {
|
|
goto l134
|
|
}
|
|
}
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l134
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleListBlock]() {
|
|
goto l134
|
|
}
|
|
do(28)
|
|
l136:
|
|
{
|
|
position137, thunkPosition137 := position, thunkPosition
|
|
if !p.rules[ruleListContinuationBlock]() {
|
|
goto l137
|
|
}
|
|
do(29)
|
|
goto l136
|
|
l137:
|
|
position, thunkPosition = position137, thunkPosition137
|
|
}
|
|
do(30)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l134:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 25 ListItemTight <- (((&[:~] DefMarker) | (&[*+\-] Bullet) | (&[0-9] Enumerator)) StartList ListBlock { a = cons(yy, a) } (!BlankLine ListContinuationBlock { a = cons(yy, a) })* !ListContinuationBlock {
|
|
raw := p.mkStringFromList(a, false)
|
|
raw.key = RAW
|
|
yy = p.mkElem(LISTITEM)
|
|
yy.children = raw
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l138
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ':', '~':
|
|
if !p.rules[ruleDefMarker]() {
|
|
goto l138
|
|
}
|
|
break
|
|
case '*', '+', '-':
|
|
if !p.rules[ruleBullet]() {
|
|
goto l138
|
|
}
|
|
break
|
|
default:
|
|
if !p.rules[ruleEnumerator]() {
|
|
goto l138
|
|
}
|
|
}
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l138
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleListBlock]() {
|
|
goto l138
|
|
}
|
|
do(31)
|
|
l140:
|
|
{
|
|
position141, thunkPosition141 := position, thunkPosition
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l142
|
|
}
|
|
goto l141
|
|
l142:
|
|
if !p.rules[ruleListContinuationBlock]() {
|
|
goto l141
|
|
}
|
|
do(32)
|
|
goto l140
|
|
l141:
|
|
position, thunkPosition = position141, thunkPosition141
|
|
}
|
|
if !p.rules[ruleListContinuationBlock]() {
|
|
goto l143
|
|
}
|
|
goto l138
|
|
l143:
|
|
do(33)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l138:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 26 ListBlock <- (StartList !BlankLine Line { a = cons(yy, a) } (ListBlockLine { a = cons(yy, a) })* { yy = p.mkStringFromList(a, false) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l144
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l145
|
|
}
|
|
goto l144
|
|
l145:
|
|
if !p.rules[ruleLine]() {
|
|
goto l144
|
|
}
|
|
do(34)
|
|
l146:
|
|
{
|
|
position147 := position
|
|
if !p.rules[ruleListBlockLine]() {
|
|
goto l147
|
|
}
|
|
do(35)
|
|
goto l146
|
|
l147:
|
|
position = position147
|
|
}
|
|
do(36)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l144:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 27 ListContinuationBlock <- (StartList (< BlankLine* > { if len(yytext) == 0 {
|
|
a = cons(p.mkString("\001"), a) // block separator
|
|
} else {
|
|
a = cons(p.mkString(yytext), a)
|
|
}
|
|
}) (Indent ListBlock { a = cons(yy, a) })+ { yy = p.mkStringFromList(a, false) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l148
|
|
}
|
|
doarg(yySet, -1)
|
|
begin = position
|
|
l149:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l150
|
|
}
|
|
goto l149
|
|
l150:
|
|
end = position
|
|
do(37)
|
|
if !p.rules[ruleIndent]() {
|
|
goto l148
|
|
}
|
|
if !p.rules[ruleListBlock]() {
|
|
goto l148
|
|
}
|
|
do(38)
|
|
l151:
|
|
{
|
|
position152, thunkPosition152 := position, thunkPosition
|
|
if !p.rules[ruleIndent]() {
|
|
goto l152
|
|
}
|
|
if !p.rules[ruleListBlock]() {
|
|
goto l152
|
|
}
|
|
do(38)
|
|
goto l151
|
|
l152:
|
|
position, thunkPosition = position152, thunkPosition152
|
|
}
|
|
do(39)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l148:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 28 Enumerator <- (NonindentSpace [0-9]+ '.' Spacechar+) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l153
|
|
}
|
|
if !matchClass(0) {
|
|
goto l153
|
|
}
|
|
l154:
|
|
if !matchClass(0) {
|
|
goto l155
|
|
}
|
|
goto l154
|
|
l155:
|
|
if !matchChar('.') {
|
|
goto l153
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l153
|
|
}
|
|
l156:
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l157
|
|
}
|
|
goto l156
|
|
l157:
|
|
return true
|
|
l153:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 29 OrderedList <- (&Enumerator (ListTight / ListLoose) { yy.key = ORDEREDLIST }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
{
|
|
position159 := position
|
|
if !p.rules[ruleEnumerator]() {
|
|
goto l158
|
|
}
|
|
position = position159
|
|
}
|
|
if !p.rules[ruleListTight]() {
|
|
goto l161
|
|
}
|
|
goto l160
|
|
l161:
|
|
if !p.rules[ruleListLoose]() {
|
|
goto l158
|
|
}
|
|
l160:
|
|
do(40)
|
|
return true
|
|
l158:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 30 ListBlockLine <- (!BlankLine !((&[:~] DefMarker) | (&[\t *+\-0-9] (Indent? ((&[*+\-] Bullet) | (&[0-9] Enumerator))))) !HorizontalRule OptionallyIndentedLine) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l163
|
|
}
|
|
goto l162
|
|
l163:
|
|
{
|
|
position164 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l164
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ':', '~':
|
|
if !p.rules[ruleDefMarker]() {
|
|
goto l164
|
|
}
|
|
break
|
|
default:
|
|
if !p.rules[ruleIndent]() {
|
|
goto l166
|
|
}
|
|
l166:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l164
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '*', '+', '-':
|
|
if !p.rules[ruleBullet]() {
|
|
goto l164
|
|
}
|
|
break
|
|
default:
|
|
if !p.rules[ruleEnumerator]() {
|
|
goto l164
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
goto l162
|
|
l164:
|
|
position = position164
|
|
}
|
|
if !p.rules[ruleHorizontalRule]() {
|
|
goto l169
|
|
}
|
|
goto l162
|
|
l169:
|
|
if !p.rules[ruleOptionallyIndentedLine]() {
|
|
goto l162
|
|
}
|
|
return true
|
|
l162:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 31 HtmlBlockOpenAddress <- ('<' Spnl ((&[A] 'ADDRESS') | (&[a] 'address')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l170
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l170
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l170
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'A':
|
|
position++
|
|
if !matchString("DDRESS") {
|
|
goto l170
|
|
}
|
|
break
|
|
case 'a':
|
|
position++
|
|
if !matchString("ddress") {
|
|
goto l170
|
|
}
|
|
break
|
|
default:
|
|
goto l170
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l170
|
|
}
|
|
l172:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l173
|
|
}
|
|
goto l172
|
|
l173:
|
|
if !matchChar('>') {
|
|
goto l170
|
|
}
|
|
return true
|
|
l170:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 32 HtmlBlockCloseAddress <- ('<' Spnl '/' ((&[A] 'ADDRESS') | (&[a] 'address')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l174
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l174
|
|
}
|
|
if !matchChar('/') {
|
|
goto l174
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l174
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'A':
|
|
position++
|
|
if !matchString("DDRESS") {
|
|
goto l174
|
|
}
|
|
break
|
|
case 'a':
|
|
position++
|
|
if !matchString("ddress") {
|
|
goto l174
|
|
}
|
|
break
|
|
default:
|
|
goto l174
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l174
|
|
}
|
|
if !matchChar('>') {
|
|
goto l174
|
|
}
|
|
return true
|
|
l174:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 33 HtmlBlockAddress <- (HtmlBlockOpenAddress (HtmlBlockAddress / (!HtmlBlockCloseAddress .))* HtmlBlockCloseAddress) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenAddress]() {
|
|
goto l176
|
|
}
|
|
l177:
|
|
{
|
|
position178 := position
|
|
if !p.rules[ruleHtmlBlockAddress]() {
|
|
goto l180
|
|
}
|
|
goto l179
|
|
l180:
|
|
if !p.rules[ruleHtmlBlockCloseAddress]() {
|
|
goto l181
|
|
}
|
|
goto l178
|
|
l181:
|
|
if !matchDot() {
|
|
goto l178
|
|
}
|
|
l179:
|
|
goto l177
|
|
l178:
|
|
position = position178
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseAddress]() {
|
|
goto l176
|
|
}
|
|
return true
|
|
l176:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 34 HtmlBlockOpenBlockquote <- ('<' Spnl ((&[B] 'BLOCKQUOTE') | (&[b] 'blockquote')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l182
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l182
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l182
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'B':
|
|
position++
|
|
if !matchString("LOCKQUOTE") {
|
|
goto l182
|
|
}
|
|
break
|
|
case 'b':
|
|
position++
|
|
if !matchString("lockquote") {
|
|
goto l182
|
|
}
|
|
break
|
|
default:
|
|
goto l182
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l182
|
|
}
|
|
l184:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l185
|
|
}
|
|
goto l184
|
|
l185:
|
|
if !matchChar('>') {
|
|
goto l182
|
|
}
|
|
return true
|
|
l182:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 35 HtmlBlockCloseBlockquote <- ('<' Spnl '/' ((&[B] 'BLOCKQUOTE') | (&[b] 'blockquote')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l186
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l186
|
|
}
|
|
if !matchChar('/') {
|
|
goto l186
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l186
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'B':
|
|
position++
|
|
if !matchString("LOCKQUOTE") {
|
|
goto l186
|
|
}
|
|
break
|
|
case 'b':
|
|
position++
|
|
if !matchString("lockquote") {
|
|
goto l186
|
|
}
|
|
break
|
|
default:
|
|
goto l186
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l186
|
|
}
|
|
if !matchChar('>') {
|
|
goto l186
|
|
}
|
|
return true
|
|
l186:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 36 HtmlBlockBlockquote <- (HtmlBlockOpenBlockquote (HtmlBlockBlockquote / (!HtmlBlockCloseBlockquote .))* HtmlBlockCloseBlockquote) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenBlockquote]() {
|
|
goto l188
|
|
}
|
|
l189:
|
|
{
|
|
position190 := position
|
|
if !p.rules[ruleHtmlBlockBlockquote]() {
|
|
goto l192
|
|
}
|
|
goto l191
|
|
l192:
|
|
if !p.rules[ruleHtmlBlockCloseBlockquote]() {
|
|
goto l193
|
|
}
|
|
goto l190
|
|
l193:
|
|
if !matchDot() {
|
|
goto l190
|
|
}
|
|
l191:
|
|
goto l189
|
|
l190:
|
|
position = position190
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseBlockquote]() {
|
|
goto l188
|
|
}
|
|
return true
|
|
l188:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 37 HtmlBlockOpenCenter <- ('<' Spnl ((&[C] 'CENTER') | (&[c] 'center')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l194
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l194
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l194
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'C':
|
|
position++
|
|
if !matchString("ENTER") {
|
|
goto l194
|
|
}
|
|
break
|
|
case 'c':
|
|
position++
|
|
if !matchString("enter") {
|
|
goto l194
|
|
}
|
|
break
|
|
default:
|
|
goto l194
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l194
|
|
}
|
|
l196:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l197
|
|
}
|
|
goto l196
|
|
l197:
|
|
if !matchChar('>') {
|
|
goto l194
|
|
}
|
|
return true
|
|
l194:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 38 HtmlBlockCloseCenter <- ('<' Spnl '/' ((&[C] 'CENTER') | (&[c] 'center')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l198
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l198
|
|
}
|
|
if !matchChar('/') {
|
|
goto l198
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l198
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'C':
|
|
position++
|
|
if !matchString("ENTER") {
|
|
goto l198
|
|
}
|
|
break
|
|
case 'c':
|
|
position++
|
|
if !matchString("enter") {
|
|
goto l198
|
|
}
|
|
break
|
|
default:
|
|
goto l198
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l198
|
|
}
|
|
if !matchChar('>') {
|
|
goto l198
|
|
}
|
|
return true
|
|
l198:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 39 HtmlBlockCenter <- (HtmlBlockOpenCenter (HtmlBlockCenter / (!HtmlBlockCloseCenter .))* HtmlBlockCloseCenter) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenCenter]() {
|
|
goto l200
|
|
}
|
|
l201:
|
|
{
|
|
position202 := position
|
|
if !p.rules[ruleHtmlBlockCenter]() {
|
|
goto l204
|
|
}
|
|
goto l203
|
|
l204:
|
|
if !p.rules[ruleHtmlBlockCloseCenter]() {
|
|
goto l205
|
|
}
|
|
goto l202
|
|
l205:
|
|
if !matchDot() {
|
|
goto l202
|
|
}
|
|
l203:
|
|
goto l201
|
|
l202:
|
|
position = position202
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseCenter]() {
|
|
goto l200
|
|
}
|
|
return true
|
|
l200:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 40 HtmlBlockOpenDir <- ('<' Spnl ((&[D] 'DIR') | (&[d] 'dir')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l206
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l206
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l206
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++
|
|
if !matchString("IR") {
|
|
goto l206
|
|
}
|
|
break
|
|
case 'd':
|
|
position++
|
|
if !matchString("ir") {
|
|
goto l206
|
|
}
|
|
break
|
|
default:
|
|
goto l206
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l206
|
|
}
|
|
l208:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l209
|
|
}
|
|
goto l208
|
|
l209:
|
|
if !matchChar('>') {
|
|
goto l206
|
|
}
|
|
return true
|
|
l206:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 41 HtmlBlockCloseDir <- ('<' Spnl '/' ((&[D] 'DIR') | (&[d] 'dir')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l210
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l210
|
|
}
|
|
if !matchChar('/') {
|
|
goto l210
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l210
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++
|
|
if !matchString("IR") {
|
|
goto l210
|
|
}
|
|
break
|
|
case 'd':
|
|
position++
|
|
if !matchString("ir") {
|
|
goto l210
|
|
}
|
|
break
|
|
default:
|
|
goto l210
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l210
|
|
}
|
|
if !matchChar('>') {
|
|
goto l210
|
|
}
|
|
return true
|
|
l210:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 42 HtmlBlockDir <- (HtmlBlockOpenDir (HtmlBlockDir / (!HtmlBlockCloseDir .))* HtmlBlockCloseDir) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenDir]() {
|
|
goto l212
|
|
}
|
|
l213:
|
|
{
|
|
position214 := position
|
|
if !p.rules[ruleHtmlBlockDir]() {
|
|
goto l216
|
|
}
|
|
goto l215
|
|
l216:
|
|
if !p.rules[ruleHtmlBlockCloseDir]() {
|
|
goto l217
|
|
}
|
|
goto l214
|
|
l217:
|
|
if !matchDot() {
|
|
goto l214
|
|
}
|
|
l215:
|
|
goto l213
|
|
l214:
|
|
position = position214
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseDir]() {
|
|
goto l212
|
|
}
|
|
return true
|
|
l212:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 43 HtmlBlockOpenDiv <- ('<' Spnl ((&[D] 'DIV') | (&[d] 'div')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l218
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l218
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l218
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++
|
|
if !matchString("IV") {
|
|
goto l218
|
|
}
|
|
break
|
|
case 'd':
|
|
position++
|
|
if !matchString("iv") {
|
|
goto l218
|
|
}
|
|
break
|
|
default:
|
|
goto l218
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l218
|
|
}
|
|
l220:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l221
|
|
}
|
|
goto l220
|
|
l221:
|
|
if !matchChar('>') {
|
|
goto l218
|
|
}
|
|
return true
|
|
l218:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 44 HtmlBlockCloseDiv <- ('<' Spnl '/' ((&[D] 'DIV') | (&[d] 'div')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l222
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l222
|
|
}
|
|
if !matchChar('/') {
|
|
goto l222
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l222
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++
|
|
if !matchString("IV") {
|
|
goto l222
|
|
}
|
|
break
|
|
case 'd':
|
|
position++
|
|
if !matchString("iv") {
|
|
goto l222
|
|
}
|
|
break
|
|
default:
|
|
goto l222
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l222
|
|
}
|
|
if !matchChar('>') {
|
|
goto l222
|
|
}
|
|
return true
|
|
l222:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 45 HtmlBlockDiv <- (HtmlBlockOpenDiv (HtmlBlockDiv / (!HtmlBlockCloseDiv .))* HtmlBlockCloseDiv) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenDiv]() {
|
|
goto l224
|
|
}
|
|
l225:
|
|
{
|
|
position226 := position
|
|
if !p.rules[ruleHtmlBlockDiv]() {
|
|
goto l228
|
|
}
|
|
goto l227
|
|
l228:
|
|
if !p.rules[ruleHtmlBlockCloseDiv]() {
|
|
goto l229
|
|
}
|
|
goto l226
|
|
l229:
|
|
if !matchDot() {
|
|
goto l226
|
|
}
|
|
l227:
|
|
goto l225
|
|
l226:
|
|
position = position226
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseDiv]() {
|
|
goto l224
|
|
}
|
|
return true
|
|
l224:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 46 HtmlBlockOpenDl <- ('<' Spnl ((&[D] 'DL') | (&[d] 'dl')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l230
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l230
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l230
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++ // matchString(`DL`)
|
|
if !matchChar('L') {
|
|
goto l230
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dl`)
|
|
if !matchChar('l') {
|
|
goto l230
|
|
}
|
|
break
|
|
default:
|
|
goto l230
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l230
|
|
}
|
|
l232:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l233
|
|
}
|
|
goto l232
|
|
l233:
|
|
if !matchChar('>') {
|
|
goto l230
|
|
}
|
|
return true
|
|
l230:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 47 HtmlBlockCloseDl <- ('<' Spnl '/' ((&[D] 'DL') | (&[d] 'dl')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l234
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l234
|
|
}
|
|
if !matchChar('/') {
|
|
goto l234
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l234
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++ // matchString(`DL`)
|
|
if !matchChar('L') {
|
|
goto l234
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dl`)
|
|
if !matchChar('l') {
|
|
goto l234
|
|
}
|
|
break
|
|
default:
|
|
goto l234
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l234
|
|
}
|
|
if !matchChar('>') {
|
|
goto l234
|
|
}
|
|
return true
|
|
l234:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 48 HtmlBlockDl <- (HtmlBlockOpenDl (HtmlBlockDl / (!HtmlBlockCloseDl .))* HtmlBlockCloseDl) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenDl]() {
|
|
goto l236
|
|
}
|
|
l237:
|
|
{
|
|
position238 := position
|
|
if !p.rules[ruleHtmlBlockDl]() {
|
|
goto l240
|
|
}
|
|
goto l239
|
|
l240:
|
|
if !p.rules[ruleHtmlBlockCloseDl]() {
|
|
goto l241
|
|
}
|
|
goto l238
|
|
l241:
|
|
if !matchDot() {
|
|
goto l238
|
|
}
|
|
l239:
|
|
goto l237
|
|
l238:
|
|
position = position238
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseDl]() {
|
|
goto l236
|
|
}
|
|
return true
|
|
l236:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 49 HtmlBlockOpenFieldset <- ('<' Spnl ((&[F] 'FIELDSET') | (&[f] 'fieldset')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l242
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l242
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l242
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'F':
|
|
position++
|
|
if !matchString("IELDSET") {
|
|
goto l242
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("ieldset") {
|
|
goto l242
|
|
}
|
|
break
|
|
default:
|
|
goto l242
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l242
|
|
}
|
|
l244:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l245
|
|
}
|
|
goto l244
|
|
l245:
|
|
if !matchChar('>') {
|
|
goto l242
|
|
}
|
|
return true
|
|
l242:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 50 HtmlBlockCloseFieldset <- ('<' Spnl '/' ((&[F] 'FIELDSET') | (&[f] 'fieldset')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l246
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l246
|
|
}
|
|
if !matchChar('/') {
|
|
goto l246
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l246
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'F':
|
|
position++
|
|
if !matchString("IELDSET") {
|
|
goto l246
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("ieldset") {
|
|
goto l246
|
|
}
|
|
break
|
|
default:
|
|
goto l246
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l246
|
|
}
|
|
if !matchChar('>') {
|
|
goto l246
|
|
}
|
|
return true
|
|
l246:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 51 HtmlBlockFieldset <- (HtmlBlockOpenFieldset (HtmlBlockFieldset / (!HtmlBlockCloseFieldset .))* HtmlBlockCloseFieldset) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenFieldset]() {
|
|
goto l248
|
|
}
|
|
l249:
|
|
{
|
|
position250 := position
|
|
if !p.rules[ruleHtmlBlockFieldset]() {
|
|
goto l252
|
|
}
|
|
goto l251
|
|
l252:
|
|
if !p.rules[ruleHtmlBlockCloseFieldset]() {
|
|
goto l253
|
|
}
|
|
goto l250
|
|
l253:
|
|
if !matchDot() {
|
|
goto l250
|
|
}
|
|
l251:
|
|
goto l249
|
|
l250:
|
|
position = position250
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseFieldset]() {
|
|
goto l248
|
|
}
|
|
return true
|
|
l248:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 52 HtmlBlockOpenForm <- ('<' Spnl ((&[F] 'FORM') | (&[f] 'form')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l254
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l254
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l254
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'F':
|
|
position++
|
|
if !matchString("ORM") {
|
|
goto l254
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("orm") {
|
|
goto l254
|
|
}
|
|
break
|
|
default:
|
|
goto l254
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l254
|
|
}
|
|
l256:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l257
|
|
}
|
|
goto l256
|
|
l257:
|
|
if !matchChar('>') {
|
|
goto l254
|
|
}
|
|
return true
|
|
l254:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 53 HtmlBlockCloseForm <- ('<' Spnl '/' ((&[F] 'FORM') | (&[f] 'form')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l258
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l258
|
|
}
|
|
if !matchChar('/') {
|
|
goto l258
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l258
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'F':
|
|
position++
|
|
if !matchString("ORM") {
|
|
goto l258
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("orm") {
|
|
goto l258
|
|
}
|
|
break
|
|
default:
|
|
goto l258
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l258
|
|
}
|
|
if !matchChar('>') {
|
|
goto l258
|
|
}
|
|
return true
|
|
l258:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 54 HtmlBlockForm <- (HtmlBlockOpenForm (HtmlBlockForm / (!HtmlBlockCloseForm .))* HtmlBlockCloseForm) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenForm]() {
|
|
goto l260
|
|
}
|
|
l261:
|
|
{
|
|
position262 := position
|
|
if !p.rules[ruleHtmlBlockForm]() {
|
|
goto l264
|
|
}
|
|
goto l263
|
|
l264:
|
|
if !p.rules[ruleHtmlBlockCloseForm]() {
|
|
goto l265
|
|
}
|
|
goto l262
|
|
l265:
|
|
if !matchDot() {
|
|
goto l262
|
|
}
|
|
l263:
|
|
goto l261
|
|
l262:
|
|
position = position262
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseForm]() {
|
|
goto l260
|
|
}
|
|
return true
|
|
l260:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 55 HtmlBlockOpenH1 <- ('<' Spnl ((&[H] 'H1') | (&[h] 'h1')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l266
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l266
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l266
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H1`)
|
|
if !matchChar('1') {
|
|
goto l266
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h1`)
|
|
if !matchChar('1') {
|
|
goto l266
|
|
}
|
|
break
|
|
default:
|
|
goto l266
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l266
|
|
}
|
|
l268:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l269
|
|
}
|
|
goto l268
|
|
l269:
|
|
if !matchChar('>') {
|
|
goto l266
|
|
}
|
|
return true
|
|
l266:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 56 HtmlBlockCloseH1 <- ('<' Spnl '/' ((&[H] 'H1') | (&[h] 'h1')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l270
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l270
|
|
}
|
|
if !matchChar('/') {
|
|
goto l270
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l270
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H1`)
|
|
if !matchChar('1') {
|
|
goto l270
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h1`)
|
|
if !matchChar('1') {
|
|
goto l270
|
|
}
|
|
break
|
|
default:
|
|
goto l270
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l270
|
|
}
|
|
if !matchChar('>') {
|
|
goto l270
|
|
}
|
|
return true
|
|
l270:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 57 HtmlBlockH1 <- (HtmlBlockOpenH1 (HtmlBlockH1 / (!HtmlBlockCloseH1 .))* HtmlBlockCloseH1) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenH1]() {
|
|
goto l272
|
|
}
|
|
l273:
|
|
{
|
|
position274 := position
|
|
if !p.rules[ruleHtmlBlockH1]() {
|
|
goto l276
|
|
}
|
|
goto l275
|
|
l276:
|
|
if !p.rules[ruleHtmlBlockCloseH1]() {
|
|
goto l277
|
|
}
|
|
goto l274
|
|
l277:
|
|
if !matchDot() {
|
|
goto l274
|
|
}
|
|
l275:
|
|
goto l273
|
|
l274:
|
|
position = position274
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseH1]() {
|
|
goto l272
|
|
}
|
|
return true
|
|
l272:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 58 HtmlBlockOpenH2 <- ('<' Spnl ((&[H] 'H2') | (&[h] 'h2')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l278
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l278
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l278
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H2`)
|
|
if !matchChar('2') {
|
|
goto l278
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h2`)
|
|
if !matchChar('2') {
|
|
goto l278
|
|
}
|
|
break
|
|
default:
|
|
goto l278
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l278
|
|
}
|
|
l280:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l281
|
|
}
|
|
goto l280
|
|
l281:
|
|
if !matchChar('>') {
|
|
goto l278
|
|
}
|
|
return true
|
|
l278:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 59 HtmlBlockCloseH2 <- ('<' Spnl '/' ((&[H] 'H2') | (&[h] 'h2')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l282
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l282
|
|
}
|
|
if !matchChar('/') {
|
|
goto l282
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l282
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H2`)
|
|
if !matchChar('2') {
|
|
goto l282
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h2`)
|
|
if !matchChar('2') {
|
|
goto l282
|
|
}
|
|
break
|
|
default:
|
|
goto l282
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l282
|
|
}
|
|
if !matchChar('>') {
|
|
goto l282
|
|
}
|
|
return true
|
|
l282:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 60 HtmlBlockH2 <- (HtmlBlockOpenH2 (HtmlBlockH2 / (!HtmlBlockCloseH2 .))* HtmlBlockCloseH2) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenH2]() {
|
|
goto l284
|
|
}
|
|
l285:
|
|
{
|
|
position286 := position
|
|
if !p.rules[ruleHtmlBlockH2]() {
|
|
goto l288
|
|
}
|
|
goto l287
|
|
l288:
|
|
if !p.rules[ruleHtmlBlockCloseH2]() {
|
|
goto l289
|
|
}
|
|
goto l286
|
|
l289:
|
|
if !matchDot() {
|
|
goto l286
|
|
}
|
|
l287:
|
|
goto l285
|
|
l286:
|
|
position = position286
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseH2]() {
|
|
goto l284
|
|
}
|
|
return true
|
|
l284:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 61 HtmlBlockOpenH3 <- ('<' Spnl ((&[H] 'H3') | (&[h] 'h3')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l290
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l290
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l290
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H3`)
|
|
if !matchChar('3') {
|
|
goto l290
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h3`)
|
|
if !matchChar('3') {
|
|
goto l290
|
|
}
|
|
break
|
|
default:
|
|
goto l290
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l290
|
|
}
|
|
l292:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l293
|
|
}
|
|
goto l292
|
|
l293:
|
|
if !matchChar('>') {
|
|
goto l290
|
|
}
|
|
return true
|
|
l290:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 62 HtmlBlockCloseH3 <- ('<' Spnl '/' ((&[H] 'H3') | (&[h] 'h3')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l294
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l294
|
|
}
|
|
if !matchChar('/') {
|
|
goto l294
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l294
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H3`)
|
|
if !matchChar('3') {
|
|
goto l294
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h3`)
|
|
if !matchChar('3') {
|
|
goto l294
|
|
}
|
|
break
|
|
default:
|
|
goto l294
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l294
|
|
}
|
|
if !matchChar('>') {
|
|
goto l294
|
|
}
|
|
return true
|
|
l294:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 63 HtmlBlockH3 <- (HtmlBlockOpenH3 (HtmlBlockH3 / (!HtmlBlockCloseH3 .))* HtmlBlockCloseH3) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenH3]() {
|
|
goto l296
|
|
}
|
|
l297:
|
|
{
|
|
position298 := position
|
|
if !p.rules[ruleHtmlBlockH3]() {
|
|
goto l300
|
|
}
|
|
goto l299
|
|
l300:
|
|
if !p.rules[ruleHtmlBlockCloseH3]() {
|
|
goto l301
|
|
}
|
|
goto l298
|
|
l301:
|
|
if !matchDot() {
|
|
goto l298
|
|
}
|
|
l299:
|
|
goto l297
|
|
l298:
|
|
position = position298
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseH3]() {
|
|
goto l296
|
|
}
|
|
return true
|
|
l296:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 64 HtmlBlockOpenH4 <- ('<' Spnl ((&[H] 'H4') | (&[h] 'h4')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l302
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l302
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l302
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H4`)
|
|
if !matchChar('4') {
|
|
goto l302
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h4`)
|
|
if !matchChar('4') {
|
|
goto l302
|
|
}
|
|
break
|
|
default:
|
|
goto l302
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l302
|
|
}
|
|
l304:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l305
|
|
}
|
|
goto l304
|
|
l305:
|
|
if !matchChar('>') {
|
|
goto l302
|
|
}
|
|
return true
|
|
l302:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 65 HtmlBlockCloseH4 <- ('<' Spnl '/' ((&[H] 'H4') | (&[h] 'h4')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l306
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l306
|
|
}
|
|
if !matchChar('/') {
|
|
goto l306
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l306
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H4`)
|
|
if !matchChar('4') {
|
|
goto l306
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h4`)
|
|
if !matchChar('4') {
|
|
goto l306
|
|
}
|
|
break
|
|
default:
|
|
goto l306
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l306
|
|
}
|
|
if !matchChar('>') {
|
|
goto l306
|
|
}
|
|
return true
|
|
l306:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 66 HtmlBlockH4 <- (HtmlBlockOpenH4 (HtmlBlockH4 / (!HtmlBlockCloseH4 .))* HtmlBlockCloseH4) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenH4]() {
|
|
goto l308
|
|
}
|
|
l309:
|
|
{
|
|
position310 := position
|
|
if !p.rules[ruleHtmlBlockH4]() {
|
|
goto l312
|
|
}
|
|
goto l311
|
|
l312:
|
|
if !p.rules[ruleHtmlBlockCloseH4]() {
|
|
goto l313
|
|
}
|
|
goto l310
|
|
l313:
|
|
if !matchDot() {
|
|
goto l310
|
|
}
|
|
l311:
|
|
goto l309
|
|
l310:
|
|
position = position310
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseH4]() {
|
|
goto l308
|
|
}
|
|
return true
|
|
l308:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 67 HtmlBlockOpenH5 <- ('<' Spnl ((&[H] 'H5') | (&[h] 'h5')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l314
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l314
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l314
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H5`)
|
|
if !matchChar('5') {
|
|
goto l314
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h5`)
|
|
if !matchChar('5') {
|
|
goto l314
|
|
}
|
|
break
|
|
default:
|
|
goto l314
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l314
|
|
}
|
|
l316:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l317
|
|
}
|
|
goto l316
|
|
l317:
|
|
if !matchChar('>') {
|
|
goto l314
|
|
}
|
|
return true
|
|
l314:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 68 HtmlBlockCloseH5 <- ('<' Spnl '/' ((&[H] 'H5') | (&[h] 'h5')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l318
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l318
|
|
}
|
|
if !matchChar('/') {
|
|
goto l318
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l318
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H5`)
|
|
if !matchChar('5') {
|
|
goto l318
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h5`)
|
|
if !matchChar('5') {
|
|
goto l318
|
|
}
|
|
break
|
|
default:
|
|
goto l318
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l318
|
|
}
|
|
if !matchChar('>') {
|
|
goto l318
|
|
}
|
|
return true
|
|
l318:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 69 HtmlBlockH5 <- (HtmlBlockOpenH5 (HtmlBlockH5 / (!HtmlBlockCloseH5 .))* HtmlBlockCloseH5) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenH5]() {
|
|
goto l320
|
|
}
|
|
l321:
|
|
{
|
|
position322 := position
|
|
if !p.rules[ruleHtmlBlockH5]() {
|
|
goto l324
|
|
}
|
|
goto l323
|
|
l324:
|
|
if !p.rules[ruleHtmlBlockCloseH5]() {
|
|
goto l325
|
|
}
|
|
goto l322
|
|
l325:
|
|
if !matchDot() {
|
|
goto l322
|
|
}
|
|
l323:
|
|
goto l321
|
|
l322:
|
|
position = position322
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseH5]() {
|
|
goto l320
|
|
}
|
|
return true
|
|
l320:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 70 HtmlBlockOpenH6 <- ('<' Spnl ((&[H] 'H6') | (&[h] 'h6')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l326
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l326
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l326
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H6`)
|
|
if !matchChar('6') {
|
|
goto l326
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h6`)
|
|
if !matchChar('6') {
|
|
goto l326
|
|
}
|
|
break
|
|
default:
|
|
goto l326
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l326
|
|
}
|
|
l328:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l329
|
|
}
|
|
goto l328
|
|
l329:
|
|
if !matchChar('>') {
|
|
goto l326
|
|
}
|
|
return true
|
|
l326:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 71 HtmlBlockCloseH6 <- ('<' Spnl '/' ((&[H] 'H6') | (&[h] 'h6')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l330
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l330
|
|
}
|
|
if !matchChar('/') {
|
|
goto l330
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l330
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'H':
|
|
position++ // matchString(`H6`)
|
|
if !matchChar('6') {
|
|
goto l330
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`h6`)
|
|
if !matchChar('6') {
|
|
goto l330
|
|
}
|
|
break
|
|
default:
|
|
goto l330
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l330
|
|
}
|
|
if !matchChar('>') {
|
|
goto l330
|
|
}
|
|
return true
|
|
l330:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 72 HtmlBlockH6 <- (HtmlBlockOpenH6 (HtmlBlockH6 / (!HtmlBlockCloseH6 .))* HtmlBlockCloseH6) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenH6]() {
|
|
goto l332
|
|
}
|
|
l333:
|
|
{
|
|
position334 := position
|
|
if !p.rules[ruleHtmlBlockH6]() {
|
|
goto l336
|
|
}
|
|
goto l335
|
|
l336:
|
|
if !p.rules[ruleHtmlBlockCloseH6]() {
|
|
goto l337
|
|
}
|
|
goto l334
|
|
l337:
|
|
if !matchDot() {
|
|
goto l334
|
|
}
|
|
l335:
|
|
goto l333
|
|
l334:
|
|
position = position334
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseH6]() {
|
|
goto l332
|
|
}
|
|
return true
|
|
l332:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 73 HtmlBlockOpenMenu <- ('<' Spnl ((&[M] 'MENU') | (&[m] 'menu')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l338
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l338
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l338
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'M':
|
|
position++
|
|
if !matchString("ENU") {
|
|
goto l338
|
|
}
|
|
break
|
|
case 'm':
|
|
position++
|
|
if !matchString("enu") {
|
|
goto l338
|
|
}
|
|
break
|
|
default:
|
|
goto l338
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l338
|
|
}
|
|
l340:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l341
|
|
}
|
|
goto l340
|
|
l341:
|
|
if !matchChar('>') {
|
|
goto l338
|
|
}
|
|
return true
|
|
l338:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 74 HtmlBlockCloseMenu <- ('<' Spnl '/' ((&[M] 'MENU') | (&[m] 'menu')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l342
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l342
|
|
}
|
|
if !matchChar('/') {
|
|
goto l342
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l342
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'M':
|
|
position++
|
|
if !matchString("ENU") {
|
|
goto l342
|
|
}
|
|
break
|
|
case 'm':
|
|
position++
|
|
if !matchString("enu") {
|
|
goto l342
|
|
}
|
|
break
|
|
default:
|
|
goto l342
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l342
|
|
}
|
|
if !matchChar('>') {
|
|
goto l342
|
|
}
|
|
return true
|
|
l342:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 75 HtmlBlockMenu <- (HtmlBlockOpenMenu (HtmlBlockMenu / (!HtmlBlockCloseMenu .))* HtmlBlockCloseMenu) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenMenu]() {
|
|
goto l344
|
|
}
|
|
l345:
|
|
{
|
|
position346 := position
|
|
if !p.rules[ruleHtmlBlockMenu]() {
|
|
goto l348
|
|
}
|
|
goto l347
|
|
l348:
|
|
if !p.rules[ruleHtmlBlockCloseMenu]() {
|
|
goto l349
|
|
}
|
|
goto l346
|
|
l349:
|
|
if !matchDot() {
|
|
goto l346
|
|
}
|
|
l347:
|
|
goto l345
|
|
l346:
|
|
position = position346
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseMenu]() {
|
|
goto l344
|
|
}
|
|
return true
|
|
l344:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 76 HtmlBlockOpenNoframes <- ('<' Spnl ((&[N] 'NOFRAMES') | (&[n] 'noframes')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l350
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l350
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l350
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'N':
|
|
position++
|
|
if !matchString("OFRAMES") {
|
|
goto l350
|
|
}
|
|
break
|
|
case 'n':
|
|
position++
|
|
if !matchString("oframes") {
|
|
goto l350
|
|
}
|
|
break
|
|
default:
|
|
goto l350
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l350
|
|
}
|
|
l352:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l353
|
|
}
|
|
goto l352
|
|
l353:
|
|
if !matchChar('>') {
|
|
goto l350
|
|
}
|
|
return true
|
|
l350:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 77 HtmlBlockCloseNoframes <- ('<' Spnl '/' ((&[N] 'NOFRAMES') | (&[n] 'noframes')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l354
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l354
|
|
}
|
|
if !matchChar('/') {
|
|
goto l354
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l354
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'N':
|
|
position++
|
|
if !matchString("OFRAMES") {
|
|
goto l354
|
|
}
|
|
break
|
|
case 'n':
|
|
position++
|
|
if !matchString("oframes") {
|
|
goto l354
|
|
}
|
|
break
|
|
default:
|
|
goto l354
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l354
|
|
}
|
|
if !matchChar('>') {
|
|
goto l354
|
|
}
|
|
return true
|
|
l354:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 78 HtmlBlockNoframes <- (HtmlBlockOpenNoframes (HtmlBlockNoframes / (!HtmlBlockCloseNoframes .))* HtmlBlockCloseNoframes) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenNoframes]() {
|
|
goto l356
|
|
}
|
|
l357:
|
|
{
|
|
position358 := position
|
|
if !p.rules[ruleHtmlBlockNoframes]() {
|
|
goto l360
|
|
}
|
|
goto l359
|
|
l360:
|
|
if !p.rules[ruleHtmlBlockCloseNoframes]() {
|
|
goto l361
|
|
}
|
|
goto l358
|
|
l361:
|
|
if !matchDot() {
|
|
goto l358
|
|
}
|
|
l359:
|
|
goto l357
|
|
l358:
|
|
position = position358
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseNoframes]() {
|
|
goto l356
|
|
}
|
|
return true
|
|
l356:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 79 HtmlBlockOpenNoscript <- ('<' Spnl ((&[N] 'NOSCRIPT') | (&[n] 'noscript')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l362
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l362
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l362
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'N':
|
|
position++
|
|
if !matchString("OSCRIPT") {
|
|
goto l362
|
|
}
|
|
break
|
|
case 'n':
|
|
position++
|
|
if !matchString("oscript") {
|
|
goto l362
|
|
}
|
|
break
|
|
default:
|
|
goto l362
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l362
|
|
}
|
|
l364:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l365
|
|
}
|
|
goto l364
|
|
l365:
|
|
if !matchChar('>') {
|
|
goto l362
|
|
}
|
|
return true
|
|
l362:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 80 HtmlBlockCloseNoscript <- ('<' Spnl '/' ((&[N] 'NOSCRIPT') | (&[n] 'noscript')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l366
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l366
|
|
}
|
|
if !matchChar('/') {
|
|
goto l366
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l366
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'N':
|
|
position++
|
|
if !matchString("OSCRIPT") {
|
|
goto l366
|
|
}
|
|
break
|
|
case 'n':
|
|
position++
|
|
if !matchString("oscript") {
|
|
goto l366
|
|
}
|
|
break
|
|
default:
|
|
goto l366
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l366
|
|
}
|
|
if !matchChar('>') {
|
|
goto l366
|
|
}
|
|
return true
|
|
l366:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 81 HtmlBlockNoscript <- (HtmlBlockOpenNoscript (HtmlBlockNoscript / (!HtmlBlockCloseNoscript .))* HtmlBlockCloseNoscript) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenNoscript]() {
|
|
goto l368
|
|
}
|
|
l369:
|
|
{
|
|
position370 := position
|
|
if !p.rules[ruleHtmlBlockNoscript]() {
|
|
goto l372
|
|
}
|
|
goto l371
|
|
l372:
|
|
if !p.rules[ruleHtmlBlockCloseNoscript]() {
|
|
goto l373
|
|
}
|
|
goto l370
|
|
l373:
|
|
if !matchDot() {
|
|
goto l370
|
|
}
|
|
l371:
|
|
goto l369
|
|
l370:
|
|
position = position370
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseNoscript]() {
|
|
goto l368
|
|
}
|
|
return true
|
|
l368:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 82 HtmlBlockOpenOl <- ('<' Spnl ((&[O] 'OL') | (&[o] 'ol')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l374
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l374
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l374
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'O':
|
|
position++ // matchString(`OL`)
|
|
if !matchChar('L') {
|
|
goto l374
|
|
}
|
|
break
|
|
case 'o':
|
|
position++ // matchString(`ol`)
|
|
if !matchChar('l') {
|
|
goto l374
|
|
}
|
|
break
|
|
default:
|
|
goto l374
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l374
|
|
}
|
|
l376:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l377
|
|
}
|
|
goto l376
|
|
l377:
|
|
if !matchChar('>') {
|
|
goto l374
|
|
}
|
|
return true
|
|
l374:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 83 HtmlBlockCloseOl <- ('<' Spnl '/' ((&[O] 'OL') | (&[o] 'ol')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l378
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l378
|
|
}
|
|
if !matchChar('/') {
|
|
goto l378
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l378
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'O':
|
|
position++ // matchString(`OL`)
|
|
if !matchChar('L') {
|
|
goto l378
|
|
}
|
|
break
|
|
case 'o':
|
|
position++ // matchString(`ol`)
|
|
if !matchChar('l') {
|
|
goto l378
|
|
}
|
|
break
|
|
default:
|
|
goto l378
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l378
|
|
}
|
|
if !matchChar('>') {
|
|
goto l378
|
|
}
|
|
return true
|
|
l378:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 84 HtmlBlockOl <- (HtmlBlockOpenOl (HtmlBlockOl / (!HtmlBlockCloseOl .))* HtmlBlockCloseOl) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenOl]() {
|
|
goto l380
|
|
}
|
|
l381:
|
|
{
|
|
position382 := position
|
|
if !p.rules[ruleHtmlBlockOl]() {
|
|
goto l384
|
|
}
|
|
goto l383
|
|
l384:
|
|
if !p.rules[ruleHtmlBlockCloseOl]() {
|
|
goto l385
|
|
}
|
|
goto l382
|
|
l385:
|
|
if !matchDot() {
|
|
goto l382
|
|
}
|
|
l383:
|
|
goto l381
|
|
l382:
|
|
position = position382
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseOl]() {
|
|
goto l380
|
|
}
|
|
return true
|
|
l380:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 85 HtmlBlockOpenP <- ('<' Spnl ((&[P] 'P') | (&[p] 'p')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l386
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l386
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l386
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'P':
|
|
position++ // matchChar
|
|
break
|
|
case 'p':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l386
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l386
|
|
}
|
|
l388:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l389
|
|
}
|
|
goto l388
|
|
l389:
|
|
if !matchChar('>') {
|
|
goto l386
|
|
}
|
|
return true
|
|
l386:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 86 HtmlBlockCloseP <- ('<' Spnl '/' ((&[P] 'P') | (&[p] 'p')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l390
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l390
|
|
}
|
|
if !matchChar('/') {
|
|
goto l390
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l390
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'P':
|
|
position++ // matchChar
|
|
break
|
|
case 'p':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l390
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l390
|
|
}
|
|
if !matchChar('>') {
|
|
goto l390
|
|
}
|
|
return true
|
|
l390:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 87 HtmlBlockP <- (HtmlBlockOpenP (HtmlBlockP / (!HtmlBlockCloseP .))* HtmlBlockCloseP) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenP]() {
|
|
goto l392
|
|
}
|
|
l393:
|
|
{
|
|
position394 := position
|
|
if !p.rules[ruleHtmlBlockP]() {
|
|
goto l396
|
|
}
|
|
goto l395
|
|
l396:
|
|
if !p.rules[ruleHtmlBlockCloseP]() {
|
|
goto l397
|
|
}
|
|
goto l394
|
|
l397:
|
|
if !matchDot() {
|
|
goto l394
|
|
}
|
|
l395:
|
|
goto l393
|
|
l394:
|
|
position = position394
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseP]() {
|
|
goto l392
|
|
}
|
|
return true
|
|
l392:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 88 HtmlBlockOpenPre <- ('<' Spnl ((&[P] 'PRE') | (&[p] 'pre')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l398
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l398
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l398
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'P':
|
|
position++
|
|
if !matchString("RE") {
|
|
goto l398
|
|
}
|
|
break
|
|
case 'p':
|
|
position++
|
|
if !matchString("re") {
|
|
goto l398
|
|
}
|
|
break
|
|
default:
|
|
goto l398
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l398
|
|
}
|
|
l400:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l401
|
|
}
|
|
goto l400
|
|
l401:
|
|
if !matchChar('>') {
|
|
goto l398
|
|
}
|
|
return true
|
|
l398:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 89 HtmlBlockClosePre <- ('<' Spnl '/' ((&[P] 'PRE') | (&[p] 'pre')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l402
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l402
|
|
}
|
|
if !matchChar('/') {
|
|
goto l402
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l402
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'P':
|
|
position++
|
|
if !matchString("RE") {
|
|
goto l402
|
|
}
|
|
break
|
|
case 'p':
|
|
position++
|
|
if !matchString("re") {
|
|
goto l402
|
|
}
|
|
break
|
|
default:
|
|
goto l402
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l402
|
|
}
|
|
if !matchChar('>') {
|
|
goto l402
|
|
}
|
|
return true
|
|
l402:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 90 HtmlBlockPre <- (HtmlBlockOpenPre (HtmlBlockPre / (!HtmlBlockClosePre .))* HtmlBlockClosePre) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenPre]() {
|
|
goto l404
|
|
}
|
|
l405:
|
|
{
|
|
position406 := position
|
|
if !p.rules[ruleHtmlBlockPre]() {
|
|
goto l408
|
|
}
|
|
goto l407
|
|
l408:
|
|
if !p.rules[ruleHtmlBlockClosePre]() {
|
|
goto l409
|
|
}
|
|
goto l406
|
|
l409:
|
|
if !matchDot() {
|
|
goto l406
|
|
}
|
|
l407:
|
|
goto l405
|
|
l406:
|
|
position = position406
|
|
}
|
|
if !p.rules[ruleHtmlBlockClosePre]() {
|
|
goto l404
|
|
}
|
|
return true
|
|
l404:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 91 HtmlBlockOpenTable <- ('<' Spnl ((&[T] 'TABLE') | (&[t] 'table')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l410
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l410
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l410
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("ABLE") {
|
|
goto l410
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("able") {
|
|
goto l410
|
|
}
|
|
break
|
|
default:
|
|
goto l410
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l410
|
|
}
|
|
l412:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l413
|
|
}
|
|
goto l412
|
|
l413:
|
|
if !matchChar('>') {
|
|
goto l410
|
|
}
|
|
return true
|
|
l410:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 92 HtmlBlockCloseTable <- ('<' Spnl '/' ((&[T] 'TABLE') | (&[t] 'table')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l414
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l414
|
|
}
|
|
if !matchChar('/') {
|
|
goto l414
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l414
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("ABLE") {
|
|
goto l414
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("able") {
|
|
goto l414
|
|
}
|
|
break
|
|
default:
|
|
goto l414
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l414
|
|
}
|
|
if !matchChar('>') {
|
|
goto l414
|
|
}
|
|
return true
|
|
l414:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 93 HtmlBlockTable <- (HtmlBlockOpenTable (HtmlBlockTable / (!HtmlBlockCloseTable .))* HtmlBlockCloseTable) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenTable]() {
|
|
goto l416
|
|
}
|
|
l417:
|
|
{
|
|
position418 := position
|
|
if !p.rules[ruleHtmlBlockTable]() {
|
|
goto l420
|
|
}
|
|
goto l419
|
|
l420:
|
|
if !p.rules[ruleHtmlBlockCloseTable]() {
|
|
goto l421
|
|
}
|
|
goto l418
|
|
l421:
|
|
if !matchDot() {
|
|
goto l418
|
|
}
|
|
l419:
|
|
goto l417
|
|
l418:
|
|
position = position418
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseTable]() {
|
|
goto l416
|
|
}
|
|
return true
|
|
l416:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 94 HtmlBlockOpenUl <- ('<' Spnl ((&[U] 'UL') | (&[u] 'ul')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l422
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l422
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l422
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'U':
|
|
position++ // matchString(`UL`)
|
|
if !matchChar('L') {
|
|
goto l422
|
|
}
|
|
break
|
|
case 'u':
|
|
position++ // matchString(`ul`)
|
|
if !matchChar('l') {
|
|
goto l422
|
|
}
|
|
break
|
|
default:
|
|
goto l422
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l422
|
|
}
|
|
l424:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l425
|
|
}
|
|
goto l424
|
|
l425:
|
|
if !matchChar('>') {
|
|
goto l422
|
|
}
|
|
return true
|
|
l422:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 95 HtmlBlockCloseUl <- ('<' Spnl '/' ((&[U] 'UL') | (&[u] 'ul')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l426
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l426
|
|
}
|
|
if !matchChar('/') {
|
|
goto l426
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l426
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'U':
|
|
position++ // matchString(`UL`)
|
|
if !matchChar('L') {
|
|
goto l426
|
|
}
|
|
break
|
|
case 'u':
|
|
position++ // matchString(`ul`)
|
|
if !matchChar('l') {
|
|
goto l426
|
|
}
|
|
break
|
|
default:
|
|
goto l426
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l426
|
|
}
|
|
if !matchChar('>') {
|
|
goto l426
|
|
}
|
|
return true
|
|
l426:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 96 HtmlBlockUl <- (HtmlBlockOpenUl (HtmlBlockUl / (!HtmlBlockCloseUl .))* HtmlBlockCloseUl) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenUl]() {
|
|
goto l428
|
|
}
|
|
l429:
|
|
{
|
|
position430 := position
|
|
if !p.rules[ruleHtmlBlockUl]() {
|
|
goto l432
|
|
}
|
|
goto l431
|
|
l432:
|
|
if !p.rules[ruleHtmlBlockCloseUl]() {
|
|
goto l433
|
|
}
|
|
goto l430
|
|
l433:
|
|
if !matchDot() {
|
|
goto l430
|
|
}
|
|
l431:
|
|
goto l429
|
|
l430:
|
|
position = position430
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseUl]() {
|
|
goto l428
|
|
}
|
|
return true
|
|
l428:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 97 HtmlBlockOpenDd <- ('<' Spnl ((&[D] 'DD') | (&[d] 'dd')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l434
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l434
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l434
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++ // matchString(`DD`)
|
|
if !matchChar('D') {
|
|
goto l434
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dd`)
|
|
if !matchChar('d') {
|
|
goto l434
|
|
}
|
|
break
|
|
default:
|
|
goto l434
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l434
|
|
}
|
|
l436:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l437
|
|
}
|
|
goto l436
|
|
l437:
|
|
if !matchChar('>') {
|
|
goto l434
|
|
}
|
|
return true
|
|
l434:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 98 HtmlBlockCloseDd <- ('<' Spnl '/' ((&[D] 'DD') | (&[d] 'dd')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l438
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l438
|
|
}
|
|
if !matchChar('/') {
|
|
goto l438
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l438
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++ // matchString(`DD`)
|
|
if !matchChar('D') {
|
|
goto l438
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dd`)
|
|
if !matchChar('d') {
|
|
goto l438
|
|
}
|
|
break
|
|
default:
|
|
goto l438
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l438
|
|
}
|
|
if !matchChar('>') {
|
|
goto l438
|
|
}
|
|
return true
|
|
l438:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 99 HtmlBlockDd <- (HtmlBlockOpenDd (HtmlBlockDd / (!HtmlBlockCloseDd .))* HtmlBlockCloseDd) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenDd]() {
|
|
goto l440
|
|
}
|
|
l441:
|
|
{
|
|
position442 := position
|
|
if !p.rules[ruleHtmlBlockDd]() {
|
|
goto l444
|
|
}
|
|
goto l443
|
|
l444:
|
|
if !p.rules[ruleHtmlBlockCloseDd]() {
|
|
goto l445
|
|
}
|
|
goto l442
|
|
l445:
|
|
if !matchDot() {
|
|
goto l442
|
|
}
|
|
l443:
|
|
goto l441
|
|
l442:
|
|
position = position442
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseDd]() {
|
|
goto l440
|
|
}
|
|
return true
|
|
l440:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 100 HtmlBlockOpenDt <- ('<' Spnl ((&[D] 'DT') | (&[d] 'dt')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l446
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l446
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l446
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++ // matchString(`DT`)
|
|
if !matchChar('T') {
|
|
goto l446
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dt`)
|
|
if !matchChar('t') {
|
|
goto l446
|
|
}
|
|
break
|
|
default:
|
|
goto l446
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l446
|
|
}
|
|
l448:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l449
|
|
}
|
|
goto l448
|
|
l449:
|
|
if !matchChar('>') {
|
|
goto l446
|
|
}
|
|
return true
|
|
l446:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 101 HtmlBlockCloseDt <- ('<' Spnl '/' ((&[D] 'DT') | (&[d] 'dt')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l450
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l450
|
|
}
|
|
if !matchChar('/') {
|
|
goto l450
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l450
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'D':
|
|
position++ // matchString(`DT`)
|
|
if !matchChar('T') {
|
|
goto l450
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dt`)
|
|
if !matchChar('t') {
|
|
goto l450
|
|
}
|
|
break
|
|
default:
|
|
goto l450
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l450
|
|
}
|
|
if !matchChar('>') {
|
|
goto l450
|
|
}
|
|
return true
|
|
l450:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 102 HtmlBlockDt <- (HtmlBlockOpenDt (HtmlBlockDt / (!HtmlBlockCloseDt .))* HtmlBlockCloseDt) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenDt]() {
|
|
goto l452
|
|
}
|
|
l453:
|
|
{
|
|
position454 := position
|
|
if !p.rules[ruleHtmlBlockDt]() {
|
|
goto l456
|
|
}
|
|
goto l455
|
|
l456:
|
|
if !p.rules[ruleHtmlBlockCloseDt]() {
|
|
goto l457
|
|
}
|
|
goto l454
|
|
l457:
|
|
if !matchDot() {
|
|
goto l454
|
|
}
|
|
l455:
|
|
goto l453
|
|
l454:
|
|
position = position454
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseDt]() {
|
|
goto l452
|
|
}
|
|
return true
|
|
l452:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 103 HtmlBlockOpenFrameset <- ('<' Spnl ((&[F] 'FRAMESET') | (&[f] 'frameset')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l458
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l458
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l458
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'F':
|
|
position++
|
|
if !matchString("RAMESET") {
|
|
goto l458
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("rameset") {
|
|
goto l458
|
|
}
|
|
break
|
|
default:
|
|
goto l458
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l458
|
|
}
|
|
l460:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l461
|
|
}
|
|
goto l460
|
|
l461:
|
|
if !matchChar('>') {
|
|
goto l458
|
|
}
|
|
return true
|
|
l458:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 104 HtmlBlockCloseFrameset <- ('<' Spnl '/' ((&[F] 'FRAMESET') | (&[f] 'frameset')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l462
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l462
|
|
}
|
|
if !matchChar('/') {
|
|
goto l462
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l462
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'F':
|
|
position++
|
|
if !matchString("RAMESET") {
|
|
goto l462
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("rameset") {
|
|
goto l462
|
|
}
|
|
break
|
|
default:
|
|
goto l462
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l462
|
|
}
|
|
if !matchChar('>') {
|
|
goto l462
|
|
}
|
|
return true
|
|
l462:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 105 HtmlBlockFrameset <- (HtmlBlockOpenFrameset (HtmlBlockFrameset / (!HtmlBlockCloseFrameset .))* HtmlBlockCloseFrameset) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenFrameset]() {
|
|
goto l464
|
|
}
|
|
l465:
|
|
{
|
|
position466 := position
|
|
if !p.rules[ruleHtmlBlockFrameset]() {
|
|
goto l468
|
|
}
|
|
goto l467
|
|
l468:
|
|
if !p.rules[ruleHtmlBlockCloseFrameset]() {
|
|
goto l469
|
|
}
|
|
goto l466
|
|
l469:
|
|
if !matchDot() {
|
|
goto l466
|
|
}
|
|
l467:
|
|
goto l465
|
|
l466:
|
|
position = position466
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseFrameset]() {
|
|
goto l464
|
|
}
|
|
return true
|
|
l464:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 106 HtmlBlockOpenLi <- ('<' Spnl ((&[L] 'LI') | (&[l] 'li')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l470
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l470
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l470
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'L':
|
|
position++ // matchString(`LI`)
|
|
if !matchChar('I') {
|
|
goto l470
|
|
}
|
|
break
|
|
case 'l':
|
|
position++ // matchString(`li`)
|
|
if !matchChar('i') {
|
|
goto l470
|
|
}
|
|
break
|
|
default:
|
|
goto l470
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l470
|
|
}
|
|
l472:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l473
|
|
}
|
|
goto l472
|
|
l473:
|
|
if !matchChar('>') {
|
|
goto l470
|
|
}
|
|
return true
|
|
l470:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 107 HtmlBlockCloseLi <- ('<' Spnl '/' ((&[L] 'LI') | (&[l] 'li')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l474
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l474
|
|
}
|
|
if !matchChar('/') {
|
|
goto l474
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l474
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'L':
|
|
position++ // matchString(`LI`)
|
|
if !matchChar('I') {
|
|
goto l474
|
|
}
|
|
break
|
|
case 'l':
|
|
position++ // matchString(`li`)
|
|
if !matchChar('i') {
|
|
goto l474
|
|
}
|
|
break
|
|
default:
|
|
goto l474
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l474
|
|
}
|
|
if !matchChar('>') {
|
|
goto l474
|
|
}
|
|
return true
|
|
l474:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 108 HtmlBlockLi <- (HtmlBlockOpenLi (HtmlBlockLi / (!HtmlBlockCloseLi .))* HtmlBlockCloseLi) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenLi]() {
|
|
goto l476
|
|
}
|
|
l477:
|
|
{
|
|
position478 := position
|
|
if !p.rules[ruleHtmlBlockLi]() {
|
|
goto l480
|
|
}
|
|
goto l479
|
|
l480:
|
|
if !p.rules[ruleHtmlBlockCloseLi]() {
|
|
goto l481
|
|
}
|
|
goto l478
|
|
l481:
|
|
if !matchDot() {
|
|
goto l478
|
|
}
|
|
l479:
|
|
goto l477
|
|
l478:
|
|
position = position478
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseLi]() {
|
|
goto l476
|
|
}
|
|
return true
|
|
l476:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 109 HtmlBlockOpenTbody <- ('<' Spnl ((&[T] 'TBODY') | (&[t] 'tbody')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l482
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l482
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l482
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("BODY") {
|
|
goto l482
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("body") {
|
|
goto l482
|
|
}
|
|
break
|
|
default:
|
|
goto l482
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l482
|
|
}
|
|
l484:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l485
|
|
}
|
|
goto l484
|
|
l485:
|
|
if !matchChar('>') {
|
|
goto l482
|
|
}
|
|
return true
|
|
l482:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 110 HtmlBlockCloseTbody <- ('<' Spnl '/' ((&[T] 'TBODY') | (&[t] 'tbody')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l486
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l486
|
|
}
|
|
if !matchChar('/') {
|
|
goto l486
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l486
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("BODY") {
|
|
goto l486
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("body") {
|
|
goto l486
|
|
}
|
|
break
|
|
default:
|
|
goto l486
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l486
|
|
}
|
|
if !matchChar('>') {
|
|
goto l486
|
|
}
|
|
return true
|
|
l486:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 111 HtmlBlockTbody <- (HtmlBlockOpenTbody (HtmlBlockTbody / (!HtmlBlockCloseTbody .))* HtmlBlockCloseTbody) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenTbody]() {
|
|
goto l488
|
|
}
|
|
l489:
|
|
{
|
|
position490 := position
|
|
if !p.rules[ruleHtmlBlockTbody]() {
|
|
goto l492
|
|
}
|
|
goto l491
|
|
l492:
|
|
if !p.rules[ruleHtmlBlockCloseTbody]() {
|
|
goto l493
|
|
}
|
|
goto l490
|
|
l493:
|
|
if !matchDot() {
|
|
goto l490
|
|
}
|
|
l491:
|
|
goto l489
|
|
l490:
|
|
position = position490
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseTbody]() {
|
|
goto l488
|
|
}
|
|
return true
|
|
l488:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 112 HtmlBlockOpenTd <- ('<' Spnl ((&[T] 'TD') | (&[t] 'td')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l494
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l494
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l494
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++ // matchString(`TD`)
|
|
if !matchChar('D') {
|
|
goto l494
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`td`)
|
|
if !matchChar('d') {
|
|
goto l494
|
|
}
|
|
break
|
|
default:
|
|
goto l494
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l494
|
|
}
|
|
l496:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l497
|
|
}
|
|
goto l496
|
|
l497:
|
|
if !matchChar('>') {
|
|
goto l494
|
|
}
|
|
return true
|
|
l494:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 113 HtmlBlockCloseTd <- ('<' Spnl '/' ((&[T] 'TD') | (&[t] 'td')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l498
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l498
|
|
}
|
|
if !matchChar('/') {
|
|
goto l498
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l498
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++ // matchString(`TD`)
|
|
if !matchChar('D') {
|
|
goto l498
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`td`)
|
|
if !matchChar('d') {
|
|
goto l498
|
|
}
|
|
break
|
|
default:
|
|
goto l498
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l498
|
|
}
|
|
if !matchChar('>') {
|
|
goto l498
|
|
}
|
|
return true
|
|
l498:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 114 HtmlBlockTd <- (HtmlBlockOpenTd (HtmlBlockTd / (!HtmlBlockCloseTd .))* HtmlBlockCloseTd) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenTd]() {
|
|
goto l500
|
|
}
|
|
l501:
|
|
{
|
|
position502 := position
|
|
if !p.rules[ruleHtmlBlockTd]() {
|
|
goto l504
|
|
}
|
|
goto l503
|
|
l504:
|
|
if !p.rules[ruleHtmlBlockCloseTd]() {
|
|
goto l505
|
|
}
|
|
goto l502
|
|
l505:
|
|
if !matchDot() {
|
|
goto l502
|
|
}
|
|
l503:
|
|
goto l501
|
|
l502:
|
|
position = position502
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseTd]() {
|
|
goto l500
|
|
}
|
|
return true
|
|
l500:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 115 HtmlBlockOpenTfoot <- ('<' Spnl ((&[T] 'TFOOT') | (&[t] 'tfoot')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l506
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l506
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l506
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("FOOT") {
|
|
goto l506
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("foot") {
|
|
goto l506
|
|
}
|
|
break
|
|
default:
|
|
goto l506
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l506
|
|
}
|
|
l508:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l509
|
|
}
|
|
goto l508
|
|
l509:
|
|
if !matchChar('>') {
|
|
goto l506
|
|
}
|
|
return true
|
|
l506:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 116 HtmlBlockCloseTfoot <- ('<' Spnl '/' ((&[T] 'TFOOT') | (&[t] 'tfoot')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l510
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l510
|
|
}
|
|
if !matchChar('/') {
|
|
goto l510
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l510
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("FOOT") {
|
|
goto l510
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("foot") {
|
|
goto l510
|
|
}
|
|
break
|
|
default:
|
|
goto l510
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l510
|
|
}
|
|
if !matchChar('>') {
|
|
goto l510
|
|
}
|
|
return true
|
|
l510:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 117 HtmlBlockTfoot <- (HtmlBlockOpenTfoot (HtmlBlockTfoot / (!HtmlBlockCloseTfoot .))* HtmlBlockCloseTfoot) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenTfoot]() {
|
|
goto l512
|
|
}
|
|
l513:
|
|
{
|
|
position514 := position
|
|
if !p.rules[ruleHtmlBlockTfoot]() {
|
|
goto l516
|
|
}
|
|
goto l515
|
|
l516:
|
|
if !p.rules[ruleHtmlBlockCloseTfoot]() {
|
|
goto l517
|
|
}
|
|
goto l514
|
|
l517:
|
|
if !matchDot() {
|
|
goto l514
|
|
}
|
|
l515:
|
|
goto l513
|
|
l514:
|
|
position = position514
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseTfoot]() {
|
|
goto l512
|
|
}
|
|
return true
|
|
l512:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 118 HtmlBlockOpenTh <- ('<' Spnl ((&[T] 'TH') | (&[t] 'th')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l518
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l518
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l518
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++ // matchString(`TH`)
|
|
if !matchChar('H') {
|
|
goto l518
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`th`)
|
|
if !matchChar('h') {
|
|
goto l518
|
|
}
|
|
break
|
|
default:
|
|
goto l518
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l518
|
|
}
|
|
l520:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l521
|
|
}
|
|
goto l520
|
|
l521:
|
|
if !matchChar('>') {
|
|
goto l518
|
|
}
|
|
return true
|
|
l518:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 119 HtmlBlockCloseTh <- ('<' Spnl '/' ((&[T] 'TH') | (&[t] 'th')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l522
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l522
|
|
}
|
|
if !matchChar('/') {
|
|
goto l522
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l522
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++ // matchString(`TH`)
|
|
if !matchChar('H') {
|
|
goto l522
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`th`)
|
|
if !matchChar('h') {
|
|
goto l522
|
|
}
|
|
break
|
|
default:
|
|
goto l522
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l522
|
|
}
|
|
if !matchChar('>') {
|
|
goto l522
|
|
}
|
|
return true
|
|
l522:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 120 HtmlBlockTh <- (HtmlBlockOpenTh (HtmlBlockTh / (!HtmlBlockCloseTh .))* HtmlBlockCloseTh) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenTh]() {
|
|
goto l524
|
|
}
|
|
l525:
|
|
{
|
|
position526 := position
|
|
if !p.rules[ruleHtmlBlockTh]() {
|
|
goto l528
|
|
}
|
|
goto l527
|
|
l528:
|
|
if !p.rules[ruleHtmlBlockCloseTh]() {
|
|
goto l529
|
|
}
|
|
goto l526
|
|
l529:
|
|
if !matchDot() {
|
|
goto l526
|
|
}
|
|
l527:
|
|
goto l525
|
|
l526:
|
|
position = position526
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseTh]() {
|
|
goto l524
|
|
}
|
|
return true
|
|
l524:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 121 HtmlBlockOpenThead <- ('<' Spnl ((&[T] 'THEAD') | (&[t] 'thead')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l530
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l530
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l530
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("HEAD") {
|
|
goto l530
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("head") {
|
|
goto l530
|
|
}
|
|
break
|
|
default:
|
|
goto l530
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l530
|
|
}
|
|
l532:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l533
|
|
}
|
|
goto l532
|
|
l533:
|
|
if !matchChar('>') {
|
|
goto l530
|
|
}
|
|
return true
|
|
l530:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 122 HtmlBlockCloseThead <- ('<' Spnl '/' ((&[T] 'THEAD') | (&[t] 'thead')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l534
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l534
|
|
}
|
|
if !matchChar('/') {
|
|
goto l534
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l534
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++
|
|
if !matchString("HEAD") {
|
|
goto l534
|
|
}
|
|
break
|
|
case 't':
|
|
position++
|
|
if !matchString("head") {
|
|
goto l534
|
|
}
|
|
break
|
|
default:
|
|
goto l534
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l534
|
|
}
|
|
if !matchChar('>') {
|
|
goto l534
|
|
}
|
|
return true
|
|
l534:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 123 HtmlBlockThead <- (HtmlBlockOpenThead (HtmlBlockThead / (!HtmlBlockCloseThead .))* HtmlBlockCloseThead) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenThead]() {
|
|
goto l536
|
|
}
|
|
l537:
|
|
{
|
|
position538 := position
|
|
if !p.rules[ruleHtmlBlockThead]() {
|
|
goto l540
|
|
}
|
|
goto l539
|
|
l540:
|
|
if !p.rules[ruleHtmlBlockCloseThead]() {
|
|
goto l541
|
|
}
|
|
goto l538
|
|
l541:
|
|
if !matchDot() {
|
|
goto l538
|
|
}
|
|
l539:
|
|
goto l537
|
|
l538:
|
|
position = position538
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseThead]() {
|
|
goto l536
|
|
}
|
|
return true
|
|
l536:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 124 HtmlBlockOpenTr <- ('<' Spnl ((&[T] 'TR') | (&[t] 'tr')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l542
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l542
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l542
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++ // matchString(`TR`)
|
|
if !matchChar('R') {
|
|
goto l542
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`tr`)
|
|
if !matchChar('r') {
|
|
goto l542
|
|
}
|
|
break
|
|
default:
|
|
goto l542
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l542
|
|
}
|
|
l544:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l545
|
|
}
|
|
goto l544
|
|
l545:
|
|
if !matchChar('>') {
|
|
goto l542
|
|
}
|
|
return true
|
|
l542:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 125 HtmlBlockCloseTr <- ('<' Spnl '/' ((&[T] 'TR') | (&[t] 'tr')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l546
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l546
|
|
}
|
|
if !matchChar('/') {
|
|
goto l546
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l546
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'T':
|
|
position++ // matchString(`TR`)
|
|
if !matchChar('R') {
|
|
goto l546
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`tr`)
|
|
if !matchChar('r') {
|
|
goto l546
|
|
}
|
|
break
|
|
default:
|
|
goto l546
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l546
|
|
}
|
|
if !matchChar('>') {
|
|
goto l546
|
|
}
|
|
return true
|
|
l546:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 126 HtmlBlockTr <- (HtmlBlockOpenTr (HtmlBlockTr / (!HtmlBlockCloseTr .))* HtmlBlockCloseTr) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenTr]() {
|
|
goto l548
|
|
}
|
|
l549:
|
|
{
|
|
position550 := position
|
|
if !p.rules[ruleHtmlBlockTr]() {
|
|
goto l552
|
|
}
|
|
goto l551
|
|
l552:
|
|
if !p.rules[ruleHtmlBlockCloseTr]() {
|
|
goto l553
|
|
}
|
|
goto l550
|
|
l553:
|
|
if !matchDot() {
|
|
goto l550
|
|
}
|
|
l551:
|
|
goto l549
|
|
l550:
|
|
position = position550
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseTr]() {
|
|
goto l548
|
|
}
|
|
return true
|
|
l548:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 127 HtmlBlockOpenScript <- ('<' Spnl ((&[S] 'SCRIPT') | (&[s] 'script')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l554
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l554
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l554
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'S':
|
|
position++
|
|
if !matchString("CRIPT") {
|
|
goto l554
|
|
}
|
|
break
|
|
case 's':
|
|
position++
|
|
if !matchString("cript") {
|
|
goto l554
|
|
}
|
|
break
|
|
default:
|
|
goto l554
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l554
|
|
}
|
|
l556:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l557
|
|
}
|
|
goto l556
|
|
l557:
|
|
if !matchChar('>') {
|
|
goto l554
|
|
}
|
|
return true
|
|
l554:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 128 HtmlBlockCloseScript <- ('<' Spnl '/' ((&[S] 'SCRIPT') | (&[s] 'script')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l558
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l558
|
|
}
|
|
if !matchChar('/') {
|
|
goto l558
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l558
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'S':
|
|
position++
|
|
if !matchString("CRIPT") {
|
|
goto l558
|
|
}
|
|
break
|
|
case 's':
|
|
position++
|
|
if !matchString("cript") {
|
|
goto l558
|
|
}
|
|
break
|
|
default:
|
|
goto l558
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l558
|
|
}
|
|
if !matchChar('>') {
|
|
goto l558
|
|
}
|
|
return true
|
|
l558:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 129 HtmlBlockScript <- (HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHtmlBlockOpenScript]() {
|
|
goto l560
|
|
}
|
|
l561:
|
|
{
|
|
position562 := position
|
|
if !p.rules[ruleHtmlBlockCloseScript]() {
|
|
goto l563
|
|
}
|
|
goto l562
|
|
l563:
|
|
if !matchDot() {
|
|
goto l562
|
|
}
|
|
goto l561
|
|
l562:
|
|
position = position562
|
|
}
|
|
if !p.rules[ruleHtmlBlockCloseScript]() {
|
|
goto l560
|
|
}
|
|
return true
|
|
l560:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 130 HtmlBlockInTags <- (HtmlBlockAddress / HtmlBlockBlockquote / HtmlBlockCenter / HtmlBlockDir / HtmlBlockDiv / HtmlBlockDl / HtmlBlockFieldset / HtmlBlockForm / HtmlBlockH1 / HtmlBlockH2 / HtmlBlockH3 / HtmlBlockH4 / HtmlBlockH5 / HtmlBlockH6 / HtmlBlockMenu / HtmlBlockNoframes / HtmlBlockNoscript / HtmlBlockOl / HtmlBlockP / HtmlBlockPre / HtmlBlockTable / HtmlBlockUl / HtmlBlockDd / HtmlBlockDt / HtmlBlockFrameset / HtmlBlockLi / HtmlBlockTbody / HtmlBlockTd / HtmlBlockTfoot / HtmlBlockTh / HtmlBlockThead / HtmlBlockTr / HtmlBlockScript) */
|
|
func() bool {
|
|
if !p.rules[ruleHtmlBlockAddress]() {
|
|
goto l566
|
|
}
|
|
goto l565
|
|
l566:
|
|
if !p.rules[ruleHtmlBlockBlockquote]() {
|
|
goto l567
|
|
}
|
|
goto l565
|
|
l567:
|
|
if !p.rules[ruleHtmlBlockCenter]() {
|
|
goto l568
|
|
}
|
|
goto l565
|
|
l568:
|
|
if !p.rules[ruleHtmlBlockDir]() {
|
|
goto l569
|
|
}
|
|
goto l565
|
|
l569:
|
|
if !p.rules[ruleHtmlBlockDiv]() {
|
|
goto l570
|
|
}
|
|
goto l565
|
|
l570:
|
|
if !p.rules[ruleHtmlBlockDl]() {
|
|
goto l571
|
|
}
|
|
goto l565
|
|
l571:
|
|
if !p.rules[ruleHtmlBlockFieldset]() {
|
|
goto l572
|
|
}
|
|
goto l565
|
|
l572:
|
|
if !p.rules[ruleHtmlBlockForm]() {
|
|
goto l573
|
|
}
|
|
goto l565
|
|
l573:
|
|
if !p.rules[ruleHtmlBlockH1]() {
|
|
goto l574
|
|
}
|
|
goto l565
|
|
l574:
|
|
if !p.rules[ruleHtmlBlockH2]() {
|
|
goto l575
|
|
}
|
|
goto l565
|
|
l575:
|
|
if !p.rules[ruleHtmlBlockH3]() {
|
|
goto l576
|
|
}
|
|
goto l565
|
|
l576:
|
|
if !p.rules[ruleHtmlBlockH4]() {
|
|
goto l577
|
|
}
|
|
goto l565
|
|
l577:
|
|
if !p.rules[ruleHtmlBlockH5]() {
|
|
goto l578
|
|
}
|
|
goto l565
|
|
l578:
|
|
if !p.rules[ruleHtmlBlockH6]() {
|
|
goto l579
|
|
}
|
|
goto l565
|
|
l579:
|
|
if !p.rules[ruleHtmlBlockMenu]() {
|
|
goto l580
|
|
}
|
|
goto l565
|
|
l580:
|
|
if !p.rules[ruleHtmlBlockNoframes]() {
|
|
goto l581
|
|
}
|
|
goto l565
|
|
l581:
|
|
if !p.rules[ruleHtmlBlockNoscript]() {
|
|
goto l582
|
|
}
|
|
goto l565
|
|
l582:
|
|
if !p.rules[ruleHtmlBlockOl]() {
|
|
goto l583
|
|
}
|
|
goto l565
|
|
l583:
|
|
if !p.rules[ruleHtmlBlockP]() {
|
|
goto l584
|
|
}
|
|
goto l565
|
|
l584:
|
|
if !p.rules[ruleHtmlBlockPre]() {
|
|
goto l585
|
|
}
|
|
goto l565
|
|
l585:
|
|
if !p.rules[ruleHtmlBlockTable]() {
|
|
goto l586
|
|
}
|
|
goto l565
|
|
l586:
|
|
if !p.rules[ruleHtmlBlockUl]() {
|
|
goto l587
|
|
}
|
|
goto l565
|
|
l587:
|
|
if !p.rules[ruleHtmlBlockDd]() {
|
|
goto l588
|
|
}
|
|
goto l565
|
|
l588:
|
|
if !p.rules[ruleHtmlBlockDt]() {
|
|
goto l589
|
|
}
|
|
goto l565
|
|
l589:
|
|
if !p.rules[ruleHtmlBlockFrameset]() {
|
|
goto l590
|
|
}
|
|
goto l565
|
|
l590:
|
|
if !p.rules[ruleHtmlBlockLi]() {
|
|
goto l591
|
|
}
|
|
goto l565
|
|
l591:
|
|
if !p.rules[ruleHtmlBlockTbody]() {
|
|
goto l592
|
|
}
|
|
goto l565
|
|
l592:
|
|
if !p.rules[ruleHtmlBlockTd]() {
|
|
goto l593
|
|
}
|
|
goto l565
|
|
l593:
|
|
if !p.rules[ruleHtmlBlockTfoot]() {
|
|
goto l594
|
|
}
|
|
goto l565
|
|
l594:
|
|
if !p.rules[ruleHtmlBlockTh]() {
|
|
goto l595
|
|
}
|
|
goto l565
|
|
l595:
|
|
if !p.rules[ruleHtmlBlockThead]() {
|
|
goto l596
|
|
}
|
|
goto l565
|
|
l596:
|
|
if !p.rules[ruleHtmlBlockTr]() {
|
|
goto l597
|
|
}
|
|
goto l565
|
|
l597:
|
|
if !p.rules[ruleHtmlBlockScript]() {
|
|
goto l564
|
|
}
|
|
l565:
|
|
return true
|
|
l564:
|
|
return false
|
|
},
|
|
/* 131 HtmlBlock <- (&'<' < (HtmlBlockInTags / HtmlComment / HtmlBlockSelfClosing) > BlankLine+ { if p.extension.FilterHTML {
|
|
yy = p.mkList(LIST, nil)
|
|
} else {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTMLBLOCK
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0 := position
|
|
if !peekChar('<') {
|
|
goto l598
|
|
}
|
|
begin = position
|
|
if !p.rules[ruleHtmlBlockInTags]() {
|
|
goto l600
|
|
}
|
|
goto l599
|
|
l600:
|
|
if !p.rules[ruleHtmlComment]() {
|
|
goto l601
|
|
}
|
|
goto l599
|
|
l601:
|
|
if !p.rules[ruleHtmlBlockSelfClosing]() {
|
|
goto l598
|
|
}
|
|
l599:
|
|
end = position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l598
|
|
}
|
|
l602:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l603
|
|
}
|
|
goto l602
|
|
l603:
|
|
do(41)
|
|
return true
|
|
l598:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 132 HtmlBlockSelfClosing <- ('<' Spnl HtmlBlockType Spnl HtmlAttribute* '/' Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l604
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l604
|
|
}
|
|
if !p.rules[ruleHtmlBlockType]() {
|
|
goto l604
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l604
|
|
}
|
|
l605:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l606
|
|
}
|
|
goto l605
|
|
l606:
|
|
if !matchChar('/') {
|
|
goto l604
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l604
|
|
}
|
|
if !matchChar('>') {
|
|
goto l604
|
|
}
|
|
return true
|
|
l604:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 133 HtmlBlockType <- ('dir' / 'div' / 'dl' / 'fieldset' / 'form' / 'h1' / 'h2' / 'h3' / 'h4' / 'h5' / 'h6' / 'noframes' / 'p' / 'table' / 'dd' / 'tbody' / 'td' / 'tfoot' / 'th' / 'thead' / 'DIR' / 'DIV' / 'DL' / 'FIELDSET' / 'FORM' / 'H1' / 'H2' / 'H3' / 'H4' / 'H5' / 'H6' / 'NOFRAMES' / 'P' / 'TABLE' / 'DD' / 'TBODY' / 'TD' / 'TFOOT' / 'TH' / 'THEAD' / ((&[S] 'SCRIPT') | (&[T] 'TR') | (&[L] 'LI') | (&[F] 'FRAMESET') | (&[D] 'DT') | (&[U] 'UL') | (&[P] 'PRE') | (&[O] 'OL') | (&[N] 'NOSCRIPT') | (&[M] 'MENU') | (&[I] 'ISINDEX') | (&[H] 'HR') | (&[C] 'CENTER') | (&[B] 'BLOCKQUOTE') | (&[A] 'ADDRESS') | (&[s] 'script') | (&[t] 'tr') | (&[l] 'li') | (&[f] 'frameset') | (&[d] 'dt') | (&[u] 'ul') | (&[p] 'pre') | (&[o] 'ol') | (&[n] 'noscript') | (&[m] 'menu') | (&[i] 'isindex') | (&[h] 'hr') | (&[c] 'center') | (&[b] 'blockquote') | (&[a] 'address'))) */
|
|
func() bool {
|
|
if !matchString("dir") {
|
|
goto l609
|
|
}
|
|
goto l608
|
|
l609:
|
|
if !matchString("div") {
|
|
goto l610
|
|
}
|
|
goto l608
|
|
l610:
|
|
if !matchString("dl") {
|
|
goto l611
|
|
}
|
|
goto l608
|
|
l611:
|
|
if !matchString("fieldset") {
|
|
goto l612
|
|
}
|
|
goto l608
|
|
l612:
|
|
if !matchString("form") {
|
|
goto l613
|
|
}
|
|
goto l608
|
|
l613:
|
|
if !matchString("h1") {
|
|
goto l614
|
|
}
|
|
goto l608
|
|
l614:
|
|
if !matchString("h2") {
|
|
goto l615
|
|
}
|
|
goto l608
|
|
l615:
|
|
if !matchString("h3") {
|
|
goto l616
|
|
}
|
|
goto l608
|
|
l616:
|
|
if !matchString("h4") {
|
|
goto l617
|
|
}
|
|
goto l608
|
|
l617:
|
|
if !matchString("h5") {
|
|
goto l618
|
|
}
|
|
goto l608
|
|
l618:
|
|
if !matchString("h6") {
|
|
goto l619
|
|
}
|
|
goto l608
|
|
l619:
|
|
if !matchString("noframes") {
|
|
goto l620
|
|
}
|
|
goto l608
|
|
l620:
|
|
if !matchChar('p') {
|
|
goto l621
|
|
}
|
|
goto l608
|
|
l621:
|
|
if !matchString("table") {
|
|
goto l622
|
|
}
|
|
goto l608
|
|
l622:
|
|
if !matchString("dd") {
|
|
goto l623
|
|
}
|
|
goto l608
|
|
l623:
|
|
if !matchString("tbody") {
|
|
goto l624
|
|
}
|
|
goto l608
|
|
l624:
|
|
if !matchString("td") {
|
|
goto l625
|
|
}
|
|
goto l608
|
|
l625:
|
|
if !matchString("tfoot") {
|
|
goto l626
|
|
}
|
|
goto l608
|
|
l626:
|
|
if !matchString("th") {
|
|
goto l627
|
|
}
|
|
goto l608
|
|
l627:
|
|
if !matchString("thead") {
|
|
goto l628
|
|
}
|
|
goto l608
|
|
l628:
|
|
if !matchString("DIR") {
|
|
goto l629
|
|
}
|
|
goto l608
|
|
l629:
|
|
if !matchString("DIV") {
|
|
goto l630
|
|
}
|
|
goto l608
|
|
l630:
|
|
if !matchString("DL") {
|
|
goto l631
|
|
}
|
|
goto l608
|
|
l631:
|
|
if !matchString("FIELDSET") {
|
|
goto l632
|
|
}
|
|
goto l608
|
|
l632:
|
|
if !matchString("FORM") {
|
|
goto l633
|
|
}
|
|
goto l608
|
|
l633:
|
|
if !matchString("H1") {
|
|
goto l634
|
|
}
|
|
goto l608
|
|
l634:
|
|
if !matchString("H2") {
|
|
goto l635
|
|
}
|
|
goto l608
|
|
l635:
|
|
if !matchString("H3") {
|
|
goto l636
|
|
}
|
|
goto l608
|
|
l636:
|
|
if !matchString("H4") {
|
|
goto l637
|
|
}
|
|
goto l608
|
|
l637:
|
|
if !matchString("H5") {
|
|
goto l638
|
|
}
|
|
goto l608
|
|
l638:
|
|
if !matchString("H6") {
|
|
goto l639
|
|
}
|
|
goto l608
|
|
l639:
|
|
if !matchString("NOFRAMES") {
|
|
goto l640
|
|
}
|
|
goto l608
|
|
l640:
|
|
if !matchChar('P') {
|
|
goto l641
|
|
}
|
|
goto l608
|
|
l641:
|
|
if !matchString("TABLE") {
|
|
goto l642
|
|
}
|
|
goto l608
|
|
l642:
|
|
if !matchString("DD") {
|
|
goto l643
|
|
}
|
|
goto l608
|
|
l643:
|
|
if !matchString("TBODY") {
|
|
goto l644
|
|
}
|
|
goto l608
|
|
l644:
|
|
if !matchString("TD") {
|
|
goto l645
|
|
}
|
|
goto l608
|
|
l645:
|
|
if !matchString("TFOOT") {
|
|
goto l646
|
|
}
|
|
goto l608
|
|
l646:
|
|
if !matchString("TH") {
|
|
goto l647
|
|
}
|
|
goto l608
|
|
l647:
|
|
if !matchString("THEAD") {
|
|
goto l648
|
|
}
|
|
goto l608
|
|
l648:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l607
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'S':
|
|
position++
|
|
if !matchString("CRIPT") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'T':
|
|
position++ // matchString(`TR`)
|
|
if !matchChar('R') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'L':
|
|
position++ // matchString(`LI`)
|
|
if !matchChar('I') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'F':
|
|
position++
|
|
if !matchString("RAMESET") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'D':
|
|
position++ // matchString(`DT`)
|
|
if !matchChar('T') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'U':
|
|
position++ // matchString(`UL`)
|
|
if !matchChar('L') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'P':
|
|
position++
|
|
if !matchString("RE") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'O':
|
|
position++ // matchString(`OL`)
|
|
if !matchChar('L') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'N':
|
|
position++
|
|
if !matchString("OSCRIPT") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'M':
|
|
position++
|
|
if !matchString("ENU") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'I':
|
|
position++
|
|
if !matchString("SINDEX") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'H':
|
|
position++ // matchString(`HR`)
|
|
if !matchChar('R') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'C':
|
|
position++
|
|
if !matchString("ENTER") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'B':
|
|
position++
|
|
if !matchString("LOCKQUOTE") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'A':
|
|
position++
|
|
if !matchString("DDRESS") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 's':
|
|
position++
|
|
if !matchString("cript") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 't':
|
|
position++ // matchString(`tr`)
|
|
if !matchChar('r') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'l':
|
|
position++ // matchString(`li`)
|
|
if !matchChar('i') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'f':
|
|
position++
|
|
if !matchString("rameset") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'd':
|
|
position++ // matchString(`dt`)
|
|
if !matchChar('t') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'u':
|
|
position++ // matchString(`ul`)
|
|
if !matchChar('l') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'p':
|
|
position++
|
|
if !matchString("re") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'o':
|
|
position++ // matchString(`ol`)
|
|
if !matchChar('l') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'n':
|
|
position++
|
|
if !matchString("oscript") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'm':
|
|
position++
|
|
if !matchString("enu") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'i':
|
|
position++
|
|
if !matchString("sindex") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'h':
|
|
position++ // matchString(`hr`)
|
|
if !matchChar('r') {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'c':
|
|
position++
|
|
if !matchString("enter") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'b':
|
|
position++
|
|
if !matchString("lockquote") {
|
|
goto l607
|
|
}
|
|
break
|
|
case 'a':
|
|
position++
|
|
if !matchString("ddress") {
|
|
goto l607
|
|
}
|
|
break
|
|
default:
|
|
goto l607
|
|
}
|
|
}
|
|
l608:
|
|
return true
|
|
l607:
|
|
return false
|
|
},
|
|
/* 134 StyleOpen <- ('<' Spnl ((&[S] 'STYLE') | (&[s] 'style')) Spnl HtmlAttribute* '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l650
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l650
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l650
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'S':
|
|
position++
|
|
if !matchString("TYLE") {
|
|
goto l650
|
|
}
|
|
break
|
|
case 's':
|
|
position++
|
|
if !matchString("tyle") {
|
|
goto l650
|
|
}
|
|
break
|
|
default:
|
|
goto l650
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l650
|
|
}
|
|
l652:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l653
|
|
}
|
|
goto l652
|
|
l653:
|
|
if !matchChar('>') {
|
|
goto l650
|
|
}
|
|
return true
|
|
l650:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 135 StyleClose <- ('<' Spnl '/' ((&[S] 'STYLE') | (&[s] 'style')) Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l654
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l654
|
|
}
|
|
if !matchChar('/') {
|
|
goto l654
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l654
|
|
}
|
|
switch p.Buffer[position] {
|
|
case 'S':
|
|
position++
|
|
if !matchString("TYLE") {
|
|
goto l654
|
|
}
|
|
break
|
|
case 's':
|
|
position++
|
|
if !matchString("tyle") {
|
|
goto l654
|
|
}
|
|
break
|
|
default:
|
|
goto l654
|
|
}
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l654
|
|
}
|
|
if !matchChar('>') {
|
|
goto l654
|
|
}
|
|
return true
|
|
l654:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 136 InStyleTags <- (StyleOpen (!StyleClose .)* StyleClose) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleStyleOpen]() {
|
|
goto l656
|
|
}
|
|
l657:
|
|
{
|
|
position658 := position
|
|
if !p.rules[ruleStyleClose]() {
|
|
goto l659
|
|
}
|
|
goto l658
|
|
l659:
|
|
if !matchDot() {
|
|
goto l658
|
|
}
|
|
goto l657
|
|
l658:
|
|
position = position658
|
|
}
|
|
if !p.rules[ruleStyleClose]() {
|
|
goto l656
|
|
}
|
|
return true
|
|
l656:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 137 StyleBlock <- (< InStyleTags > BlankLine* { if p.extension.FilterStyles {
|
|
yy = p.mkList(LIST, nil)
|
|
} else {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTMLBLOCK
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !p.rules[ruleInStyleTags]() {
|
|
goto l660
|
|
}
|
|
end = position
|
|
l661:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l662
|
|
}
|
|
goto l661
|
|
l662:
|
|
do(42)
|
|
return true
|
|
l660:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 138 Inlines <- (StartList ((!Endline Inline { a = cons(yy, a) }) / (Endline &Inline { a = cons(c, a) }))+ Endline? { yy = p.mkList(LIST, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l663
|
|
}
|
|
doarg(yySet, -2)
|
|
{
|
|
position666 := position
|
|
if !p.rules[ruleEndline]() {
|
|
goto l668
|
|
}
|
|
goto l667
|
|
l668:
|
|
if !p.rules[ruleInline]() {
|
|
goto l667
|
|
}
|
|
do(43)
|
|
goto l666
|
|
l667:
|
|
position = position666
|
|
if !p.rules[ruleEndline]() {
|
|
goto l663
|
|
}
|
|
doarg(yySet, -1)
|
|
{
|
|
position669 := position
|
|
if !p.rules[ruleInline]() {
|
|
goto l663
|
|
}
|
|
position = position669
|
|
}
|
|
do(44)
|
|
}
|
|
l666:
|
|
l664:
|
|
{
|
|
position665, thunkPosition665 := position, thunkPosition
|
|
{
|
|
position670 := position
|
|
if !p.rules[ruleEndline]() {
|
|
goto l672
|
|
}
|
|
goto l671
|
|
l672:
|
|
if !p.rules[ruleInline]() {
|
|
goto l671
|
|
}
|
|
do(43)
|
|
goto l670
|
|
l671:
|
|
position = position670
|
|
if !p.rules[ruleEndline]() {
|
|
goto l665
|
|
}
|
|
doarg(yySet, -1)
|
|
{
|
|
position673 := position
|
|
if !p.rules[ruleInline]() {
|
|
goto l665
|
|
}
|
|
position = position673
|
|
}
|
|
do(44)
|
|
}
|
|
l670:
|
|
goto l664
|
|
l665:
|
|
position, thunkPosition = position665, thunkPosition665
|
|
}
|
|
if !p.rules[ruleEndline]() {
|
|
goto l674
|
|
}
|
|
l674:
|
|
do(45)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l663:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 139 Inline <- (Str / Endline / UlOrStarLine / Space / Strong / Emph / Image / Link / NoteReference / InlineNote / Code / RawHtml / Entity / EscapedChar / Smart / Symbol) */
|
|
func() bool {
|
|
if !p.rules[ruleStr]() {
|
|
goto l678
|
|
}
|
|
goto l677
|
|
l678:
|
|
if !p.rules[ruleEndline]() {
|
|
goto l679
|
|
}
|
|
goto l677
|
|
l679:
|
|
if !p.rules[ruleUlOrStarLine]() {
|
|
goto l680
|
|
}
|
|
goto l677
|
|
l680:
|
|
if !p.rules[ruleSpace]() {
|
|
goto l681
|
|
}
|
|
goto l677
|
|
l681:
|
|
if !p.rules[ruleStrong]() {
|
|
goto l682
|
|
}
|
|
goto l677
|
|
l682:
|
|
if !p.rules[ruleEmph]() {
|
|
goto l683
|
|
}
|
|
goto l677
|
|
l683:
|
|
if !p.rules[ruleImage]() {
|
|
goto l684
|
|
}
|
|
goto l677
|
|
l684:
|
|
if !p.rules[ruleLink]() {
|
|
goto l685
|
|
}
|
|
goto l677
|
|
l685:
|
|
if !p.rules[ruleNoteReference]() {
|
|
goto l686
|
|
}
|
|
goto l677
|
|
l686:
|
|
if !p.rules[ruleInlineNote]() {
|
|
goto l687
|
|
}
|
|
goto l677
|
|
l687:
|
|
if !p.rules[ruleCode]() {
|
|
goto l688
|
|
}
|
|
goto l677
|
|
l688:
|
|
if !p.rules[ruleRawHtml]() {
|
|
goto l689
|
|
}
|
|
goto l677
|
|
l689:
|
|
if !p.rules[ruleEntity]() {
|
|
goto l690
|
|
}
|
|
goto l677
|
|
l690:
|
|
if !p.rules[ruleEscapedChar]() {
|
|
goto l691
|
|
}
|
|
goto l677
|
|
l691:
|
|
if !p.rules[ruleSmart]() {
|
|
goto l692
|
|
}
|
|
goto l677
|
|
l692:
|
|
if !p.rules[ruleSymbol]() {
|
|
goto l676
|
|
}
|
|
l677:
|
|
return true
|
|
l676:
|
|
return false
|
|
},
|
|
/* 140 Space <- (Spacechar+ { yy = p.mkString(" ")
|
|
yy.key = SPACE }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l693
|
|
}
|
|
l694:
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l695
|
|
}
|
|
goto l694
|
|
l695:
|
|
do(46)
|
|
return true
|
|
l693:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 141 Str <- (StartList < NormalChar+ > { a = cons(p.mkString(yytext), a) } (StrChunk { a = cons(yy, a) })* { if a.next == nil { yy = a; } else { yy = p.mkList(LIST, a) } }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l696
|
|
}
|
|
doarg(yySet, -1)
|
|
begin = position
|
|
if !p.rules[ruleNormalChar]() {
|
|
goto l696
|
|
}
|
|
l697:
|
|
if !p.rules[ruleNormalChar]() {
|
|
goto l698
|
|
}
|
|
goto l697
|
|
l698:
|
|
end = position
|
|
do(47)
|
|
l699:
|
|
{
|
|
position700, thunkPosition700 := position, thunkPosition
|
|
if !p.rules[ruleStrChunk]() {
|
|
goto l700
|
|
}
|
|
do(48)
|
|
goto l699
|
|
l700:
|
|
position, thunkPosition = position700, thunkPosition700
|
|
}
|
|
do(49)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l696:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 142 StrChunk <- ((< (NormalChar / ('_'+ &Alphanumeric))+ > { yy = p.mkString(yytext) }) / AposChunk) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
position702 := position
|
|
begin = position
|
|
if !p.rules[ruleNormalChar]() {
|
|
goto l707
|
|
}
|
|
goto l706
|
|
l707:
|
|
if !matchChar('_') {
|
|
goto l703
|
|
}
|
|
l708:
|
|
if !matchChar('_') {
|
|
goto l709
|
|
}
|
|
goto l708
|
|
l709:
|
|
{
|
|
position710 := position
|
|
if !p.rules[ruleAlphanumeric]() {
|
|
goto l703
|
|
}
|
|
position = position710
|
|
}
|
|
l706:
|
|
l704:
|
|
{
|
|
position705 := position
|
|
if !p.rules[ruleNormalChar]() {
|
|
goto l712
|
|
}
|
|
goto l711
|
|
l712:
|
|
if !matchChar('_') {
|
|
goto l705
|
|
}
|
|
l713:
|
|
if !matchChar('_') {
|
|
goto l714
|
|
}
|
|
goto l713
|
|
l714:
|
|
{
|
|
position715 := position
|
|
if !p.rules[ruleAlphanumeric]() {
|
|
goto l705
|
|
}
|
|
position = position715
|
|
}
|
|
l711:
|
|
goto l704
|
|
l705:
|
|
position = position705
|
|
}
|
|
end = position
|
|
do(50)
|
|
goto l702
|
|
l703:
|
|
position = position702
|
|
if !p.rules[ruleAposChunk]() {
|
|
goto l701
|
|
}
|
|
}
|
|
l702:
|
|
return true
|
|
l701:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 143 AposChunk <- (&{p.extension.Smart} '\'' &Alphanumeric { yy = p.mkElem(APOSTROPHE) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !(p.extension.Smart) {
|
|
goto l716
|
|
}
|
|
if !matchChar('\'') {
|
|
goto l716
|
|
}
|
|
{
|
|
position717 := position
|
|
if !p.rules[ruleAlphanumeric]() {
|
|
goto l716
|
|
}
|
|
position = position717
|
|
}
|
|
do(51)
|
|
return true
|
|
l716:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 144 EscapedChar <- ('\\' !Newline < [-\\`|*_{}[\]()#+.!><] > { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('\\') {
|
|
goto l718
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l719
|
|
}
|
|
goto l718
|
|
l719:
|
|
begin = position
|
|
if !matchClass(1) {
|
|
goto l718
|
|
}
|
|
end = position
|
|
do(52)
|
|
return true
|
|
l718:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 145 Entity <- ((HexEntity / DecEntity / CharEntity) { yy = p.mkString(yytext); yy.key = HTML }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleHexEntity]() {
|
|
goto l722
|
|
}
|
|
goto l721
|
|
l722:
|
|
if !p.rules[ruleDecEntity]() {
|
|
goto l723
|
|
}
|
|
goto l721
|
|
l723:
|
|
if !p.rules[ruleCharEntity]() {
|
|
goto l720
|
|
}
|
|
l721:
|
|
do(53)
|
|
return true
|
|
l720:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 146 Endline <- (LineBreak / TerminalEndline / NormalEndline) */
|
|
func() bool {
|
|
if !p.rules[ruleLineBreak]() {
|
|
goto l726
|
|
}
|
|
goto l725
|
|
l726:
|
|
if !p.rules[ruleTerminalEndline]() {
|
|
goto l727
|
|
}
|
|
goto l725
|
|
l727:
|
|
if !p.rules[ruleNormalEndline]() {
|
|
goto l724
|
|
}
|
|
l725:
|
|
return true
|
|
l724:
|
|
return false
|
|
},
|
|
/* 147 NormalEndline <- (Sp Newline !BlankLine !'>' !AtxStart !(Line ((&[\-] ('---' '-'*)) | (&[=] ('===' '='*))) Newline) { yy = p.mkString("\n")
|
|
yy.key = SPACE }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
if !p.rules[ruleSp]() {
|
|
goto l728
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l728
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l729
|
|
}
|
|
goto l728
|
|
l729:
|
|
if peekChar('>') {
|
|
goto l728
|
|
}
|
|
if !p.rules[ruleAtxStart]() {
|
|
goto l730
|
|
}
|
|
goto l728
|
|
l730:
|
|
{
|
|
position731, thunkPosition731 := position, thunkPosition
|
|
if !p.rules[ruleLine]() {
|
|
goto l731
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l731
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '-':
|
|
position++
|
|
if !matchString("--") {
|
|
goto l731
|
|
}
|
|
l733:
|
|
if !matchChar('-') {
|
|
goto l734
|
|
}
|
|
goto l733
|
|
l734:
|
|
break
|
|
case '=':
|
|
position++
|
|
if !matchString("==") {
|
|
goto l731
|
|
}
|
|
l735:
|
|
if !matchChar('=') {
|
|
goto l736
|
|
}
|
|
goto l735
|
|
l736:
|
|
break
|
|
default:
|
|
goto l731
|
|
}
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l731
|
|
}
|
|
goto l728
|
|
l731:
|
|
position, thunkPosition = position731, thunkPosition731
|
|
}
|
|
do(54)
|
|
return true
|
|
l728:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 148 TerminalEndline <- (Sp Newline !. { yy = nil }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l737
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l737
|
|
}
|
|
if (position < len(p.Buffer)) {
|
|
goto l737
|
|
}
|
|
do(55)
|
|
return true
|
|
l737:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 149 LineBreak <- (' ' NormalEndline { yy = p.mkElem(LINEBREAK) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
if !matchString(" ") {
|
|
goto l738
|
|
}
|
|
if !p.rules[ruleNormalEndline]() {
|
|
goto l738
|
|
}
|
|
do(56)
|
|
return true
|
|
l738:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 150 Symbol <- (< SpecialChar > { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !p.rules[ruleSpecialChar]() {
|
|
goto l739
|
|
}
|
|
end = position
|
|
do(57)
|
|
return true
|
|
l739:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 151 UlOrStarLine <- ((UlLine / StarLine) { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleUlLine]() {
|
|
goto l742
|
|
}
|
|
goto l741
|
|
l742:
|
|
if !p.rules[ruleStarLine]() {
|
|
goto l740
|
|
}
|
|
l741:
|
|
do(58)
|
|
return true
|
|
l740:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 152 StarLine <- ((&[*] (< '****' '*'* >)) | (&[\t ] (< Spacechar '*'+ &Spacechar >))) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l743
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '*':
|
|
begin = position
|
|
if !matchString("****") {
|
|
goto l743
|
|
}
|
|
l745:
|
|
if !matchChar('*') {
|
|
goto l746
|
|
}
|
|
goto l745
|
|
l746:
|
|
end = position
|
|
break
|
|
case '\t', ' ':
|
|
begin = position
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l743
|
|
}
|
|
if !matchChar('*') {
|
|
goto l743
|
|
}
|
|
l747:
|
|
if !matchChar('*') {
|
|
goto l748
|
|
}
|
|
goto l747
|
|
l748:
|
|
{
|
|
position749 := position
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l743
|
|
}
|
|
position = position749
|
|
}
|
|
end = position
|
|
break
|
|
default:
|
|
goto l743
|
|
}
|
|
}
|
|
return true
|
|
l743:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 153 UlLine <- ((&[_] (< '____' '_'* >)) | (&[\t ] (< Spacechar '_'+ &Spacechar >))) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l750
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '_':
|
|
begin = position
|
|
if !matchString("____") {
|
|
goto l750
|
|
}
|
|
l752:
|
|
if !matchChar('_') {
|
|
goto l753
|
|
}
|
|
goto l752
|
|
l753:
|
|
end = position
|
|
break
|
|
case '\t', ' ':
|
|
begin = position
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l750
|
|
}
|
|
if !matchChar('_') {
|
|
goto l750
|
|
}
|
|
l754:
|
|
if !matchChar('_') {
|
|
goto l755
|
|
}
|
|
goto l754
|
|
l755:
|
|
{
|
|
position756 := position
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l750
|
|
}
|
|
position = position756
|
|
}
|
|
end = position
|
|
break
|
|
default:
|
|
goto l750
|
|
}
|
|
}
|
|
return true
|
|
l750:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 154 Emph <- ((&[_] EmphUl) | (&[*] EmphStar)) */
|
|
func() bool {
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l757
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '_':
|
|
if !p.rules[ruleEmphUl]() {
|
|
goto l757
|
|
}
|
|
break
|
|
case '*':
|
|
if !p.rules[ruleEmphStar]() {
|
|
goto l757
|
|
}
|
|
break
|
|
default:
|
|
goto l757
|
|
}
|
|
}
|
|
return true
|
|
l757:
|
|
return false
|
|
},
|
|
/* 155 OneStarOpen <- (!StarLine '*' !Spacechar !Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleStarLine]() {
|
|
goto l760
|
|
}
|
|
goto l759
|
|
l760:
|
|
if !matchChar('*') {
|
|
goto l759
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l761
|
|
}
|
|
goto l759
|
|
l761:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l762
|
|
}
|
|
goto l759
|
|
l762:
|
|
return true
|
|
l759:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 156 OneStarClose <- (!Spacechar !Newline Inline '*' { yy = a }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l764
|
|
}
|
|
goto l763
|
|
l764:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l765
|
|
}
|
|
goto l763
|
|
l765:
|
|
if !p.rules[ruleInline]() {
|
|
goto l763
|
|
}
|
|
doarg(yySet, -1)
|
|
if !matchChar('*') {
|
|
goto l763
|
|
}
|
|
do(59)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l763:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 157 EmphStar <- (OneStarOpen StartList (!OneStarClose Inline { a = cons(yy, a) })* OneStarClose { a = cons(yy, a) } { yy = p.mkList(EMPH, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleOneStarOpen]() {
|
|
goto l766
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l766
|
|
}
|
|
doarg(yySet, -1)
|
|
l767:
|
|
{
|
|
position768, thunkPosition768 := position, thunkPosition
|
|
if !p.rules[ruleOneStarClose]() {
|
|
goto l769
|
|
}
|
|
goto l768
|
|
l769:
|
|
if !p.rules[ruleInline]() {
|
|
goto l768
|
|
}
|
|
do(60)
|
|
goto l767
|
|
l768:
|
|
position, thunkPosition = position768, thunkPosition768
|
|
}
|
|
if !p.rules[ruleOneStarClose]() {
|
|
goto l766
|
|
}
|
|
do(61)
|
|
do(62)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l766:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 158 OneUlOpen <- (!UlLine '_' !Spacechar !Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleUlLine]() {
|
|
goto l771
|
|
}
|
|
goto l770
|
|
l771:
|
|
if !matchChar('_') {
|
|
goto l770
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l772
|
|
}
|
|
goto l770
|
|
l772:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l773
|
|
}
|
|
goto l770
|
|
l773:
|
|
return true
|
|
l770:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 159 OneUlClose <- (!Spacechar !Newline Inline '_' !Alphanumeric { yy = a }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l775
|
|
}
|
|
goto l774
|
|
l775:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l776
|
|
}
|
|
goto l774
|
|
l776:
|
|
if !p.rules[ruleInline]() {
|
|
goto l774
|
|
}
|
|
doarg(yySet, -1)
|
|
if !matchChar('_') {
|
|
goto l774
|
|
}
|
|
if !p.rules[ruleAlphanumeric]() {
|
|
goto l777
|
|
}
|
|
goto l774
|
|
l777:
|
|
do(63)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l774:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 160 EmphUl <- (OneUlOpen StartList (!OneUlClose Inline { a = cons(yy, a) })* OneUlClose { a = cons(yy, a) } { yy = p.mkList(EMPH, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleOneUlOpen]() {
|
|
goto l778
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l778
|
|
}
|
|
doarg(yySet, -1)
|
|
l779:
|
|
{
|
|
position780, thunkPosition780 := position, thunkPosition
|
|
if !p.rules[ruleOneUlClose]() {
|
|
goto l781
|
|
}
|
|
goto l780
|
|
l781:
|
|
if !p.rules[ruleInline]() {
|
|
goto l780
|
|
}
|
|
do(64)
|
|
goto l779
|
|
l780:
|
|
position, thunkPosition = position780, thunkPosition780
|
|
}
|
|
if !p.rules[ruleOneUlClose]() {
|
|
goto l778
|
|
}
|
|
do(65)
|
|
do(66)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l778:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 161 Strong <- ((&[_] StrongUl) | (&[*] StrongStar)) */
|
|
func() bool {
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l782
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '_':
|
|
if !p.rules[ruleStrongUl]() {
|
|
goto l782
|
|
}
|
|
break
|
|
case '*':
|
|
if !p.rules[ruleStrongStar]() {
|
|
goto l782
|
|
}
|
|
break
|
|
default:
|
|
goto l782
|
|
}
|
|
}
|
|
return true
|
|
l782:
|
|
return false
|
|
},
|
|
/* 162 TwoStarOpen <- (!StarLine '**' !Spacechar !Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleStarLine]() {
|
|
goto l785
|
|
}
|
|
goto l784
|
|
l785:
|
|
if !matchString("**") {
|
|
goto l784
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l786
|
|
}
|
|
goto l784
|
|
l786:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l787
|
|
}
|
|
goto l784
|
|
l787:
|
|
return true
|
|
l784:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 163 TwoStarClose <- (!Spacechar !Newline Inline '**' { yy = a }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l789
|
|
}
|
|
goto l788
|
|
l789:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l790
|
|
}
|
|
goto l788
|
|
l790:
|
|
if !p.rules[ruleInline]() {
|
|
goto l788
|
|
}
|
|
doarg(yySet, -1)
|
|
if !matchString("**") {
|
|
goto l788
|
|
}
|
|
do(67)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l788:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 164 StrongStar <- (TwoStarOpen StartList (!TwoStarClose Inline { a = cons(yy, a) })* TwoStarClose { a = cons(yy, a) } { yy = p.mkList(STRONG, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleTwoStarOpen]() {
|
|
goto l791
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l791
|
|
}
|
|
doarg(yySet, -1)
|
|
l792:
|
|
{
|
|
position793, thunkPosition793 := position, thunkPosition
|
|
if !p.rules[ruleTwoStarClose]() {
|
|
goto l794
|
|
}
|
|
goto l793
|
|
l794:
|
|
if !p.rules[ruleInline]() {
|
|
goto l793
|
|
}
|
|
do(68)
|
|
goto l792
|
|
l793:
|
|
position, thunkPosition = position793, thunkPosition793
|
|
}
|
|
if !p.rules[ruleTwoStarClose]() {
|
|
goto l791
|
|
}
|
|
do(69)
|
|
do(70)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l791:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 165 TwoUlOpen <- (!UlLine '__' !Spacechar !Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleUlLine]() {
|
|
goto l796
|
|
}
|
|
goto l795
|
|
l796:
|
|
if !matchString("__") {
|
|
goto l795
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l797
|
|
}
|
|
goto l795
|
|
l797:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l798
|
|
}
|
|
goto l795
|
|
l798:
|
|
return true
|
|
l795:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 166 TwoUlClose <- (!Spacechar !Newline Inline '__' !Alphanumeric { yy = a }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l800
|
|
}
|
|
goto l799
|
|
l800:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l801
|
|
}
|
|
goto l799
|
|
l801:
|
|
if !p.rules[ruleInline]() {
|
|
goto l799
|
|
}
|
|
doarg(yySet, -1)
|
|
if !matchString("__") {
|
|
goto l799
|
|
}
|
|
if !p.rules[ruleAlphanumeric]() {
|
|
goto l802
|
|
}
|
|
goto l799
|
|
l802:
|
|
do(71)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l799:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 167 StrongUl <- (TwoUlOpen StartList (!TwoUlClose Inline { a = cons(yy, a) })* TwoUlClose { a = cons(yy, a) } { yy = p.mkList(STRONG, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleTwoUlOpen]() {
|
|
goto l803
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l803
|
|
}
|
|
doarg(yySet, -1)
|
|
l804:
|
|
{
|
|
position805, thunkPosition805 := position, thunkPosition
|
|
if !p.rules[ruleTwoUlClose]() {
|
|
goto l806
|
|
}
|
|
goto l805
|
|
l806:
|
|
if !p.rules[ruleInline]() {
|
|
goto l805
|
|
}
|
|
do(72)
|
|
goto l804
|
|
l805:
|
|
position, thunkPosition = position805, thunkPosition805
|
|
}
|
|
if !p.rules[ruleTwoUlClose]() {
|
|
goto l803
|
|
}
|
|
do(73)
|
|
do(74)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l803:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 168 Image <- ('!' (ExplicitLink / ReferenceLink) { if yy.key == LINK {
|
|
yy.key = IMAGE
|
|
} else {
|
|
result := yy
|
|
yy.children = cons(p.mkString("!"), result.children)
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
if !matchChar('!') {
|
|
goto l807
|
|
}
|
|
if !p.rules[ruleExplicitLink]() {
|
|
goto l809
|
|
}
|
|
goto l808
|
|
l809:
|
|
if !p.rules[ruleReferenceLink]() {
|
|
goto l807
|
|
}
|
|
l808:
|
|
do(75)
|
|
return true
|
|
l807:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 169 Link <- (ExplicitLink / ReferenceLink / AutoLink) */
|
|
func() bool {
|
|
if !p.rules[ruleExplicitLink]() {
|
|
goto l812
|
|
}
|
|
goto l811
|
|
l812:
|
|
if !p.rules[ruleReferenceLink]() {
|
|
goto l813
|
|
}
|
|
goto l811
|
|
l813:
|
|
if !p.rules[ruleAutoLink]() {
|
|
goto l810
|
|
}
|
|
l811:
|
|
return true
|
|
l810:
|
|
return false
|
|
},
|
|
/* 170 ReferenceLink <- (ReferenceLinkDouble / ReferenceLinkSingle) */
|
|
func() bool {
|
|
if !p.rules[ruleReferenceLinkDouble]() {
|
|
goto l816
|
|
}
|
|
goto l815
|
|
l816:
|
|
if !p.rules[ruleReferenceLinkSingle]() {
|
|
goto l814
|
|
}
|
|
l815:
|
|
return true
|
|
l814:
|
|
return false
|
|
},
|
|
/* 171 ReferenceLinkDouble <- (Label < Spnl > !'[]' Label {
|
|
if match, found := p.findReference(b.children); found {
|
|
yy = p.mkLink(a.children, match.url, match.title);
|
|
a = nil
|
|
b = nil
|
|
} else {
|
|
result := p.mkElem(LIST)
|
|
result.children = cons(p.mkString("["), cons(a, cons(p.mkString("]"), cons(p.mkString(yytext),
|
|
cons(p.mkString("["), cons(b, p.mkString("]")))))))
|
|
yy = result
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleLabel]() {
|
|
goto l817
|
|
}
|
|
doarg(yySet, -2)
|
|
begin = position
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l817
|
|
}
|
|
end = position
|
|
if !matchString("[]") {
|
|
goto l818
|
|
}
|
|
goto l817
|
|
l818:
|
|
if !p.rules[ruleLabel]() {
|
|
goto l817
|
|
}
|
|
doarg(yySet, -1)
|
|
do(76)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l817:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 172 ReferenceLinkSingle <- (Label < (Spnl '[]')? > {
|
|
if match, found := p.findReference(a.children); found {
|
|
yy = p.mkLink(a.children, match.url, match.title)
|
|
a = nil
|
|
} else {
|
|
result := p.mkElem(LIST)
|
|
result.children = cons(p.mkString("["), cons(a, cons(p.mkString("]"), p.mkString(yytext))));
|
|
yy = result
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleLabel]() {
|
|
goto l819
|
|
}
|
|
doarg(yySet, -1)
|
|
begin = position
|
|
{
|
|
position820 := position
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l820
|
|
}
|
|
if !matchString("[]") {
|
|
goto l820
|
|
}
|
|
goto l821
|
|
l820:
|
|
position = position820
|
|
}
|
|
l821:
|
|
end = position
|
|
do(77)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l819:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 173 ExplicitLink <- (Label Spnl '(' Sp Source Spnl Title Sp ')' { yy = p.mkLink(l.children, s.contents.str, t.contents.str)
|
|
s = nil
|
|
t = nil
|
|
l = nil }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 3)
|
|
if !p.rules[ruleLabel]() {
|
|
goto l822
|
|
}
|
|
doarg(yySet, -2)
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l822
|
|
}
|
|
if !matchChar('(') {
|
|
goto l822
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l822
|
|
}
|
|
if !p.rules[ruleSource]() {
|
|
goto l822
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l822
|
|
}
|
|
if !p.rules[ruleTitle]() {
|
|
goto l822
|
|
}
|
|
doarg(yySet, -3)
|
|
if !p.rules[ruleSp]() {
|
|
goto l822
|
|
}
|
|
if !matchChar(')') {
|
|
goto l822
|
|
}
|
|
do(78)
|
|
doarg(yyPop, 3)
|
|
return true
|
|
l822:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 174 Source <- ((('<' < SourceContents > '>') / (< SourceContents >)) { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
position824 := position
|
|
if !matchChar('<') {
|
|
goto l825
|
|
}
|
|
begin = position
|
|
if !p.rules[ruleSourceContents]() {
|
|
goto l825
|
|
}
|
|
end = position
|
|
if !matchChar('>') {
|
|
goto l825
|
|
}
|
|
goto l824
|
|
l825:
|
|
position = position824
|
|
begin = position
|
|
if !p.rules[ruleSourceContents]() {
|
|
goto l823
|
|
}
|
|
end = position
|
|
}
|
|
l824:
|
|
do(79)
|
|
return true
|
|
l823:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 175 SourceContents <- (((!'(' !')' !'>' Nonspacechar)+ / ('(' SourceContents ')'))* / '') */
|
|
func() bool {
|
|
l829:
|
|
{
|
|
position830 := position
|
|
if position == len(p.Buffer) {
|
|
goto l832
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '(', ')', '>':
|
|
goto l832
|
|
default:
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l832
|
|
}
|
|
}
|
|
l833:
|
|
if position == len(p.Buffer) {
|
|
goto l834
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '(', ')', '>':
|
|
goto l834
|
|
default:
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l834
|
|
}
|
|
}
|
|
goto l833
|
|
l834:
|
|
goto l831
|
|
l832:
|
|
if !matchChar('(') {
|
|
goto l830
|
|
}
|
|
if !p.rules[ruleSourceContents]() {
|
|
goto l830
|
|
}
|
|
if !matchChar(')') {
|
|
goto l830
|
|
}
|
|
l831:
|
|
goto l829
|
|
l830:
|
|
position = position830
|
|
}
|
|
goto l827
|
|
l827:
|
|
return true
|
|
},
|
|
/* 176 Title <- ((TitleSingle / TitleDouble / (< '' >)) { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
if !p.rules[ruleTitleSingle]() {
|
|
goto l837
|
|
}
|
|
goto l836
|
|
l837:
|
|
if !p.rules[ruleTitleDouble]() {
|
|
goto l838
|
|
}
|
|
goto l836
|
|
l838:
|
|
begin = position
|
|
end = position
|
|
l836:
|
|
do(80)
|
|
return true
|
|
},
|
|
/* 177 TitleSingle <- ('\'' < (!('\'' Sp ((&[)] ')') | (&[\n\r] Newline))) .)* > '\'') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('\'') {
|
|
goto l839
|
|
}
|
|
begin = position
|
|
l840:
|
|
{
|
|
position841 := position
|
|
{
|
|
position842 := position
|
|
if !matchChar('\'') {
|
|
goto l842
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l842
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l842
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ')':
|
|
position++ // matchChar
|
|
break
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l842
|
|
}
|
|
break
|
|
default:
|
|
goto l842
|
|
}
|
|
}
|
|
goto l841
|
|
l842:
|
|
position = position842
|
|
}
|
|
if !matchDot() {
|
|
goto l841
|
|
}
|
|
goto l840
|
|
l841:
|
|
position = position841
|
|
}
|
|
end = position
|
|
if !matchChar('\'') {
|
|
goto l839
|
|
}
|
|
return true
|
|
l839:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 178 TitleDouble <- ('"' < (!('"' Sp ((&[)] ')') | (&[\n\r] Newline))) .)* > '"') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('"') {
|
|
goto l844
|
|
}
|
|
begin = position
|
|
l845:
|
|
{
|
|
position846 := position
|
|
{
|
|
position847 := position
|
|
if !matchChar('"') {
|
|
goto l847
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l847
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l847
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ')':
|
|
position++ // matchChar
|
|
break
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l847
|
|
}
|
|
break
|
|
default:
|
|
goto l847
|
|
}
|
|
}
|
|
goto l846
|
|
l847:
|
|
position = position847
|
|
}
|
|
if !matchDot() {
|
|
goto l846
|
|
}
|
|
goto l845
|
|
l846:
|
|
position = position846
|
|
}
|
|
end = position
|
|
if !matchChar('"') {
|
|
goto l844
|
|
}
|
|
return true
|
|
l844:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 179 AutoLink <- (AutoLinkUrl / AutoLinkEmail) */
|
|
func() bool {
|
|
if !p.rules[ruleAutoLinkUrl]() {
|
|
goto l851
|
|
}
|
|
goto l850
|
|
l851:
|
|
if !p.rules[ruleAutoLinkEmail]() {
|
|
goto l849
|
|
}
|
|
l850:
|
|
return true
|
|
l849:
|
|
return false
|
|
},
|
|
/* 180 AutoLinkUrl <- ('<' < [A-Za-z]+ '://' (!Newline !'>' .)+ > '>' { yy = p.mkLink(p.mkString(yytext), yytext, "") }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l852
|
|
}
|
|
begin = position
|
|
if !matchClass(2) {
|
|
goto l852
|
|
}
|
|
l853:
|
|
if !matchClass(2) {
|
|
goto l854
|
|
}
|
|
goto l853
|
|
l854:
|
|
if !matchString("://") {
|
|
goto l852
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l857
|
|
}
|
|
goto l852
|
|
l857:
|
|
if peekChar('>') {
|
|
goto l852
|
|
}
|
|
if !matchDot() {
|
|
goto l852
|
|
}
|
|
l855:
|
|
{
|
|
position856 := position
|
|
if !p.rules[ruleNewline]() {
|
|
goto l858
|
|
}
|
|
goto l856
|
|
l858:
|
|
if peekChar('>') {
|
|
goto l856
|
|
}
|
|
if !matchDot() {
|
|
goto l856
|
|
}
|
|
goto l855
|
|
l856:
|
|
position = position856
|
|
}
|
|
end = position
|
|
if !matchChar('>') {
|
|
goto l852
|
|
}
|
|
do(81)
|
|
return true
|
|
l852:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 181 AutoLinkEmail <- ('<' 'mailto:'? < [-A-Za-z0-9+_./!%~$]+ '@' (!Newline !'>' .)+ > '>' {
|
|
yy = p.mkLink(p.mkString(yytext), "mailto:"+yytext, "")
|
|
}) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l859
|
|
}
|
|
if !matchString("mailto:") {
|
|
goto l860
|
|
}
|
|
l860:
|
|
begin = position
|
|
if !matchClass(3) {
|
|
goto l859
|
|
}
|
|
l862:
|
|
if !matchClass(3) {
|
|
goto l863
|
|
}
|
|
goto l862
|
|
l863:
|
|
if !matchChar('@') {
|
|
goto l859
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l866
|
|
}
|
|
goto l859
|
|
l866:
|
|
if peekChar('>') {
|
|
goto l859
|
|
}
|
|
if !matchDot() {
|
|
goto l859
|
|
}
|
|
l864:
|
|
{
|
|
position865 := position
|
|
if !p.rules[ruleNewline]() {
|
|
goto l867
|
|
}
|
|
goto l865
|
|
l867:
|
|
if peekChar('>') {
|
|
goto l865
|
|
}
|
|
if !matchDot() {
|
|
goto l865
|
|
}
|
|
goto l864
|
|
l865:
|
|
position = position865
|
|
}
|
|
end = position
|
|
if !matchChar('>') {
|
|
goto l859
|
|
}
|
|
do(82)
|
|
return true
|
|
l859:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 182 Reference <- (NonindentSpace !'[]' Label ':' Spnl RefSrc RefTitle BlankLine+ { yy = p.mkLink(l.children, s.contents.str, t.contents.str)
|
|
s = nil
|
|
t = nil
|
|
l = nil
|
|
yy.key = REFERENCE }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 3)
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l868
|
|
}
|
|
if !matchString("[]") {
|
|
goto l869
|
|
}
|
|
goto l868
|
|
l869:
|
|
if !p.rules[ruleLabel]() {
|
|
goto l868
|
|
}
|
|
doarg(yySet, -1)
|
|
if !matchChar(':') {
|
|
goto l868
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l868
|
|
}
|
|
if !p.rules[ruleRefSrc]() {
|
|
goto l868
|
|
}
|
|
doarg(yySet, -2)
|
|
if !p.rules[ruleRefTitle]() {
|
|
goto l868
|
|
}
|
|
doarg(yySet, -3)
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l868
|
|
}
|
|
l870:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l871
|
|
}
|
|
goto l870
|
|
l871:
|
|
do(83)
|
|
doarg(yyPop, 3)
|
|
return true
|
|
l868:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 183 Label <- ('[' ((!'^' &{p.extension.Notes}) / (&. &{!p.extension.Notes})) StartList (!']' Inline { a = cons(yy, a) })* ']' { yy = p.mkList(LIST, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !matchChar('[') {
|
|
goto l872
|
|
}
|
|
if peekChar('^') {
|
|
goto l874
|
|
}
|
|
if !(p.extension.Notes) {
|
|
goto l874
|
|
}
|
|
goto l873
|
|
l874:
|
|
if !(position < len(p.Buffer)) {
|
|
goto l872
|
|
}
|
|
if !(!p.extension.Notes) {
|
|
goto l872
|
|
}
|
|
l873:
|
|
if !p.rules[ruleStartList]() {
|
|
goto l872
|
|
}
|
|
doarg(yySet, -1)
|
|
l875:
|
|
{
|
|
position876 := position
|
|
if peekChar(']') {
|
|
goto l876
|
|
}
|
|
if !p.rules[ruleInline]() {
|
|
goto l876
|
|
}
|
|
do(84)
|
|
goto l875
|
|
l876:
|
|
position = position876
|
|
}
|
|
if !matchChar(']') {
|
|
goto l872
|
|
}
|
|
do(85)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l872:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 184 RefSrc <- (< Nonspacechar+ > { yy = p.mkString(yytext)
|
|
yy.key = HTML }) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l877
|
|
}
|
|
l878:
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l879
|
|
}
|
|
goto l878
|
|
l879:
|
|
end = position
|
|
do(86)
|
|
return true
|
|
l877:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 185 RefTitle <- ((RefTitleSingle / RefTitleDouble / RefTitleParens / EmptyTitle) { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleRefTitleSingle]() {
|
|
goto l882
|
|
}
|
|
goto l881
|
|
l882:
|
|
if !p.rules[ruleRefTitleDouble]() {
|
|
goto l883
|
|
}
|
|
goto l881
|
|
l883:
|
|
if !p.rules[ruleRefTitleParens]() {
|
|
goto l884
|
|
}
|
|
goto l881
|
|
l884:
|
|
if !p.rules[ruleEmptyTitle]() {
|
|
goto l880
|
|
}
|
|
l881:
|
|
do(87)
|
|
return true
|
|
l880:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 186 EmptyTitle <- (< '' >) */
|
|
func() bool {
|
|
begin = position
|
|
end = position
|
|
return true
|
|
},
|
|
/* 187 RefTitleSingle <- (Spnl '\'' < (!((&[\'] ('\'' Sp Newline)) | (&[\n\r] Newline)) .)* > '\'') */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l886
|
|
}
|
|
if !matchChar('\'') {
|
|
goto l886
|
|
}
|
|
begin = position
|
|
l887:
|
|
{
|
|
position888 := position
|
|
{
|
|
position889 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l889
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\'':
|
|
position++ // matchChar
|
|
if !p.rules[ruleSp]() {
|
|
goto l889
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l889
|
|
}
|
|
break
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l889
|
|
}
|
|
break
|
|
default:
|
|
goto l889
|
|
}
|
|
}
|
|
goto l888
|
|
l889:
|
|
position = position889
|
|
}
|
|
if !matchDot() {
|
|
goto l888
|
|
}
|
|
goto l887
|
|
l888:
|
|
position = position888
|
|
}
|
|
end = position
|
|
if !matchChar('\'') {
|
|
goto l886
|
|
}
|
|
return true
|
|
l886:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 188 RefTitleDouble <- (Spnl '"' < (!((&[\"] ('"' Sp Newline)) | (&[\n\r] Newline)) .)* > '"') */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l891
|
|
}
|
|
if !matchChar('"') {
|
|
goto l891
|
|
}
|
|
begin = position
|
|
l892:
|
|
{
|
|
position893 := position
|
|
{
|
|
position894 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l894
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '"':
|
|
position++ // matchChar
|
|
if !p.rules[ruleSp]() {
|
|
goto l894
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l894
|
|
}
|
|
break
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l894
|
|
}
|
|
break
|
|
default:
|
|
goto l894
|
|
}
|
|
}
|
|
goto l893
|
|
l894:
|
|
position = position894
|
|
}
|
|
if !matchDot() {
|
|
goto l893
|
|
}
|
|
goto l892
|
|
l893:
|
|
position = position893
|
|
}
|
|
end = position
|
|
if !matchChar('"') {
|
|
goto l891
|
|
}
|
|
return true
|
|
l891:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 189 RefTitleParens <- (Spnl '(' < (!((&[)] (')' Sp Newline)) | (&[\n\r] Newline)) .)* > ')') */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l896
|
|
}
|
|
if !matchChar('(') {
|
|
goto l896
|
|
}
|
|
begin = position
|
|
l897:
|
|
{
|
|
position898 := position
|
|
{
|
|
position899 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l899
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ')':
|
|
position++ // matchChar
|
|
if !p.rules[ruleSp]() {
|
|
goto l899
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l899
|
|
}
|
|
break
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l899
|
|
}
|
|
break
|
|
default:
|
|
goto l899
|
|
}
|
|
}
|
|
goto l898
|
|
l899:
|
|
position = position899
|
|
}
|
|
if !matchDot() {
|
|
goto l898
|
|
}
|
|
goto l897
|
|
l898:
|
|
position = position898
|
|
}
|
|
end = position
|
|
if !matchChar(')') {
|
|
goto l896
|
|
}
|
|
return true
|
|
l896:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 190 References <- (StartList ((Reference { a = cons(b, a) }) / SkipBlock)* { p.references = reverse(a) } commit) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l901
|
|
}
|
|
doarg(yySet, -1)
|
|
l902:
|
|
{
|
|
position903, thunkPosition903 := position, thunkPosition
|
|
{
|
|
position904, thunkPosition904 := position, thunkPosition
|
|
if !p.rules[ruleReference]() {
|
|
goto l905
|
|
}
|
|
doarg(yySet, -2)
|
|
do(88)
|
|
goto l904
|
|
l905:
|
|
position, thunkPosition = position904, thunkPosition904
|
|
if !p.rules[ruleSkipBlock]() {
|
|
goto l903
|
|
}
|
|
}
|
|
l904:
|
|
goto l902
|
|
l903:
|
|
position, thunkPosition = position903, thunkPosition903
|
|
}
|
|
do(89)
|
|
if !(commit(thunkPosition0)) {
|
|
goto l901
|
|
}
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l901:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 191 Ticks1 <- ('`' !'`') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('`') {
|
|
goto l906
|
|
}
|
|
if peekChar('`') {
|
|
goto l906
|
|
}
|
|
return true
|
|
l906:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 192 Ticks2 <- ('``' !'`') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("``") {
|
|
goto l907
|
|
}
|
|
if peekChar('`') {
|
|
goto l907
|
|
}
|
|
return true
|
|
l907:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 193 Ticks3 <- ('```' !'`') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("```") {
|
|
goto l908
|
|
}
|
|
if peekChar('`') {
|
|
goto l908
|
|
}
|
|
return true
|
|
l908:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 194 Ticks4 <- ('````' !'`') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("````") {
|
|
goto l909
|
|
}
|
|
if peekChar('`') {
|
|
goto l909
|
|
}
|
|
return true
|
|
l909:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 195 Ticks5 <- ('`````' !'`') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("`````") {
|
|
goto l910
|
|
}
|
|
if peekChar('`') {
|
|
goto l910
|
|
}
|
|
return true
|
|
l910:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 196 Code <- (((Ticks1 Sp < ((!'`' Nonspacechar)+ / ((&[`] (!Ticks1 '`'+)) | (&[\t\n\r ] (!(Sp Ticks1) ((&[\n\r] (Newline !BlankLine)) | (&[\t ] Spacechar))))))+ > Sp Ticks1) / (Ticks2 Sp < ((!'`' Nonspacechar)+ / ((&[`] (!Ticks2 '`'+)) | (&[\t\n\r ] (!(Sp Ticks2) ((&[\n\r] (Newline !BlankLine)) | (&[\t ] Spacechar))))))+ > Sp Ticks2) / (Ticks3 Sp < ((!'`' Nonspacechar)+ / ((&[`] (!Ticks3 '`'+)) | (&[\t\n\r ] (!(Sp Ticks3) ((&[\n\r] (Newline !BlankLine)) | (&[\t ] Spacechar))))))+ > Sp Ticks3) / (Ticks4 Sp < ((!'`' Nonspacechar)+ / ((&[`] (!Ticks4 '`'+)) | (&[\t\n\r ] (!(Sp Ticks4) ((&[\n\r] (Newline !BlankLine)) | (&[\t ] Spacechar))))))+ > Sp Ticks4) / (Ticks5 Sp < ((!'`' Nonspacechar)+ / ((&[`] (!Ticks5 '`'+)) | (&[\t\n\r ] (!(Sp Ticks5) ((&[\n\r] (Newline !BlankLine)) | (&[\t ] Spacechar))))))+ > Sp Ticks5)) { yy = p.mkString(yytext); yy.key = CODE }) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
position912 := position
|
|
if !p.rules[ruleTicks1]() {
|
|
goto l913
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l913
|
|
}
|
|
begin = position
|
|
if peekChar('`') {
|
|
goto l917
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l917
|
|
}
|
|
l918:
|
|
if peekChar('`') {
|
|
goto l919
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l919
|
|
}
|
|
goto l918
|
|
l919:
|
|
goto l916
|
|
l917:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l913
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks1]() {
|
|
goto l921
|
|
}
|
|
goto l913
|
|
l921:
|
|
if !matchChar('`') {
|
|
goto l913
|
|
}
|
|
l922:
|
|
if !matchChar('`') {
|
|
goto l923
|
|
}
|
|
goto l922
|
|
l923:
|
|
break
|
|
default:
|
|
{
|
|
position924 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l924
|
|
}
|
|
if !p.rules[ruleTicks1]() {
|
|
goto l924
|
|
}
|
|
goto l913
|
|
l924:
|
|
position = position924
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l913
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l913
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l926
|
|
}
|
|
goto l913
|
|
l926:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l913
|
|
}
|
|
break
|
|
default:
|
|
goto l913
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l916:
|
|
l914:
|
|
{
|
|
position915 := position
|
|
if peekChar('`') {
|
|
goto l928
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l928
|
|
}
|
|
l929:
|
|
if peekChar('`') {
|
|
goto l930
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l930
|
|
}
|
|
goto l929
|
|
l930:
|
|
goto l927
|
|
l928:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l915
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks1]() {
|
|
goto l932
|
|
}
|
|
goto l915
|
|
l932:
|
|
if !matchChar('`') {
|
|
goto l915
|
|
}
|
|
l933:
|
|
if !matchChar('`') {
|
|
goto l934
|
|
}
|
|
goto l933
|
|
l934:
|
|
break
|
|
default:
|
|
{
|
|
position935 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l935
|
|
}
|
|
if !p.rules[ruleTicks1]() {
|
|
goto l935
|
|
}
|
|
goto l915
|
|
l935:
|
|
position = position935
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l915
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l915
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l937
|
|
}
|
|
goto l915
|
|
l937:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l915
|
|
}
|
|
break
|
|
default:
|
|
goto l915
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l927:
|
|
goto l914
|
|
l915:
|
|
position = position915
|
|
}
|
|
end = position
|
|
if !p.rules[ruleSp]() {
|
|
goto l913
|
|
}
|
|
if !p.rules[ruleTicks1]() {
|
|
goto l913
|
|
}
|
|
goto l912
|
|
l913:
|
|
position = position912
|
|
if !p.rules[ruleTicks2]() {
|
|
goto l938
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l938
|
|
}
|
|
begin = position
|
|
if peekChar('`') {
|
|
goto l942
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l942
|
|
}
|
|
l943:
|
|
if peekChar('`') {
|
|
goto l944
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l944
|
|
}
|
|
goto l943
|
|
l944:
|
|
goto l941
|
|
l942:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l938
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks2]() {
|
|
goto l946
|
|
}
|
|
goto l938
|
|
l946:
|
|
if !matchChar('`') {
|
|
goto l938
|
|
}
|
|
l947:
|
|
if !matchChar('`') {
|
|
goto l948
|
|
}
|
|
goto l947
|
|
l948:
|
|
break
|
|
default:
|
|
{
|
|
position949 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l949
|
|
}
|
|
if !p.rules[ruleTicks2]() {
|
|
goto l949
|
|
}
|
|
goto l938
|
|
l949:
|
|
position = position949
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l938
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l938
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l951
|
|
}
|
|
goto l938
|
|
l951:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l938
|
|
}
|
|
break
|
|
default:
|
|
goto l938
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l941:
|
|
l939:
|
|
{
|
|
position940 := position
|
|
if peekChar('`') {
|
|
goto l953
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l953
|
|
}
|
|
l954:
|
|
if peekChar('`') {
|
|
goto l955
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l955
|
|
}
|
|
goto l954
|
|
l955:
|
|
goto l952
|
|
l953:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l940
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks2]() {
|
|
goto l957
|
|
}
|
|
goto l940
|
|
l957:
|
|
if !matchChar('`') {
|
|
goto l940
|
|
}
|
|
l958:
|
|
if !matchChar('`') {
|
|
goto l959
|
|
}
|
|
goto l958
|
|
l959:
|
|
break
|
|
default:
|
|
{
|
|
position960 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l960
|
|
}
|
|
if !p.rules[ruleTicks2]() {
|
|
goto l960
|
|
}
|
|
goto l940
|
|
l960:
|
|
position = position960
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l940
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l940
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l962
|
|
}
|
|
goto l940
|
|
l962:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l940
|
|
}
|
|
break
|
|
default:
|
|
goto l940
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l952:
|
|
goto l939
|
|
l940:
|
|
position = position940
|
|
}
|
|
end = position
|
|
if !p.rules[ruleSp]() {
|
|
goto l938
|
|
}
|
|
if !p.rules[ruleTicks2]() {
|
|
goto l938
|
|
}
|
|
goto l912
|
|
l938:
|
|
position = position912
|
|
if !p.rules[ruleTicks3]() {
|
|
goto l963
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l963
|
|
}
|
|
begin = position
|
|
if peekChar('`') {
|
|
goto l967
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l967
|
|
}
|
|
l968:
|
|
if peekChar('`') {
|
|
goto l969
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l969
|
|
}
|
|
goto l968
|
|
l969:
|
|
goto l966
|
|
l967:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l963
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks3]() {
|
|
goto l971
|
|
}
|
|
goto l963
|
|
l971:
|
|
if !matchChar('`') {
|
|
goto l963
|
|
}
|
|
l972:
|
|
if !matchChar('`') {
|
|
goto l973
|
|
}
|
|
goto l972
|
|
l973:
|
|
break
|
|
default:
|
|
{
|
|
position974 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l974
|
|
}
|
|
if !p.rules[ruleTicks3]() {
|
|
goto l974
|
|
}
|
|
goto l963
|
|
l974:
|
|
position = position974
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l963
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l963
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l976
|
|
}
|
|
goto l963
|
|
l976:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l963
|
|
}
|
|
break
|
|
default:
|
|
goto l963
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l966:
|
|
l964:
|
|
{
|
|
position965 := position
|
|
if peekChar('`') {
|
|
goto l978
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l978
|
|
}
|
|
l979:
|
|
if peekChar('`') {
|
|
goto l980
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l980
|
|
}
|
|
goto l979
|
|
l980:
|
|
goto l977
|
|
l978:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l965
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks3]() {
|
|
goto l982
|
|
}
|
|
goto l965
|
|
l982:
|
|
if !matchChar('`') {
|
|
goto l965
|
|
}
|
|
l983:
|
|
if !matchChar('`') {
|
|
goto l984
|
|
}
|
|
goto l983
|
|
l984:
|
|
break
|
|
default:
|
|
{
|
|
position985 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l985
|
|
}
|
|
if !p.rules[ruleTicks3]() {
|
|
goto l985
|
|
}
|
|
goto l965
|
|
l985:
|
|
position = position985
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l965
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l965
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l987
|
|
}
|
|
goto l965
|
|
l987:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l965
|
|
}
|
|
break
|
|
default:
|
|
goto l965
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l977:
|
|
goto l964
|
|
l965:
|
|
position = position965
|
|
}
|
|
end = position
|
|
if !p.rules[ruleSp]() {
|
|
goto l963
|
|
}
|
|
if !p.rules[ruleTicks3]() {
|
|
goto l963
|
|
}
|
|
goto l912
|
|
l963:
|
|
position = position912
|
|
if !p.rules[ruleTicks4]() {
|
|
goto l988
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l988
|
|
}
|
|
begin = position
|
|
if peekChar('`') {
|
|
goto l992
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l992
|
|
}
|
|
l993:
|
|
if peekChar('`') {
|
|
goto l994
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l994
|
|
}
|
|
goto l993
|
|
l994:
|
|
goto l991
|
|
l992:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l988
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks4]() {
|
|
goto l996
|
|
}
|
|
goto l988
|
|
l996:
|
|
if !matchChar('`') {
|
|
goto l988
|
|
}
|
|
l997:
|
|
if !matchChar('`') {
|
|
goto l998
|
|
}
|
|
goto l997
|
|
l998:
|
|
break
|
|
default:
|
|
{
|
|
position999 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l999
|
|
}
|
|
if !p.rules[ruleTicks4]() {
|
|
goto l999
|
|
}
|
|
goto l988
|
|
l999:
|
|
position = position999
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l988
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l988
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1001
|
|
}
|
|
goto l988
|
|
l1001:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l988
|
|
}
|
|
break
|
|
default:
|
|
goto l988
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l991:
|
|
l989:
|
|
{
|
|
position990 := position
|
|
if peekChar('`') {
|
|
goto l1003
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1003
|
|
}
|
|
l1004:
|
|
if peekChar('`') {
|
|
goto l1005
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1005
|
|
}
|
|
goto l1004
|
|
l1005:
|
|
goto l1002
|
|
l1003:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l990
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks4]() {
|
|
goto l1007
|
|
}
|
|
goto l990
|
|
l1007:
|
|
if !matchChar('`') {
|
|
goto l990
|
|
}
|
|
l1008:
|
|
if !matchChar('`') {
|
|
goto l1009
|
|
}
|
|
goto l1008
|
|
l1009:
|
|
break
|
|
default:
|
|
{
|
|
position1010 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l1010
|
|
}
|
|
if !p.rules[ruleTicks4]() {
|
|
goto l1010
|
|
}
|
|
goto l990
|
|
l1010:
|
|
position = position1010
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l990
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l990
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1012
|
|
}
|
|
goto l990
|
|
l1012:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l990
|
|
}
|
|
break
|
|
default:
|
|
goto l990
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l1002:
|
|
goto l989
|
|
l990:
|
|
position = position990
|
|
}
|
|
end = position
|
|
if !p.rules[ruleSp]() {
|
|
goto l988
|
|
}
|
|
if !p.rules[ruleTicks4]() {
|
|
goto l988
|
|
}
|
|
goto l912
|
|
l988:
|
|
position = position912
|
|
if !p.rules[ruleTicks5]() {
|
|
goto l911
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l911
|
|
}
|
|
begin = position
|
|
if peekChar('`') {
|
|
goto l1016
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1016
|
|
}
|
|
l1017:
|
|
if peekChar('`') {
|
|
goto l1018
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1018
|
|
}
|
|
goto l1017
|
|
l1018:
|
|
goto l1015
|
|
l1016:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l911
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks5]() {
|
|
goto l1020
|
|
}
|
|
goto l911
|
|
l1020:
|
|
if !matchChar('`') {
|
|
goto l911
|
|
}
|
|
l1021:
|
|
if !matchChar('`') {
|
|
goto l1022
|
|
}
|
|
goto l1021
|
|
l1022:
|
|
break
|
|
default:
|
|
{
|
|
position1023 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l1023
|
|
}
|
|
if !p.rules[ruleTicks5]() {
|
|
goto l1023
|
|
}
|
|
goto l911
|
|
l1023:
|
|
position = position1023
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l911
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l911
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1025
|
|
}
|
|
goto l911
|
|
l1025:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l911
|
|
}
|
|
break
|
|
default:
|
|
goto l911
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l1015:
|
|
l1013:
|
|
{
|
|
position1014 := position
|
|
if peekChar('`') {
|
|
goto l1027
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1027
|
|
}
|
|
l1028:
|
|
if peekChar('`') {
|
|
goto l1029
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1029
|
|
}
|
|
goto l1028
|
|
l1029:
|
|
goto l1026
|
|
l1027:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1014
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '`':
|
|
if !p.rules[ruleTicks5]() {
|
|
goto l1031
|
|
}
|
|
goto l1014
|
|
l1031:
|
|
if !matchChar('`') {
|
|
goto l1014
|
|
}
|
|
l1032:
|
|
if !matchChar('`') {
|
|
goto l1033
|
|
}
|
|
goto l1032
|
|
l1033:
|
|
break
|
|
default:
|
|
{
|
|
position1034 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l1034
|
|
}
|
|
if !p.rules[ruleTicks5]() {
|
|
goto l1034
|
|
}
|
|
goto l1014
|
|
l1034:
|
|
position = position1034
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1014
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1014
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1036
|
|
}
|
|
goto l1014
|
|
l1036:
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1014
|
|
}
|
|
break
|
|
default:
|
|
goto l1014
|
|
}
|
|
}
|
|
}
|
|
}
|
|
l1026:
|
|
goto l1013
|
|
l1014:
|
|
position = position1014
|
|
}
|
|
end = position
|
|
if !p.rules[ruleSp]() {
|
|
goto l911
|
|
}
|
|
if !p.rules[ruleTicks5]() {
|
|
goto l911
|
|
}
|
|
}
|
|
l912:
|
|
do(90)
|
|
return true
|
|
l911:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 197 RawHtml <- (< (HtmlComment / HtmlBlockScript / HtmlTag) > { if p.extension.FilterHTML {
|
|
yy = p.mkList(LIST, nil)
|
|
} else {
|
|
yy = p.mkString(yytext)
|
|
yy.key = HTML
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !p.rules[ruleHtmlComment]() {
|
|
goto l1039
|
|
}
|
|
goto l1038
|
|
l1039:
|
|
if !p.rules[ruleHtmlBlockScript]() {
|
|
goto l1040
|
|
}
|
|
goto l1038
|
|
l1040:
|
|
if !p.rules[ruleHtmlTag]() {
|
|
goto l1037
|
|
}
|
|
l1038:
|
|
end = position
|
|
do(91)
|
|
return true
|
|
l1037:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 198 BlankLine <- (Sp Newline) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l1041
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1041
|
|
}
|
|
return true
|
|
l1041:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 199 Quoted <- ((&[\'] ('\'' (!'\'' .)* '\'')) | (&[\"] ('"' (!'"' .)* '"'))) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1042
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\'':
|
|
position++ // matchChar
|
|
l1044:
|
|
if position == len(p.Buffer) {
|
|
goto l1045
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\'':
|
|
goto l1045
|
|
default:
|
|
position++
|
|
}
|
|
goto l1044
|
|
l1045:
|
|
if !matchChar('\'') {
|
|
goto l1042
|
|
}
|
|
break
|
|
case '"':
|
|
position++ // matchChar
|
|
l1046:
|
|
if position == len(p.Buffer) {
|
|
goto l1047
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '"':
|
|
goto l1047
|
|
default:
|
|
position++
|
|
}
|
|
goto l1046
|
|
l1047:
|
|
if !matchChar('"') {
|
|
goto l1042
|
|
}
|
|
break
|
|
default:
|
|
goto l1042
|
|
}
|
|
}
|
|
return true
|
|
l1042:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 200 HtmlAttribute <- (((&[\-] '-') | (&[0-9A-Za-z] [A-Za-z0-9]))+ Spnl ('=' Spnl (Quoted / (!'>' Nonspacechar)+))? Spnl) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1048
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '-':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
if !matchClass(6) {
|
|
goto l1048
|
|
}
|
|
}
|
|
}
|
|
l1049:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1050
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '-':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
if !matchClass(6) {
|
|
goto l1050
|
|
}
|
|
}
|
|
}
|
|
goto l1049
|
|
l1050:
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l1048
|
|
}
|
|
{
|
|
position1053 := position
|
|
if !matchChar('=') {
|
|
goto l1053
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l1053
|
|
}
|
|
if !p.rules[ruleQuoted]() {
|
|
goto l1056
|
|
}
|
|
goto l1055
|
|
l1056:
|
|
if peekChar('>') {
|
|
goto l1053
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1053
|
|
}
|
|
l1057:
|
|
if peekChar('>') {
|
|
goto l1058
|
|
}
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1058
|
|
}
|
|
goto l1057
|
|
l1058:
|
|
l1055:
|
|
goto l1054
|
|
l1053:
|
|
position = position1053
|
|
}
|
|
l1054:
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l1048
|
|
}
|
|
return true
|
|
l1048:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 201 HtmlComment <- ('<!--' (!'-->' .)* '-->') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("<!--") {
|
|
goto l1059
|
|
}
|
|
l1060:
|
|
{
|
|
position1061 := position
|
|
if !matchString("-->") {
|
|
goto l1062
|
|
}
|
|
goto l1061
|
|
l1062:
|
|
if !matchDot() {
|
|
goto l1061
|
|
}
|
|
goto l1060
|
|
l1061:
|
|
position = position1061
|
|
}
|
|
if !matchString("-->") {
|
|
goto l1059
|
|
}
|
|
return true
|
|
l1059:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 202 HtmlTag <- ('<' Spnl '/'? [A-Za-z0-9]+ Spnl HtmlAttribute* '/'? Spnl '>') */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('<') {
|
|
goto l1063
|
|
}
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l1063
|
|
}
|
|
matchChar('/')
|
|
if !matchClass(6) {
|
|
goto l1063
|
|
}
|
|
l1064:
|
|
if !matchClass(6) {
|
|
goto l1065
|
|
}
|
|
goto l1064
|
|
l1065:
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l1063
|
|
}
|
|
l1066:
|
|
if !p.rules[ruleHtmlAttribute]() {
|
|
goto l1067
|
|
}
|
|
goto l1066
|
|
l1067:
|
|
matchChar('/')
|
|
if !p.rules[ruleSpnl]() {
|
|
goto l1063
|
|
}
|
|
if !matchChar('>') {
|
|
goto l1063
|
|
}
|
|
return true
|
|
l1063:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 203 Eof <- !. */
|
|
func() bool {
|
|
if (position < len(p.Buffer)) {
|
|
goto l1068
|
|
}
|
|
return true
|
|
l1068:
|
|
return false
|
|
},
|
|
/* 204 Spacechar <- ((&[\t] '\t') | (&[ ] ' ')) */
|
|
func() bool {
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1069
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\t':
|
|
position++ // matchChar
|
|
break
|
|
case ' ':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l1069
|
|
}
|
|
}
|
|
return true
|
|
l1069:
|
|
return false
|
|
},
|
|
/* 205 Nonspacechar <- (!Spacechar !Newline .) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1072
|
|
}
|
|
goto l1071
|
|
l1072:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1073
|
|
}
|
|
goto l1071
|
|
l1073:
|
|
if !matchDot() {
|
|
goto l1071
|
|
}
|
|
return true
|
|
l1071:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 206 Newline <- ((&[\r] ('\r' '\n'?)) | (&[\n] '\n')) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1074
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\r':
|
|
position++ // matchChar
|
|
matchChar('\n')
|
|
break
|
|
case '\n':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l1074
|
|
}
|
|
}
|
|
return true
|
|
l1074:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 207 Sp <- Spacechar* */
|
|
func() bool {
|
|
l1077:
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1078
|
|
}
|
|
goto l1077
|
|
l1078:
|
|
return true
|
|
},
|
|
/* 208 Spnl <- (Sp (Newline Sp)?) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleSp]() {
|
|
goto l1079
|
|
}
|
|
{
|
|
position1080 := position
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1080
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l1080
|
|
}
|
|
goto l1081
|
|
l1080:
|
|
position = position1080
|
|
}
|
|
l1081:
|
|
return true
|
|
l1079:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 209 SpecialChar <- ('\'' / '"' / ((&[\\] '\\') | (&[#] '#') | (&[!] '!') | (&[<] '<') | (&[)] ')') | (&[(] '(') | (&[\]] ']') | (&[\[] '[') | (&[&] '&') | (&[`] '`') | (&[_] '_') | (&[*] '*') | (&[\"\'\-.^] ExtendedSpecialChar))) */
|
|
func() bool {
|
|
if !matchChar('\'') {
|
|
goto l1084
|
|
}
|
|
goto l1083
|
|
l1084:
|
|
if !matchChar('"') {
|
|
goto l1085
|
|
}
|
|
goto l1083
|
|
l1085:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1082
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\\':
|
|
position++ // matchChar
|
|
break
|
|
case '#':
|
|
position++ // matchChar
|
|
break
|
|
case '!':
|
|
position++ // matchChar
|
|
break
|
|
case '<':
|
|
position++ // matchChar
|
|
break
|
|
case ')':
|
|
position++ // matchChar
|
|
break
|
|
case '(':
|
|
position++ // matchChar
|
|
break
|
|
case ']':
|
|
position++ // matchChar
|
|
break
|
|
case '[':
|
|
position++ // matchChar
|
|
break
|
|
case '&':
|
|
position++ // matchChar
|
|
break
|
|
case '`':
|
|
position++ // matchChar
|
|
break
|
|
case '_':
|
|
position++ // matchChar
|
|
break
|
|
case '*':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
if !p.rules[ruleExtendedSpecialChar]() {
|
|
goto l1082
|
|
}
|
|
}
|
|
}
|
|
l1083:
|
|
return true
|
|
l1082:
|
|
return false
|
|
},
|
|
/* 210 NormalChar <- (!((&[\n\r] Newline) | (&[\t ] Spacechar) | (&[!-#&-*\-.<\[-`] SpecialChar)) .) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1088
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1088
|
|
}
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1088
|
|
}
|
|
break
|
|
default:
|
|
if !p.rules[ruleSpecialChar]() {
|
|
goto l1088
|
|
}
|
|
}
|
|
}
|
|
goto l1087
|
|
l1088:
|
|
if !matchDot() {
|
|
goto l1087
|
|
}
|
|
return true
|
|
l1087:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 211 NonAlphanumeric <- [\000-\057\072-\100\133-\140\173-\177] */
|
|
func() bool {
|
|
if !matchClass(4) {
|
|
goto l1090
|
|
}
|
|
return true
|
|
l1090:
|
|
return false
|
|
},
|
|
/* 212 Alphanumeric <- ((&[\377] '\377') | (&[\376] '\376') | (&[\375] '\375') | (&[\374] '\374') | (&[\373] '\373') | (&[\372] '\372') | (&[\371] '\371') | (&[\370] '\370') | (&[\367] '\367') | (&[\366] '\366') | (&[\365] '\365') | (&[\364] '\364') | (&[\363] '\363') | (&[\362] '\362') | (&[\361] '\361') | (&[\360] '\360') | (&[\357] '\357') | (&[\356] '\356') | (&[\355] '\355') | (&[\354] '\354') | (&[\353] '\353') | (&[\352] '\352') | (&[\351] '\351') | (&[\350] '\350') | (&[\347] '\347') | (&[\346] '\346') | (&[\345] '\345') | (&[\344] '\344') | (&[\343] '\343') | (&[\342] '\342') | (&[\341] '\341') | (&[\340] '\340') | (&[\337] '\337') | (&[\336] '\336') | (&[\335] '\335') | (&[\334] '\334') | (&[\333] '\333') | (&[\332] '\332') | (&[\331] '\331') | (&[\330] '\330') | (&[\327] '\327') | (&[\326] '\326') | (&[\325] '\325') | (&[\324] '\324') | (&[\323] '\323') | (&[\322] '\322') | (&[\321] '\321') | (&[\320] '\320') | (&[\317] '\317') | (&[\316] '\316') | (&[\315] '\315') | (&[\314] '\314') | (&[\313] '\313') | (&[\312] '\312') | (&[\311] '\311') | (&[\310] '\310') | (&[\307] '\307') | (&[\306] '\306') | (&[\305] '\305') | (&[\304] '\304') | (&[\303] '\303') | (&[\302] '\302') | (&[\301] '\301') | (&[\300] '\300') | (&[\277] '\277') | (&[\276] '\276') | (&[\275] '\275') | (&[\274] '\274') | (&[\273] '\273') | (&[\272] '\272') | (&[\271] '\271') | (&[\270] '\270') | (&[\267] '\267') | (&[\266] '\266') | (&[\265] '\265') | (&[\264] '\264') | (&[\263] '\263') | (&[\262] '\262') | (&[\261] '\261') | (&[\260] '\260') | (&[\257] '\257') | (&[\256] '\256') | (&[\255] '\255') | (&[\254] '\254') | (&[\253] '\253') | (&[\252] '\252') | (&[\251] '\251') | (&[\250] '\250') | (&[\247] '\247') | (&[\246] '\246') | (&[\245] '\245') | (&[\244] '\244') | (&[\243] '\243') | (&[\242] '\242') | (&[\241] '\241') | (&[\240] '\240') | (&[\237] '\237') | (&[\236] '\236') | (&[\235] '\235') | (&[\234] '\234') | (&[\233] '\233') | (&[\232] '\232') | (&[\231] '\231') | (&[\230] '\230') | (&[\227] '\227') | (&[\226] '\226') | (&[\225] '\225') | (&[\224] '\224') | (&[\223] '\223') | (&[\222] '\222') | (&[\221] '\221') | (&[\220] '\220') | (&[\217] '\217') | (&[\216] '\216') | (&[\215] '\215') | (&[\214] '\214') | (&[\213] '\213') | (&[\212] '\212') | (&[\211] '\211') | (&[\210] '\210') | (&[\207] '\207') | (&[\206] '\206') | (&[\205] '\205') | (&[\204] '\204') | (&[\203] '\203') | (&[\202] '\202') | (&[\201] '\201') | (&[\200] '\200') | (&[0-9A-Za-z] [0-9A-Za-z])) */
|
|
func() bool {
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1091
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\377':
|
|
position++ // matchChar
|
|
break
|
|
case '\376':
|
|
position++ // matchChar
|
|
break
|
|
case '\375':
|
|
position++ // matchChar
|
|
break
|
|
case '\374':
|
|
position++ // matchChar
|
|
break
|
|
case '\373':
|
|
position++ // matchChar
|
|
break
|
|
case '\372':
|
|
position++ // matchChar
|
|
break
|
|
case '\371':
|
|
position++ // matchChar
|
|
break
|
|
case '\370':
|
|
position++ // matchChar
|
|
break
|
|
case '\367':
|
|
position++ // matchChar
|
|
break
|
|
case '\366':
|
|
position++ // matchChar
|
|
break
|
|
case '\365':
|
|
position++ // matchChar
|
|
break
|
|
case '\364':
|
|
position++ // matchChar
|
|
break
|
|
case '\363':
|
|
position++ // matchChar
|
|
break
|
|
case '\362':
|
|
position++ // matchChar
|
|
break
|
|
case '\361':
|
|
position++ // matchChar
|
|
break
|
|
case '\360':
|
|
position++ // matchChar
|
|
break
|
|
case '\357':
|
|
position++ // matchChar
|
|
break
|
|
case '\356':
|
|
position++ // matchChar
|
|
break
|
|
case '\355':
|
|
position++ // matchChar
|
|
break
|
|
case '\354':
|
|
position++ // matchChar
|
|
break
|
|
case '\353':
|
|
position++ // matchChar
|
|
break
|
|
case '\352':
|
|
position++ // matchChar
|
|
break
|
|
case '\351':
|
|
position++ // matchChar
|
|
break
|
|
case '\350':
|
|
position++ // matchChar
|
|
break
|
|
case '\347':
|
|
position++ // matchChar
|
|
break
|
|
case '\346':
|
|
position++ // matchChar
|
|
break
|
|
case '\345':
|
|
position++ // matchChar
|
|
break
|
|
case '\344':
|
|
position++ // matchChar
|
|
break
|
|
case '\343':
|
|
position++ // matchChar
|
|
break
|
|
case '\342':
|
|
position++ // matchChar
|
|
break
|
|
case '\341':
|
|
position++ // matchChar
|
|
break
|
|
case '\340':
|
|
position++ // matchChar
|
|
break
|
|
case '\337':
|
|
position++ // matchChar
|
|
break
|
|
case '\336':
|
|
position++ // matchChar
|
|
break
|
|
case '\335':
|
|
position++ // matchChar
|
|
break
|
|
case '\334':
|
|
position++ // matchChar
|
|
break
|
|
case '\333':
|
|
position++ // matchChar
|
|
break
|
|
case '\332':
|
|
position++ // matchChar
|
|
break
|
|
case '\331':
|
|
position++ // matchChar
|
|
break
|
|
case '\330':
|
|
position++ // matchChar
|
|
break
|
|
case '\327':
|
|
position++ // matchChar
|
|
break
|
|
case '\326':
|
|
position++ // matchChar
|
|
break
|
|
case '\325':
|
|
position++ // matchChar
|
|
break
|
|
case '\324':
|
|
position++ // matchChar
|
|
break
|
|
case '\323':
|
|
position++ // matchChar
|
|
break
|
|
case '\322':
|
|
position++ // matchChar
|
|
break
|
|
case '\321':
|
|
position++ // matchChar
|
|
break
|
|
case '\320':
|
|
position++ // matchChar
|
|
break
|
|
case '\317':
|
|
position++ // matchChar
|
|
break
|
|
case '\316':
|
|
position++ // matchChar
|
|
break
|
|
case '\315':
|
|
position++ // matchChar
|
|
break
|
|
case '\314':
|
|
position++ // matchChar
|
|
break
|
|
case '\313':
|
|
position++ // matchChar
|
|
break
|
|
case '\312':
|
|
position++ // matchChar
|
|
break
|
|
case '\311':
|
|
position++ // matchChar
|
|
break
|
|
case '\310':
|
|
position++ // matchChar
|
|
break
|
|
case '\307':
|
|
position++ // matchChar
|
|
break
|
|
case '\306':
|
|
position++ // matchChar
|
|
break
|
|
case '\305':
|
|
position++ // matchChar
|
|
break
|
|
case '\304':
|
|
position++ // matchChar
|
|
break
|
|
case '\303':
|
|
position++ // matchChar
|
|
break
|
|
case '\302':
|
|
position++ // matchChar
|
|
break
|
|
case '\301':
|
|
position++ // matchChar
|
|
break
|
|
case '\300':
|
|
position++ // matchChar
|
|
break
|
|
case '\277':
|
|
position++ // matchChar
|
|
break
|
|
case '\276':
|
|
position++ // matchChar
|
|
break
|
|
case '\275':
|
|
position++ // matchChar
|
|
break
|
|
case '\274':
|
|
position++ // matchChar
|
|
break
|
|
case '\273':
|
|
position++ // matchChar
|
|
break
|
|
case '\272':
|
|
position++ // matchChar
|
|
break
|
|
case '\271':
|
|
position++ // matchChar
|
|
break
|
|
case '\270':
|
|
position++ // matchChar
|
|
break
|
|
case '\267':
|
|
position++ // matchChar
|
|
break
|
|
case '\266':
|
|
position++ // matchChar
|
|
break
|
|
case '\265':
|
|
position++ // matchChar
|
|
break
|
|
case '\264':
|
|
position++ // matchChar
|
|
break
|
|
case '\263':
|
|
position++ // matchChar
|
|
break
|
|
case '\262':
|
|
position++ // matchChar
|
|
break
|
|
case '\261':
|
|
position++ // matchChar
|
|
break
|
|
case '\260':
|
|
position++ // matchChar
|
|
break
|
|
case '\257':
|
|
position++ // matchChar
|
|
break
|
|
case '\256':
|
|
position++ // matchChar
|
|
break
|
|
case '\255':
|
|
position++ // matchChar
|
|
break
|
|
case '\254':
|
|
position++ // matchChar
|
|
break
|
|
case '\253':
|
|
position++ // matchChar
|
|
break
|
|
case '\252':
|
|
position++ // matchChar
|
|
break
|
|
case '\251':
|
|
position++ // matchChar
|
|
break
|
|
case '\250':
|
|
position++ // matchChar
|
|
break
|
|
case '\247':
|
|
position++ // matchChar
|
|
break
|
|
case '\246':
|
|
position++ // matchChar
|
|
break
|
|
case '\245':
|
|
position++ // matchChar
|
|
break
|
|
case '\244':
|
|
position++ // matchChar
|
|
break
|
|
case '\243':
|
|
position++ // matchChar
|
|
break
|
|
case '\242':
|
|
position++ // matchChar
|
|
break
|
|
case '\241':
|
|
position++ // matchChar
|
|
break
|
|
case '\240':
|
|
position++ // matchChar
|
|
break
|
|
case '\237':
|
|
position++ // matchChar
|
|
break
|
|
case '\236':
|
|
position++ // matchChar
|
|
break
|
|
case '\235':
|
|
position++ // matchChar
|
|
break
|
|
case '\234':
|
|
position++ // matchChar
|
|
break
|
|
case '\233':
|
|
position++ // matchChar
|
|
break
|
|
case '\232':
|
|
position++ // matchChar
|
|
break
|
|
case '\231':
|
|
position++ // matchChar
|
|
break
|
|
case '\230':
|
|
position++ // matchChar
|
|
break
|
|
case '\227':
|
|
position++ // matchChar
|
|
break
|
|
case '\226':
|
|
position++ // matchChar
|
|
break
|
|
case '\225':
|
|
position++ // matchChar
|
|
break
|
|
case '\224':
|
|
position++ // matchChar
|
|
break
|
|
case '\223':
|
|
position++ // matchChar
|
|
break
|
|
case '\222':
|
|
position++ // matchChar
|
|
break
|
|
case '\221':
|
|
position++ // matchChar
|
|
break
|
|
case '\220':
|
|
position++ // matchChar
|
|
break
|
|
case '\217':
|
|
position++ // matchChar
|
|
break
|
|
case '\216':
|
|
position++ // matchChar
|
|
break
|
|
case '\215':
|
|
position++ // matchChar
|
|
break
|
|
case '\214':
|
|
position++ // matchChar
|
|
break
|
|
case '\213':
|
|
position++ // matchChar
|
|
break
|
|
case '\212':
|
|
position++ // matchChar
|
|
break
|
|
case '\211':
|
|
position++ // matchChar
|
|
break
|
|
case '\210':
|
|
position++ // matchChar
|
|
break
|
|
case '\207':
|
|
position++ // matchChar
|
|
break
|
|
case '\206':
|
|
position++ // matchChar
|
|
break
|
|
case '\205':
|
|
position++ // matchChar
|
|
break
|
|
case '\204':
|
|
position++ // matchChar
|
|
break
|
|
case '\203':
|
|
position++ // matchChar
|
|
break
|
|
case '\202':
|
|
position++ // matchChar
|
|
break
|
|
case '\201':
|
|
position++ // matchChar
|
|
break
|
|
case '\200':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
if !matchClass(5) {
|
|
goto l1091
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
l1091:
|
|
return false
|
|
},
|
|
/* 213 AlphanumericAscii <- [A-Za-z0-9] */
|
|
func() bool {
|
|
if !matchClass(6) {
|
|
goto l1093
|
|
}
|
|
return true
|
|
l1093:
|
|
return false
|
|
},
|
|
/* 214 Digit <- [0-9] */
|
|
func() bool {
|
|
if !matchClass(0) {
|
|
goto l1094
|
|
}
|
|
return true
|
|
l1094:
|
|
return false
|
|
},
|
|
/* 215 HexEntity <- (< '&' '#' [Xx] [0-9a-fA-F]+ ';' >) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !matchChar('&') {
|
|
goto l1095
|
|
}
|
|
if !matchChar('#') {
|
|
goto l1095
|
|
}
|
|
if !matchClass(7) {
|
|
goto l1095
|
|
}
|
|
if !matchClass(8) {
|
|
goto l1095
|
|
}
|
|
l1096:
|
|
if !matchClass(8) {
|
|
goto l1097
|
|
}
|
|
goto l1096
|
|
l1097:
|
|
if !matchChar(';') {
|
|
goto l1095
|
|
}
|
|
end = position
|
|
return true
|
|
l1095:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 216 DecEntity <- (< '&' '#' [0-9]+ > ';' >) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !matchChar('&') {
|
|
goto l1098
|
|
}
|
|
if !matchChar('#') {
|
|
goto l1098
|
|
}
|
|
if !matchClass(0) {
|
|
goto l1098
|
|
}
|
|
l1099:
|
|
if !matchClass(0) {
|
|
goto l1100
|
|
}
|
|
goto l1099
|
|
l1100:
|
|
end = position
|
|
if !matchChar(';') {
|
|
goto l1098
|
|
}
|
|
end = position
|
|
return true
|
|
l1098:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 217 CharEntity <- (< '&' [A-Za-z0-9]+ ';' >) */
|
|
func() bool {
|
|
position0 := position
|
|
begin = position
|
|
if !matchChar('&') {
|
|
goto l1101
|
|
}
|
|
if !matchClass(6) {
|
|
goto l1101
|
|
}
|
|
l1102:
|
|
if !matchClass(6) {
|
|
goto l1103
|
|
}
|
|
goto l1102
|
|
l1103:
|
|
if !matchChar(';') {
|
|
goto l1101
|
|
}
|
|
end = position
|
|
return true
|
|
l1101:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 218 NonindentSpace <- (' ' / ' ' / ' ' / '') */
|
|
func() bool {
|
|
if !matchString(" ") {
|
|
goto l1106
|
|
}
|
|
goto l1105
|
|
l1106:
|
|
if !matchString(" ") {
|
|
goto l1107
|
|
}
|
|
goto l1105
|
|
l1107:
|
|
if !matchChar(' ') {
|
|
goto l1108
|
|
}
|
|
goto l1105
|
|
l1108:
|
|
l1105:
|
|
return true
|
|
},
|
|
/* 219 Indent <- ((&[ ] ' ') | (&[\t] '\t')) */
|
|
func() bool {
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1109
|
|
}
|
|
switch p.Buffer[position] {
|
|
case ' ':
|
|
position++
|
|
if !matchString(" ") {
|
|
goto l1109
|
|
}
|
|
break
|
|
case '\t':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l1109
|
|
}
|
|
}
|
|
return true
|
|
l1109:
|
|
return false
|
|
},
|
|
/* 220 IndentedLine <- (Indent Line) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleIndent]() {
|
|
goto l1111
|
|
}
|
|
if !p.rules[ruleLine]() {
|
|
goto l1111
|
|
}
|
|
return true
|
|
l1111:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 221 OptionallyIndentedLine <- (Indent? Line) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleIndent]() {
|
|
goto l1113
|
|
}
|
|
l1113:
|
|
if !p.rules[ruleLine]() {
|
|
goto l1112
|
|
}
|
|
return true
|
|
l1112:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 222 StartList <- (&. { yy = nil }) */
|
|
func() bool {
|
|
if !(position < len(p.Buffer)) {
|
|
goto l1115
|
|
}
|
|
do(92)
|
|
return true
|
|
l1115:
|
|
return false
|
|
},
|
|
/* 223 Line <- (RawLine { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l1116
|
|
}
|
|
do(93)
|
|
return true
|
|
l1116:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 224 RawLine <- ((< (!'\r' !'\n' .)* Newline >) / (< .+ > !.)) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
position1118 := position
|
|
begin = position
|
|
l1120:
|
|
if position == len(p.Buffer) {
|
|
goto l1121
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\r', '\n':
|
|
goto l1121
|
|
default:
|
|
position++
|
|
}
|
|
goto l1120
|
|
l1121:
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1119
|
|
}
|
|
end = position
|
|
goto l1118
|
|
l1119:
|
|
position = position1118
|
|
begin = position
|
|
if !matchDot() {
|
|
goto l1117
|
|
}
|
|
l1122:
|
|
if !matchDot() {
|
|
goto l1123
|
|
}
|
|
goto l1122
|
|
l1123:
|
|
end = position
|
|
if (position < len(p.Buffer)) {
|
|
goto l1117
|
|
}
|
|
}
|
|
l1118:
|
|
return true
|
|
l1117:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 225 SkipBlock <- (HtmlBlock / ((!'#' !SetextBottom1 !SetextBottom2 !BlankLine RawLine)+ BlankLine*) / BlankLine+ / RawLine) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
position1125 := position
|
|
if !p.rules[ruleHtmlBlock]() {
|
|
goto l1126
|
|
}
|
|
goto l1125
|
|
l1126:
|
|
if peekChar('#') {
|
|
goto l1127
|
|
}
|
|
if !p.rules[ruleSetextBottom1]() {
|
|
goto l1130
|
|
}
|
|
goto l1127
|
|
l1130:
|
|
if !p.rules[ruleSetextBottom2]() {
|
|
goto l1131
|
|
}
|
|
goto l1127
|
|
l1131:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1132
|
|
}
|
|
goto l1127
|
|
l1132:
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l1127
|
|
}
|
|
l1128:
|
|
{
|
|
position1129 := position
|
|
if peekChar('#') {
|
|
goto l1129
|
|
}
|
|
if !p.rules[ruleSetextBottom1]() {
|
|
goto l1133
|
|
}
|
|
goto l1129
|
|
l1133:
|
|
if !p.rules[ruleSetextBottom2]() {
|
|
goto l1134
|
|
}
|
|
goto l1129
|
|
l1134:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1135
|
|
}
|
|
goto l1129
|
|
l1135:
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l1129
|
|
}
|
|
goto l1128
|
|
l1129:
|
|
position = position1129
|
|
}
|
|
l1136:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1137
|
|
}
|
|
goto l1136
|
|
l1137:
|
|
goto l1125
|
|
l1127:
|
|
position = position1125
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1138
|
|
}
|
|
l1139:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1140
|
|
}
|
|
goto l1139
|
|
l1140:
|
|
goto l1125
|
|
l1138:
|
|
position = position1125
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l1124
|
|
}
|
|
}
|
|
l1125:
|
|
return true
|
|
l1124:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 226 ExtendedSpecialChar <- ((&[^] (&{p.extension.Notes} '^')) | (&[\"\'\-.] (&{p.extension.Smart} ((&[\"] '"') | (&[\'] '\'') | (&[\-] '-') | (&[.] '.'))))) */
|
|
func() bool {
|
|
position0 := position
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1141
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '^':
|
|
if !(p.extension.Notes) {
|
|
goto l1141
|
|
}
|
|
if !matchChar('^') {
|
|
goto l1141
|
|
}
|
|
break
|
|
default:
|
|
if !(p.extension.Smart) {
|
|
goto l1141
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1141
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '"':
|
|
position++ // matchChar
|
|
break
|
|
case '\'':
|
|
position++ // matchChar
|
|
break
|
|
case '-':
|
|
position++ // matchChar
|
|
break
|
|
case '.':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l1141
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
l1141:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 227 Smart <- (&{p.extension.Smart} (SingleQuoted / ((&[\'] Apostrophe) | (&[\"] DoubleQuoted) | (&[\-] Dash) | (&[.] Ellipsis)))) */
|
|
func() bool {
|
|
if !(p.extension.Smart) {
|
|
goto l1144
|
|
}
|
|
if !p.rules[ruleSingleQuoted]() {
|
|
goto l1146
|
|
}
|
|
goto l1145
|
|
l1146:
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1144
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\'':
|
|
if !p.rules[ruleApostrophe]() {
|
|
goto l1144
|
|
}
|
|
break
|
|
case '"':
|
|
if !p.rules[ruleDoubleQuoted]() {
|
|
goto l1144
|
|
}
|
|
break
|
|
case '-':
|
|
if !p.rules[ruleDash]() {
|
|
goto l1144
|
|
}
|
|
break
|
|
case '.':
|
|
if !p.rules[ruleEllipsis]() {
|
|
goto l1144
|
|
}
|
|
break
|
|
default:
|
|
goto l1144
|
|
}
|
|
}
|
|
l1145:
|
|
return true
|
|
l1144:
|
|
return false
|
|
},
|
|
/* 228 Apostrophe <- ('\'' { yy = p.mkElem(APOSTROPHE) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('\'') {
|
|
goto l1148
|
|
}
|
|
do(94)
|
|
return true
|
|
l1148:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 229 Ellipsis <- (('...' / '. . .') { yy = p.mkElem(ELLIPSIS) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("...") {
|
|
goto l1151
|
|
}
|
|
goto l1150
|
|
l1151:
|
|
if !matchString(". . .") {
|
|
goto l1149
|
|
}
|
|
l1150:
|
|
do(95)
|
|
return true
|
|
l1149:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 230 Dash <- (EmDash / EnDash) */
|
|
func() bool {
|
|
if !p.rules[ruleEmDash]() {
|
|
goto l1154
|
|
}
|
|
goto l1153
|
|
l1154:
|
|
if !p.rules[ruleEnDash]() {
|
|
goto l1152
|
|
}
|
|
l1153:
|
|
return true
|
|
l1152:
|
|
return false
|
|
},
|
|
/* 231 EnDash <- ('-' &[0-9] { yy = p.mkElem(ENDASH) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('-') {
|
|
goto l1155
|
|
}
|
|
if !peekClass(0) {
|
|
goto l1155
|
|
}
|
|
do(96)
|
|
return true
|
|
l1155:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 232 EmDash <- (('---' / '--') { yy = p.mkElem(EMDASH) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("---") {
|
|
goto l1158
|
|
}
|
|
goto l1157
|
|
l1158:
|
|
if !matchString("--") {
|
|
goto l1156
|
|
}
|
|
l1157:
|
|
do(97)
|
|
return true
|
|
l1156:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 233 SingleQuoteStart <- ('\'' !((&[\n\r] Newline) | (&[\t ] Spacechar))) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('\'') {
|
|
goto l1159
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1160
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '\n', '\r':
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1160
|
|
}
|
|
break
|
|
case '\t', ' ':
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1160
|
|
}
|
|
break
|
|
default:
|
|
goto l1160
|
|
}
|
|
}
|
|
goto l1159
|
|
l1160:
|
|
return true
|
|
l1159:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 234 SingleQuoteEnd <- ('\'' !Alphanumeric) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchChar('\'') {
|
|
goto l1162
|
|
}
|
|
if !p.rules[ruleAlphanumeric]() {
|
|
goto l1163
|
|
}
|
|
goto l1162
|
|
l1163:
|
|
return true
|
|
l1162:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 235 SingleQuoted <- (SingleQuoteStart StartList (!SingleQuoteEnd Inline { a = cons(b, a) })+ SingleQuoteEnd { yy = p.mkList(SINGLEQUOTED, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleSingleQuoteStart]() {
|
|
goto l1164
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1164
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleSingleQuoteEnd]() {
|
|
goto l1167
|
|
}
|
|
goto l1164
|
|
l1167:
|
|
if !p.rules[ruleInline]() {
|
|
goto l1164
|
|
}
|
|
doarg(yySet, -2)
|
|
do(98)
|
|
l1165:
|
|
{
|
|
position1166, thunkPosition1166 := position, thunkPosition
|
|
if !p.rules[ruleSingleQuoteEnd]() {
|
|
goto l1168
|
|
}
|
|
goto l1166
|
|
l1168:
|
|
if !p.rules[ruleInline]() {
|
|
goto l1166
|
|
}
|
|
doarg(yySet, -2)
|
|
do(98)
|
|
goto l1165
|
|
l1166:
|
|
position, thunkPosition = position1166, thunkPosition1166
|
|
}
|
|
if !p.rules[ruleSingleQuoteEnd]() {
|
|
goto l1164
|
|
}
|
|
do(99)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l1164:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 236 DoubleQuoteStart <- '"' */
|
|
func() bool {
|
|
if !matchChar('"') {
|
|
goto l1169
|
|
}
|
|
return true
|
|
l1169:
|
|
return false
|
|
},
|
|
/* 237 DoubleQuoteEnd <- '"' */
|
|
func() bool {
|
|
if !matchChar('"') {
|
|
goto l1170
|
|
}
|
|
return true
|
|
l1170:
|
|
return false
|
|
},
|
|
/* 238 DoubleQuoted <- ('"' StartList (!'"' Inline { a = cons(b, a) })+ '"' { yy = p.mkList(DOUBLEQUOTED, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !matchChar('"') {
|
|
goto l1171
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1171
|
|
}
|
|
doarg(yySet, -2)
|
|
if peekChar('"') {
|
|
goto l1171
|
|
}
|
|
if !p.rules[ruleInline]() {
|
|
goto l1171
|
|
}
|
|
doarg(yySet, -1)
|
|
do(100)
|
|
l1172:
|
|
{
|
|
position1173, thunkPosition1173 := position, thunkPosition
|
|
if peekChar('"') {
|
|
goto l1173
|
|
}
|
|
if !p.rules[ruleInline]() {
|
|
goto l1173
|
|
}
|
|
doarg(yySet, -1)
|
|
do(100)
|
|
goto l1172
|
|
l1173:
|
|
position, thunkPosition = position1173, thunkPosition1173
|
|
}
|
|
if !matchChar('"') {
|
|
goto l1171
|
|
}
|
|
do(101)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l1171:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 239 NoteReference <- (&{p.extension.Notes} RawNoteReference {
|
|
if match, ok := p.find_note(ref.contents.str); ok {
|
|
yy = p.mkElem(NOTE)
|
|
yy.children = match.children
|
|
yy.contents.str = ""
|
|
} else {
|
|
yy = p.mkString("[^"+ref.contents.str+"]")
|
|
}
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !(p.extension.Notes) {
|
|
goto l1174
|
|
}
|
|
if !p.rules[ruleRawNoteReference]() {
|
|
goto l1174
|
|
}
|
|
doarg(yySet, -1)
|
|
do(102)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l1174:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 240 RawNoteReference <- ('[^' < (!Newline !']' .)+ > ']' { yy = p.mkString(yytext) }) */
|
|
func() bool {
|
|
position0 := position
|
|
if !matchString("[^") {
|
|
goto l1175
|
|
}
|
|
begin = position
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1178
|
|
}
|
|
goto l1175
|
|
l1178:
|
|
if peekChar(']') {
|
|
goto l1175
|
|
}
|
|
if !matchDot() {
|
|
goto l1175
|
|
}
|
|
l1176:
|
|
{
|
|
position1177 := position
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1179
|
|
}
|
|
goto l1177
|
|
l1179:
|
|
if peekChar(']') {
|
|
goto l1177
|
|
}
|
|
if !matchDot() {
|
|
goto l1177
|
|
}
|
|
goto l1176
|
|
l1177:
|
|
position = position1177
|
|
}
|
|
end = position
|
|
if !matchChar(']') {
|
|
goto l1175
|
|
}
|
|
do(103)
|
|
return true
|
|
l1175:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 241 Note <- (&{p.extension.Notes} NonindentSpace RawNoteReference ':' Sp StartList (RawNoteBlock { a = cons(yy, a) }) (&Indent RawNoteBlock { a = cons(yy, a) })* { yy = p.mkList(NOTE, a)
|
|
yy.contents.str = ref.contents.str
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !(p.extension.Notes) {
|
|
goto l1180
|
|
}
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l1180
|
|
}
|
|
if !p.rules[ruleRawNoteReference]() {
|
|
goto l1180
|
|
}
|
|
doarg(yySet, -2)
|
|
if !matchChar(':') {
|
|
goto l1180
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l1180
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1180
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleRawNoteBlock]() {
|
|
goto l1180
|
|
}
|
|
do(104)
|
|
l1181:
|
|
{
|
|
position1182, thunkPosition1182 := position, thunkPosition
|
|
{
|
|
position1183 := position
|
|
if !p.rules[ruleIndent]() {
|
|
goto l1182
|
|
}
|
|
position = position1183
|
|
}
|
|
if !p.rules[ruleRawNoteBlock]() {
|
|
goto l1182
|
|
}
|
|
do(105)
|
|
goto l1181
|
|
l1182:
|
|
position, thunkPosition = position1182, thunkPosition1182
|
|
}
|
|
do(106)
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l1180:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 242 InlineNote <- (&{p.extension.Notes} '^[' StartList (!']' Inline { a = cons(yy, a) })+ ']' { yy = p.mkList(NOTE, a)
|
|
yy.contents.str = "" }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !(p.extension.Notes) {
|
|
goto l1184
|
|
}
|
|
if !matchString("^[") {
|
|
goto l1184
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1184
|
|
}
|
|
doarg(yySet, -1)
|
|
if peekChar(']') {
|
|
goto l1184
|
|
}
|
|
if !p.rules[ruleInline]() {
|
|
goto l1184
|
|
}
|
|
do(107)
|
|
l1185:
|
|
{
|
|
position1186 := position
|
|
if peekChar(']') {
|
|
goto l1186
|
|
}
|
|
if !p.rules[ruleInline]() {
|
|
goto l1186
|
|
}
|
|
do(107)
|
|
goto l1185
|
|
l1186:
|
|
position = position1186
|
|
}
|
|
if !matchChar(']') {
|
|
goto l1184
|
|
}
|
|
do(108)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l1184:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 243 Notes <- (StartList ((Note { a = cons(b, a) }) / SkipBlock)* { p.notes = reverse(a) } commit) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 2)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1187
|
|
}
|
|
doarg(yySet, -2)
|
|
l1188:
|
|
{
|
|
position1189, thunkPosition1189 := position, thunkPosition
|
|
{
|
|
position1190, thunkPosition1190 := position, thunkPosition
|
|
if !p.rules[ruleNote]() {
|
|
goto l1191
|
|
}
|
|
doarg(yySet, -1)
|
|
do(109)
|
|
goto l1190
|
|
l1191:
|
|
position, thunkPosition = position1190, thunkPosition1190
|
|
if !p.rules[ruleSkipBlock]() {
|
|
goto l1189
|
|
}
|
|
}
|
|
l1190:
|
|
goto l1188
|
|
l1189:
|
|
position, thunkPosition = position1189, thunkPosition1189
|
|
}
|
|
do(110)
|
|
if !(commit(thunkPosition0)) {
|
|
goto l1187
|
|
}
|
|
doarg(yyPop, 2)
|
|
return true
|
|
l1187:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 244 RawNoteBlock <- (StartList (!BlankLine OptionallyIndentedLine { a = cons(yy, a) })+ (< BlankLine* > { a = cons(p.mkString(yytext), a) }) { yy = p.mkStringFromList(a, true)
|
|
yy.key = RAW
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1192
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1195
|
|
}
|
|
goto l1192
|
|
l1195:
|
|
if !p.rules[ruleOptionallyIndentedLine]() {
|
|
goto l1192
|
|
}
|
|
do(111)
|
|
l1193:
|
|
{
|
|
position1194 := position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1196
|
|
}
|
|
goto l1194
|
|
l1196:
|
|
if !p.rules[ruleOptionallyIndentedLine]() {
|
|
goto l1194
|
|
}
|
|
do(111)
|
|
goto l1193
|
|
l1194:
|
|
position = position1194
|
|
}
|
|
begin = position
|
|
l1197:
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1198
|
|
}
|
|
goto l1197
|
|
l1198:
|
|
end = position
|
|
do(112)
|
|
do(113)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l1192:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 245 DefinitionList <- (&{p.extension.Dlists} StartList (Definition { a = cons(yy, a) })+ { yy = p.mkList(DEFINITIONLIST, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !(p.extension.Dlists) {
|
|
goto l1199
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1199
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleDefinition]() {
|
|
goto l1199
|
|
}
|
|
do(114)
|
|
l1200:
|
|
{
|
|
position1201, thunkPosition1201 := position, thunkPosition
|
|
if !p.rules[ruleDefinition]() {
|
|
goto l1201
|
|
}
|
|
do(114)
|
|
goto l1200
|
|
l1201:
|
|
position, thunkPosition = position1201, thunkPosition1201
|
|
}
|
|
do(115)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l1199:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 246 Definition <- (&(NonindentSpace !Defmark Nonspacechar RawLine BlankLine? Defmark) StartList (DListTitle { a = cons(yy, a) })+ (DefTight / DefLoose) {
|
|
for e := yy.children; e != nil; e = e.next {
|
|
e.key = DEFDATA
|
|
}
|
|
a = cons(yy, a)
|
|
} { yy = p.mkList(LIST, a) }) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
{
|
|
position1203 := position
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l1202
|
|
}
|
|
if !p.rules[ruleDefmark]() {
|
|
goto l1204
|
|
}
|
|
goto l1202
|
|
l1204:
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1202
|
|
}
|
|
if !p.rules[ruleRawLine]() {
|
|
goto l1202
|
|
}
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1205
|
|
}
|
|
l1205:
|
|
if !p.rules[ruleDefmark]() {
|
|
goto l1202
|
|
}
|
|
position = position1203
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1202
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleDListTitle]() {
|
|
goto l1202
|
|
}
|
|
do(116)
|
|
l1207:
|
|
{
|
|
position1208, thunkPosition1208 := position, thunkPosition
|
|
if !p.rules[ruleDListTitle]() {
|
|
goto l1208
|
|
}
|
|
do(116)
|
|
goto l1207
|
|
l1208:
|
|
position, thunkPosition = position1208, thunkPosition1208
|
|
}
|
|
if !p.rules[ruleDefTight]() {
|
|
goto l1210
|
|
}
|
|
goto l1209
|
|
l1210:
|
|
if !p.rules[ruleDefLoose]() {
|
|
goto l1202
|
|
}
|
|
l1209:
|
|
do(117)
|
|
do(118)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l1202:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 247 DListTitle <- (NonindentSpace !Defmark &Nonspacechar StartList (!Endline Inline { a = cons(yy, a) })+ Sp Newline { yy = p.mkList(LIST, a)
|
|
yy.key = DEFTITLE
|
|
}) */
|
|
func() bool {
|
|
position0, thunkPosition0 := position, thunkPosition
|
|
doarg(yyPush, 1)
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l1211
|
|
}
|
|
if !p.rules[ruleDefmark]() {
|
|
goto l1212
|
|
}
|
|
goto l1211
|
|
l1212:
|
|
{
|
|
position1213 := position
|
|
if !p.rules[ruleNonspacechar]() {
|
|
goto l1211
|
|
}
|
|
position = position1213
|
|
}
|
|
if !p.rules[ruleStartList]() {
|
|
goto l1211
|
|
}
|
|
doarg(yySet, -1)
|
|
if !p.rules[ruleEndline]() {
|
|
goto l1216
|
|
}
|
|
goto l1211
|
|
l1216:
|
|
if !p.rules[ruleInline]() {
|
|
goto l1211
|
|
}
|
|
do(119)
|
|
l1214:
|
|
{
|
|
position1215 := position
|
|
if !p.rules[ruleEndline]() {
|
|
goto l1217
|
|
}
|
|
goto l1215
|
|
l1217:
|
|
if !p.rules[ruleInline]() {
|
|
goto l1215
|
|
}
|
|
do(119)
|
|
goto l1214
|
|
l1215:
|
|
position = position1215
|
|
}
|
|
if !p.rules[ruleSp]() {
|
|
goto l1211
|
|
}
|
|
if !p.rules[ruleNewline]() {
|
|
goto l1211
|
|
}
|
|
do(120)
|
|
doarg(yyPop, 1)
|
|
return true
|
|
l1211:
|
|
position, thunkPosition = position0, thunkPosition0
|
|
return false
|
|
},
|
|
/* 248 DefTight <- (&Defmark ListTight) */
|
|
func() bool {
|
|
{
|
|
position1219 := position
|
|
if !p.rules[ruleDefmark]() {
|
|
goto l1218
|
|
}
|
|
position = position1219
|
|
}
|
|
if !p.rules[ruleListTight]() {
|
|
goto l1218
|
|
}
|
|
return true
|
|
l1218:
|
|
return false
|
|
},
|
|
/* 249 DefLoose <- (BlankLine &Defmark ListLoose) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleBlankLine]() {
|
|
goto l1220
|
|
}
|
|
{
|
|
position1221 := position
|
|
if !p.rules[ruleDefmark]() {
|
|
goto l1220
|
|
}
|
|
position = position1221
|
|
}
|
|
if !p.rules[ruleListLoose]() {
|
|
goto l1220
|
|
}
|
|
return true
|
|
l1220:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 250 Defmark <- (NonindentSpace ((&[~] '~') | (&[:] ':')) Spacechar+) */
|
|
func() bool {
|
|
position0 := position
|
|
if !p.rules[ruleNonindentSpace]() {
|
|
goto l1222
|
|
}
|
|
{
|
|
if position == len(p.Buffer) {
|
|
goto l1222
|
|
}
|
|
switch p.Buffer[position] {
|
|
case '~':
|
|
position++ // matchChar
|
|
break
|
|
case ':':
|
|
position++ // matchChar
|
|
break
|
|
default:
|
|
goto l1222
|
|
}
|
|
}
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1222
|
|
}
|
|
l1224:
|
|
if !p.rules[ruleSpacechar]() {
|
|
goto l1225
|
|
}
|
|
goto l1224
|
|
l1225:
|
|
return true
|
|
l1222:
|
|
position = position0
|
|
return false
|
|
},
|
|
/* 251 DefMarker <- (&{p.extension.Dlists} Defmark) */
|
|
func() bool {
|
|
if !(p.extension.Dlists) {
|
|
goto l1226
|
|
}
|
|
if !p.rules[ruleDefmark]() {
|
|
goto l1226
|
|
}
|
|
return true
|
|
l1226:
|
|
return false
|
|
},
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* List manipulation functions
|
|
*/
|
|
|
|
|
|
/* cons - cons an element onto a list, returning pointer to new head
|
|
*/
|
|
func cons(new, list *element) *element {
|
|
new.next = list
|
|
return new
|
|
}
|
|
|
|
/* reverse - reverse a list, returning pointer to new list
|
|
*/
|
|
func reverse(list *element) (new *element) {
|
|
for list != nil {
|
|
next := list.next
|
|
new = cons(list, new)
|
|
list = next
|
|
}
|
|
return
|
|
}
|
|
|
|
|
|
/*
|
|
* Auxiliary functions for parsing actions.
|
|
* These make it easier to build up data structures (including lists)
|
|
* in the parsing actions.
|
|
*/
|
|
|
|
|
|
/* p.mkElem - generic constructor for element
|
|
*/
|
|
func (p *yyParser) mkElem(key int) *element {
|
|
r := p.state.heap.row
|
|
if len(r) == 0 {
|
|
r = p.state.heap.nextRow()
|
|
}
|
|
e := &r[0]
|
|
*e = element{}
|
|
p.state.heap.row = r[1:]
|
|
e.key = key
|
|
return e
|
|
}
|
|
|
|
/* p.mkString - constructor for STR element
|
|
*/
|
|
func (p *yyParser) mkString(s string) (result *element) {
|
|
result = p.mkElem(STR)
|
|
result.contents.str = s
|
|
return
|
|
}
|
|
|
|
/* p.mkStringFromList - makes STR element by concatenating a
|
|
* reversed list of strings, adding optional extra newline
|
|
*/
|
|
func (p *yyParser) mkStringFromList(list *element, extra_newline bool) (result *element) {
|
|
s := ""
|
|
for list = reverse(list); list != nil; list = list.next {
|
|
s += list.contents.str
|
|
}
|
|
|
|
if extra_newline {
|
|
s += "\n"
|
|
}
|
|
result = p.mkElem(STR)
|
|
result.contents.str = s
|
|
return
|
|
}
|
|
|
|
/* p.mkList - makes new list with key 'key' and children the reverse of 'lst'.
|
|
* This is designed to be used with cons to build lists in a parser action.
|
|
* The reversing is necessary because cons adds to the head of a list.
|
|
*/
|
|
func (p *yyParser) mkList(key int, lst *element) (el *element) {
|
|
el = p.mkElem(key)
|
|
el.children = reverse(lst)
|
|
return
|
|
}
|
|
|
|
/* p.mkLink - constructor for LINK element
|
|
*/
|
|
func (p *yyParser) mkLink(label *element, url, title string) (el *element) {
|
|
el = p.mkElem(LINK)
|
|
el.contents.link = &link{label: label, url: url, title: title}
|
|
return
|
|
}
|
|
|
|
|
|
/* match_inlines - returns true if inline lists match (case-insensitive...)
|
|
*/
|
|
func match_inlines(l1, l2 *element) bool {
|
|
for l1 != nil && l2 != nil {
|
|
if l1.key != l2.key {
|
|
return false
|
|
}
|
|
switch l1.key {
|
|
case SPACE, LINEBREAK, ELLIPSIS, EMDASH, ENDASH, APOSTROPHE:
|
|
break
|
|
case CODE, STR, HTML:
|
|
if strings.ToUpper(l1.contents.str) != strings.ToUpper(l2.contents.str) {
|
|
return false
|
|
}
|
|
case EMPH, STRONG, LIST, SINGLEQUOTED, DOUBLEQUOTED:
|
|
if !match_inlines(l1.children, l2.children) {
|
|
return false
|
|
}
|
|
case LINK, IMAGE:
|
|
return false /* No links or images within links */
|
|
default:
|
|
log.Fatalf("match_inlines encountered unknown key = %d\n", l1.key)
|
|
}
|
|
l1 = l1.next
|
|
l2 = l2.next
|
|
}
|
|
return l1 == nil && l2 == nil /* return true if both lists exhausted */
|
|
}
|
|
|
|
|
|
/* find_reference - return true if link found in references matching label.
|
|
* 'link' is modified with the matching url and title.
|
|
*/
|
|
func (p *yyParser) findReference(label *element) (*link, bool) {
|
|
for cur := p.references; cur != nil; cur = cur.next {
|
|
l := cur.contents.link
|
|
if match_inlines(label, l.label) {
|
|
return l, true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
|
|
/* find_note - return true if note found in notes matching label.
|
|
* if found, 'result' is set to point to matched note.
|
|
*/
|
|
func (p *yyParser) find_note(label string) (*element, bool) {
|
|
for el := p.notes; el != nil; el = el.next {
|
|
if label == el.contents.str {
|
|
return el, true
|
|
}
|
|
}
|
|
return nil, false
|
|
}
|
|
|
|
|
|
/* print tree of elements, for debugging only.
|
|
*/
|
|
func print_tree(w io.Writer, elt *element, indent int) {
|
|
var key string
|
|
|
|
for elt != nil {
|
|
for i := 0; i < indent; i++ {
|
|
fmt.Fprint(w, "\t")
|
|
}
|
|
key = keynames[elt.key]
|
|
if key == "" {
|
|
key = "?"
|
|
}
|
|
if elt.key == STR {
|
|
fmt.Fprintf(w, "%p:\t%s\t'%s'\n", elt, key, elt.contents.str)
|
|
} else {
|
|
fmt.Fprintf(w, "%p:\t%s %p\n", elt, key, elt.next)
|
|
}
|
|
if elt.children != nil {
|
|
print_tree(w, elt.children, indent+1)
|
|
}
|
|
elt = elt.next
|
|
}
|
|
}
|
|
|
|
var keynames = [numVAL]string{
|
|
LIST: "LIST",
|
|
RAW: "RAW",
|
|
SPACE: "SPACE",
|
|
LINEBREAK: "LINEBREAK",
|
|
ELLIPSIS: "ELLIPSIS",
|
|
EMDASH: "EMDASH",
|
|
ENDASH: "ENDASH",
|
|
APOSTROPHE: "APOSTROPHE",
|
|
SINGLEQUOTED: "SINGLEQUOTED",
|
|
DOUBLEQUOTED: "DOUBLEQUOTED",
|
|
STR: "STR",
|
|
LINK: "LINK",
|
|
IMAGE: "IMAGE",
|
|
CODE: "CODE",
|
|
HTML: "HTML",
|
|
EMPH: "EMPH",
|
|
STRONG: "STRONG",
|
|
PLAIN: "PLAIN",
|
|
PARA: "PARA",
|
|
LISTITEM: "LISTITEM",
|
|
BULLETLIST: "BULLETLIST",
|
|
ORDEREDLIST: "ORDEREDLIST",
|
|
H1: "H1",
|
|
H2: "H2",
|
|
H3: "H3",
|
|
H4: "H4",
|
|
H5: "H5",
|
|
H6: "H6",
|
|
BLOCKQUOTE: "BLOCKQUOTE",
|
|
VERBATIM: "VERBATIM",
|
|
HTMLBLOCK: "HTMLBLOCK",
|
|
HRULE: "HRULE",
|
|
REFERENCE: "REFERENCE",
|
|
NOTE: "NOTE",
|
|
DEFINITIONLIST: "DEFINITIONLIST",
|
|
DEFTITLE: "DEFTITLE",
|
|
DEFDATA: "DEFDATA",
|
|
}
|