classafPegger::Peg

Returns true if the string contains a PEG match. Convenience for:

fantom: syntax
search != null

See matches() to check for a match against the entire string.

Turns debug messaging on and off.

Searches the string and calls the given function for each PEG Match found.

Also see search(), and eachWhile().

Searches the string and calls the given function for each PEG Match found, until a non-null result is returned. Returns null if there are no matches.

Also see search(), and each().

Returns the matched text of the next PEG match, optionally returning the contents of the given label.

peg := Peg("a12 + b23 / c69 * z666", "foo:[a-z] [0-9]+")
peg.find         // --> "a12"
peg.find         // --> "b23"
peg.find("foo")  // --> "c"
peg.find("foo")  // --> "z"

See matched() to match against the entire string.

Parses the given PEG pattern in to a rule. Convenience for:

Peg(str, Peg.parseRule(pattern))

See Rule.parseRule

Creates a PEG class ready to match the given string and rule.

Performs a PEG match against the entire string (from the given offset) - use for matching grammars.

See search() to search for a match anywhere in the string.

Performs a PEG match against the entire string. Returns the matched string.

See find() to search for a match anywhere in the string.

Performs a PEG match against the entire string. Returns true if it matches.

See contains() to search for a match instead.

Parses a list of PEG grammar definitions. For example:

parseGrammar("a <- [abc] / [xyz] / b
              b <- \space+ [^abc]")

See Grammar.parseGrammar

Parses a pattern in to simple rule. For example:

parseRule("[abc] / [xyz]")

See Rule.parseRule

Returns the grammar PEG used to parse PEG grammar.

It's not particularly useful, but it may be interesting to some.

Searches for the next PEG match and replaces a portion of it.

replacements is a map of label names to replacement values.

Use the label root to replace the entire Match.

Use standard ${interpolation} in values to reference other matched labels. Interpolation may be escaped with a backslash - \${not interpolated}.

str := "(34) -> {12}"
pat := "foo:[0-9]+ ' -> ' bar:[0-9]+"
peg := Peg(str, pat)
val := peg.replace(["foo":"\${bar}", "bar":"\${foo}"])
    // --> (12) -> {34}

Replaces all occurrences of a PEG match.

replacements is a map of label names to replacement values.

Use the label root to replace the entire Match.

Use standard ${interpolation} in values to reference other matched labels. Interpolation may be escaped with a backslash - \${this is not interpolated}.

str := "I like abba!"
pat := "foo:'a' / bar:'b'"
peg := Peg(str, pat)
val := peg.replaceAll(["foo":"b", "bar":"a"])
    // --> I like baab!

Calls the given fn on each match, that returns the replacements to be performed.

replacements is a map of label names to replacement values.

Use the label root to replace the entire Match.

Use standard ${interpolation} in values to reference other matched labels. Interpolation may be escaped with a backslash - \${this is not interpolated}.

Searches for the next PEG match (optionally with the given label) and returns the matched string (if any).

Returns null if there are no more matches.

Returns all matches from the given offset.