mixinafPegger::Rules

afPegger::Rules

@Js

(Advanced) A collection of utility methods that return PEG rules.

Use when programmatically creating PEG grammar.

alphaChar

Source

static Rule alphaChar(Bool not := false)

Matches any alphabetical character.

PEG notation:

[a-zA-Z]

alphaNumChar

Source

static Rule alphaNumChar(Bool not := false)

Matches any alphabetical or numerical character.

PEG notation:

[a-zA-Z0-9]

anyChar

Source

static Rule anyChar()

Matches any character.

PEG notation:

atLeast

Source

static Rule atLeast(Int n, Rule rule)

Processes the given rule repeatedly until it fails. Returns success if it succeeded at least n times.

Example PEG notation:

???

atMost

Source

static Rule atMost(Int n, Rule rule)

Processes the given rule repeatedly, but at most n times. Returns success always.

Example PEG notation:

???

between

Source

static Rule between(Range times, Rule rule)

Processes the given rule at most n times. Returns success if it succeeded at least n times.

Example PEG notation:

???

char

Source

static Rule char(Int char, Bool not := false)

Matches the given character.

Example PEG notation:

[C]

charIn

Source

static Rule charIn(Range charRange, Bool not := false)

Matches any character in the given range.

Example PEG notation:

[C-N]

charNot

Source

static Rule charNot(Int ch)

Matches any character except the given one.

Example PEG notation:

[^C]

charNotOf

Source

static Rule charNotOf(Int[] chars)

Matches any character not in the given list.

Example PEG notation:

[^ChukNoris]

charOf

Source

static Rule charOf(Int[] chars, Bool not := false)

Matches any character in the given list.

Example PEG notation:

[ChukNoris]

charRule

Source

static Rule charRule(Str charClass)

Multi-purpose char class rule.

Example PEG notation:

[a-z_]i

doAction

Source

static Rule doAction(|Str? action)

Essentially a no-op rule as it always returns true - but processes the given action func when successful. Useful for inserting arbitrary actions in sequences:

sequence { rule1, doAction { echo("Hello!") }, rule2, }

eol

Source

static Rule eol()

Matches end of line (or the end of the stream).

Example PEG notation:

\nl / \eos

eos

Source

static Rule eos()

Matches if the of the stream (EOS) is reached.

Example PEG notation:

\eos

err

Source

static Rule err(Str msg := "FAIL")

This rule throws an error if processed.

Example PEG notation:

\\fail(FAIL)

firstOf

Source

static Rule firstOf(Rule[] rules := Rule[,])

Processes the given rules in order until one succeeds. Returns success any succeeded.

firstOf([rule1, rule2, rule3])

Example PEG notation:

rule1 / rule2 / rule3 / ... / rule4

When defining a firstOf() rule you may also use it-block syntax:

firstOf { rule1, rule2, rule3, }

hexChar

Source

static Rule hexChar(Bool not := false)

Matches any hexadecimal character.

PEG notation:

[a-fA-F0-9]

nTimes

Source

static Rule nTimes(Int times, Rule rule)

Processes the given rule n times. Returns success if the it always succeeded.

Example PEG notation:

rule rule rule ... rule

newLineChar

Source

static Rule newLineChar(Bool not := false)

Matches the new line character. This assumes all new lines have been normalised to \n.

PEG notation:

[\n]

noop

Source

static Rule noop(Str msg := "TODO")

No operation - a placeholder. The rule will always succeed if pass is true, and always fail if pass is false.

Example PEG notation:

\\noop(TODO)

numChar

Source

static Rule numChar(Bool not := false)

Matches any numerical character.

PEG notation:

[0-9]

oneOrMore

Source

static Rule oneOrMore(Rule rule)

Processes the given rule repeatedly until it fails. Returns success if it succeeded at least once.

Example PEG notation:

(rule)+

onlyIf

Source

static Rule onlyIf(Rule rule)

Processes the given rule and return success if it succeeded. The rule is always rolled back so the characters may be subsequently re-read.

Example PEG notation:

&(rule)

onlyIfNot

Source

static Rule onlyIfNot(Rule rule)

Processes the given rule and return success if it failed. The rule is always rolled back so the characters may be subsequently re-read.

Example PEG notation:

!(rule)

optional

Source

static Rule optional(Rule rule)

Processes the given rule and returns success whether it passes or not.

Example PEG notation:

(rule)?

sequence

Source

static Rule sequence(Rule[] rules := Rule[,])

Processes the given rules in order until. Returns success if they all succeeded.

sequence([rule1, rule2, rule3])

Example PEG notation:

rule1 rule2 rule3 ... rule4

When defining a sequence() rule you may also use it-block syntax:

sequence { rule1, rule2, rule3, }

spaceChar

Source

static Rule spaceChar(Bool not := false)

Matches any space character (excluding new line chars).

PEG notation:

[ \t]

str

Source

static Rule str(Str string, Bool ignoreCase := false)

Matches the given string.

Example PEG notation:

"ChuckNorris"

strNot

Source

static Rule strNot(Str string, Bool ignoreCase := false)

Matches one or more characters up to (but not including) the given string.

Example PEG notation:

(!"ChuckNorris" .)+

whitespaceChar

Source

static Rule whitespaceChar(Bool not := false)

Matches any whitespace character, including new lines.

PEG notation:

[ \t\n]

wordChar

Source

static Rule wordChar(Bool not := false)

Matches any word character, used as a Fantom identifier.

PEG notation:

[a-zA-Z0-9_]

zeroOrMore

Source

static Rule zeroOrMore(Rule rule)

Processes the given rule repeatedly until it fails.

Example PEG notation:

(rule)*