func (lp *LanguageParser) Parse() (*parser.Node, error) {
sdata := string(lp.data)
rn := parser.Node{P: lp, Name: lp.l.ScopeName}
defer func() {
if r := recover(); r != nil {
log.Printf("Panic during parse: %v\n", r)
log.Printf("%v", rn)
}
}()
iter := maxiter
for i := 0; i < len(sdata) && iter > 0; iter-- {
pat, ret := lp.l.RootPattern.Cache(sdata, i)
nl := strings.IndexAny(sdata[i:], "\n\r")
if nl != -1 {
nl += i
}
if ret == nil {
break
} else if nl > 0 && nl <= ret[0] {
i = nl
for i < len(sdata) && (sdata[i] == '\n' || sdata[i] == '\r') {
i++
}
} else {
n := pat.CreateNode(sdata, i, lp, ret)
rn.Append(n)
i = n.Range.B
}
}
rn.UpdateRange()
if len(sdata) != 0 {
lut := make([]int, len(sdata)+1)
j := 0
for i := range sdata {
lut[i] = j
j++
}
lut[len(sdata)] = len(lp.data)
lp.patch(lut, &rn)
}
if iter == 0 {
panic("reached maximum number of iterations")
}
return &rn, nil
}
func (p *Pattern) CreateCaptureNodes(data string, pos int, d parser.DataSource, mo MatchObject, parent *parser.Node, capt Captures) {
ranges := make([]text.Region, len(mo)/2)
parentIndex := make([]int, len(ranges))
parents := make([]*parser.Node, len(parentIndex))
for i := range ranges {
ranges[i] = text.Region{A: mo[i*2+0], B: mo[i*2+1]}
if i < 2 {
parents[i] = parent
continue
}
r := ranges[i]
for j := i - 1; j >= 0; j-- {
if ranges[j].Covers(r) {
parentIndex[i] = j
break
}
}
}
for _, v := range capt {
i := v.Key
if i >= len(parents) || ranges[i].A == -1 {
continue
}
child := &parser.Node{Name: v.Name, Range: ranges[i], P: d}
parents[i] = child
if i == 0 {
parent.Append(child)
continue
}
var p *parser.Node
for p == nil {
i = parentIndex[i]
p = parents[i]
}
p.Append(child)
}
}