790 lines
14 KiB
Go
790 lines
14 KiB
Go
|
package h
|
||
|
|
||
|
import (
|
||
|
"github.com/eaburns/peggy/peg"
|
||
|
)
|
||
|
|
||
|
type _Parser struct {
|
||
|
text string
|
||
|
deltaPos []_Rules
|
||
|
deltaErr []_Rules
|
||
|
node map[_key]*peg.Node
|
||
|
fail map[_key]*peg.Fail
|
||
|
lastFail int
|
||
|
data interface{}
|
||
|
}
|
||
|
|
||
|
type _key struct {
|
||
|
start int
|
||
|
name string
|
||
|
}
|
||
|
|
||
|
func _NewParser(text string) *_Parser {
|
||
|
return &_Parser{
|
||
|
text: text,
|
||
|
deltaPos: make([]_Rules, len(text)+1),
|
||
|
deltaErr: make([]_Rules, len(text)+1),
|
||
|
node: make(map[_key]*peg.Node),
|
||
|
fail: make(map[_key]*peg.Fail),
|
||
|
}
|
||
|
}
|
||
|
|
||
|
type _Rules struct {
|
||
|
sep int32
|
||
|
space int32
|
||
|
h int32
|
||
|
H int32
|
||
|
}
|
||
|
|
||
|
func _max(a, b int) int {
|
||
|
if a > b {
|
||
|
return a
|
||
|
}
|
||
|
return b
|
||
|
}
|
||
|
|
||
|
func _next(parser *_Parser, pos int) (rune, int) {
|
||
|
r, w := peg.DecodeRuneInString(parser.text[pos:])
|
||
|
return r, w
|
||
|
}
|
||
|
|
||
|
func _node(name string) *peg.Node {
|
||
|
return &peg.Node{Name: name}
|
||
|
}
|
||
|
|
||
|
func _sub(parser *_Parser, start, end int, kids []*peg.Node) *peg.Node {
|
||
|
node := &peg.Node{
|
||
|
Text: parser.text[start:end],
|
||
|
Kids: make([]*peg.Node, len(kids)),
|
||
|
}
|
||
|
copy(node.Kids, kids)
|
||
|
return node
|
||
|
}
|
||
|
|
||
|
func _leaf(parser *_Parser, start, end int) *peg.Node {
|
||
|
return &peg.Node{Text: parser.text[start:end]}
|
||
|
}
|
||
|
|
||
|
func _sepAccepts(parser *_Parser, start int) (deltaPos, deltaErr int) {
|
||
|
if dp := parser.deltaPos[start].sep; dp != 0 {
|
||
|
de := parser.deltaErr[start].sep - 1
|
||
|
if dp > 0 {
|
||
|
dp--
|
||
|
}
|
||
|
return int(dp), int(de)
|
||
|
}
|
||
|
pos, perr := start, -1
|
||
|
// space+ h
|
||
|
// space+
|
||
|
// space
|
||
|
if dp, de := _spaceAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
for {
|
||
|
pos1 := pos
|
||
|
// space
|
||
|
if dp, de := _spaceAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail2
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
continue
|
||
|
fail2:
|
||
|
pos = pos1
|
||
|
break
|
||
|
}
|
||
|
// h
|
||
|
if dp, de := _hAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
parser.deltaPos[start].sep = int32(pos-start) + 1
|
||
|
parser.deltaErr[start].sep = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return pos - start, perr - start
|
||
|
fail:
|
||
|
parser.deltaPos[start].sep = -1
|
||
|
parser.deltaErr[start].sep = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return -1, perr - start
|
||
|
}
|
||
|
|
||
|
func _sepNode(parser *_Parser, start int) (int, *peg.Node) {
|
||
|
dp := parser.deltaPos[start].sep
|
||
|
if dp < 0 {
|
||
|
return -1, nil
|
||
|
}
|
||
|
key := _key{start: start, name: "sep"}
|
||
|
node := parser.node[key]
|
||
|
if node != nil {
|
||
|
return start + int(dp-1), node
|
||
|
}
|
||
|
pos := start
|
||
|
node = _node("sep")
|
||
|
// space+ h
|
||
|
// space+
|
||
|
// space
|
||
|
if p, kid := _spaceNode(parser, pos); kid == nil {
|
||
|
goto fail
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
for {
|
||
|
nkids0 := len(node.Kids)
|
||
|
pos1 := pos
|
||
|
// space
|
||
|
if p, kid := _spaceNode(parser, pos); kid == nil {
|
||
|
goto fail2
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
continue
|
||
|
fail2:
|
||
|
node.Kids = node.Kids[:nkids0]
|
||
|
pos = pos1
|
||
|
break
|
||
|
}
|
||
|
// h
|
||
|
if p, kid := _hNode(parser, pos); kid == nil {
|
||
|
goto fail
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
node.Text = parser.text[start:pos]
|
||
|
parser.node[key] = node
|
||
|
return pos, node
|
||
|
fail:
|
||
|
return -1, nil
|
||
|
}
|
||
|
|
||
|
func _sepFail(parser *_Parser, start, errPos int) (int, *peg.Fail) {
|
||
|
if start > parser.lastFail {
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
dp := parser.deltaPos[start].sep
|
||
|
de := parser.deltaErr[start].sep
|
||
|
if start+int(de-1) < errPos {
|
||
|
if dp > 0 {
|
||
|
return start + int(dp-1), &peg.Fail{}
|
||
|
}
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
key := _key{start: start, name: "sep"}
|
||
|
failure := parser.fail[key]
|
||
|
if dp < 0 && failure != nil {
|
||
|
return -1, failure
|
||
|
}
|
||
|
if dp > 0 && failure != nil {
|
||
|
return start + int(dp-1), failure
|
||
|
}
|
||
|
pos := start
|
||
|
failure = &peg.Fail{
|
||
|
Name: "sep",
|
||
|
Pos: int(start),
|
||
|
}
|
||
|
// space+ h
|
||
|
// space+
|
||
|
// space
|
||
|
{
|
||
|
p, kid := _spaceFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
for {
|
||
|
pos1 := pos
|
||
|
// space
|
||
|
{
|
||
|
p, kid := _spaceFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail2
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
continue
|
||
|
fail2:
|
||
|
pos = pos1
|
||
|
break
|
||
|
}
|
||
|
// h
|
||
|
{
|
||
|
p, kid := _hFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
parser.fail[key] = failure
|
||
|
return pos, failure
|
||
|
fail:
|
||
|
parser.fail[key] = failure
|
||
|
return -1, failure
|
||
|
}
|
||
|
|
||
|
func _spaceAccepts(parser *_Parser, start int) (deltaPos, deltaErr int) {
|
||
|
if dp := parser.deltaPos[start].space; dp != 0 {
|
||
|
de := parser.deltaErr[start].space - 1
|
||
|
if dp > 0 {
|
||
|
dp--
|
||
|
}
|
||
|
return int(dp), int(de)
|
||
|
}
|
||
|
pos, perr := start, -1
|
||
|
// " "
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != " " {
|
||
|
perr = _max(perr, pos)
|
||
|
goto fail
|
||
|
}
|
||
|
pos++
|
||
|
parser.deltaPos[start].space = int32(pos-start) + 1
|
||
|
parser.deltaErr[start].space = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return pos - start, perr - start
|
||
|
fail:
|
||
|
parser.deltaPos[start].space = -1
|
||
|
parser.deltaErr[start].space = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return -1, perr - start
|
||
|
}
|
||
|
|
||
|
func _spaceNode(parser *_Parser, start int) (int, *peg.Node) {
|
||
|
dp := parser.deltaPos[start].space
|
||
|
if dp < 0 {
|
||
|
return -1, nil
|
||
|
}
|
||
|
key := _key{start: start, name: "space"}
|
||
|
node := parser.node[key]
|
||
|
if node != nil {
|
||
|
return start + int(dp-1), node
|
||
|
}
|
||
|
pos := start
|
||
|
node = _node("space")
|
||
|
// " "
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != " " {
|
||
|
goto fail
|
||
|
}
|
||
|
node.Kids = append(node.Kids, _leaf(parser, pos, pos+1))
|
||
|
pos++
|
||
|
node.Text = parser.text[start:pos]
|
||
|
parser.node[key] = node
|
||
|
return pos, node
|
||
|
fail:
|
||
|
return -1, nil
|
||
|
}
|
||
|
|
||
|
func _spaceFail(parser *_Parser, start, errPos int) (int, *peg.Fail) {
|
||
|
if start > parser.lastFail {
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
dp := parser.deltaPos[start].space
|
||
|
de := parser.deltaErr[start].space
|
||
|
if start+int(de-1) < errPos {
|
||
|
if dp > 0 {
|
||
|
return start + int(dp-1), &peg.Fail{}
|
||
|
}
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
key := _key{start: start, name: "space"}
|
||
|
failure := parser.fail[key]
|
||
|
if dp < 0 && failure != nil {
|
||
|
return -1, failure
|
||
|
}
|
||
|
if dp > 0 && failure != nil {
|
||
|
return start + int(dp-1), failure
|
||
|
}
|
||
|
pos := start
|
||
|
failure = &peg.Fail{
|
||
|
Name: "space",
|
||
|
Pos: int(start),
|
||
|
}
|
||
|
// " "
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != " " {
|
||
|
if pos >= errPos {
|
||
|
failure.Kids = append(failure.Kids, &peg.Fail{
|
||
|
Pos: int(pos),
|
||
|
Want: "\" \"",
|
||
|
})
|
||
|
}
|
||
|
goto fail
|
||
|
}
|
||
|
pos++
|
||
|
parser.fail[key] = failure
|
||
|
return pos, failure
|
||
|
fail:
|
||
|
parser.fail[key] = failure
|
||
|
return -1, failure
|
||
|
}
|
||
|
|
||
|
func _hAccepts(parser *_Parser, start int) (deltaPos, deltaErr int) {
|
||
|
if dp := parser.deltaPos[start].h; dp != 0 {
|
||
|
de := parser.deltaErr[start].h - 1
|
||
|
if dp > 0 {
|
||
|
dp--
|
||
|
}
|
||
|
return int(dp), int(de)
|
||
|
}
|
||
|
pos, perr := start, -1
|
||
|
// "h"/"'"
|
||
|
{
|
||
|
pos2 := pos
|
||
|
// "h"
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != "h" {
|
||
|
perr = _max(perr, pos)
|
||
|
goto fail3
|
||
|
}
|
||
|
pos++
|
||
|
goto ok0
|
||
|
fail3:
|
||
|
pos = pos2
|
||
|
// "'"
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != "'" {
|
||
|
perr = _max(perr, pos)
|
||
|
goto fail4
|
||
|
}
|
||
|
pos++
|
||
|
goto ok0
|
||
|
fail4:
|
||
|
pos = pos2
|
||
|
goto fail
|
||
|
ok0:
|
||
|
}
|
||
|
parser.deltaPos[start].h = int32(pos-start) + 1
|
||
|
parser.deltaErr[start].h = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return pos - start, perr - start
|
||
|
fail:
|
||
|
parser.deltaPos[start].h = -1
|
||
|
parser.deltaErr[start].h = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return -1, perr - start
|
||
|
}
|
||
|
|
||
|
func _hNode(parser *_Parser, start int) (int, *peg.Node) {
|
||
|
dp := parser.deltaPos[start].h
|
||
|
if dp < 0 {
|
||
|
return -1, nil
|
||
|
}
|
||
|
key := _key{start: start, name: "h"}
|
||
|
node := parser.node[key]
|
||
|
if node != nil {
|
||
|
return start + int(dp-1), node
|
||
|
}
|
||
|
pos := start
|
||
|
node = _node("h")
|
||
|
// "h"/"'"
|
||
|
{
|
||
|
pos2 := pos
|
||
|
nkids1 := len(node.Kids)
|
||
|
// "h"
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != "h" {
|
||
|
goto fail3
|
||
|
}
|
||
|
node.Kids = append(node.Kids, _leaf(parser, pos, pos+1))
|
||
|
pos++
|
||
|
goto ok0
|
||
|
fail3:
|
||
|
node.Kids = node.Kids[:nkids1]
|
||
|
pos = pos2
|
||
|
// "'"
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != "'" {
|
||
|
goto fail4
|
||
|
}
|
||
|
node.Kids = append(node.Kids, _leaf(parser, pos, pos+1))
|
||
|
pos++
|
||
|
goto ok0
|
||
|
fail4:
|
||
|
node.Kids = node.Kids[:nkids1]
|
||
|
pos = pos2
|
||
|
goto fail
|
||
|
ok0:
|
||
|
}
|
||
|
node.Text = parser.text[start:pos]
|
||
|
parser.node[key] = node
|
||
|
return pos, node
|
||
|
fail:
|
||
|
return -1, nil
|
||
|
}
|
||
|
|
||
|
func _hFail(parser *_Parser, start, errPos int) (int, *peg.Fail) {
|
||
|
if start > parser.lastFail {
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
dp := parser.deltaPos[start].h
|
||
|
de := parser.deltaErr[start].h
|
||
|
if start+int(de-1) < errPos {
|
||
|
if dp > 0 {
|
||
|
return start + int(dp-1), &peg.Fail{}
|
||
|
}
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
key := _key{start: start, name: "h"}
|
||
|
failure := parser.fail[key]
|
||
|
if dp < 0 && failure != nil {
|
||
|
return -1, failure
|
||
|
}
|
||
|
if dp > 0 && failure != nil {
|
||
|
return start + int(dp-1), failure
|
||
|
}
|
||
|
pos := start
|
||
|
failure = &peg.Fail{
|
||
|
Name: "h",
|
||
|
Pos: int(start),
|
||
|
}
|
||
|
// "h"/"'"
|
||
|
{
|
||
|
pos2 := pos
|
||
|
// "h"
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != "h" {
|
||
|
if pos >= errPos {
|
||
|
failure.Kids = append(failure.Kids, &peg.Fail{
|
||
|
Pos: int(pos),
|
||
|
Want: "\"h\"",
|
||
|
})
|
||
|
}
|
||
|
goto fail3
|
||
|
}
|
||
|
pos++
|
||
|
goto ok0
|
||
|
fail3:
|
||
|
pos = pos2
|
||
|
// "'"
|
||
|
if len(parser.text[pos:]) < 1 || parser.text[pos:pos+1] != "'" {
|
||
|
if pos >= errPos {
|
||
|
failure.Kids = append(failure.Kids, &peg.Fail{
|
||
|
Pos: int(pos),
|
||
|
Want: "\"'\"",
|
||
|
})
|
||
|
}
|
||
|
goto fail4
|
||
|
}
|
||
|
pos++
|
||
|
goto ok0
|
||
|
fail4:
|
||
|
pos = pos2
|
||
|
goto fail
|
||
|
ok0:
|
||
|
}
|
||
|
parser.fail[key] = failure
|
||
|
return pos, failure
|
||
|
fail:
|
||
|
parser.fail[key] = failure
|
||
|
return -1, failure
|
||
|
}
|
||
|
|
||
|
func _HAccepts(parser *_Parser, start int) (deltaPos, deltaErr int) {
|
||
|
if dp := parser.deltaPos[start].H; dp != 0 {
|
||
|
de := parser.deltaErr[start].H - 1
|
||
|
if dp > 0 {
|
||
|
dp--
|
||
|
}
|
||
|
return int(dp), int(de)
|
||
|
}
|
||
|
pos, perr := start, -1
|
||
|
// h+ sep+/h
|
||
|
{
|
||
|
pos2 := pos
|
||
|
// h+ sep+
|
||
|
// h+
|
||
|
// h
|
||
|
if dp, de := _hAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail3
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
for {
|
||
|
pos5 := pos
|
||
|
// h
|
||
|
if dp, de := _hAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail6
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
continue
|
||
|
fail6:
|
||
|
pos = pos5
|
||
|
break
|
||
|
}
|
||
|
// sep+
|
||
|
// sep
|
||
|
if dp, de := _sepAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail3
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
for {
|
||
|
pos8 := pos
|
||
|
// sep
|
||
|
if dp, de := _sepAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail9
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
continue
|
||
|
fail9:
|
||
|
pos = pos8
|
||
|
break
|
||
|
}
|
||
|
goto ok0
|
||
|
fail3:
|
||
|
pos = pos2
|
||
|
// h
|
||
|
if dp, de := _hAccepts(parser, pos); dp < 0 {
|
||
|
perr = _max(perr, pos+de)
|
||
|
goto fail10
|
||
|
} else {
|
||
|
perr = _max(perr, pos+de)
|
||
|
pos += dp
|
||
|
}
|
||
|
goto ok0
|
||
|
fail10:
|
||
|
pos = pos2
|
||
|
goto fail
|
||
|
ok0:
|
||
|
}
|
||
|
parser.deltaPos[start].H = int32(pos-start) + 1
|
||
|
parser.deltaErr[start].H = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return pos - start, perr - start
|
||
|
fail:
|
||
|
parser.deltaPos[start].H = -1
|
||
|
parser.deltaErr[start].H = int32(perr-start) + 1
|
||
|
parser.lastFail = perr
|
||
|
return -1, perr - start
|
||
|
}
|
||
|
|
||
|
func _HNode(parser *_Parser, start int) (int, *peg.Node) {
|
||
|
dp := parser.deltaPos[start].H
|
||
|
if dp < 0 {
|
||
|
return -1, nil
|
||
|
}
|
||
|
key := _key{start: start, name: "H"}
|
||
|
node := parser.node[key]
|
||
|
if node != nil {
|
||
|
return start + int(dp-1), node
|
||
|
}
|
||
|
pos := start
|
||
|
node = _node("H")
|
||
|
// h+ sep+/h
|
||
|
{
|
||
|
pos2 := pos
|
||
|
nkids1 := len(node.Kids)
|
||
|
// h+ sep+
|
||
|
// h+
|
||
|
// h
|
||
|
if p, kid := _hNode(parser, pos); kid == nil {
|
||
|
goto fail3
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
for {
|
||
|
nkids4 := len(node.Kids)
|
||
|
pos5 := pos
|
||
|
// h
|
||
|
if p, kid := _hNode(parser, pos); kid == nil {
|
||
|
goto fail6
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
continue
|
||
|
fail6:
|
||
|
node.Kids = node.Kids[:nkids4]
|
||
|
pos = pos5
|
||
|
break
|
||
|
}
|
||
|
// sep+
|
||
|
// sep
|
||
|
if p, kid := _sepNode(parser, pos); kid == nil {
|
||
|
goto fail3
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
for {
|
||
|
nkids7 := len(node.Kids)
|
||
|
pos8 := pos
|
||
|
// sep
|
||
|
if p, kid := _sepNode(parser, pos); kid == nil {
|
||
|
goto fail9
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
continue
|
||
|
fail9:
|
||
|
node.Kids = node.Kids[:nkids7]
|
||
|
pos = pos8
|
||
|
break
|
||
|
}
|
||
|
goto ok0
|
||
|
fail3:
|
||
|
node.Kids = node.Kids[:nkids1]
|
||
|
pos = pos2
|
||
|
// h
|
||
|
if p, kid := _hNode(parser, pos); kid == nil {
|
||
|
goto fail10
|
||
|
} else {
|
||
|
node.Kids = append(node.Kids, kid)
|
||
|
pos = p
|
||
|
}
|
||
|
goto ok0
|
||
|
fail10:
|
||
|
node.Kids = node.Kids[:nkids1]
|
||
|
pos = pos2
|
||
|
goto fail
|
||
|
ok0:
|
||
|
}
|
||
|
node.Text = parser.text[start:pos]
|
||
|
parser.node[key] = node
|
||
|
return pos, node
|
||
|
fail:
|
||
|
return -1, nil
|
||
|
}
|
||
|
|
||
|
func _HFail(parser *_Parser, start, errPos int) (int, *peg.Fail) {
|
||
|
if start > parser.lastFail {
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
dp := parser.deltaPos[start].H
|
||
|
de := parser.deltaErr[start].H
|
||
|
if start+int(de-1) < errPos {
|
||
|
if dp > 0 {
|
||
|
return start + int(dp-1), &peg.Fail{}
|
||
|
}
|
||
|
return -1, &peg.Fail{}
|
||
|
}
|
||
|
key := _key{start: start, name: "H"}
|
||
|
failure := parser.fail[key]
|
||
|
if dp < 0 && failure != nil {
|
||
|
return -1, failure
|
||
|
}
|
||
|
if dp > 0 && failure != nil {
|
||
|
return start + int(dp-1), failure
|
||
|
}
|
||
|
pos := start
|
||
|
failure = &peg.Fail{
|
||
|
Name: "H",
|
||
|
Pos: int(start),
|
||
|
}
|
||
|
// h+ sep+/h
|
||
|
{
|
||
|
pos2 := pos
|
||
|
// h+ sep+
|
||
|
// h+
|
||
|
// h
|
||
|
{
|
||
|
p, kid := _hFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail3
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
for {
|
||
|
pos5 := pos
|
||
|
// h
|
||
|
{
|
||
|
p, kid := _hFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail6
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
continue
|
||
|
fail6:
|
||
|
pos = pos5
|
||
|
break
|
||
|
}
|
||
|
// sep+
|
||
|
// sep
|
||
|
{
|
||
|
p, kid := _sepFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail3
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
for {
|
||
|
pos8 := pos
|
||
|
// sep
|
||
|
{
|
||
|
p, kid := _sepFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail9
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
continue
|
||
|
fail9:
|
||
|
pos = pos8
|
||
|
break
|
||
|
}
|
||
|
goto ok0
|
||
|
fail3:
|
||
|
pos = pos2
|
||
|
// h
|
||
|
{
|
||
|
p, kid := _hFail(parser, pos, errPos)
|
||
|
if kid.Want != "" || len(kid.Kids) > 0 {
|
||
|
failure.Kids = append(failure.Kids, kid)
|
||
|
}
|
||
|
if p < 0 {
|
||
|
goto fail10
|
||
|
}
|
||
|
pos = p
|
||
|
}
|
||
|
goto ok0
|
||
|
fail10:
|
||
|
pos = pos2
|
||
|
goto fail
|
||
|
ok0:
|
||
|
}
|
||
|
parser.fail[key] = failure
|
||
|
return pos, failure
|
||
|
fail:
|
||
|
parser.fail[key] = failure
|
||
|
return -1, failure
|
||
|
}
|