pegex.pgx.yaml

---
+grammar: pegex
+toprule: grammar
+version: 0.2.0
ERROR_all_group:
  +min: 1
  .ref: ERROR_rule_part
  .sep:
    .rgx: (?:\s|\#.*(?:\n|\z))*
ERROR_any_group:
  +min: '2'
  .ref: ERROR_all_group
  .sep:
    .rgx: (?:\s|\#.*(?:\n|\z))*\|(?:\s|\#.*(?:\n|\z))*
ERROR_bracketed_group:
  .any:
  - .all:
    - .rgx: (?!\.)(?=[^\w\(\)</\~\|`\s]\()
    - .err: Illegal group rule modifier (can only use .)
  - .all:
    - .rgx: (\.?)\((?:\s|\#.*(?:\n|\z))*
    - .ref: rule_group
    - .any:
      - .all:
        - +asr: 1
          .ref: doc_ending
        - .err: Runaway rule group; no ending parens at EOF
      - .all:
        - .rgx: (?=(?:\s|\#.*(?:\n|\z))*\)[^\w\(\)</\~\|`\s\*\+\?!=\+\-\.:;])
        - .err: Illegal character in group rule quantifier
ERROR_error_message:
  .any:
  - .all:
    - .rgx: (?=`[^`\r\n]*[\r\n][^`]*`)
    - .err: Multi-line error messages not allowed!
  - .all:
    - .rgx: (?=`[^`]*(?:\s|\#.*(?:\n|\z))*\z)
    - .err: Runaway error message; no ending grave at EOF
ERROR_meta_definition:
  .all:
  - .rgx: (?=%\w+)
  - .err: Illegal meta rule
ERROR_regular_expression:
  .all:
  - .rgx: (?=/([^/]*)(?:\s|\#.*(?:\n|\z))*\z)
  - .err: Runaway regular expression; no ending slash at EOF
ERROR_rule_definition:
  .all:
  - .ref: ERROR_rule_start
  - .ref: ERROR_rule_group
  - .any:
    - .ref: ending
    - .err: Rule ending syntax error
ERROR_rule_group:
  .any:
  - .ref: ERROR_any_group
  - .ref: ERROR_all_group
ERROR_rule_item:
  .any:
  - .ref: rule_item
  - .ref: ERROR_rule_reference
  - .ref: ERROR_regular_expression
  - .ref: ERROR_bracketed_group
  - .ref: ERROR_error_message
ERROR_rule_part:
  +max: '2'
  +min: '1'
  .ref: ERROR_rule_item
  .sep:
    .rgx: (?:\s|\#.*(?:\n|\z))+(%{1,2})(?:\s|\#.*(?:\n|\z))+
ERROR_rule_reference:
  .any:
  - .all:
    - .rgx: (?=[!=\+\-\.]?<[a-zA-Z]\w*\b(?!>))
    - .err: Missing > in rule reference
  - .all:
    - .rgx: (?=[!=\+\-\.]?[a-zA-Z]\w*\b>)
    - .err: Missing < in rule reference
  - .all:
    - .rgx: (?=[!=\+\-\.]?(?:[a-zA-Z]\w*\b|<[a-zA-Z]\w*\b>)[^\w\(\)</\~\|`\s\*\+\?!=\+\-\.:;])
    - .err: Illegal character in rule quantifier
  - .all:
    - .rgx: (?=[!=\+\-\.]?[a-zA-Z]\w*\b\-)
    - .err: Unprotected rule name with numeric quantifier; please use <rule>#-# syntax!
  - .all:
    - +asr: -1
      .ref: rule_modifier
    - .rgx: (?=[^\w\(\)</\~\|`\s](?:[a-zA-Z]\w*\b|<[a-zA-Z]\w*\b>)(?:[\*\+\?]|[0-9]+(?:\-[0-9]+|\+)?)?(?![\
        \t]*:))
    - .err: Illegal rule modifier (must be [=!.-+]?)
ERROR_rule_start:
  .any:
  - .rgx: ([a-zA-Z]\w*\b)[\ \t]*:(?:\s|\#.*(?:\n|\z))*
  - .err: Rule header syntax error
all_group:
  .all:
  - .ref: rule_part
  - +min: 0
    .all:
    - .rgx: (?:\s|\#.*(?:\n|\z))*
    - .ref: rule_part
any_group:
  .all:
  - .ref: all_group
  - +min: 0
    .all:
    - .rgx: (?:\s|\#.*(?:\n|\z))*\|(?:\s|\#.*(?:\n|\z))*
    - .ref: all_group
bracketed_group:
  .all:
  - .rgx: (\.?)\((?:\s|\#.*(?:\n|\z))*
  - .ref: rule_group
  - .rgx: (?:\s|\#.*(?:\n|\z))*\)((?:[\*\+\?]|[0-9]+(?:\-[0-9]+|\+)?)?)
doc_ending:
  .rgx: (?:\s|\#.*(?:\n|\z))*\z
ending:
  .rgx: (?:\s|\#.*(?:\n|\z))*?(?:\n(?:\s|\#.*(?:\n|\z))*;?(?:\s|\#.*(?:\n|\z))*|\#.*(?:\n|\z)(?:\s|\#.*(?:\n|\z))*;?(?:\s|\#.*(?:\n|\z))*|;(?:\s|\#.*(?:\n|\z))*|\z)
error_message:
  .rgx: '`([^`\r\n]*)`'
grammar:
  .all:
  - .ref: meta_section
  - .ref: rule_section
  - .any:
    - .ref: doc_ending
    - .ref: ERROR_rule_definition
meta_definition:
  .rgx: '%(grammar|extends|include|version)[\ \t]+[\ \t]*([^;\n]*?)[\ \t]*(?:\s|\#.*(?:\n|\z))*?(?:\n(?:\s|\#.*(?:\n|\z))*;?(?:\s|\#.*(?:\n|\z))*|\#.*(?:\n|\z)(?:\s|\#.*(?:\n|\z))*;?(?:\s|\#.*(?:\n|\z))*|;(?:\s|\#.*(?:\n|\z))*|\z)'
meta_section:
  +min: 0
  .any:
  - .ref: meta_definition
  - .rgx: (?:\s|\#.*(?:\n|\z))+
  - .ref: ERROR_meta_definition
regular_expression:
  .rgx: /([^/]*)/
rule_definition:
  .all:
  - .ref: rule_start
  - .ref: rule_group
  - .ref: ending
rule_group:
  .ref: any_group
rule_item:
  .any:
  - .ref: rule_reference
  - .ref: regular_expression
  - .ref: bracketed_group
  - .ref: whitespace_token
  - .ref: error_message
rule_modifier:
  .rgx: '[!=\+\-\.]'
rule_part:
  +max: '2'
  +min: '1'
  .ref: rule_item
  .sep:
    .rgx: (?:\s|\#.*(?:\n|\z))+(%{1,2})(?:\s|\#.*(?:\n|\z))+
rule_reference:
  .rgx: ([!=\+\-\.]?)(?:([a-zA-Z]\w*\b)|(?:<([a-zA-Z]\w*\b)>))((?:[\*\+\?]|[0-9]+(?:\-[0-9]+|\+)?)?)(?![\
    \t]*:)
rule_section:
  +min: 0
  .any:
  - .ref: rule_definition
  - .rgx: (?:\s|\#.*(?:\n|\z))+
rule_start:
  .rgx: ([a-zA-Z]\w*\b)[\ \t]*:(?:\s|\#.*(?:\n|\z))*
whitespace_token:
  .rgx: (\~+)