mixinafPegger::Rules
afPegger::Rules
@
Js
(Advanced) A collection of utility methods that return PEG rules.
Use when programmatically creating PEG grammar.
- alpha
static Rule alpha()
- alphaChar
static Rule alphaChar(Bool not := false)
Matches any alphabetical character.
PEG notation:
[a-zA-Z]
- alphaNumChar
static Rule alphaNumChar(Bool not := false)
Matches any alphabetical or numerical character.
PEG notation:
[a-zA-Z0-9]
- anyChar
static Rule anyChar()
Matches any character.
PEG notation:
.
- atLeast
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:
rule{3,}
- atMost
static Rule atMost(Int n, Rule rule)
Processes the given rule repeatedly, but at most
n
times. Returns success always.Example PEG notation:
rule{,5}
- between
static Rule between(Int? min, Int? max, Rule rule)
Processes the given rule between the given values (inclusive). If
min
isnull
it is taken to be 0. Ifmax
isnull
it is taken to be infinity.Example PEG notation:
rule{2,6}
- char
static Rule char(Int char, Bool not := false)
Matches the given character.
Example PEG notation:
[C]
- charIn
static Rule charIn(Range charRange, Bool not := false)
Matches any character in the given range.
Example PEG notation:
[C-N]
- charNot
Matches any character except the given one.
Example PEG notation:
[^C]
- charNotOf
static Rule charNotOf(Int[] chars)
Matches any character not in the given list.
Example PEG notation:
[^ChukNoris]
- charOf
static Rule charOf(Int[] chars, Bool not := false)
Matches any character in the given list.
Example PEG notation:
[ChukNoris]
- charRule
static Rule charRule(Str charClass)
Multi-purpose char class rule.
Example PEG notation:
[a-z_]i
- eol
static Rule eol()
Matches end of line (or the end of the stream).
Example PEG notation:
"\n" / \eos
- eos
static Rule eos()
Matches if the of the stream (EOS) is reached.
Example PEG notation:
\eos
- err
static Rule err(Str msg := "FAIL")
This rule throws an error if processed.
Example PEG notation:
\fail(FAIL)
- firstOf
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
static Rule hexChar(Bool not := false)
Matches any hexadecimal character.
PEG notation:
[a-fA-F0-9]
- lower
static Rule lower()
Matches a lowercase character in the current locale. See sys::Locale for details.
Example PEG notation:
\lower
- nTimes
static Rule nTimes(Int times, Rule rule)
Processes the given rule
n
times. Returns success if the it always succeeded.Example PEG notation:
rule{5,5}
- newLineChar
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
static Rule noop(Bool pass := true)
No operation - a placeholder. This rule consumes no input and will always succeed if
pass
istrue
, and always fail ifpass
isfalse
.Example PEG notation:
\noop(true)
- numChar
static Rule numChar(Bool not := false)
Matches any numerical character.
PEG notation:
[0-9]
- oneOrMore
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
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
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
static Rule optional(Rule rule)
Processes the given rule and returns success whether it passes or not.
Example PEG notation:
(rule)?
- sequence
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
static Rule spaceChar(Bool not := false)
Matches any space character (excluding new line chars).
PEG notation:
[ \t]
- str
static Rule str(Str string, Bool ignoreCase := false)
Matches the given string.
Example PEG notation:
"ChuckNorris"
- strNot
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
static Rule upper()
Matches an uppercase character in the current locale. See sys::Locale for details.
Example PEG notation:
\upper
- whitespaceChar
static Rule whitespaceChar(Bool not := false)
Matches any whitespace character, including new lines.
PEG notation:
[ \t\n]
- wordChar
static Rule wordChar(Bool not := false)
Matches any word character, used as a Fantom identifier.
PEG notation:
[a-zA-Z0-9_]
- zeroOrMore
static Rule zeroOrMore(Rule rule)
Processes the given rule repeatedly until it fails.
Example PEG notation:
(rule)*