pegex.pgx.json

{
   "+grammar" : "pegex",
   "+include" : "pegex-atoms",
   "+toprule" : "grammar",
   "+version" : "0.2.0",
   "ERROR_all_group" : {
      ".all" : [
         {
            ".ref" : "ERROR_rule_part"
         },
         {
            "+min" : 0,
            "-flat" : 1,
            ".all" : [
               {
                  ".ref" : "_"
               },
               {
                  ".ref" : "ERROR_rule_part"
               }
            ]
         }
      ]
   },
   "ERROR_any_group" : {
      ".all" : [
         {
            ".ref" : "ERROR_all_group"
         },
         {
            "+min" : 1,
            "-flat" : 1,
            ".all" : [
               {
                  ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\|(?:\\s|\\#.*(?:\\n|\\z))*"
               },
               {
                  ".ref" : "ERROR_all_group"
               }
            ]
         }
      ]
   },
   "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" : {
      ".all" : [
         {
            ".ref" : "ERROR_rule_item"
         },
         {
            "+max" : 1,
            "+min" : 0,
            "-flat" : 1,
            ".all" : [
               {
                  ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+(%{1,2})(?:\\s|\\#.*(?:\\n|\\z))+"
               },
               {
                  ".ref" : "ERROR_rule_item"
               }
            ]
         }
      ]
   },
   "ERROR_rule_reference" : {
      ".any" : [
         {
            ".all" : [
               {
                  ".rgx" : "(?=[!=\\+\\-\\.]?<(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])(?!\\>))"
               },
               {
                  ".err" : "Missing > in rule reference"
               }
            ]
         },
         {
            ".all" : [
               {
                  ".rgx" : "(?=[!=\\+\\-\\.]?(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])\\>)"
               },
               {
                  ".err" : "Missing < in rule reference"
               }
            ]
         },
         {
            ".all" : [
               {
                  ".rgx" : "(?=[!=\\+\\-\\.]?(?:(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])|<(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])\\>)[^\\w\\(\\)</\\~\\|`\\s\\*\\+\\?!=\\+\\-\\.:;])"
               },
               {
                  ".err" : "Illegal character in rule quantifier"
               }
            ]
         },
         {
            ".all" : [
               {
                  ".rgx" : "(?=[!=\\+\\-\\.]?(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])\\-)"
               },
               {
                  ".err" : "Unprotected rule name with numeric quantifier; please use <rule>#-# syntax!"
               }
            ]
         },
         {
            ".all" : [
               {
                  "+asr" : -1,
                  ".ref" : "rule_modifier"
               },
               {
                  ".rgx" : "(?=[^\\w\\(\\)</\\~\\|`\\s](?:(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])|<(?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-])\\>)(?:[\\*\\+\\?]|[0-9]+(?:\\-[0-9]+|\\+)?)?(?![\\ \\t]*:))"
               },
               {
                  ".err" : "Illegal rule modifier (must be [=!.-+]?)"
               }
            ]
         }
      ]
   },
   "ERROR_rule_start" : {
      ".any" : [
         {
            ".rgx" : "((?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-]))[\\ \\t]*:(?:\\s|\\#.*(?:\\n|\\z))*"
         },
         {
            ".err" : "Rule header syntax error"
         }
      ]
   },
   "_" : {
      ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*"
   },
   "__" : {
      ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+"
   },
   "all_group" : {
      ".all" : [
         {
            ".ref" : "rule_part"
         },
         {
            "+min" : 0,
            ".all" : [
               {
                  ".ref" : "_"
               },
               {
                  ".ref" : "rule_part"
               }
            ]
         }
      ]
   },
   "any_group" : {
      ".all" : [
         {
            ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\|?(?:\\s|\\#.*(?:\\n|\\z))*"
         },
         {
            ".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"
         },
         {
            ".ref" : "__"
         },
         {
            ".ref" : "ERROR_meta_definition"
         }
      ]
   },
   "quoted_regex" : {
      ".rgx" : "'([^']*)'"
   },
   "regex_raw" : {
      ".rgx" : "(\\(\\??<|(?:[^\\s/'<])+)"
   },
   "regex_rule_reference" : {
      ".rgx" : "(?:(?:\\s|\\#.*(?:\\n|\\z))+((?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-]))|(?:<((?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-]))\\>))(?![\\ \\t]*:)"
   },
   "regular_expression" : {
      ".all" : [
         {
            ".rgx" : "([\\-\\.]?)"
         },
         {
            ".rgx" : "/"
         },
         {
            "+max" : 1,
            ".ref" : "whitespace_start"
         },
         {
            "+min" : 0,
            ".any" : [
               {
                  ".ref" : "whitespace_must"
               },
               {
                  ".ref" : "whitespace_maybe"
               },
               {
                  ".ref" : "quoted_regex"
               },
               {
                  ".ref" : "regex_rule_reference"
               },
               {
                  ".ref" : "__"
               },
               {
                  ".ref" : "regex_raw"
               }
            ]
         },
         {
            ".rgx" : "/"
         }
      ]
   },
   "rule_definition" : {
      ".all" : [
         {
            ".ref" : "rule_start"
         },
         {
            ".ref" : "rule_group"
         },
         {
            ".ref" : "ending"
         }
      ]
   },
   "rule_group" : {
      ".ref" : "any_group"
   },
   "rule_item" : {
      ".any" : [
         {
            ".ref" : "bracketed_group"
         },
         {
            ".ref" : "whitespace_token"
         },
         {
            ".ref" : "rule_reference"
         },
         {
            ".ref" : "quoted_regex"
         },
         {
            ".ref" : "regular_expression"
         },
         {
            ".ref" : "error_message"
         }
      ]
   },
   "rule_modifier" : {
      ".rgx" : "[!=\\+\\-\\.]"
   },
   "rule_part" : {
      ".all" : [
         {
            ".ref" : "rule_item"
         },
         {
            "+max" : 1,
            "+min" : 0,
            "-flat" : 1,
            ".all" : [
               {
                  ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+(%{1,2})(?:\\s|\\#.*(?:\\n|\\z))+"
               },
               {
                  ".ref" : "rule_item"
               }
            ]
         }
      ]
   },
   "rule_reference" : {
      ".rgx" : "([!=\\+\\-\\.]?)(?:((?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-]))|(?:<((?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-]))\\>))((?:[\\*\\+\\?]|[0-9]+(?:\\-[0-9]+|\\+)?)?)(?![\\ \\t]*:)"
   },
   "rule_section" : {
      "+min" : 0,
      ".any" : [
         {
            ".ref" : "rule_definition"
         },
         {
            ".ref" : "__"
         }
      ]
   },
   "rule_start" : {
      ".rgx" : "((?:[a-zA-Z][a-zA-Z0-9]*(?:[\\-_][a-zA-Z0-9]+)*|\\-+|_+)(?=[^\\w\\-]))[\\ \\t]*:(?:\\s|\\#.*(?:\\n|\\z))*"
   },
   "whitespace_maybe" : {
      ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\-(?=[\\ /\\r\\n])"
   },
   "whitespace_must" : {
      ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+(?:\\+|\\-\\-)(?=[\\ /\\r\\n])"
   },
   "whitespace_start" : {
      ".rgx" : "([\\+\\-])(?![\\-\\~])"
   },
   "whitespace_token" : {
      ".rgx" : "((?:\\+|\\-|\\-\\-|\\~|\\~\\~))(?=(?:\\s|\\#.*(?:\\n|\\z))+)"
   }
}