mixinafPegger::Rules

afPegger::Rules

@Js

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

Use when programmatically creating PEG grammar.

alpha

Source

const static Rule alpha()

D. See sys::Locale for details.

Example PEG notation:

\lower / \upper
alphaChar

Source

const static Rule alphaChar(Bool not := false)

Matches any alphabetical character.

PEG notation:

[a-zA-Z]
alphaNumChar

Source

const static Rule alphaNumChar(Bool not := false)

Matches any alphabetical or numerical character.

PEG notation:

[a-zA-Z0-9]
anyChar

Source

const static Rule anyChar()

Matches any character.

PEG notation:

.
atLeast

Source

const 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

const 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

const static Rule between(Int? min, Int? max, Rule rule)

Processes the given rule between the given values (inclusive). If min is null it is taken to be 0. If max is null it is taken to be infinity.

Example PEG notation:

???
char

Source

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

Matches the given character.

Example PEG notation:

[C]
charIn

Source

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

Matches any character in the given range.

Example PEG notation:

[C-N]
charNot

Source

const static Rule charNot(Int ch)

Matches any character except the given one.

Example PEG notation:

[^C]
charNotOf

Source

const static Rule charNotOf(Int[] chars)

Matches any character not in the given list.

Example PEG notation:

[^ChukNoris]
charOf

Source

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

Matches any character in the given list.

Example PEG notation:

[ChukNoris]
charRule

Source

const static Rule charRule(Str charClass)

Multi-purpose char class rule.

Example PEG notation:

[a-z_]i
eol

Source

const static Rule eol()

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

Example PEG notation:

"\n" / \eos
eos

Source

const static Rule eos()

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

Example PEG notation:

\eos
err

Source

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

This rule throws an error if processed.

Example PEG notation:

\\fail(FAIL)
firstOf

Source

const 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

const static Rule hexChar(Bool not := false)

Matches any hexadecimal character.

PEG notation:

[a-fA-F0-9]
lower

Source

const static Rule lower()

Matches a lowercase character in the current locale. See sys::Locale for details.

Example PEG notation:

\lower
nTimes

Source

const 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

const 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

const 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

const static Rule numChar(Bool not := false)

Matches any numerical character.

PEG notation:

[0-9]
oneOrMore

Source

const 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

const 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

const 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

const static Rule optional(Rule rule)

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

Example PEG notation:

(rule)?
sequence

Source

const 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

const static Rule spaceChar(Bool not := false)

Matches any space character (excluding new line chars).

PEG notation:

[ \t]
str

Source

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

Matches the given string.

Example PEG notation:

"ChuckNorris"
strNot

Source

const 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" .)+
upper

Source

const static Rule upper()

Matches an uppercase character in the current locale. See sys::Locale for details.

Example PEG notation:

\upper
whitespaceChar

Source

const static Rule whitespaceChar(Bool not := false)

Matches any whitespace character, including new lines.

PEG notation:

[ \t\n]
wordChar

Source

const static Rule wordChar(Bool not := false)

Matches any word character, used as a Fantom identifier.

PEG notation:

[a-zA-Z0-9_]
zeroOrMore

Source

const static Rule zeroOrMore(Rule rule)

Processes the given rule repeatedly until it fails.

Example PEG notation:

(rule)*