package goparsify import ( "bytes" "strings" ) // Seq matches all of the given parsers in order and returns their result as .Child[n] func Seq(parsers ...Parserish) Parser { parserfied := ParsifyAll(parsers...) return NewParser("Seq()", func(ps *State, node *Result) { node.Child = make([]Result, len(parserfied)) startpos := ps.Pos for i, parser := range parserfied { node.Child[i].Input = node.Input parser(ps, &node.Child[i]) if ps.Errored() { ps.Pos = startpos return } } node.Start = startpos node.End = ps.Pos }) } // NoAutoWS disables automatically ignoring whitespace between tokens for all parsers underneath func NoAutoWS(parser Parserish) Parser { parserfied := Parsify(parser) return func(ps *State, node *Result) { oldWS := ps.WS ps.WS = NoWhitespace startpos := ps.Pos parserfied(ps, node) node.Start = startpos node.End = ps.Pos ps.WS = oldWS } } // Any matches the first successful parser and returns its result func Any(parsers ...Parserish) Parser { parserfied := ParsifyAll(parsers...) return NewParser("Any()", func(ps *State, node *Result) { ps.WS(ps) if ps.Pos >= len(ps.Input) { ps.ErrorHere("!EOF") return } startpos := ps.Pos var longestError Error expected := []string{} for _, parser := range parserfied { parser(ps, node) if ps.Errored() { if ps.Error.pos >= longestError.pos { longestError = ps.Error expected = append(expected, ps.Error.expected) } if ps.Cut > startpos { break } ps.Recover() continue } node.Start = startpos node.End = ps.Pos return } ps.Error = Error{ pos: longestError.pos, expected: strings.Join(expected, " or "), } ps.Pos = startpos }) } // Some matches zero or more parsers and returns the value as .Child[n] // an optional separator can be provided and that value will be consumed // but not returned. Only one separator can be provided. func Some(parser Parserish, separator ...Parserish) Parser { return NewParser("Some()", manyImpl(0, parser, separator...)) } // Many matches one or more parsers and returns the value as .Child[n] // an optional separator can be provided and that value will be consumed // but not returned. Only one separator can be provided. func Many(parser Parserish, separator ...Parserish) Parser { return NewParser("Many()", manyImpl(1, parser, separator...)) } func manyImpl(min int, op Parserish, sep ...Parserish) Parser { var opParser = Parsify(op) var sepParser Parser if len(sep) > 0 { sepParser = Parsify(sep[0]) } return func(ps *State, node *Result) { node.Child = make([]Result, 0, 5) startpos := ps.Pos for { node.Child = append(node.Child, Result{Input: node.Input}) opParser(ps, &node.Child[len(node.Child)-1]) if ps.Errored() { if len(node.Child)-1 < min || ps.Cut > ps.Pos { ps.Pos = startpos return } ps.Recover() node.Child = node.Child[0 : len(node.Child)-1] return } if sepParser != nil { sepParser(ps, TrashResult) if ps.Errored() { ps.Recover() return } } } node.Start = startpos node.End = ps.Pos } } // Maybe will 0 or 1 of the parser func Maybe(parser Parserish) Parser { parserfied := Parsify(parser) return NewParser("Maybe()", func(ps *State, node *Result) { startpos := ps.Pos parserfied(ps, node) if ps.Errored() && ps.Cut <= startpos { ps.Recover() } node.Start = startpos node.End = ps.Pos }) } // Bind will set the node .Result when the given parser matches // This is useful for giving a value to keywords and constant literals // like true and false. See the json parser for an example. func Bind(parser Parserish, val interface{}) Parser { p := Parsify(parser) return func(ps *State, node *Result) { startpos := ps.Pos p(ps, node) if ps.Errored() { return } node.Result = val node.Start = startpos node.End = ps.Pos } } // Map applies the callback if the parser matches. This is used to set the Result // based on the matched result. func Map(parser Parserish, f func(n *Result)) Parser { p := Parsify(parser) return func(ps *State, node *Result) { startpos := ps.Pos p(ps, node) if ps.Errored() { return } node.Start = startpos node.End = ps.Pos f(node) } } func flatten(n *Result) { if len(n.Child) > 0 { sbuf := &bytes.Buffer{} for _, child := range n.Child { flatten(&child) sbuf.WriteString(child.Token) } n.Token = sbuf.String() } } // Merge all child Tokens together recursively func Merge(parser Parserish) Parser { return Map(parser, flatten) }