# 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`

is`null`

it is taken to be 0. If`max`

is`null`

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`

is`true`

, and always fail if`pass`

is`false`

.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)*