Datasets:

Reset23

/

the-stack-v2

like 0

{ "content": "file = *definition\n\ndefinition = command [argument] *option [input]\noption = keyword argument\nargument = elementary_value\ninput = block / elementary_list\nblock = \"{\" *definition \"}\"\nelementary_list = \"[\" *elementary_value \"]\"\nelementary_value = FLOAT / INT / STRING / bool\n\nbool = \"true\" / \"false\"\ncommand = IDENT\nkeyword = KEYWORD\n" }

{ "content": "start = CRLF\r\n" }

{ "content": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n;\r\n; RFC 5234 - ABNF CORE RULES\r\n;\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\nOCTET= %x00-FF ; 8 bits of data\r\nCHAR= %x01-7F ; any 7-bit US-ASCII character, excluding NUL\r\nVCHAR= %x21-7E ; visible (printing) characters\r\nALPHA= %x41-5A / %x61-7A ; A-Z / a-z\r\nDIGIT= %x30-39 ; 0-9\r\n \r\nCTL= %x00-1F / %x7F ; any US-ASCII control character: ; (octets 0 - 31) and DEL (127)\r\n \r\nHTAB= %x09 ; horizontal tab\r\nLF= %x0A ; linefeed\r\nCR= %x0D ; carriage return\r\nSP= %x20 ; space\r\nDQUOTE= %x22 ; \" (Double Quote)\r\nBIT= \"0\" / \"1\" \r\n \r\nHEXDIG= DIGIT / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"\r\n \r\nCRLF= CR LF ; Internet standard newline\r\nWSP= SP / HTAB ; white space\r\nLWSP= *(WSP / CRLF WSP) ; linear white space (past newline)\r\n;---------------------------------------------------------------------------------------------------------\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n;\r\n; RFC 2396 - URI\r\n;\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n\r\n;;;; 1.6. Syntax Notation and Common Elements\r\n;alpha = lowalpha / upalpha\r\nlowalpha = \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\" / \"g\" / \"h\" / \"i\" / \"j\" / \"k\" / \"l\" / \"m\" / \"n\" / \"o\" / \"p\" / \"q\" / \"r\" / \"s\" / \"t\" / \"u\" / \"v\" / \"w\" / \"x\" / \"y\" / \"z\"\r\nupalpha = \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\" / \"G\" / \"H\" / \"I\" / \"J\" / \"K\" / \"L\" / \"M\" / \"N\" / \"O\" / \"P\" / \"Q\" / \"R\" / \"S\" / \"T\" / \"U\" / \"V\" / \"W\" / \"X\" / \"Y\" / \"Z\"\r\n;digit = \"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"\r\nalphanum = alpha / digit\r\n\r\n;;;; 2. URI Characters and Escape Sequences\r\nurlc = reserved / unreserved / escaped\r\n\r\n;;;; 2.2. Reserved Characters\r\nreserved = \";\" / \"/\" / \"?\" / \":\" / \"@\" / \"&\" / \"=\" / \"+\" / \"$\" / \",\"\r\n\r\n;;;; 2.3. Unreserved Characters\r\nunreserved = alphanum / mark\r\nmark = \"-\" / \"_\" / \".\" / \"!\" / \"~\" / \"*\" / \"'\" / \"(\" / \")\"\r\n\r\n;;;; 2.4.1. Escaped Encoding\r\nescaped = \"%\" hex hex\r\nhex = digit / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\" / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"\r\n\r\n\r\n;;;; 2.4.3. Excluded US-ASCII Characters\r\ncontrol = %x00-1F / %x7F ;<US-ASCII coded characters 00-1F and 7F hexadecimal>\r\nspace = %x20 ;<US-ASCII coded character 20 hexadecimal>\r\ndelims = \"<\" / \">\" / \"#\" / \"%\" / DQUOTE\r\nunwise = \"{\" / \"}\" / \"/\" / \"\\\" / \"^\" / \"[\" / \"]\" / \"`\"\r\n\r\n\r\n;;;; 3. URI Syntactic Components\r\nabsoluteURI = scheme \":\" ( hier-part / opaque-part )\r\nhier-part = ( net-path / abs-path ) [ \"?\" query ]\r\nnet-path = \"//\" authority [ abs-path ]\r\nabs-path = \"/\" path-segments\r\nopaque-part = urlc-no-slash *urlc\r\nurlc-no-slash = unreserved / escaped / \";\" / \"?\" / \":\" / \"@\" / \"&\" / \"=\" / \"+\" / \"$\" / \",\"\r\n\r\n;;;; 3.1. Scheme Component\r\nscheme = alpha *( alpha / digit / \"+\" / \"-\" / \".\" )\r\n\r\n;;;; 3.2. Authority Component\r\nauthority = server / reg-name\r\n\r\n;;;; Registry-based Naming Authority\r\nreg-name = 1*( unreserved / escaped / \"$\" / \",\" / \";\" / \":\" / \"@\" / \"&\" / \"=\" / \"+\" )\r\n\r\n;;;; 3.2.2. Server-based Naming Authority\r\nserver = [ [ userinfo \"@\" ] hostport ]\r\nuserinfo = *( unreserved / escaped / \";\" / \":\" / \"&\" / \"=\" / \"+\" / \"$\" / \",\" )\r\nhostport = host [ \":\" port ]\r\nhost = hostname / IPv4address\r\nhostname = *( domainlabel \".\" ) toplabel [ \".\" ]\r\ndomainlabel = alphanum / alphanum *( alphanum / \"-\" ) alphanum\r\ntoplabel = alpha / alpha *( alphanum / \"-\" ) alphanum\r\nIPv4address = 1*digit \".\" 1*digit \".\" 1*digit \".\" 1*digit\r\nport = *digit\r\n\r\n;;;; 3.3. Path Component\r\npath = [ abs-path / opaque-part ]\r\npath-segments = segment *( \"/\" segment )\r\nsegment = *pchar *( \";\" param )\r\nparam = *pchar\r\npchar = unreserved / escaped / \":\" / \"@\" / \"&\" / \"=\" / \"+\" / \"$\" / \",\"\r\n\r\n;;;; 3.4. Query Component\r\nquery = *urlc\r\n\r\n;;;; 4. URI References\r\nURI-reference = [ absoluteURI / relativeURI ] [ \"#\" fragment ]\r\n\r\n\r\n;;;; 4.1. Fragment Identifier\r\nfragment = *urlc\r\n\r\n;;;; 5. Relative URI References\r\nrelativeURI = ( net-path / abs-path / rel-path ) [ \"?\" query ]\r\nrel-path = rel-segment [ abs-path ]\r\nrel-segment = 1*( unreserved / escaped / \";\" / \"@\" / \"&\" / \"=\" / \"+\" / \"$\" / \",\" )\r\n;---------------------------------------------------------------------------------------------------------\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n;\r\n; HTTP digest authentication (2617) - ABNF\r\n;\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n\r\n;;;; 1.2 Access Authentication Framework\r\nauth-scheme = token\r\nauth-param = token \"=\" ( token / quoted-string )\r\n\r\nchallenge = auth-scheme 1*SP auth-param *(COMMA auth-param)\r\n\r\nrealm = \"realm\" \"=\" realm-value\r\nrealm-value = quoted-string\r\n\r\n;;;; 2 Basic Authentication Scheme\r\nbasic-challenge = \"Basic\" realm\r\nbasic-credentials = \"Basic\" basic-credentials-value\r\n\r\nbasic-credentials-value = base64-user-pass\r\nbase64-user-pass = token ;<base64 [4] encoding of user-pass, except not limited to 76 char/line>\r\nuser-pass = userid \":\" password\r\nuserid = *TEXT ;*<TEXT excluding \":\">\r\npassword = *TEXT\r\n\r\n;;;; 3.2.1 The WWW-Authenticate Response Header\r\n;challenge = \"Digest\" digest-challenge\r\n\r\ndigest-challenge = digest-challenge-value *(COMMA digest-challenge-value)\r\ndigest-challenge-value = ( realm / [ domain ] / nonce / [ opaque ] /[ stale ] / [ algorithm ] / [ qop-options ] / [auth-param] )\r\n\r\ndomain = \"domain\" \"=\" <\"> URI ( 1*SP URI ) <\">\r\nURI = absoluteURI / abs-path\r\nnonce = \"nonce\" \"=\" nonce-value\r\nnonce-value = quoted-string\r\nopaque = \"opaque\" \"=\" quoted-string\r\nstale = \"stale\" \"=\" ( \"true\" / \"false\" )\r\nalgorithm = \"algorithm\" \"=\" ( \"MD5\" / \"MD5-sess\" / token )\r\nqop-options = \"qop\" \"=\" DQUOTE qop-value *(COMMA qop-value) DQUOTE\r\nqop-value = \"auth\" / \"auth-int\" / token\r\n\r\n\r\n;;;; 3.2.2 The Authorization Request Header\r\ncredentials = \"Digest\" digest-response\r\ndigest-response = digest-response-value *(COMMA digest-response-value)\r\ndigest-response-value = ( username / realm / nonce / digest-url / auth-response / [ algorithm ] / [cnonce] / [opaque] / [message-qop] / [nonce-count] / [auth-param] )\r\n\r\nusername = \"username\" \"=\" username-value\r\nusername-value = quoted-string\r\ndigest-url = \"url\" \"=\" digest-url-value\r\ndigest-url-value = request-url ; As specified by HTTP/1.1\r\nmessage-qop = \"qop\" \"=\" qop-value\r\ncnonce = \"cnonce\" \"=\" cnonce-value\r\ncnonce-value = nonce-value\r\nnonce-count = \"nc\" \"=\" nc-value\r\nnc-value = 8LHEX\r\nauth-response = \"response\" \"=\" request-digest\r\nrequest-digest = DQUOTE 32LHEX DQUOTE\r\nLHEX = \"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"\r\n\r\n\r\n;;;; 3.2.3 The Authentication-Info Header\r\nAuthenticationInfo = \"Authentication-Info\" \":\" auth-info\r\nauth-info = auth-info-value *(COMMA auth-info-value)\r\nauth-info-value = (nextnonce / [ message-qop ] / [ response-auth ] / [ cnonce ] / [nonce-count] )\r\nnextnonce = \"nextnonce\" \"=\" nonce-value\r\nresponse-auth = \"rspauth\" \"=\" response-digest\r\nresponse-digest = DQUOTE *LHEX DQUOTE\r\n;---------------------------------------------------------------------------------------------------------\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n;\r\n; HTTP (2616) - ABNF\r\n;\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\nHT = %x09; <US-ASCII HT, horizontal-tab (9)>\r\nseparators\t = \"(\" / \")\" / \"<\" / \">\" / \"@\" / \",\" / \";\" / \":\" / \"\\\" / DQUOTE / \"/\" / \"[\" / \"]\" / \"?\" / \"=\" / \"{\" / \"}\" / SP / HTAB\r\ntoken\t = 1*( alphanum / separators ) ; *<any CHAR except CTLs or separators>\r\nLWS\t = [*WSP CRLF] 1*WSP \t; linear whitespace\r\nSWS\t = \t[LWS] \t; sep whitespace \r\nTEXT = 1*(token / LWS) ; <any OCTET except CTLs, but including LWS>\r\nCOMMA\t = SWS \t\",\" \tSWS \t; comma\r\n\r\n;;;; text (from http ==> is it right?)\r\nTEXT-UTF8-TRIM\t= 1*TEXT-UTF8char *(*LWS TEXT-UTF8char)\r\nTEXT-UTF8char\t= %x21-7E / UTF8-NONASCII\r\nUTF8-NONASCII\t= %xC0-DF \t1UTF8-CONT /\t%xE0-EF \t2UTF8-CONT /\t%xF0-F7 \t3UTF8-CONT /\t%xF8-FB \t4UTF8-CONT /\t%xFC-FD \t5UTF8-CONT\r\nUTF8-CONT\t = %x80-BF\r\n\r\n\r\ncomment = \"(\" *( ctext / quoted-pair / comment ) \")\"\r\nctext\t = %x21-27 / %x2A-5B / %x5D-7E / UTF8-NONASCII / LWS ; <any TEXT excluding \"(\" and \")\">\r\n\r\n;;;; quoted-string\r\nquoted-string = ( DQUOTE *(qdtext / quoted-pair ) DQUOTE )\r\nqdtext\t = LWS / %x21 / %x23-5B / %x5D-7E / UTF8-NONASCII ; <any TEXT except DQUOTE>\r\nquoted-pair = \"\\\" CHAR\r\n\r\n;;;; HTTP-Version\r\nHTTP-Version = \"HTTP\" \"/\" 1*DIGIT \".\" 1*DIGIT\r\n\r\n;;;; HTTP-date\r\nHTTP-date = rfc1123-date / rfc850-date / asctime-date\r\nrfc1123-date = wkday \",\" SP date1 SP time SP \"GMT\"\r\nrfc850-date = weekday \",\" SP date2 SP time SP \"GMT\"\r\nasctime-date = wkday SP date3 SP time SP 4DIGIT\r\ndate1 = 2DIGIT SP month SP 4DIGIT ; day month year (e.g., 02 Jun 1982)\r\ndate2 = 2DIGIT \"-\" month \"-\" 2DIGIT ; day-month-year (e.g., 02-Jun-82)\r\ndate3 = month SP ( 2DIGIT / ( SP 1DIGIT )) ; month day (e.g., Jun 2)\r\ntime = 2DIGIT \":\" 2DIGIT \":\" 2DIGIT ; 00:00:00 - 23:59:59\r\nwkday = \"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" / \"Fri\" / \"Sat\" / \"Sun\"\r\nweekday = \"Monday\" / \"Tuesday\" / \"Wednesday\" / \"Thursday\" / \"Friday\" / \"Saturday\" / \"Sunday\"\r\nmonth = \"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" / \"May\" / \"Jun\" / \"Jul\" / \"Aug\" / \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"\r\n\r\n;;;; 3.3.2 Delta Seconds\r\ndelta-seconds = 1*DIGIT\r\n\r\n;;;; 3.4 Character Sets\r\ncharset = token\r\n\r\n;;;; 3.5 Content Codings\r\ncontent-coding = token\r\n\r\n;;;; 3.6 Transfer Codings\r\ntransfer-coding = \"chunked\" / transfer-extension\r\ntransfer-extension = token *( \";\" parameter )\r\nparameter = attribute \"=\" value\r\nattribute = token\r\nvalue = token / quoted-string\r\n\r\n;;;; 3.6.1 Chunked Transfer Coding\r\nChunked-Body = *chunk last-chunk chunck-trailer CRLF\r\nchunk = chunk-size [ chunk-extension ] CRLF chunk-data CRLF\r\nchunk-size = 1*HEX\r\nlast-chunk = 1*(\"0\") [ chunk-extension ] CRLF\r\nchunk-extension= *( \";\" chunk-ext-name [ \"=\" chunk-ext-val ] )\r\nchunk-ext-name = token\r\nchunk-ext-val = token / quoted-string\r\nchunk-data = chunk-size\r\nchunck-trailer = *(entity-header CRLF)\r\n\r\n;;;; 3.7 Media Types\r\nmedia-type = type \"/\" subtype *( \";\" parameter )\r\ntype = token\r\nsubtype = token\r\n\r\n;;;; 3.8 Product Tokens\r\nproduct = token [\"/\" product-version]\r\nproduct-version = token\r\n\r\n;;;;3.9 Quality Values\r\nqvalue = ( \"0\" [ \".\" 0*3DIGIT ] ) / ( \"1\" [ \".\" 0*3(\"0\") ] )\r\n\r\n;;;; 3.10 Language Tags\r\nlanguage-tag = primary-tag *( \"-\" subtag )\r\nprimary-tag = 1*8ALPHA\r\nsubtag = 1*8ALPHA\r\n\r\n;;;; 3.11 Entity Tags\r\nentity-tag = [ weak ] opaque-tag\r\nweak = \"W/\"\r\nopaque-tag = quoted-string\r\n\r\n;;;; 3.12 Range Units\r\nrange-unit = bytes-unit / other-range-unit\r\nbytes-unit = \"bytes\"\r\nother-range-unit = token\r\n\r\n\r\n;;;; 4.1 Message Types\r\nHTTP-message = Request / Response ; HTTP/1.1 messages\r\ngeneric-message = start-line *(message-header CRLF) CRLF [ message-body ]\r\nstart-line = Request-Line / Status-Line\r\n\r\n\r\n;;;;4.2 Message Headers\r\nmessage-header = field-name \":\" [ field-value ]\r\nfield-name = token\r\nfield-value = *( field-content / LWS )\r\nfield-content = token ;<the OCTETs making up the field-value and consisting of either *TEXT or combinations of token, separators, and quoted-string>\r\n\r\n\r\n;;;; 4.3 Message Body\r\nmessage-body = entity-body ;/ <entity-body encoded as per Transfer-Encoding>\r\n\r\n\r\n;;;; 4.5 General Header Fields\r\ngeneral-header = Cache-Control / Connection / Date / Pragma / Trailer / Transfer-Encoding / Upgrade / Via / Warning\r\n;Cache-Control = \"Cache-Control\" \":\" [ field-value ]\r\n;Connection = \"Connection\" \":\" [ field-value ]\r\n;Date = \"Date\" \":\" [ field-value ]\r\n;Pragma = \"Pragma\" \":\" [ field-value ]\r\n;Trailer = \"Trailer\" \":\" [ field-value ]\r\n;Transfer-Encoding = \"Transfer-Encoding\" \":\" [ field-value ]\r\n;Upgrade = \"Upgrade\" \":\" [ field-value ]\r\n;Via = \"Via\" \":\" [ field-value ]\r\n;Warning = \"Warning\" \":\" [ field-value ]\r\n\r\n;;;; 5 Request\r\nRequest = Request-Line *(( general-header / request-header / entity-header ) CRLF) CRLF [ message-body ]\r\n\r\n;;;; 5.1 Request-Line\r\nRequest-Line = Method SP Request-URI SP HTTP-Version CRLF\r\n\r\n;;;; 5.1.1 Method\r\nMethod = \"OPTIONS\" / \"GET\" / \"HEAD\" / \"POST\" / \"PUT\" / \"DELETE\" / \"TRACE\" / \"CONNECT\" / extension-method\r\nextension-method = token\r\n\r\n;;;; 5.1.2 Request-URI\r\nRequest-URI = \"*\" / absoluteURI / abs-path / authority\r\n\r\n;;;; 5.3 Request Header Fields\r\nrequest-header = Accept / Accept-Charset / Accept-Encoding / Accept-Language / Authorization / Expect / From / Host / If-Match / If-Modified-Since / If-None-Match / If-Range / If-Unmodified-Since / Max-Forwards / Proxy-Authorization / Range / Referer / TE / User-Agent\r\n\r\n;;;; 6 Response\r\nResponse = Status-Line *(( general-header / response-header / entity-header ) CRLF) CRLF [ message-body ]\r\n\r\n;;;; 6.1 Status-Line\r\nStatus-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF\r\n\r\n;;;; 6.1.1 Status Code and Reason Phrase\r\nStatus-Code = \"100\" / \"101\" / \"200\" / \"201\" / \"202\" / \"203\" / \"204\" / \"205\" / \"206\" / \"300\" / \"301\" / \"302\" / \"303\" / \"304\" / \"305\" / \"307\" / \"400\" / \"401\" / \"402\" / \"403\" / \"404\" / \"405\" / \"406\" / \"407\" / \"408\" / \"409\" / \"410\" / \"411\" / \"412\" / \"413\" / \"414\" / \"415\" / \"416\" / \"417\" / \"500\" / \"501\" / \"502\" / \"503\" / \"504\" / \"505\" / extension-code\r\nextension-code = 3DIGIT\r\nReason-Phrase = *( reserved / unreserved / escaped / UTF8-NONASCII / UTF8-CONT / SP / HTAB ) ;*<TEXT, excluding CR, LF>\r\n\r\n;;;; 6.2 Response Header Fields\r\nresponse-header = Accept-Ranges / Age / ETag / Location / Proxy-Authenticate / Retry-After / Server / Vary / WWW-Authenticate\r\n\r\n;;;; 7.1 Entity Header Fields\r\nentity-header = Allow / Content-Encoding / Content-Language / Content-Length / Content-Location / Content-MD5 / Content-Range / Content-Type / Expires / Last-Modified / extension-header\r\nextension-header = message-header\r\n\r\n;;;; 7.2 Entity Body\r\nentity-body = *OCTET\r\n\r\n;;;; 7.2.1 Type\r\n;entity-body := Content-Encoding( Content-Type( data ) )\r\n\r\n;;;; 14.1 Accept\r\nAccept = \"Accept\" \":\" [ media-range [ accept-params ] ]\r\nmedia-range = ( \"*/*\" / ( type \"/\" \"*\" ) / ( type \"/\" subtype )) *( \";\" parameter )\r\naccept-params = \";\" \"q\" \"=\" qvalue *( accept-extension )\r\naccept-extension = \";\" token [ \"=\" ( token / quoted-string ) ]\r\n\r\n;;;; 14.2 Accept-Charset\r\nAccept-Charset = \"Accept-Charset\" \":\" Accept-Charset-Value *(COMMA Accept-Charset-Value)\r\nAccept-Charset-Value = token;FIXME:( charset / \"*\" )[ \";\" \"q\" \"=\" qvalue ] )\r\n\r\n;;;; 14.3 Accept-Encoding\r\nAccept-Encoding = \"Accept-Encoding\" \":\" Accept-Encoding-Value *(COMMA Accept-Encoding-Value)\r\nAccept-Encoding-Value = ( codings [ \";\" \"q\" \"=\" qvalue ] )\r\ncodings = ( content-coding / \"*\" )\r\n\r\n;;;; 14.4 Accept-Language\r\nAccept-Language = \"Accept-Language\" \":\" Accept-Language-Value *(COMMA Accept-Language-Value)\r\nAccept-Language-Value = ( language-range [ \";\" \"q\" \"=\" qvalue ] )\r\nlanguage-range = ( ( 1*8ALPHA *( \"-\" 1*8ALPHA ) ) / \"*\" )\r\n\r\n;;;; 14.5 Accept-Ranges\r\nAccept-Ranges = \"Accept-Ranges\" \":\" acceptable-ranges\r\nacceptable-ranges = (range-unit *(COMMA range-unit)) / \"none\"\r\n\r\n;;;; 14.6 Age\r\nAge = \"Age\" \":\" age-value\r\nage-value = delta-seconds\r\n \r\n;;;; 14.7 Allow\r\nAllow = \"Allow\" \":\" [Method]\r\n\r\n;;;; 14.8 Authorization\r\nAuthorization = \"Authorization\" \":\" credentials\r\n\r\n;;;; 14.9 Cache-Control\r\nCache-Control = \"Cache-Control\" \":\" cache-directive *(COMMA cache-directive)\r\ncache-directive = cache-request-directive / cache-response-directive\r\ncache-request-directive = \"no-cache\" / \"no-store\" / \"max-age\" \"=\" delta-seconds / \"max-stale\" [ \"=\" delta-seconds ] / \"min-fresh\" \"=\" delta-seconds / \"no-transform\" / \"only-if-cached\" / cache-extension \r\ncache-response-directive = \"public\" / \"private\" [ \"=\" DQUOTE field-name *(COMMA field-name) DQUOTE ] / \"no-cache\" [ \"=\" DQUOTE field-name *(COMMA field-name) DQUOTE ] / \"no-store\" / \"no-transform\" / \"must-revalidate\" / \"proxy-revalidate\" / \"max-age\" \"=\" delta-seconds / \"s-maxage\" \"=\" delta-seconds / cache-extension\r\ncache-extension = token [ \"=\" ( token / quoted-string ) ]\r\n\r\n;;;; 14.9.6 Cache Control Extensions\r\n;Cache-Control: private, community=\"UCI\"\r\n\r\n;;;; 14.10 Connection\r\nConnection = \"Connection\" \":\" (connection-token) *(COMMA connection-token)\r\nconnection-token = token\r\n\r\n;;;; 14.11 Content-Encoding\r\nContent-Encoding = \"Content-Encoding\" \":\" content-coding *(COMMA content-coding)\r\n\r\n;;;; 14.12 Content-Language\r\nContent-Language = \"Content-Language\" \":\" language-tag *(COMMA language-tag)\r\n\r\n;;;; 14.13 Content-Length\r\nContent-Length = \"Content-Length\" \":\" 1*DIGIT\r\n\r\n;;;; 14.14 Content-Location\r\nContent-Location = \"Content-Location\" \":\" ( absoluteURI / relativeURI )\r\n\r\n;;;; 14.15 Content-MD5\r\nContent-MD5 = \"Content-MD5\" \":\" md5-digest\r\nmd5-digest = *OCTET ;<base64 of 128 bit MD5 digest as per RFC 1864>\r\n\r\n;;;; 14.16 Content-Range\r\nContent-Range = \"Content-Range\" \":\" content-range-spec\r\ncontent-range-spec = byte-content-range-spec\r\nbyte-content-range-spec = bytes-unit SP byte-range-resp-spec \"/\" ( instance-length / \"*\" )\r\nbyte-range-resp-spec = (first-byte-pos \"-\" last-byte-pos) / \"*\"\r\ninstance-length = 1*DIGIT\r\n\r\n;;;; 14.17 Content-Type\r\nContent-Type = \"Content-Type\" \":\" media-type\r\n\r\n;;;; 14.18 Date\r\nDate = \"Date\" \":\" HTTP-date\r\n\r\n;;;; 14.19 ETag\r\nETag = \"ETag\" \":\" entity-tag\r\n\r\n;;;; 14.20 Expect\r\nExpect = \"Expect\" \":\" expectation *(COMMA expectation)\r\nexpectation = \"100-continue\" / expectation-extension\r\nexpectation-extension = token [ \"=\" ( token / quoted-string ) *expect-params ]\r\nexpect-params = \";\" token [ \"=\" ( token / quoted-string ) ]\r\n\r\n;;;; 14.21 Expires\r\nExpires = \"Expires\" \":\" HTTP-date\r\n\r\n;;;; 14.22 From\r\nFrom = \"From\" \":\" mailbox\r\nmailbox = token ; FIXME\r\n\r\n;;;; 14.23 Host\r\nHost = \"Host\" \":\" host [ \":\" port ] ; Section 3.2.2\r\n\r\n;;;; 14.24 If-Match\r\nIf-Match = \"If-Match\" \":\" ( \"*\" / entity-tag *(COMMA entity-tag) )\r\n\r\n;;;; 14.25 If-Modified-Since\r\nIf-Modified-Since = \"If-Modified-Since\" \":\" HTTP-date\r\n\r\n;;;; 14.26 If-None-Match\r\nIf-None-Match = \"If-None-Match\" \":\" ( \"*\" / entity-tag *(COMMA entity-tag) )\r\n\r\n;;;; 14.27 If-Range\r\nIf-Range = \"If-Range\" \":\" ( entity-tag / HTTP-date )\r\n\r\n;;;; 14.28 If-Unmodified-Since\r\nIf-Unmodified-Since = \"If-Unmodified-Since\" \":\" HTTP-date\r\n\r\n;;;; 14.29 Last-Modified\r\nLast-Modified = \"Last-Modified\" \":\" HTTP-date\r\n\r\n;;;; 14.30 Location\r\nLocation = \"Location\" \":\" absoluteURI\r\n\r\n;;;; 14.31 Max-Forwards\r\nMax-Forwards = \"Max-Forwards\" \":\" 1*DIGIT\r\n\r\n;;;; 14.32 Pragma\r\nPragma = \"Pragma\" \":\" pragma-directive *(COMMA pragma-directive)\r\npragma-directive = \"no-cache\" / extension-pragma\r\nextension-pragma = token [ \"=\" ( token / quoted-string ) ]\r\n\r\n;;;; 14.33 Proxy-Authenticate\r\nProxy-Authenticate = \"Proxy-Authenticate\" \":\" challenge *(COMMA challenge)\r\n\r\n;;;; 14.34 Proxy-Authorization\r\nProxy-Authorization = \"Proxy-Authorization\" \":\" credentials\r\n\r\n;;;; 14.35.1 Byte Ranges\r\nranges-specifier = byte-ranges-specifier\r\nbyte-ranges-specifier = bytes-unit \"=\" byte-range-set\r\nbyte-range-set = byte-range-set-value *(COMMA byte-range-set-value)\r\nbyte-range-set-value = ( byte-range-spec / suffix-byte-range-spec )\r\nbyte-range-spec = first-byte-pos \"-\" [last-byte-pos]\r\nfirst-byte-pos = 1*DIGIT\r\nlast-byte-pos = 1*DIGIT\r\nsuffix-byte-range-spec = \"-\" suffix-length\r\nsuffix-length = 1*DIGIT\r\n\r\n;;;; 14.35.2 Range Retrieval Requests\r\nRange = \"Range\" \":\" ranges-specifier\r\n\r\n;;;; 14.36 Referer\r\nReferer = \"Referer\" \":\" ( absoluteURI / relativeURI )\r\n\r\n;;;; 14.37 Retry-After\r\nRetry-After = \"Retry-After\" \":\" ( HTTP-date / delta-seconds )\r\n\r\n;;;; 14.38 Server\r\nServer = \"Server\" \":\" 1*( product / comment )\r\n\r\n;;;; 14.39 TE\r\nTE = \"TE\" \":\" [t-codings *(COMMA t-codings)]\r\nt-codings = \"trailers\" / ( transfer-extension [ accept-params ] )\r\n\r\n;;;; 14.40 Trailer\r\nTrailer = \"Trailer\" \":\" field-name *(COMMA field-name)\r\n\r\n;;;; 14.41 Transfer-Encoding\r\nTransfer-Encoding = \"Transfer-Encoding\" \":\" transfer-coding *(COMMA transfer-coding)\r\n\r\n;;;; 14.42 Upgrade\r\nUpgrade = \"Upgrade\" \":\" product *(COMMA product)\r\n\r\n;;;; 14.43 User-Agent\r\nUser-Agent = \"User-Agent\" \":\" 1*( product / comment )\r\n\r\n;;;; 14.44 Vary\r\nVary = \"Vary\" \":\" ( \"*\" / field-name *(COMMA field-name) )\r\n\r\n;;;; 14.45 Via\r\nVia = \"Via\" \":\" Via-Value *(COMMA Via-Value)\r\nVia-Value = ( received-protocol received-by [ comment ] )\r\nreceived-protocol = [ protocol-name \"/\" ] protocol-version\r\nprotocol-name = token\r\nprotocol-version = token\r\nreceived-by = ( host [ \":\" port ] ) / pseudonym\r\npseudonym = token\r\n\r\n;;;; 14.46 Warning\r\nWarning = \"Warning\" \":\" warning-value *(COMMA warning-value)\r\nwarning-value = warn-code SP warn-agent SP warn-text [SP warn-date]\r\nwarn-code = 3DIGIT\r\nwarn-agent = ( host [ \":\" port ] ) / pseudonym ; the name or pseudonym of the server adding ; the Warning header, for use in debugging\r\nwarn-text = quoted-string\r\nwarn-date = DQUOTE HTTP-date DQUOTE\r\n\r\n;;;; 14.47 WWW-Authenticate\r\nWWW-Authenticate = \"WWW-Authenticate\" \":\" challenge *(COMMA challenge)\r\n" }

{ "content": "start = CHAR\r\n" }

{ "content": "#ABNF 1.0 ISO-8859-1;\nlanguage en-US;\nmode voice;\nroot $root;\n\n$root = [$optionalphrase] $digit $digit $digit $digit $digit $digit $digit\n$digit $digit $digit $digit $digit ;\n\n$optionalphrase = my social security number is\n| my social security is\n| my number is\n| my social is\n;\n$digit = one | two | three | four | five | six | seven | eight | nine | zero | oh ;\n" }

{ "content": "language en-US;\r\nroot $srgs_root;\r\n\r\npublic $srgs_root = (($ellipse {out=rules.ellipse}) | ($command {out=rules.command}));\r\n\r\n$command = (($move $np_piece_ref {out.act_move=true;out.piece=rules.np_piece_ref}) | ($move $np_piece_ref $aux_again {out.act_move=true;out.piece=rules.np_piece_ref}) | ($move $np_piece_ref $movement {out.act_move=true;out.piece=rules.np_piece_ref;out.movement=rules.movement}) | ($capture $np_piece_ref {out.act_move=true;out.capture=rules.np_piece_ref}) | ($capture $np_piece_ref $aux_with $np_piece {out.act_move=true;out.capture=rules.np_piece_ref;out.piece=rules.np_piece}) | (yes {out.act_yes=true}) | (no {out.act_no=true}));\r\n\r\n$ellipse = (($number {out.number=rules.number}) | ($direction {out.direction=rules.direction}) | ($np_piece {out.piece=rules.np_piece})) {out.ellipse=true};\r\n\r\n$movement = (($number $aux_steps {out.steps=rules.number}) | ($direction {out.direction=rules.direction}) | ($number $aux_steps $direction {out.steps=rules.number;out.direction=rules.direction}) | ($aux_to $square {out.square=rules.square}));\r\n\r\n$relPiecePos = ($direction_relative $np_piece {out.rel=rules.direction_relative;out.piece=rules.np_piece});\r\n\r\n$relPiecePosSimp = ($direction_relative $np_piece_simp {out.rel=rules.direction_relative;out.piece=rules.np_piece_simp});\r\n\r\n$np_piece_simp = (($determiner $piece {out.type=rules.piece}));\r\n\r\n$np_piece = (($determiner $piece {out.type=rules.piece}) | ($determiner $piece [$aux_standing] $relPiecePosSimp {out.type=rules.piece;out.relPiecePos=rules.relPiecePosSimp}) | ($determiner $direction_extreme $piece {out.type=rules.piece;out.relPos=rules.direction_extreme}) | ($square {out.square=rules.square}));\r\n\r\n$np_piece_ref = (($np_piece {out=rules.np_piece}) | ($pron));\r\n\r\n$square = ($column $number {out.column=rules.column;out.row=rules.number});\r\n\r\n$aux_again = ((again) | (once more));\r\n\r\n$aux_standing = ((standing) | (that stands) | (that is standing) | (that is));\r\n\r\n$aux_steps = ((step) | (steps));\r\n\r\n$aux_to = (to);\r\n\r\n$aux_with = (with);\r\n\r\n$capture = ((take) | (capture));\r\n\r\n$column = ((a {A}) | (alpha {A}) | (b {B}) | (bravo {B}) | (c {C}) | (charlie {C}) | (d {D}) | (delta {D}) | (e {E}) | (echo {E}) | (f {F}) | (foxtrot {F}) | (g {G}) | (golf {G}) | (h {H}) | (hotel {H}));\r\n\r\n$determiner = ((the) | (the same));\r\n\r\n$direction = ((forward {Forward}) | (ahead {Forward}) | (backwards {Backward}) | (to the left {Left}) | (left {Left}) | (to the right {Right}) | (right {Right}));\r\n\r\n$direction_extreme = ((left {Left}) | (right {Right}) | (front {Front}) | (back {Back}) | (middle {Middle}));\r\n\r\n$direction_relative = ((on the left side of {LeftOf}) | (on the right side of {RightOf}) | (in front of {FrontOf}) | (behind {Behind}) | (next to {NextTo}));\r\n\r\n$move = (move);\r\n\r\n$number = ((one {1}) | (two {2}) | (three {3}) | (four {4}) | (five {5}) | (six {6}) | (seven {7}) | (eight {8}) | (1) | (2) | (3) | (4) | (5) | (6) | (7) | (8));\r\n\r\n$piece = ((king {King}) | (queen {Queen}) | (pawn {Pawn}) | (knight {Knight}) | (horse {Knight}) | (rook {Rook}) | (bishop {Bishop}) | (piece {Piece}) | (one {Piece}));\r\n\r\n$pron = (it);\r\n\r\n" }

{ "content": "#ABNF 1.0 gb2312;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main = $place1 $place2 ;\n$place1 = 打开 | 关闭;\n$place2 = 电视 | 台灯 | 电脑 | 空调;" }

{ "content": "; Ockam DIDs conform with the Generic DID Scheme described in the DID spec.\n; https://w3c-ccg.github.io/did-spec/#the-generic-did-scheme\n; The format of the ockam-specific-idstring is described in this file in ABNF\n\nockam-did = \"did:ockam:\" ockam-specific-idstring\n\nockam-specific-idstring = *(zone \":\") idstring\n\nzone = 1*zonechar\nzonechar = %x61-7A / DIGIT ; 61-7A is a-z in US-ASCII\n\nidstring = 28*31(base58char)\nbase58char = \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\" / \"A\" / \"B\" / \"C\"\n / \"D\" / \"E\" / \"F\" / \"G\" / \"H\" / \"J\" / \"K\" / \"L\" / \"M\" / \"N\" / \"P\" / \"Q\"\n / \"R\" / \"S\" / \"T\" / \"U\" / \"V\" / \"W\" / \"X\" / \"Y\" / \"Z\" / \"a\" / \"b\" / \"c\"\n / \"d\" / \"e\" / \"f\" / \"g\" / \"h\" / \"i\" / \"j\" / \"k\" / \"m\" / \"n\" / \"o\" / \"p\"\n / \"q\" / \"r\" / \"s\" / \"t\" / \"u\" / \"v\" / \"w\" / \"x\" / \"y\" / \"z\"\n" }

{ "content": "; ABNF Syntax for ivy, a programming language for ethereum virtual machine\n; based on RFC 5234 (https://tools.ietf.org/html/rfc5234).\n\n; Arithmetic operators\nplus = \"+\" whitespace\nminus = \"-\" whitespace\nmul = \"*\" whitespace\ndiv = \"/\" whitespace\nmod = \"%\" whitespace\n\n; Comparison operators\ngreater-than = \">\" whitespace\nless-than = \"<\" whitespace\nequals = \"==\" whitespace\n\n; Other operators\nequal = \"=\" whitespace\nopen-bracket = \"[\" whitespace\nclose-bracket = \"]\" whitespace\nopen-parens = \"(\" whitespace\nclose-parens = \")\" whitespace\nstmt-separator = \";\" whitespace\nstmt-end = stmt-separator whitespace end-of-line\nline-comment = \"--\" whitespace\nsingle-quote = \"'\" whitespace\ndot = \".\"\ncurly-open = \"{\" whitespace\ncurly-close = \"}\" whitespace\ncomma = \",\" whitespace\n\n; Hex characters for case senstivity\n; These char sequences can be generated with the following Haskell function:\n; \n; convert :: String -> String\n; convert = (\"%x\" ++) . intercalate \".\" . map (flip showHex \"\" . ord)\nint = %x69.6E.74\nchar = %x63.68.61.72\nbool = %x62.6F.6F.6C\nwhile = %x77.68.69.6C.65\ntimes = %x74.69.6D.65.73\nendtimes = %x65.6E.64 times\nif = %x69.66\nreturn = %x72.65.74.75.72.6e\nelse = %x65.6c.73.65\ntrue = %x74.72.75.65\nfalse = %x66.61.6c.73.65\n\n; Utilities\nend-of-line =\n %x0A ; \"\\n\"\n / %x0D.0A ; \"\\r\\n\"\n\nALPHA =\n %x41-5A ; [A-Z]\n / %x61-7A ; [a-z]\n\nDIGIT = %x30-39 ; ASCII 0-9\n\nALPHANUM = *(ALPHA / DIGIT)\n\ntab = %x09\n\nsingle-whitespace =\n \" \"\n / tab\n\nwhitespace = *single-whitespace\n\noperator =\n plus\n / minus\n / mul\n / div\n / mod\n / greater-than\n / less-than\n / equals\n\nprim-type =\n int\n / char\n / bool\n\narr-type = prim-type open-bracket int-literal close-bracket\n\ntype =\n prim-type\n / arr-type\n\n; Statements\nblock = curly-open end-of-line stmts curly-close whitespace stmt-end\nvar-decl = type identifier whitespace equal whitespace expr\nassignment = identifier whitespace equal\ntyped-assignment = prim-type assignment\ndecl-and-assignment = var-decl whitespace equal whitespace expr\narr-assignment = identifier open-bracket int-literal close-bracket whitespace equal expr\nbinop = expr whitespace operator expr\ntimes-stmt = int-literal dot times block endtimes\nwhile-stmt = while whitespace open-parens expr close-parens\nif-stmt = if open-parens expr close-parens block\nif-then-else-stmt = if-stmt else block\n\nstmt =\n var-decl\n / decl-and-assignment\n / assignment\n / arr-assignment\n / times-stmt\n / while-stmt\n / if-stmt\n / if-then-else-stmt\n / return\n / expr\n\nstmts =\n stmt whitespace stmt-end\n / stmt whitespace stmt-end stmts\n\n; Expressions\nint-literal = *DIGIT\nchar-literal = single-quote ALPHANUM single-quote\nbool-literal = true / false\nidentifier = *ALPHA\narr-identifier = identifier open-bracket expr close-bracket\ncomma-sep-expr = expr / expr comma comma-sep-expr\nfunc-call = identifier open-parens comma-sep-expr close-parens\narray-expr = curly-open comma-sep-expr curly-close\n\nexpr =\n int-literal\n / char-literal\n / bool-literal\n / identifier\n / arr-identifier\n / binop\n / func-call\n / array-expr\n" }

{ "content": "#ABNF 1.0;\nlanguage pl-pl;\nmode voice;\nroot $root;\ntag-format <semantics/1.0-literals>;\n\n$root = ($word) <1-4>;\n\n$word = (król {K}| hetman {Q}| wieża {R}| goniec {B}| skoczek {N}| pion { }) [na]\n (a {a}| be {b} | ce {c} | de {d} | e {e}| ef {f} | gie {g} | ha {h})\n (jeden {1} | dwa {2} | trzy {3} | cztery {4} | pięć {5} | sześć {6} | siedem {7} | osiem {8});\n\n\n\n\n\n\n" }

{ "content": "expr = union / array\nunion = term 0*1(\"|\" term)\nterm = type\narray = \"[\" custom 0*1(\",\" custom) \"]\"\ntype = custom / \"object\"\ncustom = \"Type\"" }

{ "content": "false = %X66.61.6c.73.65" }

{ "content": "TEL-param = TEL-text-param / TEL-uri-param\nTEL-value = TEL-text-value / TEL-uri-value\n ; Value and parameter MUST match.\n\nTEL-text-param = \"VALUE=text\"\nTEL-text-value = text\n\nTEL-uri-param = \"VALUE=uri\" / mediatype-param\nTEL-uri-value = URI\n\nTEL-param =/ type-param / pid-param / pref-param / altid-param\n / any-param\n\ntype-param-tel = \"text\" / \"voice\" / \"fax\" / \"cell\" / \"video\"\n / \"pager\" / \"textphone\" / iana-token / x-name\n ; type-param-tel MUST NOT be used with a property other than TEL.\n" }

{ "content": ";; Using http://instaparse.mojombo.com to test this.\n\nprogramme = 1*( declaration )\n\ndeclaration = rule-def / proc-def / rule-app\n\nrule-def = \"rule\" ws identifier ws [var-list] ws graph-def ws \"=>\" ws graph-def ws [condition] ws [addendum] ws (\";\" / \"end\")\n\nvar-list = \"<\" ws *(type ws \":\" ws identifier *(\",\" ws identifier) [\",\"]) ws \">\"\ncondition = \"where\" ws expression\naddendum = \"also\" ws statement\n\ngraph-def = \"[\" ws [node-def] ws *(\",\" node-def) ws [\",\"] ws [\"|\" ws [edge-def] *(\",\" edge-def) [\",\"]] ws \"]\"\n\nnode-def = node-id ws [label]\nedge-def = node-id ws [\"<\"] \"->\" ws node-id ws [label]\n\nnode-id = integer\n\nlabel = %x28 ws value ws [\",\" ws markset] ws [\",\"] ws %x29\nlabel =/ %x28 ws [markset] ws [\",\"] ws %x29\n\nvalue = literal-value\nvalue =/ identifier ; only in rule graphs\nvalue =/ expression ; only in RHS graphs \n\nmarkset = mark ws *( \",\" ws mark )\nmarkset =/ \"unmarked\"\n\nmark = (%x23 / %xAC) identifier\n\nliteral-value = number / string / boolean\n\nnumber = [\"-\"] (integer / rational / real)\n\ntype = \"int\" / \"real\" / \"rational\" / \"string\" / \"bool\" / \"any\"\n\ninteger = 1*(DIGIT)\nrational = integer \"/\" integer\nreal = integer \".\" integer\n\nstring = %x22 *(basic-char) %x22\n\nboolean = \"true\" / \"false\"\n\nbasic-char = unescaped / escaped\nunescaped = %x20-21 / %x23-5B / %x5D-7E / %x80-10FFFF\nescaped = escape escape-seq-char\n\nescape = %x5C ; \\\nescape-seq-char = %x22 ; \" quotation mark U+0022\nescape-seq-char =/ %x5C ; \\ reverse solidus U+005C\nescape-seq-char =/ %x2F ; / solidus U+002F\nescape-seq-char =/ %x62 ; b backspace U+0008\nescape-seq-char =/ %x66 ; f form feed U+000C\nescape-seq-char =/ %x6E ; n line feed U+000A\nescape-seq-char =/ %x72 ; r carriage return U+000D\nescape-seq-char =/ %x74 ; t tab U+0009\nescape-seq-char =/ %x75 4HEXDIG ; uXXXX U+XXXX\nescape-seq-char =/ %x55 8HEXDIG ; UXXXXXXXX U+XXXXXXXX\n\n\nproc-def = \"proc\" ws identifier ws *(rule-app) ws (\";\" / \"end\")\n\nrule-app = \"try\" ws \"(\" ws rule-seq ws \")\" ; try\nrule-app =/ \"if\" ws \"(\" ws rule-seq ws [\":\" ws rule-seq] ws [\":\" ws rule-seq] ws \")\" ; if\nrule-app =/ \"with\" ws \"(\" ws rule-seq ws [\":\" ws rule-seq] ws [\":\" ws rule-seq] ws \")\" ; with\nrule-app =/ \"{\" ws rule-seq ws *(\",\" ws rule-seq) ws \"}\" ; choose\nrule-app =/ \"(\" ws rule-seq ws \")\" ; sequence (for grouping)\nrule-app =/ rule-app \"!\" ; loop\nrule-app =/ \"noop\" ; noop\nrule-app =/ \"invalid\" ; invalid\nrule-app =/ identifier ; rule/proc\n\nrule-seq = 1*(rule-app ws)\n\n\nexpression = func-call ; builtin in/out/adj functions\nexpression =/ expression ws \"^\" ws expression\nexpression =/ expression ws \"/\" ws expression\nexpression =/ expression ws \"*\" ws expression\nexpression =/ expression ws \"+\" ws expression\nexpression =/ expression ws \"-\" ws expression\nexpression =/ expression ws \"%\" ws expression\nexpression =/ expression ws \"=\" ws expression\nexpression =/ expression ws \"!=\" ws expression\nexpression =/ expression ws \"<\" ws expression\nexpression =/ expression ws \"<=\" ws expression\nexpression =/ expression ws \">\" ws expression\nexpression =/ expression ws \">=\" ws expression\nexpression =/ expression ws \"&\" ws expression\nexpression =/ expression ws \"and\" ws expression\nexpression =/ expression ws \"|\" ws expression\nexpression =/ expression ws \"or\" ws expression\nexpression =/ expression ws \"xor\" ws expression\nexpression =/ expression ws \"^=\" ws expression\nexpression =/ expression ws \"$=\" ws expression\nexpression =/ expression ws \"~=\" ws expression\nexpression =/ \"-\" expression\nexpression =/ \"!\" expression\nexpression =/ \"not\" ws expression\nexpression =/ identifier\nexpression =/ literal-value\n\nfunc-call = identifier \"(\" ws [func-args] ws \")\"\nfunc-args = expression ws *( \",\" ws expression )\n\nstatement = func-call ; builtin print/debug procedures\n\n\nidentifier = 1*( ALPHA / DIGIT / %x5F ) [\"?\"] ; A-Z / a-z / 0-9 / _\n\n\n;; Whitespace\n\nws = *wschar\nwschar = %x20 ; Space\nwschar =/ %x09 ; Horizontal tab\nwschar =/ %x0A ; LF\nwschar =/ %x0D.0A ; CRLF\n" }

{ "content": "three = \"3\" ; Inline comment" }

{ "content": "; This is an RFC 2234 (ABNF) version of bnf.300. See\n; http://www.faqs.org/rfcs/rfc2234.html\n; \n; The only part that is not ABNF is the elidable terminators. The\n; conversion was done entirely programatically, by a perl program.\n; \n; All rules have the form:\n; \n; \tname = bnf-expression\n; \n; which means that the grammatical construct \"name\" is defined by\n; \"bnf-expression\". The number cross-references this grammar with\n; the rule numbers in the YACC grammar. The names are the same as those\n; in the YACC grammar, except that subrules are labeled with A, B, C, ... in the\n; YACC grammar and with 1, 2, 3, ... in this grammar. In addition, rule 971 is\n; \"simple_tag\" in the YACC grammar but \"stag\" in this grammar, because of its\n; frequent appearance.\n; \n; 1) Names in lower case are grammatical constructs.\n; 2) Names in UPPER CASE are selma'o (lexeme) names, and are terminals.\n; 3) Concatenation is expressed by juxtaposition with no operator symbol.\n; 4) / represents alternation (choice).\n; 5) [] represents an optional element.\n; 6) * represents optional repetition of the construct to the right.\n; 7) 1* represents one-or-more repetition of the construct to the right.\n; 8) () serves to indicate the grouping of the other operators.\n; 9) {} encloses an elidable terminator, which may be omitted (without change\n; of meaning) if no grammatical ambiguity results.\n;\n; A pre-processor should remove everything after the first fa'o.\n\n; --- GRAMMAR ---\n; Do not *ever* remove the line above this one.\n\ntext = [1*NAI] [1*CMENE *free / (indicators / 1*free / indicators 1*free)] [joik-jek] text-1 [FAhO]\n\ntext-1 = [1*(I [jek / joik] [[stag] BO] *free) / 1*NIhO *free] [paragraphs]\n\nparagraphs = paragraph [1*NIhO *free paragraphs]\n\nparagraph = (statement / fragment) *(I *free [statement / fragment])\n\nstatement = statement-1 / prenex statement\n\nstatement-1 = statement-2 *(I joik-jek [statement-2])\n\nstatement-2 = statement-3 [I [jek / joik] [stag] BO *free [statement-2]]\n\nstatement-3 = sentence / [tag] TUhE *free text-1 {TUhU *free}\n\nfragment = ek *free / gihek *free / quantifier / NA *free / terms {VAU *free} / prenex / relative-clauses / links / linkargs\n\nprenex = terms ZOhU *free\n\nsentence = [terms [CU *free]] bridi-tail\n\nsubsentence = sentence / prenex subsentence\n\nbridi-tail = bridi-tail-1 [gihek [stag] KE *free bridi-tail {KEhE *free} tail-terms]\n\nbridi-tail-1 = bridi-tail-2 *(gihek *free bridi-tail-2 tail-terms)\n\nbridi-tail-2 = bridi-tail-3 [gihek [stag] BO *free bridi-tail-2 tail-terms]\n\nbridi-tail-3 = selbri tail-terms / gek-sentence\n\ngek-sentence = gek subsentence gik subsentence tail-terms / [tag] KE *free gek-sentence {KEhE *free} / NA *free gek-sentence\n\ntail-terms = [terms] {VAU *free}\n\nterms = 1*terms-1\n\nterms-1 = terms-2 *(PEhE *free joik-jek terms-2)\n\nterms-2 = term *(CEhE *free term)\n\nterm = sumti / ( (tag / FA *free) (sumti / {KU *free}) ) / termset / NA KU *free\n\ntermset = NUhI *free gek terms {NUhU *free} gik terms {NUhU *free} / NUhI *free terms {NUhU *free}\n\nsumti = sumti-1 [VUhO *free relative-clauses]\n\nsumti-1 = sumti-2 [(ek / joik) [stag] KE *free sumti {KEhE *free}]\n\nsumti-2 = sumti-3 *(joik-ek sumti-3)\n\nsumti-3 = sumti-4 [(ek / joik) [stag] BO *free sumti-3]\n\nsumti-4 = sumti-5 / gek sumti gik sumti-4\n\nsumti-5 = [quantifier] sumti-6 [relative-clauses] / quantifier selbri {KU *free} [relative-clauses]\n\nsumti-6 = (LAhE *free / NAhE BO *free) [relative-clauses] sumti {LUhU *free} / KOhA *free / lerfu-string {BOI *free} / LA *free [relative-clauses] 1*CMENE *free / (LA / LE) *free sumti-tail {KU *free} / LI *free mex {LOhO *free} / ZO any-word *free / LU text {LIhU *free} / LOhU 1*any-word LEhU *free / ZOI any-word anything any-word *free\n\nsumti-tail = [sumti-6 [relative-clauses]] sumti-tail-1 / relative-clauses sumti-tail-1\n\nsumti-tail-1 = [quantifier] selbri [relative-clauses] / quantifier sumti\n\nrelative-clauses = relative-clause *(ZIhE *free relative-clause)\n\nrelative-clause = GOI *free term {GEhU *free} / NOI *free subsentence {KUhO *free}\n\nselbri = [tag] selbri-1\n\nselbri-1 = selbri-2 / NA *free selbri\n\nselbri-2 = selbri-3 [CO *free selbri-2]\n\nselbri-3 = 1*selbri-4\n\nselbri-4 = selbri-5 *(joik-jek selbri-5 / joik [stag] KE *free selbri-3 {KEhE *free})\n\nselbri-5 = selbri-6 [(jek / joik) [stag] BO *free selbri-5]\n\nselbri-6 = tanru-unit [BO *free selbri-6] / [NAhE *free] guhek selbri gik selbri-6\n\ntanru-unit = tanru-unit-1 *(CEI *free tanru-unit-1)\n\ntanru-unit-1 = tanru-unit-2 [linkargs]\n\ntanru-unit-2 = BRIVLA *free / GOhA [RAhO] *free / KE *free selbri-3 {KEhE *free} / ME *free sumti {MEhU *free} [MOI *free] / (number / lerfu-string) MOI *free / NUhA *free mex-operator / SE *free tanru-unit-2 / JAI *free [tag] tanru-unit-2 / any-word 1*(ZEI any-word) / NAhE *free tanru-unit-2 / NU [NAI] *free *(joik-jek NU [NAI] *free) subsentence {KEI *free}\n\nlinkargs = BE *free term [links] {BEhO *free}\n\nlinks = BEI *free term [links]\n\nquantifier = number {BOI *free} / VEI *free mex {VEhO *free}\n\nmex = mex-1 *(operator mex-1) / FUhA *free rp-expression\n\nmex-1 = mex-2 [BIhE *free operator mex-1]\n\nmex-2 = operand / [PEhO *free] operator 1*mex-2 {KUhE *free}\n\nrp-expression = rp-operand rp-operand operator\n\nrp-operand = operand / rp-expression\n\noperator = operator-1 *(joik-jek operator-1 / joik [stag] KE *free operator {KEhE *free})\n\noperator-1 = operator-2 / guhek operator-1 gik operator-2 / operator-2 (jek / joik) [stag] BO *free operator-1\n\noperator-2 = mex-operator / KE *free operator {KEhE *free}\n\nmex-operator = SE *free mex-operator / NAhE *free mex-operator / MAhO *free mex {TEhU *free} / NAhU *free selbri {TEhU *free} / VUhU *free\n\noperand = operand-1 [(ek / joik) [stag] KE *free operand {KEhE *free}]\n\noperand-1 = operand-2 *(joik-ek operand-2)\n\noperand-2 = operand-3 [(ek / joik) [stag] BO *free operand-2]\n\noperand-3 = quantifier / lerfu-string {BOI *free} / NIhE *free selbri {TEhU *free} / MOhE *free sumti {TEhU *free} / JOhI *free 1*mex-2 {TEhU *free} / gek operand gik operand-3 / (LAhE *free / NAhE BO *free) operand {LUhU *free}\n\nnumber = PA *(PA / lerfu-word)\n\nlerfu-string = lerfu-word *(PA / lerfu-word)\n\nlerfu-word = BY / any-word BU / LAU lerfu-word / TEI lerfu-string FOI\n\nek = [NA] [SE] A [NAI]\n\ngihek = [NA] [SE] GIhA [NAI]\n\njek = [NA] [SE] JA [NAI]\n\njoik = [SE] JOI [NAI] / interval / GAhO interval GAhO\n\ninterval = [SE] BIhI [NAI]\n\njoik-ek = joik *free / ek *free\n\njoik-jek = joik *free / jek *free\n\ngek = [SE] GA [NAI] *free / joik GI *free / stag gik\n\nguhek = [SE] GUhA [NAI] *free\n\ngik = GI [NAI] *free\n\ntag = tense-modal *(joik-jek tense-modal)\n\nstag = simple-tense-modal *((jek / joik) simple-tense-modal)\n\ntense-modal = simple-tense-modal *free / FIhO *free selbri {FEhU *free}\n\nsimple-tense-modal = [NAhE] [SE] BAI [NAI] [KI] / [NAhE] ((time [space] / space [time]) / CAhA / (time [space] / space [time]) CAhA) [KI] / KI / CUhE\n\ntime = ZI [1*time-offset] [ZEhA [PU [NAI]]] [1*interval-property] / [ZI] 1*time-offset [ZEhA [PU [NAI]]] [1*interval-property] / [ZI] [1*time-offset] ZEhA [PU [NAI]] [1*interval-property] / [ZI] [1*time-offset] [ZEhA [PU [NAI]]] 1*interval-property\n\ntime-offset = PU [NAI] [ZI]\n\nspace = VA [1*space-offset] [space-interval] [(MOhI space-offset)] / [VA] 1*space-offset [space-interval] [(MOhI space-offset)] / [VA] [1*space-offset] space-interval [(MOhI space-offset)] / [VA] [1*space-offset] [space-interval] (MOhI space-offset)\n\nspace-offset = FAhA [NAI] [VA]\n\nspace-interval = (((VEhA / VIhA / VEhA VIhA) [FAhA [NAI]]) / space-int-props / ((VEhA / VIhA / VEhA VIhA) [FAhA [NAI]]) space-int-props)\n\nspace-int-props = 1*(FEhE interval-property)\n\ninterval-property = number ROI [NAI] / TAhE [NAI] / ZAhO [NAI]\n\nfree = SEI *free [terms [CU *free]] selbri {SEhU} / SOI *free sumti [sumti] {SEhU} / vocative [relative-clauses] selbri [relative-clauses] {DOhU} / vocative [relative-clauses] 1*CMENE *free [relative-clauses] {DOhU} / vocative [sumti] {DOhU} / (number / lerfu-string) MAI / TO text {TOI} / XI *free (number / lerfu-string) {BOI} / XI *free VEI *free mex {VEhO}\n\nvocative = (1*(COI [NAI]) / DOI / 1*(COI [NAI]) DOI)\n\nindicators = [FUhE] 1*indicator\n\nindicator = (UI / CAI) [NAI] / Y / DAhO / FUhO\n\n; The following rules are non-formal:\n; \n; word<1100> = [BAhE] any-word [indicators]\n; \n; any-word = \"any single word (no compound cmavo)\"\n; \n; anything = \"any text at all, whether Lojban or not\"\n; \n; null<1101> = any-word SI / utterance SA / text SU\n\n; --- MORPHOLOGY ---\n; Do not *ever* remove the line above this one.\n; (currently, nothing special is done to the morphology section; it\n; is treated as part of the main grammar)\n\n; a string of lexable Lojban words \nany_words = 1*any_word \n; any single lexable Lojban words \nany_word = BRIVLA / CMENE / CMAVO \n; a possibly unlexable phoneme string \nanything = \"AnyThing\" \n\n; any brivla \n; For now: gismu pattern.\n; BRIVLA\t: /[bcdfgjklmnprstvxz]{2}['a-z]{2,}[aeiou]/\n;\t\t/ /[bcdfgjklmnprstvxz][aeiou][bcdfgjklmnprstvxz]y?[bcdfgjklmnprstvxz]['a-z]*[aeiou]/\n;\t\t/ /[bcdfgjklmnprstvxz][aeiou]'?[aeiou][bcdfgjklmnprstvxz]{2}['a-z]*[aeiou]/\n;\t\t/ /[aeiou]('?[aeiou]){,2}[bcdfgjklmnprstvxz]{2}['a-z]*[aeiou]/\nBRIVLA = \"broda\" / \"brode\" / \"brodi\" / \"brodo\" / \"brodu\"\n\n; CMENE = /\\.?[,'a-pr-z]+[bcdfgjklmnprstvxz]/\nCMENE = \"cmene\" / \".alis\" / \"bab\"\n\nCMAVO = A / BAI / BAhE / BE / BEI / BEhO / BIhE / BIhI / BO / BOI / BU / BY / CAI / CAhA / CEI / CEhE / CO / COI / CU / CUhE / DAhO / DOI / DOhU / FA / FAhA / FAhO / FEhE / FEhU / FIhO / FOI / FUhA / FUhE / FUhO / GA / GAhO / GEhU / GI / GIhA / GOI / GOhA / GUhA / I / JA / JAI / JOI / JOhI / KE / KEI / KEhE / KI / KOhA / KU / KUhE / KUhO / LA / LAU / LAhE / LE / LEhU / LI / LIhU / LOhO / LOhU / LU / LUhU / MAI / MAhO / ME / MEhU / MOI / MOhE / MOhI / NA / NAI / NAhE / NAhU / NIhE / NIhO / NOI / NU / NUhA / NUhI / NUhU / PA / PEhE / PEhO / PU / RAhO / ROI / SA / SE / SEI / SEhU / SI / SOI / SU / TAhE / TEI / TEhU / TO / TOI / TUhE / TUhU / UI / VA / VAU / VEI / VEhA / VEhO / VIhA / VUhO / VUhU / XI / Y / ZAhO / ZEI / ZEhA / ZI / ZIhE / ZO / ZOI / ZOhU\n\n; --- SELMAHO ---\n; Do not *ever* remove the line above this one.\n; Special processing is done on the selma'o to stop abnf2bison from\n; breaking them up into many, many productions.\n\n; eks; basic afterthought logical connectives \nA = \".a\" / \".e\" / \"ji\" / \".o\" / \".u\" \n\n; modal operators \nBAI = \"du'o\" / \"si'u\" / \"zau\" / \"ki'i\" / \"du'i\" / \"cu'u\" / \"tu'i\" / \"ti'u\" / \"di'o\" / \"ji'u\" / \"ri'a\" / \"ni'i\" / \"mu'i\" / \"ki'u\" / \"va'u\" / \"koi\" / \"ca'i\" / \"ta'i\" / \"pu'e\" / \"ja'i\" / \"kai\" / \"bai\" / \"fi'e\" / \"de'i\" / \"ci'o\" / \"mau\" / \"mu'u\" / \"ri'i\" / \"ra'i\" / \"ka'a\" / \"pa'u\" / \"pa'a\" / \"le'a\" / \"ku'u\" / \"tai\" / \"bau\" / \"ma'i\" / \"ci'e\" / \"fau\" / \"po'i\" / \"cau\" / \"ma'e\" / \"ci'u\" / \"ra'a\" / \"pu'a\" / \"li'e\" / \"la'u\" / \"ba'i\" / \"ka'i\" / \"sau\" / \"fa'e\" / \"be'i\" / \"ti'i\" / \"ja'e\" / \"ga'a\" / \"va'o\" / \"ji'o\" / \"me'a\" / \"do'e\" / \"ji'e\" / \"pi'o\" / \"gau\" / \"zu'e\" / \"me'e\" / \"rai\" \n; next word intensifier \nBAhE = \"ba'e\" / \"za'e\" \n; sumti link to attach sumti to a selbri \nBE = \"be\" \n; multiple sumti separator between BE, BEI \nBEI = \"bei\" \n; terminates BEBEI specified descriptors \nBEhO = \"be'o\" \n; prefix for high-priority MEX operator \nBIhE = \"bi'e\" \n; interval component of JOI \nBIhI = \"mi'i\" / \"bi'o\" / \"bi'i\" \n; joins two units with shortest scope \nBO = \"bo\"\n; number or lerfu-string terminator \nBOI = \"boi\" \n; turns any word into a BY lerfu word \nBU = \"bu\" \n; individual lerfu words \nBY = \"jo'o\" / \"ru'o\" / \"ge'o\" / \"je'o\" / \"lo'a\" / \"na'a\" / \"se'e\" / \"to'a\" / \"ga'e\" / \".y'y\" / \"by\" / \"cy\" / \"dy\" / \"fy\" / \"gy\" / \"jy\" / \"ky\" / \"ly\" / \"my\" / \"ny\" / \"py\" / \"ry\" / \"sy\" / \"ty\" / \"vy\" / \"xy\" / \"zy\" \n\n; specifies actualitypotentiality of tense \nCAhA = \"ca'a\" / \"pu'i\" / \"nu'o\" / \"ka'e\" \n; afterthought intensity marker \nCAI = \"pei\" / \"cai\" / \"cu'i\" / \"sai\" / \"ru'e\" \n; pro-bridi assignment operator \nCEI = \"cei\" \n; afterthought term list connective \nCEhE = \"ce'e\" \n; names; require consonant end, then pause no\n; LA or DOI selma'o embedded, pause before if\n; vowel initial and preceded by a vowel \n; tanru inversion \nCO = \"co\" \nCOI = \"ju'i\" / \"coi\" / \"fi'i\" / \"ta'a\" / \"mu'o\" / \"fe'o\" / \"co'o\" / \"pe'u\" / \"ke'o\" / \"nu'e\" / \"re'i\" / \"be'e\" / \"je'e\" / \"mi'e\" / \"ki'e\" / \"vi'o\"\n; vocative marker permitted inside names; must\n; always be followed by pause or DOI \n; separator between head sumti and selbri \nCU = \"cu\" \n; tensemodal question \nCUhE = \"cu'e\" / \"nau\" \n\n; cancel anaphoracataphora assignments \nDAhO = \"da'o\" \n; vocative marker \nDOI = \"doi\" \n; terminator for DOI-marked vocatives \nDOhU = \"do'u\" \n\n; modifier head generic case tag \nFA = \"fa\" / \"fe\" / \"fi\" / \"fo\" / \"fu\" / \"fai\" / \"fi'a\" \n; superdirections in space \nFAhA = \"du'a\" / \"be'a\" / \"ne'u\" / \"vu'a\" / \"ga'u\" / \"ti'a\" / \"ni'a\" / \"ca'u\" / \"zu'a\" / \"ri'u\" / \"ru'u\" / \"re'o\" / \"te'e\" / \"bu'u\" / \"ne'a\" / \"pa'o\" / \"ne'i\" / \"to'o\" / \"zo'i\" / \"ze'o\" / \"zo'a\" / \"fa'a\" \nFAhO = \"fa'o\"\n; normally elided 'done pause' to indicate end\n; of utterance string \n; space interval mod flag \nFEhE = \"fe'e\" \n; ends bridi to modal conversion \nFEhU = \"fe'u\" \n; marks bridi to modal conversion \nFIhO = \"fi'o\" \n; end compound lerfu \nFOI = \"foi\" \n; reverse Polish flag \nFUhA = \"fu'a\" \n; open long scope for indicator \nFUhE = \"fu'e\" \n; close long scope for indicator \nFUhO = \"fu'o\" \n\n; geks; forethought logical connectives \nGA = \"ge\" / \"ge'i\" / \"go\" / \"ga\" / \"gu\" \n; openclosed interval markers for BIhI \nGAhO = \"ke'i\" / \"ga'o\" \n; marker ending GOI relative clauses \nGEhU = \"ge'u\" \n; forethought medial marker \nGI = \"gi\" \n; logical connectives for bridi-tails \nGIhA = \"gi'e\" / \"gi'i\" / \"gi'o\" / \"gi'a\" / \"gi'u\" \n; attaches a sumti modifier to a sumti \nGOI = \"no'u\" / \"ne\" / \"po\" / \"goi\" / \"po'u\" / \"pe\" / \"po'e\" \n; pro-bridi \nGOhA = \"mo\" / \"nei\" / \"go'u\" / \"go'o\" / \"go'i\" / \"no'a\" / \"go'e\" / \"go'a\" / \"du\" / \"bu'a\" / \"bu'e\" / \"bu'i\" / \"co'e\" \n; GEK for tanru units, corresponds to JEKs \nGUhA = \"gu'e\" / \"gu'i\" / \"gu'o\" / \"gu'a\" / \"gu'u\" \n\n; sentence link \nI = \".i\" \n\n; jeks; logical connectives within tanru \nJA = \"je\" / \"je'i\" / \"jo\" / \"ja\" / \"ju\" \n; modal conversion flag \nJAI = \"jai\" \n; flags an array operand \nJOhI = \"jo'i\" \n; non-logical connectives \nJOI = \"fa'u\" / \"pi'u\" / \"joi\" / \"ce'o\" / \"ce\" / \"jo'u\" / \"ku'a\" / \"jo'e\" / \"ju'e\" \n\n; left long scope marker \nKE = \"ke\" \n; right terminator for KE groups \nKEhE = \"ke'e\" \n; right terminator, NU abstractions \nKEI = \"kei\" \n; multiple utterance scope for tenses \nKI = \"ki\" \n; sumti anaphora \nKOhA = \"da\" / \"de\" / \"di\" / \"da'u\" / \"da'e\" / \"di'u\" / \"di'e\" / \"de'u\" / \"de'e\" / \"dei\" / \"do'i\" / \"ko\" / \"mi\" / \"mi'o\" / \"ma'a\" / \"mi'a\" / \"do\" / \"do'o\" / \"ko'a\" / \"fo'u\" / \"ko'e\" / \"ko'i\" / \"ko'o\" / \"ko'u\" / \"fo'a\" / \"fo'e\" / \"fo'i\" / \"fo'o\" / \"vo'a\" / \"vo'e\" / \"vo'i\" / \"vo'o\" / \"vo'u\" / \"ru\" / \"ri\" / \"ra\" / \"ta\" / \"tu\" / \"ti\" / \"zi'o\" / \"ke'a\" / \"ma\" / \"zu'i\" / \"zo'e\" / \"ce'u\" \n; right terminator for descriptions, etc. \nKU = \"ku\" \n; MEX forethought delimiter \nKUhE = \"ku'e\" \n; right terminator, NOI relative clauses \nKUhO = \"ku'o\" \n\n; name descriptors \nLA = \"la\" / \"lai\" / \"la'i\" \n; lerfu prefixes \nLAU = \"ce'a\" / \"lau\" / \"zai\" / \"tau\" \n; sumti qualifiers \nLAhE = \"tu'a\" / \"lu'a\" / \"lu'o\" / \"la'e\" / \"vu'i\" / \"lu'i\" / \"lu'e\" \n; sumti descriptors \nLE = \"le\" / \"lei\" / \"loi\" / \"lo\" / \"le'i\" / \"lo'i\" / \"le'e\" / \"lo'e\" \n; possibly ungrammatical text right quote \nLEhU = \"le'u\" \n; convert number to sumti \nLI = \"me'o\" / \"li\" \n; grammatical text right quote \nLIhU = \"li'u\" \n; elidable terminator for LI \nLOhO = \"lo'o\" \n; possibly ungrammatical text left quote \nLOhU = \"lo'u\" \n; grammatical text left quote \nLU = \"lu\" \n; LAhE close delimiter \nLUhU = \"lu'u\" \n\n; change MEX expressions to MEX operators \nMAhO = \"ma'o\" \n; change numbers to utterance ordinals \nMAI = \"mo'o\" / \"mai\" \n; converts a sumti into a tanru_unit \nME = \"me\" \n; terminator for ME \nMEhU = \"me'u\" \n; change sumti to operand, inverse of LI \nMOhE = \"mo'e\" \n; motion tense marker \nMOhI = \"mo'i\" \n; change number to selbri \nMOI = \"mei\" / \"moi\" / \"si'e\" / \"cu'o\" / \"va'e\" \n\n; bridi negation \nNA = \"ja'a\" / \"na\" \n; attached to words to negate them \nNAI = \"nai\" \n; scalar negation \nNAhE = \"to'e\" / \"je'a\" / \"na'e\" / \"no'e\" \n; change a selbri into an operator \nNAhU = \"na'u\" \n; change selbri to operand; inverse of MOI \nNIhE = \"ni'e\" \n; new paragraph; change of subject \nNIhO = \"ni'o\" / \"no'i\" \n; attaches a subordinate clause to a sumti \nNOI = \"voi\" / \"noi\" / \"poi\" \n; abstraction \nNU = \"ni\" / \"du'u\" / \"si'o\" / \"nu\" / \"li'i\" / \"ka\" / \"jei\" / \"su'u\" / \"zu'o\" / \"mu'e\" / \"pu'u\" / \"za'i\" \n; change operator to selbri; inverse of MOhE \nNUhA = \"nu'a\" \n; marks the start of a termset \nNUhI = \"nu'i\" \n; marks the middle and end of a termset \nNUhU = \"nu'u\" \n\n; numbers and numeric punctuation \nPA = \"no\" / \"pa\" / \"re\" / \"ci\" / \"vo\" / \"mu\" / \"xa\" / \"ze\" / \"bi\" / \"so\" / \"dau\" / \"fei\" / \"gai\" / \"jau\" / \"rei\" / \"vai\" / \"pi\" / \"pi'e\" / \"fi'u\" / \"za'u\" / \"me'i\" / \"ni'u\" / \"ki'o\" / \"ce'i\" / \"ma'u\" / \"ra'e\" / \"da'a\" / \"so'a\" / \"ji'i\" / \"su'o\" / \"su'e\" / \"ro\" / \"rau\" / \"so'u\" / \"so'i\" / \"so'e\" / \"so'o\" / \"mo'a\" / \"du'e\" / \"te'o\" / \"ka'o\" / \"ci'i\" / \"tu'o\" / \"xo\" / \"pai\" / \"no'o\" \n; afterthought termset connective prefix \nPEhE = \"pe'e\" \n; forethought (Polish) flag \nPEhO = \"pe'o\" \n; directions in time \nPU = \"ba\" / \"pu\" / \"ca\" \n\n; flag for modified interpretation of GOhI \nRAhO = \"ra'o\" \n; converts number to extensional tense \nROI = \"re'u\" / \"roi\" \n\nSA = \"sa\"\n; metalinguistic eraser to the beginning of\n; the current utterance \n; conversions \nSE = \"se\" / \"te\" / \"ve\" / \"xe\" \n; metalinguistic bridi insert marker \nSEI = \"sei\" / \"ti'o\" \n; metalinguistic bridi end marker \nSEhU = \"se'u\" \n; metalinguistic single word eraser \nSI = \"si\" \n; reciprocal sumti marker \nSOI = \"soi\" \n; metalinguistic eraser of the entire text \nSU = \"su\" \n\n; tense interval properties \nTAhE = \"ru'i\" / \"ta'e\" / \"di'i\" / \"na'o\" \n; closing gap for MEX constructs \nTEhU = \"te'u\" \n; start compound lerfu \nTEI = \"tei\" \n; left discursive parenthesis \nTO = \"to'i\" / \"to\" \n; right discursive parenthesis \nTOI = \"toi\" \n; multiple utterance scope mark \nTUhE = \"tu'e\" \n; multiple utterance end scope mark \nTUhU = \"tu'u\" \n\n; attitudinals, observationals, discursives \nUI = \".i'a\" / \".ie\" / \".a'e\" / \".u'i\" / \".i'o\" / \".i'e\" / \".a'a\" / \".ia\" / \".o'i\" / \".o'e\" / \".e'e\" / \".oi\" / \".uo\" / \".e'i\" / \".u'o\" / \".au\" / \".ua\" / \".a'i\" / \".i'u\" / \".ii\" / \".u'a\" / \".ui\" / \".a'o\" / \".ai\" / \".a'u\" / \".iu\" / \".ei\" / \".o'o\" / \".e'a\" / \".uu\" / \".o'a\" / \".o'u\" / \".u'u\" / \".e'o\" / \".io\" / \".e'u\" / \".ue\" / \".i'i\" / \".u'e\" / \"ba'a\" / \"ja'o\" / \"ca'e\" / \"su'a\" / \"ti'e\" / \"ka'u\" / \"se'o\" / \"za'a\" / \"pe'i\" / \"ru'a\" / \"ju'a\" / \"ta'o\" / \"ra'u\" / \"li'a\" / \"ba'u\" / \"mu'a\" / \"do'a\" / \"to'u\" / \"va'i\" / \"pa'e\" / \"zu'u\" / \"sa'e\" / \"la'a\" / \"ke'u\" / \"sa'u\" / \"da'i\" / \"je'u\" / \"sa'a\" / \"kau\" / \"ta'u\" / \"na'i\" / \"jo'a\" / \"bi'u\" / \"li'o\" / \"pau\" / \"mi'u\" / \"ku'i\" / \"ji'a\" / \"si'a\" / \"po'o\" / \"pe'a\" / \"ro'i\" / \"ro'e\" / \"ro'o\" / \"ro'u\" / \"ro'a\" / \"re'e\" / \"le'o\" / \"ju'o\" / \"fu'i\" / \"dai\" / \"ga'i\" / \"zo'o\" / \"be'u\" / \"ri'e\" / \"se'i\" / \"se'a\" / \"vu'e\" / \"ki'a\" / \"xu\" / \"ge'e\" / \"bu'o\" \n\n; distance in space-time \nVA = \"vi\" / \"va\" / \"vu\" \n; end simple bridi or bridi-tail \nVAU = \"vau\" \n; left MEX bracket \nVEI = \"vei\" \n; right MEX bracket \nVEhO = \"ve'o\" \n; MEX operator \nVUhU = \"ge'a\" / \"fu'u\" / \"pi'i\" / \"fe'i\" / \"vu'u\" / \"su'i\" / \"ju'u\" / \"gei\" / \"pa'i\" / \"fa'i\" / \"te'a\" / \"cu'a\" / \"va'a\" / \"ne'o\" / \"de'o\" / \"fe'a\" / \"sa'o\" / \"re'a\" / \"ri'o\" / \"sa'i\" / \"pi'a\" / \"si'i\" \n; space-time interval size \nVEhA = \"ve'u\" / \"ve'a\" / \"ve'i\" / \"ve'e\" \n; space-time dimensionality marker \nVIhA = \"vi'i\" / \"vi'a\" / \"vi'u\" / \"vi'e\" \nVUhO = \"vu'o\"\n; glue between logically connected sumti\n; and relative clauses \n\n; subscripting operator \nXI = \"xi\" \n\n; hesitation \nY = \".y\" \n\n; event properties - inchoative, etc. \nZAhO = \"co'i\" / \"pu'o\" / \"co'u\" / \"mo'u\" / \"ca'o\" / \"co'a\" / \"de'a\" / \"ba'o\" / \"di'a\" / \"za'o\" \n; time interval size tense \nZEhA = \"ze'u\" / \"ze'a\" / \"ze'i\" / \"ze'e\" \n; lujvo glue \nZEI = \"zei\" \n; time distance tense \nZI = \"zu\" / \"za\" / \"zi\" \n; conjoins relative clauses \nZIhE = \"zi'e\" \n; single word metalinguistic quote marker \nZO = \"zo\" \n; delimited quote marker \nZOI = \"zoi\" / \"la'o\" \n; prenex terminator (not elidable) \nZOhU = \"zo'u\" \n\n" }

{ "content": "\n// Exported Rules\n\n<tempnumber> = <threedigit> [POINT=>\".\" <onedigit>];\n\n\n" }

{ "content": "space = %x20\r\n\r\nalpha = %x41-5A / %x61-7A ; A-Z / a-z\r\n\r\ntext = *(*(alpha) *(space))\r\n" }

{ "content": "#ABNF 1.0 UTF-8;\n\nlanguage fi-FI;\nroot $root;\n\npublic $root = (([$greeting] [$filler] $productType {out.productType = rules.productType; out.confirm = meta.productType.text} [please]) | ($yes {out.yes=1}) | ($no {out.no=1}) | ($req_info {out.req_info=1}) | ($req_directions {out.req_directions=rules.req_directions}) | ($goodbye {out.goodbye=rules.goodbye}) | ($req_closing {out.req_closing=rules.req_closing}));\n\n$productType = (($coffee {out.type=\"coffee\"}) | ($electronics {out.type=\"electronics\"}) | ($clothing {out.type=\"clothing\"}));\n\n$buy = ((buy) | (get) | (find) | (have) |(drink));\n\npublic $req_directions = ([$greeting] (I need [some] directions {out.dest=\"null\"}) | (How can I ((get) | (go)) to $shops {out.dest=rules.shops; out.confirm=meta.shops.text}) | (Where can I find $shops {out.dest=rules.shops; out.confirm=meta.shops.text}) | ([Can you] Show me the way to $shops {out.dest=rules.shops; out.confirm=meta.shops.text}) | (Guide me to $shops {out.dest=rules.shops; out.confirm=meta.shops.text}) | (Where is $shops {out.dest=rules.shops; out.confirm=meta.shops.text}) | (direct me to $shops {out.dest=rules.shops; out.confirm=meta.shops.text}) | ([$shops {out.dest=rules.shops; out.confirm=meta.shops.text}]));\n\npublic $req_info = ([$greeting] (I need [some] information) | ($det have some questions) | (I want to ask you something) | (Can I ask you ((a [few] question?) | (something))));\n\npublic $coffee = [drink] [cup of] ((Etsin kahvilaa) | (coffee) | (cappuccino) | (latte) | (mocha) | (espresso));\n\n$electronics = (([mobile] phone) | (charger) | (TV) | (television) | (iphone) | (LG) | (Samsung) | (USB stick) | (phone covers) | (laptop) | (cable [for my phone]) | ([personal] computer));\n\n$clothing = ((shoes) | (jacket) | (t-shirt) | (skirt) | (belt) | (jeans) | (trousers) | (socks) | (shirt) | (suit) | (coat) | (underwear) | (lingerie) | (clothing [shop]));\n\n$det = ((I) | (we));\n\n$article = ((a) | (an) | (some));\n\n$greeting = ((Hello) | (Hi) | (Hi there) | (Good $partOfDay)) {out.req_greeting=1};\n\n$partOfDay = ((morning) | (afternoon) | (day) | (night));\n\n$number = ((one {out=1}) | (two {out=2}) | (three {out=3}) | (four {out=4}) | (five {out=5}) | (six {out=6}) | (seven {out=7}) | (eight {out=8}) | (nine {out=9}) | (ten {out=10}));\n\n$yes = ((yes) | (yes I do) | (sure) | (yeah) | (of course) | (okay));\n\n$no = ((no) | (no way) | (nope) | (not really) | (I don't think so));\n\n$filler = ((ahm) | (ah) | (eh) | (ehm) | (mm) | (can you (tell me) | (show me)));\n\npublic $shops = ((Starbucks) | (Hardware electronics) | (Costa) | (Tesco) | (Public) | (Primark) | (Phone heaven));\n\npublic $goodbye = ([OK] ((Bye) | (Goodbye) | (See you [later]) | (Cheers)));\n\n\n" }

{ "content": "#ABNF 1.0 ISO-8859-1;\nlanguage en-US;\nmode voice;\nroot $root;\n\n$root = $wmi-honda $alphanum $alphanum $alphanum $alphanum $alphanum $alphanum\n$alphanum_modelyear $alphanum $alphanum $alphanum $alphanum $alphanum $alphanum $alphanum ;\n\n//1H | 2H | 3H | 4S6 | 5FN | 5J6 | 93H | JH | LUC | MA7 | MAK | MHR | MLH | MRH\n| NLA | SHH | SHS | 19* | 3CZ\n$wmi-honda = (one|two|three) H. $alphanum | one nine $alphanum | three C. Z.\n| four S. six | five F. N. | five J. six | nine three H. | J. H. $alphanum\n| L. U. C. | M. A. seven | M. A. K. | M. H. R. | M. L. H. | M. R. H. | N. L. A.\n| S. H. (H.|S.) ;\n\n$alphanum = $digit | $spelling_wo_ioq ;\n$alphanum_modelyear = $digit_wo_zero | $spelling_wo_ioquz ;\n$digit_wo_zero = one | two | three | four | five | six | seven | eight | nine ;\n$digit = zero | oh | $digit_wo_zero ;\n\n$spelling_wo_ioquz = A. | B. | C. | D. | E. | F. | G. | H. | J. | K. | L. | M.\n| N. | P. | R. | S. | T. | V. | W. | X. | Y. ;\n$spelling_wo_ioq = $spelling_wo_ioquz | U. | Z. ;\n" }

{ "content": "#####BASIC RULES#####\nHTAB = %x09;\nCR = %x0d;\nLF = %x0a;\nSP = %x20;\nCRLF = [CR] LF;\nQUOT = %x22;\nHASH = %x23;\nCOMMA = %x2c;\nDOT = %x2e;\nCOLON = %x3a;\nSEMICOLON = %x3b;\nEQ = %x3d;\nUNDERSCORE = %x5f;\nALPHA = %x41-5a / %x61-7a;\nDIGIT = %x30-39;\nHEXDIG = DIGIT / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\" ;\nVCHAR = %x21-7e;\n\n#####COMMON RULES#####\nfmtSeparator = SP / HTAB;\nescSymbol = ALPHA / DIGIT / SP / %x21 / %x5c %x22 / %x23-2f / %x3a-40 / %x5b / %x5c %x5c / %x5d-60 / %x7b-7e / %x5c %x72 / %x5c %x6e / %x5c %x74;\nqualifier = (ALPHA / UNDERSCORE) *(ALPHA / DIGIT / UNDERSCORE);\nclassName = %x4c qualifier *(%x2f qualifier) [\"$\" qualifier] SEMICOLON;\ncommentSequence = %x23 *(fmtSeparator / VCHAR);\ncomment = *fmtSeparator commentSequence CRLF;\nemptyLine = *fmtSeparator CRLF;\nskipLine = comment / emptyLine;\nfileName = QUOT *(ALPHA / DIGIT) DOT *(ALPHA / DIGIT) QUOT;\naccessMode = \"public\" / \"private\" / \"protected\" / \"static\" / \"final\" / \"abstract\";\ntype = \"V\" / \"Z\" / \"B\" / \"S\" / \"C\" / \"I\" / \"J\" / \"F\" / \"D\" / className / \"[\" type;\nboolValue = \"true\" / \"false\";\nintDecValue = [%x2d] 1*DIGIT;\nintHexValue = [%x2d] %x30 %x78 1*HEXDIG;\nintValue = intHexValue / intDecValue;\nstrValue = QUOT *escSymbol QUOT;\nvalue = boolValue / intValue / strValue;\nlabel = COLON qualifier;\nsmaliParam = \"p\" intDecValue;\nsmaliVar = \"v\" intDecValue;\nsmaliVarDst = smaliVar;\nsmaliVarInit = smaliVar;\nsmaliVarGroup = \"{\" *fmtSeparator (smaliParam / smaliVar) *fmtSeparator *(COMMA *fmtSeparator (smaliParam / smaliVar) *fmtSeparator) \"}\";\n\n#####SMALI DIRECTIVE RULE#####\nendDirective = \".end\";\nclassDirective = \".class\";\nsuperDirective = \".super\";\nsourceDirective = \".source\";\nimplementsDirective = \".implements\";\nfieldDirective = \".field\";\nmethodDirective = \".method\";\nendMethodDirective = endDirective *fmtSeparator \"method\";\nregistersDirective = \".registers\";\nlocalDirective = \".local\";\n\n#####SMALI GENERAL RULES#####\nsmali = classHeader *(classField / skipLine) *(classMethod / skipLine);\ntodoStubLine = *(VCHAR / fmtSeparator);\n\n#####SMALI HEADER RULES#####\nclassHeader = classDirectiveHeader superDirectiveHeader [sourceDirectiveHeader] *implementsDirectiveHeader;\nclassDirectiveHeader = *fmtSeparator classDirective *fmtSeparator *(accessMode *fmtSeparator) *fmtSeparator className *fmtSeparator CRLF;\n\nsuperDirectiveHeader = *fmtSeparator superDirective *fmtSeparator className *fmtSeparator CRLF;\n\nsourceDirectiveHeader = *fmtSeparator sourceDirective *fmtSeparator fileName *fmtSeparator CRLF;\n\nimplementsDirectiveHeader = *fmtSeparator implementsDirective *fmtSeparator className *fmtSeparator CRLF;\n\n#####SMALI FIELD RULES#####\nclassField = *fmtSeparator fieldDirective 1*fmtSeparator *(accessMode 1*fmtSeparator) qualifier COLON type *fmtSeparator [EQ *fmtSeparator value] *fmtSeparator CRLF;\n\n#####SMALI METHOD RULES#####\nclassMethod = *(fmtSeparator) methodDirective *(fmtSeparator) *(accessMode 1*fmtSeparator) (classConstructorName / qualifier) *(fmtSeparator) classMethodProto *(fmtSeparator) CRLF methodBody *(fmtSeparator) endMethodDirective *(fmtSeparator) CRLF;\nclassConstructorName = \"constructor\" *(fmtSeparator) smaliConstructorName;\nclassMethodProto = %x28 *type %x29 type;\nmethodBody = [methodLineLocals] [methodLineRegisters] *(methodLineParam / skipLine) methodLinePrologue *(methodLineNumber / methodLineLocal / cmdAny / skipLine);\nmethodLineLocals = *fmtSeparator \".locals\" 1*fmtSeparator intValue *fmtSeparator CRLF;\nmethodLineParam = *fmtSeparator \".parameter\" [1*fmtSeparator strValue *fmtSeparator] *fmtSeparator CRLF;\nmethodLinePrologue = *fmtSeparator \".prologue\" *fmtSeparator CRLF;\nmethodLineNumber = *fmtSeparator \".line\" 1*fmtSeparator intValue *fmtSeparator CRLF;\nmethodLineRegisters = *fmtSeparator \".registers\" 1*fmtSeparator intValue *fmtSeparator CRLF;\nmethodLineLocal = *fmtSeparator \".local\" 1*fmtSeparator todoStubLine CRLF;\n\nsmaliConstructorName = (\"<init>\" / \"<clinit>\");\nsmaliFieldRef = className \"->\" qualifier COLON type;\nsmaliMethodRef = className \"->\" (smaliConstructorName / qualifier) classMethodProto;\n\n#####SMALI COMMANDS RULES#####\ncmdAny = cmdConst4;\ncmdAny =/ cmdConstString;\ncmdAny =/ cmdGoto;\ncmdAny =/ cmdIfEq;\ncmdAny =/ cmdIfEqz;\ncmdAny =/ cmdIfNe;\ncmdAny =/ cmdIfNez;\ncmdAny =/ cmdIget;\ncmdAny =/ cmdIgetObject;\ncmdAny =/ cmdIgetWide;\ncmdAny =/ cmdInvokeDirect;\ncmdAny =/ cmdInvokeStatic;\ncmdAny =/ cmdInvokeVirtual;\ncmdAny =/ cmdIput;\ncmdAny =/ cmdIputObject;\ncmdAny =/ cmdIputWide;\ncmdAny =/ cmdLabel;\ncmdAny =/ cmdMove;\ncmdAny =/ cmdMoveResultObject;\ncmdAny =/ cmdNewInstance;\ncmdAny =/ cmdNop;\ncmdAny =/ cmdReturn;\ncmdAny =/ cmdReturnObject;\ncmdAny =/ cmdReturnVoid;\ncmdAny =/ cmdReturnWide;\ncmdAny =/ cmdSputObject;\n\ncmdConst4 = *fmtSeparator \"const/4\" 1*fmtSeparator smaliVarInit *fmtSeparator COMMA *fmtSeparator intValue *fmtSeparator [commentSequence] CRLF;\ncmdConstString = *fmtSeparator \"const-string\" 1*fmtSeparator smaliVarInit *fmtSeparator COMMA *fmtSeparator strValue *fmtSeparator [commentSequence] CRLF;\ncmdGoto = *fmtSeparator \"goto\" 1*fmtSeparator label *fmtSeparator [commentSequence] CRLF;\ncmdIfEq = *fmtSeparator \"if-eq\" 1*fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator label *fmtSeparator [commentSequence] CRLF;\ncmdIfEqz = *fmtSeparator \"if-eqz\" 1*fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator label *fmtSeparator [commentSequence] CRLF;\ncmdIfNe = *fmtSeparator \"if-ne\" 1*fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator label *fmtSeparator [commentSequence] CRLF;\ncmdIfNez = *fmtSeparator \"if-nez\" 1*fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator label *fmtSeparator [commentSequence] CRLF;\ncmdIget = *fmtSeparator \"iget\" 1*fmtSeparator smaliVarDst *fmtSeparator COMMA *fmtSeparator (smaliVar / smaliParam) *fmtSeparator COMMA *fmtSeparator smaliFieldRef *fmtSeparator [commentSequence] CRLF;\ncmdIgetObject = *fmtSeparator \"iget-object\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\ncmdIgetWide = *fmtSeparator \"iget-wide\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\ncmdInvokeDirect = *fmtSeparator \"invoke-direct\" 1*fmtSeparator smaliVarGroup *fmtSeparator COMMA *fmtSeparator smaliMethodRef *fmtSeparator [commentSequence] CRLF;\ncmdInvokeStatic = *fmtSeparator \"invoke-static\" 1*fmtSeparator smaliVarGroup *fmtSeparator COMMA *fmtSeparator smaliMethodRef *fmtSeparator [commentSequence] CRLF;\ncmdInvokeVirtual = *fmtSeparator \"invoke-virtual\" 1*fmtSeparator smaliVarGroup *fmtSeparator COMMA *fmtSeparator smaliMethodRef *fmtSeparator [commentSequence] CRLF;\ncmdIput = *fmtSeparator \"iput\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\ncmdIputObject = *fmtSeparator \"iput-object\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\ncmdIputWide = *fmtSeparator \"iput-wide\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\ncmdLabel = *fmtSeparator label *fmtSeparator [commentSequence] CRLF;\ncmdMove = *fmtSeparator \"move\" 1*fmtSeparator smaliVarDst *fmtSeparator COMMA *fmtSeparator (smaliVar / smaliParam) *fmtSeparator [commentSequence] CRLF;\ncmdMoveResultObject = *fmtSeparator \"move-result-object\" 1*fmtSeparator smaliVarDst *fmtSeparator [commentSequence] CRLF;\ncmdNewInstance = *fmtSeparator \"new-instance\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\ncmdNop = *fmtSeparator \"nop\" *fmtSeparator [commentSequence] CRLF;\ncmdReturn = *fmtSeparator \"return\" 1*fmtSeparator smaliVar *fmtSeparator [commentSequence] CRLF;\ncmdReturnObject = *fmtSeparator \"return-object\" 1*fmtSeparator smaliVar *fmtSeparator [commentSequence] CRLF;\ncmdReturnVoid = *fmtSeparator \"return-void\" *fmtSeparator [commentSequence] CRLF;\ncmdReturnWide = *fmtSeparator \"return-wide\" 1*fmtSeparator smaliVar *fmtSeparator [commentSequence] CRLF;\ncmdSputObject = *fmtSeparator \"sput-object\" 1*fmtSeparator todoStubLine *fmtSeparator [commentSequence] CRLF;\n" }

{ "content": "; Copyright Glen Knowles 2017 - 2018.\n; Distributed under the Boost Software License, Version 1.0.\n;\n; uri.abnf - dim uri\n;\n; Rules to parse uri, based on the ABNF in the spec at:\n; https://tools.ietf.org/html/rfc3986\n\n%root = URI\n%api.prefix = Uri\n%api.namespace = Dim::Detail\n\n; Characters\ngen-delims = \":\" / \"/\" / \"?\" / \"#\" / \"[\" / \"]\" / \"@\"\nqry-delims = \"!\" / \"$\" / \"'\" / \"(\" / \")\" / \"*\" / \",\" / \";\"\nsub-delims = qry-delims / \"&\" / \"=\" / \"+\"\nunreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\" { Char }\n\ngen-delims-copy = gen-delims { Char, As copy }\n\n\npct-encoded = \"%\" pct-high pct-low\npct-high = HEXDIG { Char }\npct-low = HEXDIG { Char }\n\n; URI Grammar\nURI = scheme \"://\" authority path-abempty [ \"?\" query ] [ \"#\" fragment ]\n\nhttp-path = \"*\" / origin-form\norigin-form = absolute-path [ \"?\" query ]\n\n; Scheme\nscheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" ) { Start+, End+ }\n\n; Authority\nauthority = [ userinfo \"@\" ] host [ \":\" port ]\nuserinfo = *( unreserved / pct-encoded / sub-delims / \":\" )\nhost = IP-literal / IPv4address / reg-name { End+ }\nport = *5DIGIT { Char+ }\n\nIP-literal = \"[\" ( IPv6address [\"%25\" ZoneId] / IPvFuture ) \"]\"\nIPvFuture = \"v\" 1*HEXDIG \".\" 1*( unreserved / sub-delims / \":\" )\nZoneId = 1*( unreserved / pct-encoded )\n\nIPv6address = 6( h16 \":\" ) ls32\n / \"::\" 5( h16 \":\" ) ls32\n / [ h16 ] \"::\" 4( h16 \":\" ) ls32\n / [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n / [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n / [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32\n / [ *4( h16 \":\" ) h16 ] \"::\" ls32\n / [ *5( h16 \":\" ) h16 ] \"::\" h16\n / [ *6( h16 \":\" ) h16 ] \"::\"\n\nls32 = ( h16 \":\" h16 ) / IPv4address\n ; least-significant 32 bits of address\n\nh16 = 1*4HEXDIG\n ; 16 bits of address represented in hexadecimal\n\nIPv4address = dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet\ndec-octet = DIGIT ; 0-9\n / %x31-39 DIGIT ; 10-99\n / \"1\" 2DIGIT ; 100-199\n / \"2\" %x30-34 DIGIT ; 200-249\n / \"25\" %x30-35 ; 250-255\n\nreg-name = *( unreserved / pct-encoded / sub-delims )\n\n; Path\nabsolute-path = 1*( \"/\" segment )\npath-abempty = *( \"/\" segment )\nsegment = *pchar { Start+, End+ }\npchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\"\n\n; Query\nquery = [ qry-pair ] *(\"&\" qry-pair)\nqry-pair = qry-name [ \"=\" qry-value ]\nqry-name = 1*qchar { Start+, End+ }\nqry-value = *(qchar / \"=\") { Start+, End+ }\nqchar = unreserved / pct-encoded / qry-delims / qry-plus\n / \":\" / \"@\" / \"/\" / \"?\"\nqry-plus = \"+\" { Char }\n\n; Fragment\nfragment = *( pchar / \"/\" / \"?\" ) { Start, End }\n" }

{ "content": "Value = BitStringValue /\n BooleanValue /\n CharacterStringValue /\n ChoiceValue /\n EmbeddedPDVValue /\n EnumeratedValue /\n ExternalValue /\n GeneralizedTimeValue /\n IntegerValue /\n InstanceOfValue /\n NullValue /\n ObjectDescriptorValue /\n ObjectIdentifierValue /\n OctetStringValue /\n RealValue /\n RelativeOIDValue /\n SequenceOfValue /\n SequenceValue /\n SetOfValue /\n SetValue /\n StringValue /\n UTCTimeValue /\n VariantEncoding\nStringValue = dquote *SafeUTF8Character dquote\ndquote = %x22 ; \" (double quote)\nSafeUTF8Character = %x00-21 / %x23-7F / ; ASCII minus dquote\n dquote dquote / ; escaped double quote\n %xC0-DF %x80-BF / ; 2 byte UTF-8 character\n %xE0-EF 2(%x80-BF) / ; 3 byte UTF-8 character\n %xF0-F7 3(%x80-BF) ; 4 byte UTF-8 character\nGeneralizedTimeValue = StringValue\n UTCTimeValue = StringValue\n ObjectDescriptorValue = StringValue\nidentifier = lowercase *alphanumeric *(hyphen 1*alphanumeric)\nalphanumeric = uppercase / lowercase / decimal-digit\nuppercase = %x41-5A ; \"A\" to \"Z\"\nlowercase = %x61-7A ; \"a\" to \"z\"\ndecimal-digit = %x30-39 ; \"0\" to \"9\"\nhyphen = \"-\"\nBitStringValue = bstring / hstring / bit-list\nbit-list = \"{\" [ sp identifier\n *( \",\" sp identifier ) ] sp \"}\"\nhstring = squote *hexadecimal-digit squote %x48 ; '...'H\nhexadecimal-digit = %x30-39 / ; \"0\" to \"9\"\n %x41-46 ; \"A\" to \"F\"\nbstring = squote *binary-digit squote %x42 ; '...'B\nbinary-digit = \"0\" / \"1\"\nsp = *%x20 ; zero, one or more space characters\nsquote = %x27 ; ' (single quote)\nBooleanValue = %x54.52.55.45 / ; \"TRUE\"\n %x46.41.4C.53.45 ; \"FALSE\"\nEnumeratedValue = identifier\nIntegerValue = \"0\" /\n positive-number /\n (\"-\" positive-number) /\n identifier\npositive-number = non-zero-digit *decimal-digit\nnon-zero-digit = %x31-39 ; \"1\" to \"9\"\nNullValue = %x4E.55.4C.4C ; \"NULL\"\nObjectIdentifierValue = numeric-oid / descr\nnumeric-oid = oid-component 1*( \".\" oid-component )\noid-component = \"0\" / positive-number\nRelativeOIDValue = oid-component *( \".\" oid-component )\nOctetStringValue = hstring\nChoiceValue = IdentifiedChoiceValue /\n ChoiceOfStringsValue\nIdentifiedChoiceValue = identifier \":\" Value\nChoiceOfStringsValue = StringValue\nSequenceValue = ComponentList\nComponentList = \"{\" [ sp NamedValue *( \",\" sp NamedValue) ] sp \"}\"\nNamedValue = identifier msp Value\nmsp = 1*%x20 ; one or more space characters\nSetValue = ComponentList\nSequenceOfValue = \"{\" [ sp Value *( \",\" sp Value) ] sp \"}\"\nSetOfValue = \"{\" [ sp Value *( \",\" sp Value) ] sp \"}\"\nCharacterStringValue = SequenceValue\nEmbeddedPDVValue = SequenceValue\nExternalValue = SequenceValue\nInstanceOfValue = SequenceValue\nRealValue = \"0\" ; zero REAL value\n / PLUS-INFINITY ; positive infinity\n / MINUS-INFINITY ; negative infinity\n / realnumber ; positive base 10 REAL value\n / \"-\" realnumber ; negative base 10 REAL value\n / SequenceValue ; non-zero REAL value, base 2 or 10\nrealnumber = mantissa exponent\nmantissa = (positive-number [ \".\" *decimal-digit ])\n / ( \"0.\" *(\"0\") positive-number )\nexponent = \"E\" ( \"0\" / ([ \"-\" ] positive-number))\nPLUS-INFINITY = %x50.4C.55.53.2D.49.4E.46.49.4E.49.54.59\n ; \"PLUS-INFINITY\"\nMINUS-INFINITY = %x4D.49.4E.55.53.2D.49.4E.46.49.4E.49.54.59\n ; \"MINUS-INFINITY\"\nVariantEncoding = RDNSequenceValue /\n RelativeDistinguishedNameValue /\n ORAddressValue\nRDNSequenceValue = StringValue\nRelativeDistinguishedNameValue = StringValue\nORAddressValue = StringValue" }

{ "content": "start = CTL\r\n" }

{ "content": "; abc\r\nstart = ALPHA ; def\r\n; ghi\r\n" }

{ "content": "value = text\n / text-list\n / date-list\n / time-list\n / date-time-list\n / date-and-or-time-list\n / timestamp-list\n / boolean\n / integer-list\n / float-list\n / URI ; from Section 3 of [RFC3986]\n / utc-offset\n / Language-Tag\n / iana-valuespec\n ; Actual value type depends on property name and VALUE parameter.\ntext = *TEXT-CHAR\nTEXT-CHAR = \"\\\\\" / \"\\,\" / \"\\n\" / WSP / NON-ASCII / %x21-2B / %x2D-5B / %x5D-7E ; Backslashes, commas, and newlines must be encoded. \ncomponent = \"\\\\\" / \"\\,\" / \"\\;\" / \"\\n\" / WSP / NON-ASCII\n / %x21-2B / %x2D-3A / %x3C-5B / %x5D-7E\nlist-component = component *(\",\" component)\ntext-list = text *(\",\" text)\ndate-list = date *(\",\" date)\ntime-list = time *(\",\" time)\ndate-time-list = date-time *(\",\" date-time)\ndate-and-or-time-list = date-and-or-time *(\",\" date-and-or-time)\ntimestamp-list = timestamp *(\",\" timestamp)\ninteger-list = integer *(\",\" integer)\nfloat-list = float *(\",\" float)\nboolean = \"TRUE\" / \"FALSE\"\ninteger = [sign] 1*DIGIT\nfloat = [sign] 1*DIGIT [\".\" 1*DIGIT]\nsign = \"+\" / \"-\"\nyear = 4DIGIT ; 0000-9999\nmonth = 2DIGIT ; 01-12\nday = 2DIGIT ; 01-28/29/30/31 depending on month and leap year\nhour = 2DIGIT ; 00-23\nminute = 2DIGIT ; 00-59\nsecond = 2DIGIT ; 00-58/59/60 depending on leap second\nzone = utc-designator / utc-offset\nutc-designator = %x5A ; uppercase \"Z\"\ndate = year [month day]\n / year \"-\" month\n / \"--\" month [day]\n / \"--\" \"-\" day\ndate-noreduc = year month day\n / \"--\" month day\n / \"--\" \"-\" day\ndate-complete = year month day\ntime = hour [minute [second]] [zone]\n / \"-\" minute [second] [zone]\n / \"-\" \"-\" second [zone]\ntime-notrunc = hour [minute [second]] [zone]\ntime-complete = hour minute second [zone] time-designator = %x54 ; uppercase \"T\"\ndate-time = date-noreduc time-designator time-notrunc\ntimestamp = date-complete time-designator time-complete\ndate-and-or-time = date-time / date / time-designator time\nutc-offset = sign hour [minute]\nLanguage-Tag = <Language-Tag, defined in [RFC5646], Section 2.1>\niana-valuespec = <value-spec, see Section 12>\n ; a publicly defined valuetype format, registered\n ; with IANA, as defined in Section 12 of this\n ; document.\nparam-value = *SAFE-CHAR / DQUOTE *QSAFE-CHAR DQUOTE\nany-param = (iana-token / x-name) \"=\" param-value *(\",\" param-value)\nNON-ASCII = UTF8-2 / UTF8-3 / UTF8-4\n ; UTF8-{2,3,4} are defined in [RFC3629]\nQSAFE-CHAR = WSP / \"!\" / %x23-7E / NON-ASCII\n ; Any character except CTLs, DQUOTE\nSAFE-CHAR = WSP / \"!\" / %x23-39 / %x3C-7E / NON-ASCII\n ; Any character except CTLs, DQUOTE, \";\", \":\"\nVALUE-CHAR = WSP / VCHAR / NON-ASCII\n ; Any textual character\nparam = language-param / value-param / pref-param / pid-param / type-param / geo-parameter / tz-parameter / sort-as-param / calscale-param / any-param ; Allowed parameters depend on property name.\ngroup = 1*(ALPHA / DIGIT / \"-\")\nname = \"SOURCE\" / \"KIND\" / \"FN\" / \"N\" / \"NICKNAME\"\n / \"PHOTO\" / \"BDAY\" / \"ANNIVERSARY\" / \"GENDER\" / \"ADR\" / \"TEL\"\n / \"EMAIL\" / \"IMPP\" / \"LANG\" / \"TZ\" / \"GEO\" / \"TITLE\" / \"ROLE\"\n / \"LOGO\" / \"ORG\" / \"MEMBER\" / \"RELATED\" / \"CATEGORIES\"\n / \"NOTE\" / \"PRODID\" / \"REV\" / \"SOUND\" / \"UID\" / \"CLIENTPIDMAP\"\n / \"URL\" / \"KEY\" / \"FBURL\" / \"CALADRURI\" / \"CALURI\" / \"XML\"\n / iana-token / x-name\n ; Parsing of the param and value is based on the \"name\" as\n ; defined in ABNF sections below.\n ; Group and name are case-insensitive.\niana-token = 1*(ALPHA / DIGIT / \"-\")\n ; identifier registered with IANA\nx-name = \"x-\" 1*(ALPHA / DIGIT / \"-\")\n ; Names that begin with \"x-\" or \"X-\" are\n ; reserved for experimental use, not intended for released\n ; products, or for use in bilateral agreements.\ncontentline = [group \".\"] name *(\";\" param) \":\" value CRLF\n ; When parsing a content line, folded lines must first\n ; be unfolded according to the unfolding procedure\n ; described in Section 3.2.\n ; When generating a content line, lines longer than 75\n ; characters SHOULD be folded according to the folding\n ; procedure described in Section 3.2.\nvcard = \"BEGIN:VCARD\" CRLF \"VERSION:4.0\" CRLF 1*contentline \"END:VCARD\" CRLF ; A vCard object MUST include the VERSION and FN properties. ; VERSION MUST come immediately after BEGIN:VCARD\nvcard-entity = 1*vcard" }

{ "content": "; # ABNF rules for GCode in Kodachi.\n;\n; This grammar is based primarily on the document:\n; Kramer TR, Proctor FM and Messina E (2000)\n; The NIST RS274NGC Interpreter - Version 3. NISTIR 6556.\n; Section 3.3 - Format of a Line\n;\n; In keeping with Kramer (2000), all whitespace outside of comments must be\n; stripped BEFORE this grammar is considered. Comments are defined completely\n; by the comment-inline and comment-eol rules. Because GCode permits whitespace\n; to occur anywhere, such pre-stripping is necessary to make the grammar\n; succinct.\n;\n; For the format of ABNF, please consult RFC5234.\n; ABNF summary:\n; a b - a followed by b\n; a / b - a or b\n; [a] - a single occurrence of a is optional\n; *a - zero or more instances of a\n; 1*a - one or more instances of a\n; <n>*<m>a - minimum of <n> and maximum of <m> instances of a\n; \n; GCode is assumed to consist of ASCII characters.\n;\n; Not all of the GCode specification is permitted. In particular; the following\n; features of GCode are included:\n; - optional block delete character (a slash \"/\")\n; - optional line numbers\n; - inline comments delimited by parentheses\n; - end of line comments; preceded by a semicolon\n; - control words\n\n; A GCode file consists of zero or more lines.\n; Lines in the middle of the file must be terminated by an eol character.\n; The last line in the file can optionally be terminated by an eol.\ngcode = *(line eol)\n [(line [eol])]\n\n; Each line has:\nline = [block-delete-char] ; An optional block delete character\n [line-num] ; An optional line number\n *(word / comment-inline) ; Any number of words or inline comments\n [comment-eol] ; An optional end-of-line comment\n\n; An end of line marker is a carriage return or line feed or both\neol = (CR [LF]) / (LF [CR])\n\n; Printable characters and white space inside parentheses is a comment\ncomment-inline = \"(\" *comment-inline-char \")\"\n; An inline comment character is any character excluding a closing parenthesis\ncomment-inline-char = HTAB / %d32-40 / %d42-126\n; Comments can start with a semicolon and extend for the rest of the line\n; (NB: These comments are common in 3D printer GCode, but do not appear in\n; Kramer 2000.)\ncomment-eol = \";\" *comment-eol-char\n; A semi-colon delimited comment can contain any printable character\ncomment-eol-char = HTAB / %d32-126\n\n; A word is a letter other than N followed by a real value\nword = word-char number\nword-char = %x41-4D / %x4F-5A / %x61-6D / %x6F-7A\n\n; A number consists of:\n; 1. An optional plus or minus sign, followed by\n; 2. Zero to many digits, followed by\n; 3. An optional decimal point and zero to many digits.\n; A number must have a digit somewhere. Consequently, a number can have a\n; digit preceding the decimal point (lnumber) or following the decimal point\n; (rnumber).\nnumber = [\"+\" / \"-\"] (lnumber / rnumber)\nlnumber = 1*DIGIT [\".\" *DIGIT] ; must have digit on LHS of \".\"\nrnumber = \".\" 1*DIGIT ; must have digit on RHS of \".\"\n\n; A line number is the letter N followed by an integer (with no sign) between\n; 0 and 99999 written with no more than five digits.\nline-num = (\"N\" / \"n\") 1*5DIGIT\n\n; A block delete character is a slash.\nblock-delete-char = \"/\"\n" }

{ "content": "#ABNF 1.0;\nlanguage es-ES;\nroot $animal;\n$animal = perro | toro | conejo | pajaro | serpiente | leon ;\n" }

{ "content": "U29 = U29-1 | U29-2 | U29-3 | U29-4\nU29-1 = %x00-7F\nU29-2 = %x80-FF %x00-7F\nU29-3 = %x80-FF %x80-FF %x00-7F\nU29-4 = %x80-FF %x80-FF %x80-FF %x00-FF\n\nUTF8-char = UTF8-1 | UTF8-2 | UTF8-3 | UTF8-4\nUTF8-1 = %x00-7F\nUTF8-2 = %xC2-DF UTF8-tail\nUTF8-3 = %xE0 %xA0-BF UTF8-tail | %xE1-EC 2(UTF8-tail) | %xED %x80-9F UTF8-tail | %xEE-EF 2(UTF8-tail)\nUTF8-4 = %xF0 %x90-BF 2(UTF8-tail) | %xF1-F3 3(UTF8-tail) | %xF4 %x80-8F 2(UTF8-tail)\nUTF8-tail = %x80-BF\nU29S-ref = U29\nU29S-value = U29\nUTF-8-empty = 0x01\nUTF-8-vr = U29S-ref\n\nmarker = U8\nundefined-marker = 0x00\nnull-marker = 0x01\nfalse-marker = 0x02\ntrue-marker = 0x03\ninteger-marker = 0x04\ndouble-marker = 0x05\nstring-marker = 0x06\nxml-doc-marker = 0x07\ndate-marker = 0x08\narray-marker = 0x09\nobject-marker = 0x0A\nxml-marker = 0x0B\nbyte-array-marker = 0x0C\n\nvalue-type = undefined-marker | null-marker | false-marker | true-marker | integer-type | double-type | string-type | xml-doc-type | date-type | array-type | object-type | xml-type | byte-array-type\n\nundefined-type = undefined-marker\nnull-type = null-marker\nfalse-type = false-marker\ntrue-type = true-marker\ninteger-type = integer-marker U29\ndouble-type = double-marker DOUBLE\nstring-type = string-marker UTF-8-vr\nU29X-value = U29\nxml-doc-type = xml-doc-marker (U29O-ref | (U29X-value *(UTF8-char)))\nU29D-value = U29\ndate-time = DOUBLE\ndate-type = date-marker (U29O-ref | (U29D-value date-time))\n\nU29A-value = U29\nassoc-value = UTF-8-vr value-type\narray-type = array-marker (U29O-ref | (U29A-value (UTF-8-empty | *(assoc-value) UTF-8-empty) *(value-type)))\n\nU29O-ref = U29\nU29O-traits-ref = U29\nU29O-traits-ext = U29\nU29O-traits = U29\nclass-name = UTF-8-vr\ndynamic-member = UTF-8-vr value-type\nobject-type = object-marker (U29O-ref | (U29O-traits-ext class-name *(U8)) | U29O-traits-ref | (U29O-traits class-name *(UTF-8-vr))) *(value-type) *(dynamic-member)))\n\nxml-type = xml-marker (U29O-ref | (U29X-value *(UTF8-char)))\n\nU29B-value = U29\nbytearray-type = bytearray-marker (U29O-ref | U29B-value *(U8))\n" }

{ "content": ";;;;;;;;;;;;;;;;;\n;; ASCII Lexer ;;\n;;;;;;;;;;;;;;;;;\n\n;; Visible characters\n; The excluded characters are either below in ascii-nl or ascii-space, or are\n; control charactres.\nascii-visible = %x21-7E\nascii-visible-nonquote = %x21 / %x23-7E\n\n;; Whitespace\nascii-nl = %x0D %x0A / %x0A-0D\nascii-space = %x09 / %x20\n\n;; Letters\nascii-lower = %x61-7A\nascii-upper = %x41-5A\nascii-alpha = ascii-lower / ascii-upper\n\n;; Numbers\nascii-digit = %x30-39\n" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main = $place1 到 $place2 | $place13 $place3 | $place13 $place4 | $place13 $place5 | $place13 $place6 | $place13 $place7 | $place13 $place8 | $place13 $place9 | $place13 $place11 $place10 | $place13 $place12 $place10;\n$place1 = 北京|武汉|南京|天津|东京;\n$place2 = 上海|合肥;\n$place3 = 你好;\n$place4 = 前进|走起来|跑起来|开始|start;\n$place5 = 加速|加快速度|再快点|快|快快的;\n$place6 = 减速|减慢速度|再慢点|慢|慢慢的;\n$place7 = 停下|停下来|stop|停止|停;\n$place8 = 高一点|再高一点|抬高|增加坡度;\n$place9 = 低一点|在低一点|降低|降低坡度;\n$place10 = 0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16;\n$place11 = 速度;\n$place12 = 坡度;\n\n$place13 = 迈迈;" }

{ "content": "bit = \"0\" / \"1\"\n!test bit, 1" }

{ "content": "; This document is in ABNF, see <https://tools.ietf.org/html/std68>\n; This document uses RFC 7405 to add case-sensitive literals to ABNF.\n\n; ------------- Characters -------------\n\nbanned = %x00-08 / %x0B-0C / %x0E-1F ; C0 other than LF CR and Tab\n / %x7F ; DEL\n / %x80-9F ; C1\n / %xD800-DFFF ; Surrogates\n / %xFFFE-FFFF ; invalid\n; All other rules assume the absence of any banned characters\n\n\ndigit = %x30-39 ; 0 through 9\nnonzero = %x31-39 ; 1 through 9\nucletter = %x41-5A ; A through Z\nunderscore = %x5F ; _\natsign = %x40 ; @\n\n\n; ------------- Lines -------------\n\nLine = Level D [Xref D] Tag [D LineVal] EOL\n\nLevel = \"0\" / nonzero *digit\nD = %x20 ; space\nXref = atsign 1*tagchar atsign ; but not \"@VOID@\"\nTag = stdTag / extTag\nLineVal = pointer / lineStr\nEOL = %x0D [%x0A] / %x0A ; CR-LF, CR, or LF\n\nstdTag = ucletter *tagchar\nextTag = underscore 1*tagchar\ntagchar = ucletter / digit / underscore\n\npointer = voidPtr / Xref\nvoidPtr = %s\"@VOID@\"\n\nnonAt = %x09 / %x20-3F / %x41-10FFFF ; non-EOL, non-@\nnonEOL = %x09 / %x20-10FFFF ; non-EOL\nlineStr = (nonAt / atsign atsign) *nonEOL ; leading @ doubled\n\n\n; ------------- Text -------------\n\nanychar = %x09-10FFFF ; but not banned, as with all ABNF rules\nText = *anychar\n\n\n; ------------- Integer -------------\n\nInteger = 1*digit\n\n\n; ------------- Enumeration -------------\n\nEnum = Tag\n\n\n; ------------- Date -------------\n\nDateValue = date / DatePeriod / dateRange / dateApprox\nDateExact = day D month D year ; in Gregorian calendar\nDatePeriod = %s\"FROM\" D date [D %s\"TO\" D date]\n / %s\"TO\" D date\n\ndate = [calendar D] [[day D] month D] year [D epoch]\ndateRange = %s\"BET\" D date D %s\"AND\" D date\n / %s\"AFT\" D date\n / %s\"BEF\" D date\ndateApprox = (%s\"ABT\" / %s\"CAL\" / %s\"EST\") D date\n\ndateRestrict = %s\"FROM\" / %s\"TO\" / %s\"BET\" / %s\"AND\" / %s\"BEF\"\n / %s\"AFT\" / %s\"ABT\" / %s\"CAL\" / %s\"EST\" / %s\"BCE\"\n\ncalendar = %s\"GREGORIAN\" / %s\"JULIAN\" / %s\"FRENCH_R\" / %s\"HEBREW\"\n / extTag\n\nday = Integer\nyear = Integer\nmonth = stdTag / extTag ; constrained by calendar\nepoch = %s\"BCE\" / extTag ; constrained by calendar\n\n\n; ------------- Time -------------\n\nTime = hour \":\" minute [\":\" second [\".\" fraction]] [%s\"Z\"]\n\nhour = digit / (\"0\" / \"1\") digit / \"2\" (\"0\" / \"1\" / \"2\" / \"3\")\nminute = (\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\") digit\nsecond = (\"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\") digit\nfraction = 1*digit\n\n\n; ------------- Age -------------\n\nAge = [ageBound D] ageDuration\n\nageBound = \"<\" / \">\"\nageDuration = years [D months] [D weeks] [D days]\n / months [D weeks] [D days]\n / weeks [D days]\n / days\n\nyears = Integer %x79 ; 35y\nmonths = Integer %x6D ; 11m\nweeks = Integer %x77 ; 8w\ndays = Integer %x64 ; 21d\n\n\n; ------------- List -------------\n\nList = listItem *(listDelim listItem)\nlistItem = \"\" / nocommasp / nocommasp *nocomma nocommasp\nlistDelim = *D \",\" *D\nnocomma = %x09-2B / %x2D-10FFFF\nnocommasp = %x09-1D / %x21-2B / %x2D-10FFFF\n\nList-Text = List\nList-Enum = Enum *(listDelim Enum)\n\n\n; ------------- Personal Name -------------\n\nNamePersonal = nameStr\n / [nameStr] \"/\" [nameStr] \"/\" [nameStr]\n\nnameChar = %x20-2E / %x30-10FFFF ; any but '/' and '\\t'\nnameStr = 1*nameChar\n\n\n; ------------- Media Type -------------\n\nMediaType = mt-type \"/\" mt-subtype *(\";\" mt-parameter)\n\nmt-type = mt-token\nmt-subtype = mt-token\nmt-parameter = mt-attribute \"=\" mt-value\nmt-token = 1*mt-char\nmt-attribute = mt-token\nmt-value = mt-token / quoted-string\nmt-char = %x20-21 / %x23-27 / %x2A-2B / %x2D-2E ; not \"(),/\n / %x30-39 / %x41-5A / %x5E-7E ; not :;<=>?@[\\]\n\nmt-qstring = %x22 *(mt-qtext / mt-qpair) %x22\nmt-qtext = %x09-0A / %x20-21 / %x23-5B / %x5D-7E ; not CR \"\\\nmt-qpair = \"\\\" %x09-7E\n\n\n; ------------- Special -------------\n\nSpecial = Text\n\n\n" }

{ "content": "#ABNF 1.0 ;\nlanguage zh-cn;\nmode dtmf;\nroot $main;\n\n$main = $digits { out = meta.digits.text.replace(/ /g, ''); };\n\n$digits = $digit<1->;\n$digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;\n" }

{ "content": "date-time = [ day-of-week \",\" ] date time [CFWS]\n\n day-of-week = ([FWS] day-name) / obs-day-of-week\n\n day-name = \"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" /\n \"Fri\" / \"Sat\" / \"Sun\"\n\n date = day month year\n\n day = ([FWS] 1*2DIGIT FWS) / obs-day\n\n month = \"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" /\n \"May\" / \"Jun\" / \"Jul\" / \"Aug\" /\n \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"\n\n year = (FWS 4*DIGIT FWS) / obs-year\n\n time = time-of-day zone\n\n time-of-day = hour \":\" minute [ \":\" second ]\n\n hour = 2DIGIT / obs-hour\n\n minute = 2DIGIT / obs-minute\n\n second = 2DIGIT / obs-second\n\n zone = (FWS ( \"+\" / \"-\" ) 4DIGIT) / obs-zone\n\n\n" }

{ "content": "fraction = *%d48-57\nexponent = [\"e\" esign exp]\nesign = [\"+\" / \"-\"]\nexp = 1*%d48-57\n" }

{ "content": "a = b / c\na =/ d / e\nb = \"b\"\nc = (\"c\" \"whatever\") / [\"optional\"] \"value\"\nd = \"d\"\ne = \"e\"\nb =/ a / b\n\n" }

{ "content": "/* 正则表达式使用说明\n . 任意字符\n%a 字母\n%d 数字\n%w 字母、数字、下划线\n\n上面字符类的大写形式表示小写所代表的集合的补集。例如, '%A'非字母的字符: \n\n特殊字符\n'%' 用作特殊字符的转义字符\n'%.' 匹配 .\n'%%' 匹配字符 '%'\n'%n' 匹配 换行\n\n用'[]'匹配字符集中的字符一次\n'[%w]' 匹配字母、数字、下划线\n'[01]' 匹配二进制数字\n'[%[%]]'匹配一对方括号\n在'[]'中使用连字符'-'\n'%d' 表示 '[0-9]'；\n'%w' 表示 '[0-9a-zA-Z_]'\n'[0-7]' 表示 '[01234567]'\n\n用'()'对匹配规则进行优先级调整\n'(-%d)*' 遇到 非横杠数字 就停止匹配\n用'!'和'()'配合使用表示非匹配，'!'符号的优先级比* + ? 要高\n'!(-%d)*' 遇到横杠数字就停止匹配\n\n在'[]'开始处使用 '^' 表示其补集：\n'[^0-7]' 匹配任何不是八进制数字的字符；\n'[^%n]' 匹配任何非换行符户的字符。\n\n用'{}'查找下一个大括号内的字符串，内部的%只会转义%,{,}\n'--[[{--]]}' 匹配以--[[开始，然后查找到--]]作为结束\n'<!--{-->}' 匹配以<!--开始，然后查找到-->作为结束\n\n模式修饰符\n + 匹配前一字符1次或多次\n * 匹配前一字符0次或多次,最长匹配\n ? 匹配前一字符0次或1次\n*/\n\n/* ABnf使用说明\nRoot 是根部规则，将整个文件从Root开始解析\nLineComment 是单行注释解析\nBlockComment 表示多行注释解析\n\n通用规则\n规则名 ':' 下一个字符预测的正则表达式（后面如果带上@表示一旦比配成那么一定是这个规则） 着色[R,G,B] '=' 规则内容 ';'\n\n规则内容\n<key> 使用尖括号包起来表示关键字\n'symbol' 使用单引号包起来表示普通字符串\n\"[_a-zA-Z]\" 使用双引号包起来表示正则表达式\n\n规则后缀\n@ 表示一旦匹配成功，那么一定是这个规则\n# 表示如果当前匹配成功之后，如果是key那么也不能算匹配成功\n? 表示有一个或者没有\n* 表示没有或者很多个\n+ 表示至少有一个\n\n'(' ')' 表示提高规则优先级\n'|' 表示或者\n*/\n\n// 语法树的跟【Root是系统内置，必须定义Root作为语法根节点，没有定义会报错】\nRoot = NamespaceDec?;\n// 行注释【LineComment是系统内置的行注释语法规则名】\nLineComment : \"/\" = \"//.*\";\n// 块注释【BlockComment是系统内置的块注释语法规则名】\nBlockComment : \"/\" = \"/%*{*/}\";\n\n/////////////////////////////////////////////////////////////////////////////////////////////\n// 字符串\nText : \"\\\"\"@ = \"\\\"([^\\\"\\\\]|\\\\.)*\\\"\";\n// 规则名称\nId : \"[_a-zA-Z]\" = \"[_a-zA-Z][_a-zA-Z0-9]*\";\n// 整型数值\nNumber : \"[0-9]\" = \"0x[0-9a-fA-F]+\" | \"[0-9]+(%.[0-9]+)?\";\n\n//修饰符////////////////////////////////////////////////////////////////////////////////////\n// 注册修饰符，如果有这个修饰，那么就不会生成目标代码\nRegisterModifier = <register>@;\n// 访问修饰符，public表示全局可访问，private本文件，子类可访问，protected当前命名域内可访问\nAccessModifier = <public>@ | <private>@ | <protected>@;\n// 协程修饰符，用于修饰函数，async表示一个协程函数，await表示必须在协程函数里面调用\nCoroutineModifier = <async>@ | <await>@;\n\n// 协议修饰符\nProtocolModifier = <Http> | <HttpDownload> | <HttpUpload> | <Msg> | <Worker>;\n\n// 命令修饰符，用于开发人员指令执行函数\nCommandBodyDec = '('@ Text ')';\nCommandModifier = <Cmd>@ CommandBodyDec?;\n\n// 是否可以为null，用于修饰函数形参\nNullableModifier = <Nullable>;\n\n// 语言生效修饰符，用于修饰结构体，枚举，类，类成员变量，类成员函数，类静态函数，全局函数\n// 表示修饰目标只有在规定的语言范围内生效\nLanguageNameDec = Id;\nLanguageBodyDec = '('@ (LanguageNameDec (','@ LanguageNameDec)*)? ')';\nLanguageModifier = <Language>@ LanguageBodyDec?;\n\n// 常量修饰符，用于修饰函数。表示这个函数不会对数据进行修改\nConstModifier = <Constant>;\n\n// 原生修饰\nNativeModifier = <Native>;\n\n// 属性修饰符汇总\nAttributeModifier = '['@ (NativeModifier | LanguageModifier | ConstModifier | NullableModifier | ProtocolModifier | CommandModifier)? ']';\n// 所有修饰符汇总\nModifier = AttributeModifier | AccessModifier | CoroutineModifier | RegisterModifier;\n\n/////////////////////////////////////////////////////////////////////////////////////////////\n// 命名域\nNamespaceDec = Modifier* <namespace>@ NamespaceNameDec ';' NamespaceElementDec*;\nNamespaceElementDec = Modifier* (GlobalMethodDec | ClassDec | EnumDec | StructDec | UsingDec | InstanceDec | OpAssignExpr);\nNamespaceNameDec = Id;\n\n// 模板定义\nTemplateDec = '<'@ TemplatePairDec (','@ TemplatePairDec)* '>';\nTemplatePairDec = TemplateNameDec@ TemplateExtendsDec?;\nTemplateNameDec = Id;\nTemplateExtendsDec = ':'@ (AllType | TemplateExtendsClassDec | TemplateExtendsStructDec);\nTemplateExtendsClassDec = <class>;\nTemplateExtendsStructDec = <struct>;\n\n// 类定义\nClassDec = <class>@ (ClassNameDec TemplateDec? ClassExtendsDec? ClassBodyDec?)?;\nClassNameDec = Id#;\nClassExtendsDec = ':'@ (NamespaceNameDec '.')? ClassNameDec;\nClassElementDec = Modifier* (ClassCtorDec | ClassGetterDec | ClassSetterDec | ClassStaticDec | ClassMethodDec | ClassVarDec);\nClassBodyDec = '{'@ ClassElementDec* '}';\nClassVarValueDec = '='@ (ConstValue | OpNewStat);\nClassVarDec = AllType@ ClassVarNameDec ClassVarValueDec? ';';\nClassVarNameDec = Id;\n\n// 结构体定义\nStructDec = <struct>@ (StructNameDec StructExtendsDec? StructBodyDec?)?;\nStructNameDec = Id#;\nStructExtendsDec = ':'@ (NamespaceNameDec '.')? StructNameDec;\nStructBodyDec = '{'@ (StructOptionDec | StructVarDec)* '}';\nStructVarDec = AllType@ StructVarNameDec ';';\nStructVarNameDec = Id#;\nStructOptionDec = <option>@ StructOptionNameDec '='@ Text ';';\nStructOptionNameDec = Id#;\n\n// 枚举定义\nEnumDec = <enum>@ (EnumNameDec EnumBodyDec?)?;\nEnumNameDec = Id;\nEnumBodyDec = '{'@ EnumVarDec* '}';\nEnumVarDec = EnumVarNameDec@ ('='@ (Number | Text))? ';';\nEnumVarNameDec = Id;\n\n// 全局变量\nInstanceDec = VarAssignExpr;\n\n// using定义\nUsingDec = <using>@ UsingNameDec '=' AllType ';';\nUsingNameDec = Id;\n\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n// 函数参数部分\nMethodParamTailDec = '...';\nMethodParamOneDec = MethodParamTailDec | Modifier* AllType@ MethodParamNameDec;\nMethodParamNameDec = Id;\nMethodParamDec = '('@ (MethodParamOneDec (','@ MethodParamOneDec)*)? ')';\nMethodGetterParamDec = '('@ ')';\nMethodSetterParamDec = '('@ MethodParamOneDec ')';\n\n// 函数体部分\nMethodBodyDec = '{'@ AllExpr* '}';\n// 函数名部分\nMethodNameDec = Id#;\n// 函数返回值类型\nMethodReturnTailDec = '...';\nMethodReturnOneDec = MethodReturnTailDec | AllType;\nMethodReturnDec = ':'@ (MethodReturnOneDec (','@ MethodReturnOneDec)*)?;\n\n// 类构造函数定义\nClassCtorDec = <ctor>@ (MethodParamDec MethodBodyDec?)?;\n// 类getter函数\nClassGetterDec = <get>@ (MethodNameDec (MethodGetterParamDec (':'@ (AllType MethodBodyDec?)?)?)?)?;\n// 类setter函数\nClassSetterDec = <set>@ (MethodNameDec (MethodSetterParamDec MethodBodyDec?)?)?;\n// 类成员函数定义\nClassMethodDec = <fun>@ (MethodNameDec (TemplateDec? MethodParamDec MethodReturnDec? MethodBodyDec?)?)?;\n// 类静态函数定义\nClassStaticDec = <static>@ (MethodNameDec (TemplateDec? MethodParamDec MethodReturnDec? MethodBodyDec?)?)?;\n// 全局函数\nGlobalMethodDec = <static>@ (MethodNameDec (TemplateDec? MethodParamDec MethodReturnDec? MethodBodyDec?)?)?;\n\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n// 表达式\nAllExpr = Modifier* (IfExpr |\n ForExpr |\n WhileExpr |\n DoWhileExpr |\n ReturnExpr |\n FlowExpr |\n ThrowExpr |\n AssertExpr |\n WrapExpr |\n Op1Expr |\n EmptyExpr |\n VarAssignExpr |\n OpAssignExpr);\n\n// 空语句\nEmptyExpr = ';';\n\n// for 流程控制\nForExpr = <for>@ ForCondition (ForBody | AllExpr)?;\nForCondition = '('@ (<var>@ ForPairDec (ForStepCondition | ForInCondition))? ')';\nForBody = '{'@ AllExpr* '}';\n\nForStepCondition = ForStartStat ';'@ ForEndStat ';'@ ForStepStat;\nForStartStat = '='@ ValueStat;\nForEndStat = ValueStat;\nForStepStat = ValueStat;\n\nForInCondition = (','@ ForPairDec)* <in>@ ValueStat;\nForPairDec = VarAssignNameDec (':'@ AllType)?;\n\n// while 流程控制\nWhileExpr = <while>@ WhileCondition (WhileBody | AllExpr)?;\nWhileCondition = '('@ ValueStat? ')';\nWhileBody = '{'@ AllExpr* '}';\n\n// do while 流程控制\nDoWhileExpr = <do>@ DoWhileBody <while> DoWhileCondition ';';\nDoWhileCondition = '('@ ValueStat? ')';\nDoWhileBody = '{'@ AllExpr* '}';\n\n// if else 流程控制\nIfExpr = <if>@ IfCondition (IfBody | AllExpr)? ElseIfExpr* ElseExpr?;\nIfCondition = '('@ ValueStat? ')';\nIfBody = '{'@ AllExpr* '}';\nElseExpr = <else>@ (ElseBody | AllExpr)?;\nElseBody = '{'@ AllExpr* '}';\nElseIfExpr = <elseif>@ ElseIfCondition (ElseIfBody | AllExpr)?;\nElseIfCondition = '('@ ValueStat? ')';\nElseIfBody = '{'@ AllExpr* '}';\n\n// 表达式包装 比如 { 表达式列表 }\nWrapExpr = '{'@ AllExpr* '}';\n\n// return\nReturnExpr = <return>@ ((ValueStat (','@ ValueStat)*) | ReturnYield)? ';';\nReturnYield = <yield>;\n\n// break\nFlowExpr = (<break> | <continue>)@ ';';\n\n// 定义语句\nVarAssignExpr = <var>@ VarAssignDec (','@ VarAssignDec)* ('='@ ValueStat)? ';';\nVarAssignDec = VarAssignNameDec (':'@ AllType)?;\nVarAssignNameDec = Id;\n\n// 赋值\nOpAssign = '=' | '+=' | '-=' | '*=' | '/=' | '%=';\nOpAssignExpr = PropertyValue ((','@ PropertyValue)* OpAssign@ ValueStat)? ';';\n\n// 单目运算表达式\nOp1Expr = Op1@ ValueStat ';';\n\n// throw\nThrowExpr = <throw>@ '(' (ValueStat (','@ ValueStat)*)? ')' ';';\n\n// assert\nAssertExpr = <assert>@ '(' (ValueStat (','@ ValueStat)*)? ')' ';';\n\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n// 所有类型\nAllType = AllTypeConst? (PrimitiveType | GenericType | CustomType);\nAllTypeConst = <const>@;\n\n// 自定义类型\nCustomType = CustomTypeName CustomTypeDotId? CustomTypeTemplate?;\nCustomTypeName = Id@;\nCustomTypeDotId = '.'@ CustomTypeDotIdName;\nCustomTypeDotIdName = Id#;\nCustomTypeTemplate = '<'@ AllType (',' AllType)* '>';\n\n// 通用类型\nGenericType = GenericListType | GenericMapType | GenericFunctorType;\nGenericMapType = <Map>@ '<' (AllType (','@ AllType)?)? '>';\nGenericListType = <List>@ '<' AllType? '>';\nGenericFunctorType = <Functor>@ '<' (AllTypeConst? CoroutineModifier? '('@ GenericFunctorParamType? ')' GenericFunctorReturnType?)? '>';\n\nGenericFunctorParamOneType = GenericFunctorParamTail | AllType;\nGenericFunctorParamTail = '...';\nGenericFunctorParamType = GenericFunctorParamOneType (','@ GenericFunctorParamOneType)*;\n\nGenericFunctorReturnTail = '...';\nGenericFunctorReturnOneType = GenericFunctorReturnTail | AllType;\nGenericFunctorReturnType = ':'@ GenericFunctorReturnOneType (','@ GenericFunctorReturnOneType)*;\n\n// 基本类型\nPrimitiveType = <bool> | <double> | <int> | <long> | <any> | <string>;\n\n//复合值///////////////////////////////////////////////////////////////////\nValueStat = OpNewStat | OpNewListStat | BindStat | TcallStat | Op2Stat | ValueOpStat;\nValueFactorStat = WrapValueStat | ConstValue | ReflectValue | PathsValue | PropertyValue | MethodParamTailDec | CoroutineStat;\nValueOpStat = ValueFactorStat (Op3Stat | Op4Stat | Op5Stat | Op6Stat | Op7Stat | Op8Stat | Op9Stat | Op10Stat | Op11Stat | Op12Stat)?;\n\n// new\nOpNewStat = <new>@ (CustomType | GenericType) '(' (ValueStat (','@ ValueStat)*)? ')';\n// list 快捷表达式\nOpNewListStat = '['@ (ValueStat (','@ ValueStat)*)? ']';\n// bind\nBindStat = <bind>@ '(' (ValueStat (','@ ValueStat)*)? ')';\n// tcall\nTcallStat = <tcall>@ '(' (ValueStat (','@ ValueStat)*)? ')';\n// 值\nWrapValueStat = '('@ ValueStat? ')';\n// 常量值\nConstValue = <true> | <false> | <null> | Text | Number;\n\n// 当前协程对象\nCoroutineStat = <co>;\n\n// 反射机制\nReflectValue = <reflect>@ (ReflectCustomType | ReflectValueStat);\nReflectCustomType = '<'@ CustomType? '>';\nReflectValueStat = '('@ ValueStat? ')';\n\n// 文件宏\nPathsValue = <paths>@ '('@ Text? ')';\n\n// 属性\nPropertyValue = PropertyValueFirstType PropertyValueSuffix*;\n\nPropertyValueFirstType = PropertyValueThisType | PropertyValueCastType | PropertyValueCustomType;\nPropertyValueCastType = <cast>@ '<' AllType? '>' '(' ValueFactorStat? ')';\nPropertyValueCustomType = Id@;\nPropertyValueThisType = <this>@;\n\nPropertyValueSuffix = PropertyValueDotId | PropertyValueBracketValue | PropertyValueMethodCall;\nPropertyValueDotId = '.'@ PropertyValueDotIdName;\nPropertyValueDotIdName = Id#;\nPropertyValueBracketValue = '['@ ValueStat? ']';\nPropertyValueMethodCall = PropertyValueMethodTemplate? '('@ (ValueStat (','@ ValueStat)*)? ')';\nPropertyValueMethodTemplate = '{'@ (AllType (','@ AllType)*)? '}';\n\n// Op 类型的运算，编号越大，优先级越低///////////////////////////////////////////////////\n\n// 双目运算\nOp12 = '||';\nOp12Stat = Op12Suffix Op12SuffixEx*;\nOp12Suffix = Op12@ (ValueFactorStat | Op2Value) Op12SuffixEe*;\nOp12SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix;\nOp12SuffixEx = Op12Suffix;\n\nOp11 = '&&';\nOp11Stat = Op11Suffix Op11SuffixEx*;\nOp11Suffix = Op11@ (ValueFactorStat | Op2Value) Op11SuffixEe*;\nOp11SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix;\nOp11SuffixEx = Op11Suffix | Op12Suffix;\n\nOp10 = '<=' | '<' | '>=' | '>' | '==' | '!=';\nOp10Stat = Op10Suffix Op10SuffixEx*;\nOp10Suffix = Op10@ (ValueFactorStat | Op2Value) Op10SuffixEe*;\nOp10SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix;\nOp10SuffixEx = Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp9 = '|';\nOp9Stat = Op9Suffix Op9SuffixEx*;\nOp9Suffix = Op9@ (ValueFactorStat | Op2Value) Op9SuffixEe*;\nOp9SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix;\nOp9SuffixEx = Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp8 = '^';\nOp8Stat = Op8Suffix Op8SuffixEx*;\nOp8Suffix = Op8@ (ValueFactorStat | Op2Value) Op8SuffixEe*;\nOp8SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix;\nOp8SuffixEx = Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp7 = '&';\nOp7Stat = Op7Suffix Op7SuffixEx*;\nOp7Suffix = Op7@ (ValueFactorStat | Op2Value) Op7SuffixEe*;\nOp7SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix;\nOp7SuffixEx = Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp6 = '<<-' | '->>';\nOp6Stat = Op6Suffix Op6SuffixEx*;\nOp6Suffix = Op6@ (ValueFactorStat | Op2Value) Op6SuffixEe*;\nOp6SuffixEe = Op3Suffix | Op4Suffix | Op5Suffix;\nOp6SuffixEx = Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp5 = '..';\nOp5Stat = Op5Suffix Op5SuffixEx*;\nOp5Suffix = Op5@ (ValueFactorStat | Op2Value) Op5SuffixEe*;\nOp5SuffixEe = Op3Suffix | Op4Suffix;\nOp5SuffixEx = Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp4 = '+' | '-';\nOp4Stat = Op4Suffix Op4SuffixEx*;\nOp4Suffix = Op4@ (ValueFactorStat | Op2Value) Op4SuffixEe*;\nOp4SuffixEe = Op3Suffix;\nOp4SuffixEx = Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\nOp3 = '*' | '/' | '%';\nOp3Stat = Op3Suffix Op3SuffixEx*;\nOp3Suffix = Op3@ (ValueFactorStat | Op2Value);\nOp3SuffixEx = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\n// 单目运算\nOp2 = '!' | '-' | '~';\nOp2Stat = Op2Value Op2SuffixEx*;\nOp2Value = Op2@ ValueFactorStat;\nOp2SuffixEx = Op3Suffix | Op4Suffix | Op5Suffix | Op6Suffix | Op7Suffix | Op8Suffix | Op9Suffix | Op10Suffix | Op11Suffix | Op12Suffix;\n\n// 优先级1 前缀自加，前缀自减 从右到左\nOp1 = '++' | '--';\n" }

{ "content": "start = \"justCTF{\"\nend = \"}\"\n\nflag = \"Asia\" / ( start (prefix \"_\" infix \"_\" sufix) end )\n\nprefix = (1*\"a\") (*2\"b\") (\"left\" / \"right\" / \"something_else\")\n\ninfix = (\"short\" / \"long\") *(\"c\" / \"dd\") 1*DIGIT\nsufix = (\"simple\"/\"hard\") \"-\" Q\n\nQ = L M R 4\"xoxo\"\n\nL = 0*3\"WRC\"\nM = 0*7(\"QSP\" / \"WSP\")\nR = (*\"CWR\") / (\"WCR\")\n\n" }

{ "content": "; ---------------------------------------------------------------------------- ;\n; Type ;\n; ---------------------------------------------------------------------------- ;\n\nType\n\t= Atomic [Union / Intersection]\n\t/ Nullable\n\nParenthesizedType\n\t= Atomic [Union / Intersection / Conditional]\n\t/ Nullable\n\nUnion\n\t= 1*(TokenUnion Atomic)\n\nIntersection\n\t= 1*(TokenIntersection Atomic)\n\nConditional\n = 1*ByteHorizontalWs TokenIs [TokenNot] Atomic TokenNullable Type TokenColon ParenthesizedType\n\nNullable\n\t= TokenNullable Atomic\n\nAtomic\n\t= TokenIdentifier [Generic / Callable / Array]\n\t/ TokenThisVariable\n\t/ TokenParenthesesOpen ParenthesizedType TokenParenthesesClose [Array]\n\nGeneric\n\t= TokenAngleBracketOpen GenericTypeArgument *(TokenComma GenericTypeArgument) TokenAngleBracketClose\n\nGenericTypeArgument\n = [TokenContravariant / TokenCovariant] Type\n / TokenWildcard\n\nCallable\n\t= TokenParenthesesOpen [CallableParameters] TokenParenthesesClose TokenColon CallableReturnType\n\nCallableParameters\n\t= CallableParameter *(TokenComma CallableParameter)\n\nCallableParameter\n\t= Type [CallableParameterIsReference] [CallableParameterIsVariadic] [CallableParameterName] [CallableParameterIsOptional]\n\nCallableParameterIsReference\n\t= TokenIntersection\n\nCallableParameterIsVariadic\n\t= TokenVariadic\n\nCallableParameterName\n\t= TokenVariable\n\nCallableParameterIsOptional\n\t= TokenEqualSign\n\nCallableReturnType\n\t= TokenIdentifier [Generic]\n\t/ Nullable\n\t/ TokenParenthesesOpen Type TokenParenthesesClose\n\nArray\n\t= 1*(TokenSquareBracketOpen TokenSquareBracketClose)\n\nArrayShape\n = TokenCurlyBracketOpen ArrayShapeItem *(TokenComma ArrayShapeItem) TokenCurlyBracketClose\n\nArrayShapeItem\n = (ConstantString / ConstantInt / TokenIdentifier) TokenNullable TokenColon Type\n / Type\n\n; ---------------------------------------------------------------------------- ;\n; ConstantExpr ;\n; ---------------------------------------------------------------------------- ;\n\nConstantExpr\n\t= ConstantFloat *ByteHorizontalWs\n\t/ ConstantInt *ByteHorizontalWs\n\t/ ConstantTrue *ByteHorizontalWs\n\t/ ConstantFalse *ByteHorizontalWs\n\t/ ConstantNull *ByteHorizontalWs\n\t/ ConstantString *ByteHorizontalWs\n\t/ ConstantArray *ByteHorizontalWs\n\t/ ConstantFetch *ByteHorizontalWs\n\nConstantFloat\n\t= [ByteNumberSign] 1*ByteDecDigit *(\"_\" 1*ByteDecDigit) \".\" [1*ByteDecDigit *(\"_\" 1*ByteDecDigit)] [ConstantFloatExp]\n\t/ [ByteNumberSign] 1*ByteDecDigit *(\"_\" 1*ByteDecDigit) ConstantFloatExp\n\t/ [ByteNumberSign] \".\" 1*ByteDecDigit *(\"_\" 1*ByteDecDigit) [ConstantFloatExp]\n\nConstantFloatExp\n\t= \"e\" [ByteNumberSign] 1*ByteDecDigit *(\"_\" 1*ByteDecDigit)\n\nConstantInt\n\t= [ByteNumberSign] \"0b\" 1*ByteBinDigit *(\"_\" 1*ByteBinDigit)\n\t/ [ByteNumberSign] \"0o\" 1*ByteOctDigit *(\"_\" 1*ByteOctDigit)\n\t/ [ByteNumberSign] \"0x\" 1*ByteHexDigit *(\"_\" 1*ByteHexDigit)\n\t/ [ByteNumberSign] 1*ByteDecDigit *(\"_\" 1*ByteDecDigit)\n\nConstantTrue\n\t= \"true\"\n\nConstantFalse\n\t= \"false\"\n\nConstantNull\n\t= \"null\"\n\nConstantString\n\t= ByteSingleQuote *(ByteBackslash ByteNotEol / ByteNotEolAndNotBackslashAndNotSingleQuote) ByteSingleQuote\n\t/ ByteDoubleQuote *(ByteBackslash ByteNotEol / ByteNotEolAndNotBackslashAndNotDoubleQuote) ByteDoubleQuote\n\nConstantArray\n\t= TokenSquareBracketOpen [ConstantArrayItems] TokenSquareBracketClose\n\t/ \"array\" TokenParenthesesOpen [ConstantArrayItems] TokenParenthesesClose\n\nConstantArrayItems\n\t= ConstantArrayItem *(TokenComma ConstantArrayItem) [TokenComma]\n\nConstantArrayItem\n\t= ConstantExpr [TokenDoubleArrow ConstantExpr]\n\nConstantFetch\n\t= TokenIdentifier [TokenDoubleColon ByteIdentifierFirst *ByteIdentifierSecond *ByteHorizontalWs]\n\n\n; ---------------------------------------------------------------------------- ;\n; Tokens ;\n; ---------------------------------------------------------------------------- ;\n\nTokenUnion\n\t= \"|\" *ByteHorizontalWs\n\nTokenIntersection\n\t= \"&\" *ByteHorizontalWs\n\nTokenNullable\n\t= \"?\" *ByteHorizontalWs\n\nTokenParenthesesOpen\n\t= \"(\" *ByteHorizontalWs\n\nTokenParenthesesClose\n\t= \")\" *ByteHorizontalWs\n\nTokenAngleBracketOpen\n\t= \"<\" *ByteHorizontalWs\n\nTokenAngleBracketClose\n\t= \">\" *ByteHorizontalWs\n\nTokenSquareBracketOpen\n\t= \"[\" *ByteHorizontalWs\n\nTokenSquareBracketClose\n\t= \"]\" *ByteHorizontalWs\n\nTokenCurlyBracketOpen\n = \"{\" *ByteHorizontalWs\n\nTokenCurlyBracketClose\n = \"}\" *ByteHorizontalWs\n\nTokenComma\n\t= \",\" *ByteHorizontalWs\n\nTokenColon\n\t= \":\" *ByteHorizontalWs\n\nTokenVariadic\n\t= \"...\" *ByteHorizontalWs\n\nTokenEqualSign\n\t= \"=\" *ByteHorizontalWs\n\nTokenVariable\n\t= \"$\" ByteIdentifierFirst *ByteIdentifierSecond *ByteHorizontalWs\n\nTokenDoubleArrow\n\t= \"=>\" *ByteHorizontalWs\n\nTokenDoubleColon\n\t= \"::\" *ByteHorizontalWs\n\nTokenThisVariable\n\t= %s\"$this\" *ByteHorizontalWs\n\nTokenIs\n\t= %s\"is\" 1*ByteHorizontalWs\n\nTokenNot\n\t= %s\"not\" 1*ByteHorizontalWs\n\nTokenContravariant\n = %s\"contravariant\" 1*ByteHorizontalWs\n\nTokenCovariant\n = %s\"covariant\" 1*ByteHorizontalWs\n\nTokenWildcard\n\t= \"*\" *ByteHorizontalWs\n\nTokenIdentifier\n\t= [ByteBackslash] ByteIdentifierFirst *ByteIdentifierSecond *(ByteBackslash ByteIdentifierFirst *ByteIdentifierSecond) *ByteHorizontalWs\n\n\n; ---------------------------------------------------------------------------- ;\n; Bytes ;\n; ---------------------------------------------------------------------------- ;\n\nByteHorizontalWs\n\t= %x09 ; horizontal tab\n\t/ %x20 ; space\n\nByteNumberSign\n\t= \"+\"\n\t/ \"-\"\n\nByteBinDigit\n\t= %x30-31 ; 0-1\n\nByteOctDigit\n\t= %x30-37 ; 0-7\n\nByteDecDigit\n\t= %x30-39 ; 0-9\n\nByteHexDigit\n\t= %x30-39 ; 0-9\n\t/ %x41-46 ; A-F\n\t/ %x61-66 ; a-f\n\nByteIdentifierFirst\n\t= %x41-5A ; A-Z\n\t/ \"_\"\n\t/ %x61-7A ; a-z\n\t/ %x80-FF\n\nByteIdentifierSecond\n\t= %x30-39 ; 0-9\n\t/ %x41-5A ; A-Z\n\t/ \"_\"\n\t/ %x61-7A ; a-z\n\t/ %x80-FF\n\nByteSingleQuote\n\t= %x27 ; '\n\nByteDoubleQuote\n\t= %x22 ; \"\n\nByteBackslash\n\t= %x5C ; \\\n\nByteNotEol\n\t= %x00-09 ; skip LF\n\t/ %x0B-0C ; skip CR\n\t/ %x0E-FF\n\nByteNotEolAndNotBackslashAndNotSingleQuote\n\t= %x00-09 ; skip LF\n\t/ %x0B-0C ; skip CR\n\t/ %x0E-26 ; skip single quote\n\t/ %x28-5B ; skip backslash\n\t/ %x5D-FF\n\nByteNotEolAndNotBackslashAndNotDoubleQuote\n\t= %x00-09 ; skip LF\n\t/ %x0B-0C ; skip CR\n\t/ %x0E-21 ; skip double quote\n\t/ %x23-5B ; skip backslash\n\t/ %x5D-FF\n" }

{ "content": "session-description = proto-version\r\n origin-field\r\n session-name-field\r\n information-field\r\n uri-field\r\n email-fields\r\n phone-fields\r\n connection-field\r\n bandwidth-fields\r\n time-fields\r\n key-field\r\n attribute-fields\r\n media-descriptions\r\n\r\nproto-version = %x76 \"=\" 1*DIGIT CRLF !!!\r\n [_, _, v, _] = values\r\n {:ok, Map.put(state, :version, :lists.flatten(v))}\r\n!!!\r\n ;this memo describes version 0\r\n\r\norigin-field = %x6f \"=\" username SP sess-id SP sess-version SP\r\n nettype SP addrtype SP unicast-address CRLF !!!\r\n [\r\n _,\r\n _,\r\n username,\r\n _,\r\n sess_id,\r\n _,\r\n sess_version,\r\n _,\r\n net_type,\r\n _,\r\n addr_type,\r\n _,\r\n unicast,\r\n _\r\n ] = values\r\n {:ok, Map.put(state, :origin, %{\r\n username: :lists.flatten(username),\r\n session_id: :lists.flatten(sess_id),\r\n session_version: :lists.flatten(sess_version),\r\n net_type: :lists.flatten(net_type),\r\n address_type: :lists.flatten(addr_type),\r\n unicast_address: :lists.flatten(unicast)\r\n })}\r\n!!!\r\n\r\nsession-name-field = %x73 \"=\" text CRLF !!!\r\n [_, _, s, _] = values\r\n {:ok, Map.put(state, :session_name, :lists.flatten(s))}\r\n!!!\r\n\r\ninformation-field = [%x69 \"=\" text CRLF]\r\n\r\nuri-field = [%x75 \"=\" uri CRLF]\r\n\r\nemail-fields = *(%x65 \"=\" email-address CRLF)\r\n\r\nphone-fields = *(%x70 \"=\" phone-number CRLF)\r\n\r\nconnection-field = [%x63 \"=\" nettype SP addrtype SP\r\n connection-address CRLF] !!!\r\n{:ok, state}\r\n!!!\r\n ;a connection field must be present\r\n ;in every media description or at the\r\n ;session-level\r\n\r\nbandwidth-fields = *(%x62 \"=\" bwtype \":\" bandwidth CRLF)\r\n\r\ntime-fields = 1*( %x74 \"=\" start-time SP stop-time\r\n *(CRLF repeat-fields) CRLF)\r\n [zone-adjustments CRLF]\r\n\r\nrepeat-fields = %x72 \"=\" repeat-interval SP typed-time\r\n 1*(SP typed-time)\r\n\r\nzone-adjustments = %x7a \"=\" time SP [\"-\"] typed-time\r\n *(SP time SP [\"-\"] typed-time)\r\n\r\nkey-field = [%x6b \"=\" key-type CRLF]\r\n\r\nattribute-fields = *(%x61 \"=\" attribute CRLF)\r\n\r\nmedia-descriptions = *( media-field\r\n information-field\r\n *connection-field\r\n bandwidth-fields\r\n key-field\r\n attribute-fields )\r\n\r\nmedia-field = %x6d \"=\" media SP port [\"/\" integer]\r\n SP proto 1*(SP fmt) CRLF\r\n\r\n; sub-rules of 'o='\r\nusername = non-ws-string\r\n ;pretty wide definition, but doesn't\r\n ;include space\r\n\r\nsess-id = 1*DIGIT\r\n ;should be unique for this username/host\r\n\r\nsess-version = 1*DIGIT\r\n\r\nnettype = token\r\n ;typically \"IN\"\r\n\r\naddrtype = token\r\n ;typically \"IP4\" or \"IP6\"\r\n\r\n; sub-rules of 'u='\r\nuri = URI-reference\r\n ; see RFC 3986\r\n\r\n\r\n; sub-rules of 'e=', see RFC 2822 for definitions\r\nemail-address = address-and-comment / dispname-and-address\r\n / addr-spec\r\naddress-and-comment = addr-spec 1*SP \"(\" 1*email-safe \")\"\r\ndispname-and-address = 1*email-safe 1*SP \"<\" addr-spec \">\"\r\n\r\n; sub-rules of 'p='\r\nphone-number = phone *SP \"(\" 1*email-safe \")\" /\r\n 1*email-safe \"<\" phone \">\" /\r\n phone\r\n\r\nphone = [\"+\"] DIGIT 1*(SP / \"-\" / DIGIT)\r\n\r\n; sub-rules of 'c='\r\nconnection-address = multicast-address / unicast-address\r\n\r\n; sub-rules of 'b='\r\nbwtype = token\r\n\r\nbandwidth = 1*DIGIT\r\n\r\n; sub-rules of 't='\r\nstart-time = time / \"0\"\r\n\r\nstop-time = time / \"0\"\r\n\r\ntime = POS-DIGIT 9*DIGIT\r\n ; Decimal representation of NTP time in\r\n ; seconds since 1900. The representation\r\n ; of NTP time is an unbounded length field\r\n ; containing at least 10 digits. Unlike the\r\n ; 64-bit representation used elsewhere, time\r\n ; in SDP does not wrap in the year 2036.\r\n\r\n; sub-rules of 'r=' and 'z='\r\nrepeat-interval = POS-DIGIT *DIGIT [fixed-len-time-unit]\r\n\r\ntyped-time = 1*DIGIT [fixed-len-time-unit]\r\n\r\nfixed-len-time-unit = %x64 / %x68 / %x6d / %x73\r\n\r\n; sub-rules of 'k='\r\nkey-type = %x70 %x72 %x6f %x6d %x70 %x74 / ; \"prompt\"\r\n %x63 %x6c %x65 %x61 %x72 \":\" text / ; \"clear:\"\r\n %x62 %x61 %x73 %x65 \"64:\" base64 / ; \"base64:\"\r\n %x75 %x72 %x69 \":\" uri ; \"uri:\"\r\n\r\nbase64 = *base64-unit [base64-pad]\r\n\r\nbase64-unit = 4base64-char\r\nbase64-pad = 2base64-char \"==\" / 3base64-char \"=\"\r\nbase64-char = ALPHA / DIGIT / \"+\" / \"/\"\r\n\r\n; sub-rules of 'a='\r\nattribute = (att-field \":\" att-value) / att-field\r\n\r\natt-field = token\r\n\r\natt-value = byte-string\r\n\r\n; sub-rules of 'm='\r\nmedia = token\r\n ;typically \"audio\", \"video\", \"text\", or\r\n ;\"application\"\r\n\r\nfmt = token\r\n ;typically an RTP payload type for audio\r\n ;and video media\r\n\r\nproto = token *(\"/\" token)\r\n ;typically \"RTP/AVP\" or \"udp\"\r\n\r\nport = 1*DIGIT\r\n\r\n; generic sub-rules: addressing\r\nunicast-address = IP4-address / IP6-address / FQDN / extn-addr\r\n\r\nmulticast-address = IP4-multicast / IP6-multicast / FQDN\r\n / extn-addr\r\n\r\nIP4-multicast = m1 3( \".\" decimal-uchar )\r\n \"/\" ttl [ \"/\" integer ]\r\n ; IPv4 multicast addresses may be in the\r\n ; range 224.0.0.0 to 239.255.255.255\r\n\r\nm1 = (\"22\" (\"4\"/\"5\"/\"6\"/\"7\"/\"8\"/\"9\")) /\r\n (\"23\" DIGIT )\r\n\r\nIP6-multicast = hexpart [ \"/\" integer ]\r\n ; IPv6 address starting with FF\r\n\r\nttl = (POS-DIGIT *2DIGIT) / \"0\"\r\n\r\nFQDN = 4*(alpha-numeric / \"-\" / \".\")\r\n ; fully qualified domain name as specified\r\n ; in RFC 1035 (and updates)\r\n\r\nIP4-address = b1 3(\".\" decimal-uchar)\r\n\r\nb1 = decimal-uchar\r\n ; less than \"224\"\r\n\r\n; The following is consistent with RFC 2373 [30], Appendix B.\r\nIP6-address = hexpart [ \":\" IP4-address ]\r\n\r\nhexpart = hexseq / hexseq \"::\" [ hexseq ] /\r\n \"::\" [ hexseq ]\r\n\r\nhexseq = hex4 *( \":\" hex4)\r\n\r\nhex4 = 1*4HEXDIG\r\n\r\n; Generic for other address families\r\nextn-addr = non-ws-string\r\n\r\n; generic sub-rules: datatypes\r\ntext = byte-string\r\n ;default is to interpret this as UTF8 text.\r\n ;ISO 8859-1 requires \"a=charset:ISO-8859-1\"\r\n ;session-level attribute to be used\r\n\r\nbyte-string = 1*(%x01-09/%x0B-0C/%x0E-FF)\r\n ;any byte except NUL, CR, or LF\r\n\r\nnon-ws-string = 1*(VCHAR/%x80-FF)\r\n ;string of visible characters\r\n\r\ntoken-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39\r\n / %x41-5A / %x5E-7E\r\n\r\ntoken = 1*(token-char)\r\n\r\nemail-safe = %x01-09/%x0B-0C/%x0E-27/%x2A-3B/%x3D/%x3F-FF\r\n ;any byte except NUL, CR, LF, or the quoting\r\n ;characters ()<>\r\n\r\ninteger = POS-DIGIT *DIGIT\r\n\r\n; generic sub-rules: primitives\r\nalpha-numeric = ALPHA / DIGIT\r\n\r\nPOS-DIGIT = %x31-39 ; 1 - 9\r\ndecimal-uchar = DIGIT\r\n / POS-DIGIT DIGIT\r\n / (\"1\" 2*(DIGIT))\r\n / (\"2\" (\"0\"/\"1\"/\"2\"/\"3\"/\"4\") DIGIT)\r\n / (\"2\" \"5\" (\"0\"/\"1\"/\"2\"/\"3\"/\"4\"/\"5\"))\r\nALPHA = %x41-5A / %x61-7A ; A-Z / a-z\r\n\r\nBIT = \"0\" / \"1\"\r\n\r\nCHAR = %x01-7F\r\n ; any 7-bit US-ASCII character,\r\n ; excluding NUL\r\n\r\nCR = %x0D\r\n ; carriage return\r\n\r\nCRLF = [CR] LF\r\n ; Internet standard newline\r\n\r\nCTL = %x00-1F / %x7F\r\n ; controls\r\n\r\nDIGIT = %x30-39\r\n ; 0-9\r\n\r\nDQUOTE = %x22\r\n ; \" (Double Quote)\r\n\r\nHEXDIG = DIGIT / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"\r\n\r\nHTAB = %x09\r\n ; horizontal tab\r\n\r\nLF = %x0A\r\n ; linefeed\r\n\r\nLWSP = *(WSP / CRLF WSP)\r\n ; linear white space (past newline)\r\n\r\nOCTET = %x00-FF\r\n ; 8 bits of data\r\n\r\nSP = %x20\r\n\r\nVCHAR = %x21-7E\r\n ; visible (printing) characters\r\n\r\nWSP = SP / HTAB\r\n ; white space\r\n" }

{ "content": " message = (fields / obs-fields)\n [CRLF body]\n\n quoted-pair = (\"\\\" (VCHAR / WSP)) / obs-qp\n\n FWS = ([*WSP CRLF] 1*WSP) / obs-FWS\n ; Folding white space\n\n ctext = %d33-39 / ; Printable US-ASCII\n %d42-91 / ; characters not including\n %d93-126 / ; \"(\", \")\", or \"\\\"\n obs-ctext\n\n ; Errata 7382\n ccontent = ctext / quoted-pair\n\n comment = \"(\" *([FWS] ccontent) [FWS] \")\"\n\n CFWS = (1*([FWS] comment) [FWS]) / FWS\n\n\n atext = ALPHA / DIGIT / ; Printable US-ASCII\n \"!\" / \"#\" / ; characters not including\n \"$\" / \"%\" / ; specials. Used for atoms.\n \"&\" / \"'\" /\n \"*\" / \"+\" /\n \"-\" / \"/\" /\n \"=\" / \"?\" /\n \"^\" / \"_\" /\n \"`\" / \"{\" /\n \"|\" / \"}\" /\n \"~\"\n\n atom = [CFWS] 1*atext [CFWS]\n\n dot-atom-text = 1*atext *(\".\" 1*atext)\n\n dot-atom = [CFWS] dot-atom-text [CFWS]\n\n specials = \"(\" / \")\" / ; Special characters that do\n \"<\" / \">\" / ; not appear in atext\n \"[\" / \"]\" /\n \":\" / \";\" /\n \"@\" / \"\\\" /\n \",\" / \".\" /\n DQUOTE\n\n qtext = %d33 / ; Printable US-ASCII\n %d35-91 / ; characters not including\n %d93-126 / ; \"\\\" or the quote character\n obs-qtext\n\n qcontent = qtext / quoted-pair\n\n ; Errata 3135\n quoted-string = [CFWS]\n DQUOTE ((1*([FWS] qcontent) [FWS]) / FWS) DQUOTE\n [CFWS]\n\n\n word = atom / quoted-string\n\n phrase = 1*word / obs-phrase\n\n unstructured = (*([FWS] VCHAR) *WSP) / obs-unstruct\n\n\n\n date-time = [ day-of-week \",\" ] date time [CFWS]\n\n day-of-week = ([FWS] day-name) / obs-day-of-week\n\n day-name = \"Mon\" / \"Tue\" / \"Wed\" / \"Thu\" /\n \"Fri\" / \"Sat\" / \"Sun\"\n\n date = day month year\n\n day = ([FWS] 1*2DIGIT FWS) / obs-day\n\n month = \"Jan\" / \"Feb\" / \"Mar\" / \"Apr\" /\n \"May\" / \"Jun\" / \"Jul\" / \"Aug\" /\n \"Sep\" / \"Oct\" / \"Nov\" / \"Dec\"\n\n year = (FWS 4*DIGIT FWS) / obs-year\n\n time = time-of-day zone\n\n time-of-day = hour \":\" minute [ \":\" second ]\n\n hour = 2DIGIT / obs-hour\n\n minute = 2DIGIT / obs-minute\n\n second = 2DIGIT / obs-second\n\n ; Errata 6639\n zone = (FWS ( \"+\" / \"-\" ) 4DIGIT) / [FWS] obs-zone\n\n\n address = mailbox / group\n\n mailbox = name-addr / addr-spec\n\n name-addr = [display-name] angle-addr\n\n angle-addr = [CFWS] \"<\" addr-spec \">\" [CFWS] /\n obs-angle-addr\n\n group = display-name \":\" [group-list] \";\" [CFWS]\n\n display-name = phrase\n\n mailbox-list = (mailbox *(\",\" mailbox)) / obs-mbox-list\n\n address-list = (address *(\",\" address)) / obs-addr-list\n\n group-list = mailbox-list / CFWS / obs-group-list\n\n addr-spec = local-part \"@\" domain\n\n local-part = dot-atom / quoted-string / obs-local-part\n\n domain = dot-atom / domain-literal / obs-domain\n\n domain-literal = [CFWS] \"[\" *([FWS] dtext) [FWS] \"]\" [CFWS]\n\n dtext = %d33-90 / ; Printable US-ASCII\n %d94-126 / ; characters not including\n obs-dtext ; \"[\", \"]\", or \"\\\"\n\n body = (*(*998text CRLF) *998text) / obs-body\n\n text = %d1-9 / ; Characters excluding CR\n %d11 / ; and LF\n %d12 /\n %d14-127\n\n ; Errata 2950\n fields = *(trace\n *optional-field /\n 1*(resent-date /\n resent-from /\n resent-sender /\n resent-to /\n resent-cc /\n resent-bcc /\n resent-msg-id))\n *(orig-date /\n from /\n sender /\n reply-to /\n to /\n cc /\n bcc /\n message-id /\n in-reply-to /\n references /\n subject /\n comments /\n keywords /\n optional-field)\n\n orig-date = \"Date:\" date-time CRLF\n\n from = \"From:\" mailbox-list CRLF\n\n sender = \"Sender:\" mailbox CRLF\n\n reply-to = \"Reply-To:\" address-list CRLF\n\n to = \"To:\" address-list CRLF\n\n cc = \"Cc:\" address-list CRLF\n\n bcc = \"Bcc:\" [address-list / CFWS] CRLF\n\n message-id = \"Message-ID:\" msg-id CRLF\n\n in-reply-to = \"In-Reply-To:\" 1*msg-id CRLF\n\n references = \"References:\" 1*msg-id CRLF\n\n msg-id = [CFWS] \"<\" id-left \"@\" id-right \">\" [CFWS]\n\n id-left = dot-atom-text / obs-id-left\n\n id-right = dot-atom-text / no-fold-literal / obs-id-right\n\n no-fold-literal = \"[\" *dtext \"]\"\n\n subject = \"Subject:\" unstructured CRLF\n\n comments = \"Comments:\" unstructured CRLF\n\n keywords = \"Keywords:\" phrase *(\",\" phrase) CRLF\n\n\n resent-date = \"Resent-Date:\" date-time CRLF\n\n resent-from = \"Resent-From:\" mailbox-list CRLF\n\n resent-sender = \"Resent-Sender:\" mailbox CRLF\n\n resent-to = \"Resent-To:\" address-list CRLF\n\n resent-cc = \"Resent-Cc:\" address-list CRLF\n\n resent-bcc = \"Resent-Bcc:\" [address-list / CFWS] CRLF\n\n resent-msg-id = \"Resent-Message-ID:\" msg-id CRLF\n\n\n trace = [return]\n 1*received\n\n return = \"Return-Path:\" path CRLF\n\n path = angle-addr / ([CFWS] \"<\" [CFWS] \">\" [CFWS])\n\n ; Errata 3979\n received = \"Received:\" [1*received-token / CFWS] \";\" date-time CRLF\n\n received-token = word / angle-addr / addr-spec / domain\n\n\n optional-field = field-name \":\" unstructured CRLF\n\n field-name = 1*ftext\n\n ftext = %d33-57 / ; Printable US-ASCII\n %d59-126 ; characters not including\n ; \":\".\n\n obs-NO-WS-CTL = %d1-8 / ; US-ASCII control\n %d11 / ; characters that do not\n %d12 / ; include the carriage\n %d14-31 / ; return, line feed, and\n %d127 ; white space characters\n\n obs-ctext = obs-NO-WS-CTL\n\n obs-qtext = obs-NO-WS-CTL\n\n obs-utext = %d0 / obs-NO-WS-CTL / VCHAR\n\n obs-qp = \"\\\" (%d0 / obs-NO-WS-CTL / LF / CR)\n\n ; Errata 1906\n obs-body = *(%d0-127)\n\n ; Errata 1905\n obs-unstruct = *( (*CR 1*(obs-utext / FWS)) / 1*LF ) *CR\n\n obs-phrase = word *(word / \".\" / CFWS)\n\n obs-phrase-list = [phrase / CFWS] *(\",\" [phrase / CFWS])\n\n ; Errata 1908\n obs-FWS = 1*([CRLF] WSP)\n\n obs-day-of-week = [CFWS] day-name [CFWS]\n\n obs-day = [CFWS] 1*2DIGIT [CFWS]\n\n obs-year = [CFWS] 2*DIGIT [CFWS]\n\n obs-hour = [CFWS] 2DIGIT [CFWS]\n\n obs-minute = [CFWS] 2DIGIT [CFWS]\n\n obs-second = [CFWS] 2DIGIT [CFWS]\n\n obs-zone = \"UT\" / \"GMT\" / ; Universal Time\n ; North American UT\n ; offsets\n \"EST\" / \"EDT\" / ; Eastern: - 5/ - 4\n \"CST\" / \"CDT\" / ; Central: - 6/ - 5\n \"MST\" / \"MDT\" / ; Mountain: - 7/ - 6\n \"PST\" / \"PDT\" / ; Pacific: - 8/ - 7\n %d65-73 / ; Military zones - \"A\"\n %d75-90 / ; through \"I\" and \"K\"\n %d97-105 / ; through \"Z\", both\n %d107-122 ; upper and lower case\n\n\n obs-angle-addr = [CFWS] \"<\" obs-route addr-spec \">\" [CFWS]\n\n obs-route = obs-domain-list \":\"\n\n obs-domain-list = *(CFWS / \",\") \"@\" domain\n *(\",\" [CFWS] [\"@\" domain])\n\n obs-mbox-list = *([CFWS] \",\") mailbox *(\",\" [mailbox / CFWS])\n\n obs-addr-list = *([CFWS] \",\") address *(\",\" [address / CFWS])\n\n obs-group-list = 1*([CFWS] \",\") [CFWS]\n\n obs-local-part = word *(\".\" word)\n\n obs-domain = atom *(\".\" atom)\n\n obs-dtext = obs-NO-WS-CTL / quoted-pair\n\n\n obs-fields = *(obs-return /\n obs-received /\n obs-orig-date /\n obs-from /\n obs-sender /\n obs-reply-to /\n obs-to /\n obs-cc /\n obs-bcc /\n obs-message-id /\n obs-in-reply-to /\n obs-references /\n obs-subject /\n obs-comments /\n obs-keywords /\n obs-resent-date /\n obs-resent-from /\n obs-resent-send /\n obs-resent-rply /\n obs-resent-to /\n obs-resent-cc /\n obs-resent-bcc /\n obs-resent-mid /\n obs-optional)\n\n obs-orig-date = \"Date\" *WSP \":\" date-time CRLF\n\n obs-from = \"From\" *WSP \":\" mailbox-list CRLF\n\n obs-sender = \"Sender\" *WSP \":\" mailbox CRLF\n\n obs-reply-to = \"Reply-To\" *WSP \":\" address-list CRLF\n\n obs-to = \"To\" *WSP \":\" address-list CRLF\n\n obs-cc = \"Cc\" *WSP \":\" address-list CRLF\n\n obs-bcc = \"Bcc\" *WSP \":\"\n (address-list / (*([CFWS] \",\") [CFWS])) CRLF\n\n\n obs-message-id = \"Message-ID\" *WSP \":\" msg-id CRLF\n\n obs-in-reply-to = \"In-Reply-To\" *WSP \":\" *(phrase / msg-id) CRLF\n\n obs-references = \"References\" *WSP \":\" *(phrase / msg-id) CRLF\n\n obs-id-left = local-part\n\n obs-id-right = domain\n\n\n obs-subject = \"Subject\" *WSP \":\" unstructured CRLF\n\n obs-comments = \"Comments\" *WSP \":\" unstructured CRLF\n\n obs-keywords = \"Keywords\" *WSP \":\" obs-phrase-list CRLF\n\n\n\n obs-resent-from = \"Resent-From\" *WSP \":\" mailbox-list CRLF\n\n obs-resent-send = \"Resent-Sender\" *WSP \":\" mailbox CRLF\n\n obs-resent-date = \"Resent-Date\" *WSP \":\" date-time CRLF\n\n obs-resent-to = \"Resent-To\" *WSP \":\" address-list CRLF\n\n obs-resent-cc = \"Resent-Cc\" *WSP \":\" address-list CRLF\n\n obs-resent-bcc = \"Resent-Bcc\" *WSP \":\"\n (address-list / (*([CFWS] \",\") [CFWS])) CRLF\n\n obs-resent-mid = \"Resent-Message-ID\" *WSP \":\" msg-id CRLF\n\n obs-resent-rply = \"Resent-Reply-To\" *WSP \":\" address-list CRLF\n\n\n obs-return = \"Return-Path\" *WSP \":\" path CRLF\n\n ; Errata 3979 and 5867\n obs-received = \"Received\" *WSP \":\" [1*received-token / CFWS] [ \";\" date-time CRLF ]\n\n obs-optional = field-name *WSP \":\" unstructured CRLF\n\n; From RFC 5234\n\n CR = %x0D\n ; carriage return\n\n LF = %x0A\n ; linefeed\n\n CRLF = CR LF\n ; Internet standard newline\n\n LWSP = *(WSP / CRLF WSP)\n ; linear white space (past newline)\n\n HTAB = %x09\n ; horizontal tab\n\n WSP = SP / HTAB\n ; white space\n\n DIGIT = %x30-39\n ; 0-9\n\n DQUOTE = %x22\n ; \" (Double Quote)\n\n VCHAR = %x21-7E\n ; visible (printing) characters\n\n SP = %x20\n\n ALPHA = %x41-5A / %x61-7A ; A-Z / a-z\n" }

{ "content": "auth-scheme = token\nauth-param = token BWS \"=\" BWS ( token / quoted-string )\ntoken68 = 1*( ALPHA / DIGIT /\n \"-\" / \".\" / \"_\" / \"~\" / \"+\" / \"/\" ) *\"=\"\nchallenge = auth-scheme [ 1*SP ( token68 / #auth-param ) ]\ncredentials = auth-scheme [ 1*SP ( token68 / #auth-param ) ]\nWWW-Authenticate = 1#challenge\nAuthorization = credentials\nProxy-Authenticate = 1#challenge\nProxy-Authorization = credentials\n\nBWS = OWS\nOWS = *( SP / HTAB )\nquoted-string = <quoted-string, see [RFC7230], Section 3.2.6>\ntoken = <token, see [RFC7230], Section 3.2.6>\n" }

{ "content": "CSSTOKEN = IDENT\r\n / ATKEYWORD\r\n / STRING\r\n / BAD-STRING\r\n / BAD-URI\r\n / BAD-COMMENT\r\n / HASH\r\n / NUMBER\r\n / PERCENTAGE\r\n / DIMENSION\r\n / URI\r\n / UNICODE-RANGE\r\n / CDO\r\n / CDC\r\n / COLON\r\n / SEMICOLON\r\n / LEFT-CURLY\r\n / RIGHT-CURLY\r\n / LEFT-PAREN\r\n / RIGHT-PAREN\r\n / LEFT-SQUARE\r\n / RIGHT-SQUARE\r\n / S\r\n / COMMENT\r\n / FUNCTION\r\n / INCLUDES\r\n / DASHMATCH\r\n / DELIM\r\n\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n; Tokens\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\nIDENT = ident\r\nATKEYWORD = \"@\" ident\r\nSTRING = string\r\nBAD-STRING = badstring\r\nBAD-URI = baduri\r\nBAD-COMMENT = badcomment\r\nHASH = \"#\" name\r\nNUMBER = num\r\nPERCENTAGE = num \"%\"\r\nDIMENSION = num ident\r\nURI = \"url(\" w string w \")\"\r\n / \"url(\" w *(\"!\" / \"#\" / \"$\" / \"%\" / \"&\" / %x2a-5b\r\n / %x5d-7e / nonascii / escape) w \")\"\r\n\r\nUNICODE-RANGE = \"u+\" 1*6(HEXDIG / \"?\") [ \"-\" 1*6HEXDIG ]\r\nCDO = \"<!--\"\r\nCDC = \"-->\"\r\n\r\nCOLON = \":\"\r\nSEMICOLON = \";\"\r\nLEFT-CURLY = \"{\"\r\nRIGHT-CURLY = \"}\"\r\nLEFT-PAREN = \"(\"\r\nRIGHT-PAREN = \")\"\r\nLEFT-SQUARE = \"[\"\r\nRIGHT-SQUARE = \"]\"\r\n\r\nS = 1*(%x09 / %x0a / %x0d / %x0c / %x20)\r\nCOMMENT = \"/*\"\r\n *(%x00-29 / %x2b-10ffff) 1*\"*\"\r\n *((%x00-29 / %x2b-2e / %x30-10ffff) *(%x00-29 / %x2b-10ffff) 1*\"*\")\r\n \"/\"\r\n\r\nFUNCTION = ident \"(\"\r\nINCLUDES = \"~=\"\r\nDASHMATCH = \"|=\"\r\nDELIM = %x00-08 / %x0b-0b / %x0e-1f / %x21-21 / %x23-26\r\n / %x2a-39 / %x3c-5a / %x5c-5c / %x5e-7a / %x7c-7c\r\n / %x7e-10ffff\r\n\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\n; Macros\r\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\r\nident = [\"-\"] nmstart *nmchar\r\nname = 1*nmchar\r\nnmstart = (ALPHA / \"_\") / nonascii / escape\r\nnonascii = %x80-10ffff\r\nunicode = \"\\\" 1*6HEXDIG [CRLF / (%x20 / %x0a / %x0d / %x09\r\n / %x0c)]\r\n\r\nescape = unicode / \"\\\" (%x00-09 / %x0b / %x0e-2f / %x3a-40\r\n / %x47-60 / %x67-10ffff)\r\n\r\nnmchar = (ALPHA / DIGIT / \"_\" / \"-\") / nonascii / escape\r\nnum = 1*DIGIT / (*DIGIT \".\" 1*DIGIT)\r\nstring = string1 / string2\r\nstring1 = %x22 *(%x00-09 / %x0b / %x0e-21 / %x23-5b\r\n / %x5d-10ffff / nl / escape) %x22\r\n\r\nstring2 = %x27 *(%x00-09 / %x0b / %x0e-26 / %x28-5b\r\n / %x5d-10ffff / nl / escape) %x27\r\n\r\nbadstring = badstring1 / badstring2\r\nbadstring1 = %x22 *(%x00-09 / %x0b / %x0e-21 / %x23-5b\r\n / %x5d-10ffff / nl / escape) [\"\\\"]\r\n\r\nbadstring2 = %x27 *(%x00-09 / %x0b / %x0e-26 / %x28-5b\r\n / %x5d-10ffff / nl / escape) [\"\\\"]\r\n\r\nbadcomment = badcomment1 / badcomment2 \r\nbadcomment1 = \"/*\"\r\n *(%x00-29 / %x2b-10ffff) 1*\"*\"\r\n *((%x00-29 / %x2b-2e / %x30-10ffff) *(%x00-29 / %x2b-10ffff) 1*\"*\")\r\n\r\nbadcomment2 = \"/*\"\r\n *(%x00-29 / %x2b-10ffff)\r\n *(1*\"*\" (%x00-29 / %x2b-2e / %x30-10ffff) *(%x00-29 / %x2b-10ffff))\r\n\r\nbaduri = baduri1 / baduri2 / baduri3\r\nbaduri1 = \"url(\" w *(\"!\" / \"#\" / \"$\" / \"%\" / \"&\" / %x2a-7e) w\r\nbaduri2 = \"url(\" w string w\r\nbaduri3 = \"url(\" w badstring\r\n\r\nnl = %x0a / %x0d %x0a / %x0d / %x0c\r\nw = *(%x09 / %x0a / %x0d / %x0c / %x20)\r\n" }

{ "content": "#ABNF 1.0 UTF-8;\r\nlanguage zh-CN;\r\nmode voice;\r\nroot $main;\r\n$main = $name [往][向] $operate;\r\n$name = 玉帝|太白金星|哪吒|二郎神;\r\n$operate = 左|右|前进|后退|前|后|右转|左转;" }

{ "content": "u_a = %b1000001 ; Uppercase A (65)\nab = %x41.42\nalphabet = %d65-90 ; [A-Z]" }

{ "content": "; Collected rules from RFC 7231, Appendix c, D.\n; https://tools.ietf.org/html/rfc7231#appendix-C\n\nAccept = [ ( \",\" / ( media-range [ accept-params ] ) ) *( OWS \",\" [ OWS ( media-range [ accept-params ] ) ] ) ]\n\nAccept-Charset = *( \",\" OWS ) ( ( charset / \"*\" ) [ weight ] ) *( OWS \",\" [ OWS ( ( charset / \"*\" ) [ weight ] ) ] )\n\nAccept-Encoding = [ ( \",\" / ( codings [ weight ] ) ) *( OWS \",\" [ OWS ( codings [ weight ] ) ] ) ]\n\nAccept-Language = *( \",\" OWS ) ( language-range [ weight ] ) *( OWS \",\" [ OWS ( language-range [ weight ] ) ] )\n\nAllow = [ ( \",\" / method ) *( OWS \",\" [ OWS method ] ) ]\n\nContent-Encoding = *( \",\" OWS ) content-coding *( OWS \",\" [ OWS content-coding ] )\n\nContent-Language = *( \",\" OWS ) language-tag *( OWS \",\" [ OWS language-tag ] )\n\nContent-Location = absolute-URI / partial-URI\n\nContent-Type = media-type\n\nDate = HTTP-date\n\nExpect = \"100-continue\"\n\nFrom = mailbox\n\nGMT = %x47.4D.54\n\nHTTP-date = IMF-fixdate / obs-date\n\nIMF-fixdate = day-name \",\" SP date1 SP time-of-day SP GMT\n\nLocation = URI-reference\n\nMax-Forwards = 1*DIGIT\n\nReferer = absolute-URI / partial-URI\n\nRetry-After = HTTP-date / delay-seconds\n\nServer = product *( RWS ( product / comment ) )\n\nUser-Agent = product *( RWS ( product / comment ) )\n\nVary = \"*\" / ( *( \",\" OWS ) field-name *( OWS \",\" [ OWS field-name ] ) )\n\naccept-ext = OWS \";\" OWS token [ \"=\" ( token / quoted-string ) ]\n\naccept-params = weight *accept-ext\n\nasctime-date = day-name SP date3 SP time-of-day SP year\n\ncharset = token\n\ncodings = content-coding / \"identity\" / \"*\"\n\ncontent-coding = token\n\ndate1 = day SP month SP year\n\ndate2 = day \"-\" month \"-\" 2DIGIT\n\ndate3 = month SP ( 2DIGIT / ( SP DIGIT ) )\n\nday = 2DIGIT\n\nday-name = %x4D.6F.6E / %x54.75.65 / %x57.65.64 / %x54.68.75 / %x46.72.69 / %x53.61.74 / %x53.75.6E\n\nday-name-l = %x4D.6F.6E.64.61.79 / %x54.75.65.73.64.61.79 / %x57.65.64.6E.65.73.64.61.79 / %x54.68.75.72.73.64.61.79 / %x46.72.69.64.61.79 / %x53.61.74.75.72.64.61.79 / %x53.75.6E.64.61.79\n\ndelay-seconds = 1*DIGIT\n\nhour = 2DIGIT\n\nmedia-range = ( \"*/*\" / ( type \"/*\" ) / ( type \"/\" subtype ) ) *( OWS \";\" OWS parameter )\n\nmedia-type = type \"/\" subtype *( OWS \";\" OWS parameter )\n\nmethod = token\n\nminute = 2DIGIT\n\nmonth = %x4A.61.6E / %x46.65.62 / %x4D.61.72 / %x41.70.72 / %x4D.61.79 / %x4A.75.6E / %x4A.75.6C / %x41.75.67 / %x53.65.70 / %x4F.63.74 / %x4E.6F.76 / %x44.65.63\n\nobs-date = rfc850-date / asctime-date\n\nparameter = token \"=\" ( token / quoted-string )\n\nproduct = token [ \"/\" product-version ]\n\nproduct-version = token\n\nqvalue = ( \"0\" [ \".\" *3DIGIT ] ) / ( \"1\" [ \".\" *3\"0\" ] )\n\nrfc850-date = day-name-l \",\" SP date2 SP time-of-day SP GMT\n\nsecond = 2DIGIT\n\nsubtype = token\n\ntime-of-day = hour \":\" minute \":\" second\n\ntype = token\n\nweight = OWS \";\" OWS \"q=\" qvalue\n\nyear = 4DIGIT\n" }

{ "content": "#ABNF 1.0 UTF-8;\r\nlanguage zh-CN;\r\nmode voice;\r\nroot $main;\r\n$main = $name [往][向]$operate;\r\n$name=达康书记\r\n$operate = 左|右|前进|后退|前|后|右转|左转;" }

{ "content": "URL-param = \"VALUE=uri\" / pid-param / pref-param / type-param\n / mediatype-param / altid-param / any-param\nURL-value = URI\n" }

{ "content": "; Compositional grammar specification\n; v2.4 June 2020\n; https://confluence.ihtsdotools.org/display/DOCSCG/5.1+Normative+Specification\n;\nexpression = ws [definitionStatus ws] subExpression ws\nsubExpression = focusConcept [ws \":\" ws refinement]\ndefinitionStatus = equivalentTo / subtypeOf\nequivalentTo = \"===\"\nsubtypeOf = \"<<<\"\nfocusConcept = conceptReference *(ws \"+\" ws conceptReference)\nconceptReference = conceptId [ws \"|\" ws term ws \"|\"]\nconceptId = sctId\nterm = nonwsNonPipe *( *SP nonwsNonPipe )\nrefinement = (attributeSet / attributeGroup) *( ws [\",\" ws] attributeGroup )\nattributeGroup = \"{\" ws attributeSet ws \"}\"\nattributeSet = attribute *(ws \",\" ws attribute)\nattribute = attributeName ws \"=\" ws attributeValue\nattributeName = conceptReference\nattributeValue = expressionValue / QM stringValue QM / \"#\" numericValue / booleanValue\nexpressionValue = conceptReference / \"(\" ws subExpression ws \")\"\nstringValue = 1*(anyNonEscapedChar / escapedChar)\nnumericValue = [\"-\"/\"+\"] (decimalValue / integerValue)\nintegerValue = digitNonZero *digit / zero\ndecimalValue = integerValue \".\" 1*digit\nbooleanValue = true / false\ntrue = (\"t\"/\"T\") (\"r\"/\"R\") (\"u\"/\"U\") (\"e\"/\"E\")\nfalse = (\"f\"/\"F\") (\"a\"/\"A\") (\"l\"/\"L\") (\"s\"/\"S\") (\"e\"/\"E\")\nsctId = digitNonZero 5*17( digit )\nws = *( SP / HTAB / CR / LF ) ; optional white space\nSP = %x20 ; space\nHTAB = %x09 ; tab\nCR = %x0D ; carriage return\nLF = %x0A ; line feed\nQM = %x22 ; quotation mark\nBS = %x5C ; back slash\ndigit = %x30-39\nzero = %x30\ndigitNonZero = %x31-39\nnonwsNonPipe = %x21-7B / %x7D-7E / UTF8-2 / UTF8-3 / UTF8-4\nanyNonEscapedChar = HTAB / CR / LF / %x20-21 / %x23-5B / %x5D-7E / UTF8-2 / UTF8-3 / UTF8-4\nescapedChar = BS QM / BS BS\nUTF8-2 = %xC2-DF UTF8-tail\nUTF8-3 = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) / %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )\nUTF8-4 = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) / %xF4 %x80-8F 2( UTF8-tail )\nUTF8-tail = %x80-BF" }

{ "content": "playlist = EXTM3U EOL *(line) <EOF>\ntag = EXT-X-VERSION\n / EXTINF\n / EXT-X-BYTERANGE\n / EXT-X-DISCONTINUITY\n / EXT-X-KEY\n / EXT-X-MAP\n / EXT-X-PROGRAM-DATE-TIME\n / EXT-X-DATERANGE\n / EXT-X-TARGETDURATION\n / EXT-X-MEDIA-SEQUENCE\n / EXT-X-DISCONTINUITY-SEQUENCE\n / EXT-X-ENDLIST\n / EXT-X-PLAYLIST-TYPE\n / EXT-X-I-FRAMES-ONLY\n / EXT-X-MEDIA\n / EXT-X-STREAM-INF\n / EXT-X-I-FRAME-STREAM-INF\n / EXT-X-SESSION-DATA\n / EXT-X-SESSION-KEY\n / EXT-X-INDEPENDENT-SEGMENTS\n / EXT-X-START\n / ignored-tag\n ; tag-name MUST be upper case\nEXTM3U = \"#EXTM3U\"\n ; EXTM3U MUST be upper case\nEXT-X-VERSION = \"#EXT-X-VERSION:\" decimal-integer\nEXTINF = \"#EXTINF:\" duration \",\" [title]\ntitle = 1*(VCHAR / WSP)\n ; TODO: support UTF-8 titles\nduration = decimal-floating-point / decimal-integer\nEXT-X-BYTERANGE = <TODO>\nEXT-X-DISCONTINUITY = \"#EXT-X-DISCONTINUITY\"\nEXT-X-KEY = \"#EXT-X-KEY:\" attribute-list\nEXT-X-MAP = <TODO>\nEXT-X-PROGRAM-DATE-TIME = <TODO>\nEXT-X-DATERANGE = <TODO>\nEXT-X-TARGETDURATION = \"#EXT-X-TARGETDURATION:\" decimal-integer\nEXT-X-MEDIA-SEQUENCE = \"#EXT-X-MEDIA-SEQUENCE:\" decimal-integer\nEXT-X-DISCONTINUITY-SEQUENCE = \"#EXT-X-DISCONTINUITY-SEQUENCE:\" decimal-integer\nEXT-X-ENDLIST = \"#EXT-X-ENDLIST\"\nEXT-X-PLAYLIST-TYPE = <TODO>\nEXT-X-I-FRAMES-ONLY = <TODO>\nEXT-X-MEDIA = \"#EXT-X-MEDIA:\" attribute-list\nEXT-X-STREAM-INF = \"#EXT-X-STREAM-INF:\" attribute-list EOL URI-reference\n ; URI-reference: see rfc3986\nEXT-X-I-FRAME-STREAM-INF = \"#EXT-X-I-FRAME-STREAM-INF\" attribute-list\nEXT-X-SESSION-DATA = <TODO>\nEXT-X-SESSION-KEY = <TODO>\nEXT-X-INDEPENDENT-SEGMENTS = <TODO>\nEXT-X-START = <TODO>\nignored-tag = \"#EXT\" *(VCHAR / WSP)\nline = (tag / comment / empty / URI-reference) EOL\n ; URI-reference: see rfc3986\ncomment = \"#\" [(%x45.58 (%x21-53 / %x55-7E / WSP) / %x45 (%x21-57 / %x59-7E / WSP) / (%x21-44 / %x46-7E / WSP)) *(VCHAR / WSP)]\n ; Any string that doesn't start with \"EXT\"\nempty = \"\"\nEOL = LF / CRLF\nattribute-list = attribute *(\",\" attribute)\nattribute = attribute-name \"=\" attribute-value\nattribute-name = 1*(%x41-5A / DIGIT / \"-\")\nattribute-value = hexadecimal-sequence\n / decimal-resolution\n / decimal-floating-point\n / signed-decimal-floating-point\n / decimal-integer\n / quoted-string\n / enumerated-string\ndecimal-integer = 1*20(DIGIT)\n ; from 0 to 2^64-1 (18446744073709551615)\nhexadecimal-sequence = \"0x\" 1*(HEXDIG)\nsigned-decimal-floating-point = [\"-\"] decimal-floating-point\ndecimal-floating-point = *(DIGIT) \".\" 1*(DIGIT)\nquoted-string = DQUOTE *(%x20-21 / %x23-7E) DQUOTE\n ; The double quote (0x22) character MUST NOT appear in a quoted-string: \nenumerated-string = *(%x21 / %x23-2B / %x2D-7E)\n ; The following characters will never appear in an enumerated-string: \n ; double quote (0x22)\n ; comma (0x2C)\ndecimal-resolution = decimal-integer %x78 decimal-integer" }

{ "content": "#ABNF 1.0 UTF-8;\nmeta \"grammar format\" is \"test\";\nroot $Statement;\n\n$Statement = ABNF grammars are so cool\n | $a \n | $Utterance_1 ;\n\n$a = b \n | $Individual_2 [new york]\n | [hello | huhu] world \n | a (b | $c and $d | rock'n'roll) ;\n\npublic $Individual_2 = don't | don't | don't ;\n\n$c = $NULL | $A2 | $A3 | $A4 ;\n\n$Statement_18 = [depart | leave] | [go] ;\n\n$Utterance_1 = do you have $Unknown_1\n | (list | (give | show) me) $Unknown_1 ;\n\n$nestedItems = (i1 | (i2 | i3)) ;\n\n$A1 = $B | $B | $B ;\n$A2 = $B | $B | $B ;\n$A3 = $B | $B ;\n\n" }

{ "content": "#ABNF 1.0 UTF-8;\nbusiness weather;\nroot main;\n#ABNF HEAD-END;\n$want = 要 | 想 | 想要;\n$where = 厕所|洗手间|卫生间;\n$main{biz:q111} = [我] [$want] 去 $where;" }

{ "content": "#ABNF 1.0 UTF-8;\r\nlanguage zh-CN; \r\nmode voice;\r\n\r\nroot $main;\r\n$main = $cmd;\r\n$cmd = 开机|关机;\r\n" }

{ "content": ";Attack grammar to produce sql-injections, main goal was to include all strings, that were also produced by the old library\n\n;startrule: All injection attack-vectors:\nsql-injection-attack-vector = drop-av / admin-av / op1-av / load-file-av / shutdown-av / or-av / hardcoded-av\n\ndrop-av = [ ( dquote / \"'\" )] \";DROP \" drop-av-tablename \";\" comment-sign\ndrop-av-tablename = \"users\"\n\nadmin-av = \"admin'\" [SP] comment-sign [SP]\n\nop1-av = \"OP1'\" [SP] comment-sign [SP]\n\nload-file-av = \";SELECT LOAD_FILE(\" load-file-fileref \");\" comment-sign\nload-file-fileref = \"0x633A5C626F6F742E696E69\"\n\nshutdown-av = \"';shutdown \" comment-sign [SP]\n\nor-av = \"'\" [\")\"] \" or \" (\"1=1\" / \"'1'='1\" / \"('1'='1\" ) comment-sign\n\nhardcoded-av = \"'sqlattempt1\" / \"(sqlattempt2)\" / \"1;SELECT%20*\" / \"OR%201=1\"\n\n;general definitions\ncomment-sign = \"--\" / \"#\" / \"/*\"\ndquote = %d34 \n" }

{ "content": "; FLINT GRAMMAR (RFC 7405)\n\n; TOP LEVEL\ntopLevelModule = 1*(topLevelDeclaration CRLF);\n\ntopLevelDeclaration = contractDeclaration\n / contractBehaviourDeclaration\n / structDeclaration\n / enumDeclaration\n / traitDeclaration;\n\n; CONTRACTS\ncontractDeclaration = %s\"contract\" SP identifier SP [identifierGroup] SP \"{\" *(WSP variableDeclaration CRLF) \"}\";\n\n; VARIABLES\nvariableDeclaration = [*(modifier SP)] WSP (%s\"var\" / %s\"let\") SP identifier typeAnnotation [WSP \"=\" WSP expression];\n\n; TYPES\ntypeAnnotation = \":\" WSP type;\n\ntype = identifier [\"<\" type *(\",\" WSP type) \">\"]\n / basicType\n / solidityType\n / arrayType\n / fixedArrayType\n / dictType;\n\nbasicType = %s\"Bool\"\n / %s\"Int\"\n / %s\"String\"\n / %s\"Address\";\n\nsolidityType = %s\"address\"\n / %s\"string\"\n / %s\"bool\"\n / %s\"int8\"\n / %s\"int16\"\n / %s\"int24\"\n / %s\"int32\"\n / %s\"int40\"\n / %s\"int48\"\n / %s\"int56\"\n / %s\"int64\"\n / %s\"int72\"\n / %s\"int80\"\n / %s\"int88\"\n / %s\"int96\"\n / %s\"int104\"\n / %s\"int112\"\n / %s\"int120\"\n / %s\"int128\"\n / %s\"int136\"\n / %s\"int144\"\n / %s\"int152\"\n / %s\"int160\"\n / %s\"int168\"\n / %s\"int176\"\n / %s\"int184\"\n / %s\"int192\"\n / %s\"int200\"\n / %s\"int208\"\n / %s\"int216\"\n / %s\"int224\"\n / %s\"int232\"\n / %s\"int240\"\n / %s\"int248\"\n / %s\"int256\"\n / %s\"uint8\"\n / %s\"uint16\"\n / %s\"uint24\"\n / %s\"uint32\"\n / %s\"uint40\"\n / %s\"uint48\"\n / %s\"uint56\"\n / %s\"uint64\"\n / %s\"uint72\"\n / %s\"uint80\"\n / %s\"uint88\"\n / %s\"uint96\"\n / %s\"uint104\"\n / %s\"uint112\"\n / %s\"uint120\"\n / %s\"uint128\"\n / %s\"uint136\"\n / %s\"uint144\"\n / %s\"uint152\"\n / %s\"uint160\"\n / %s\"uint168\"\n / %s\"uint176\"\n / %s\"uint184\"\n / %s\"uint192\"\n / %s\"uint200\"\n / %s\"uint208\"\n / %s\"uint216\"\n / %s\"uint224\"\n / %s\"uint232\"\n / %s\"uint240\"\n / %s\"uint248\"\n / %s\"uint256\"\n\narrayType = \"[\" type \"]\";\nfixedArrayType = type \"[\" numericLiteral \"]\";\ndictType = \"[\" type \":\" WSP type \"]\";\n\n; ENUMS\nenumDeclaration = %s\"enum\" SP identifier SP [typeAnnotation] SP \"{\" *(WSP enumCase CRLF) \"}\";\nenumCase = %s\"case\" SP identifier\n / %s\"case\" SP identifier WSP \"=\" WSP expression;\n\n; TRAITS\ntraitDeclaration = %s\"struct\" SP %s\"trait\" SP identifier SP \"{\" *(WSP traitMember CRLF) \"}\"\n / %s\"contract\" SP %s\"trait\" SP identifier SP \"{\" *(WSP traitMember CRLF) \"}\"\n / %s\"external\" SP %s\"trait\" SP identifier SP \"{\" *(WSP traitMember CRLF) \"}\";\n\ntraitMember = functionDeclaration\n / functionSignatureDeclaration\n / initializerDeclaration\n / initializerSignatureDeclaration\n / contractBehaviourDeclaration\n / eventDeclaration;\n\n; EVENTS\neventDeclaration = %s\"event\" identifer parameterList\n\n; STRUCTS\nstructDeclaration = %s\"struct\" SP identifier [\":\" WSP identifierList ] SP \"{\" *(WSP structMember CRLF) \"}\";\n\nstructMember = variableDeclaration\n / functionDeclaration\n / initializerDeclaration;\n\n; BEHAVIOUR\ncontractBehaviourDeclaration = identifier WSP [stateGroup] SP \"::\" WSP [callerBinding] callerProtectionGroup WSP \"{\" *(WSP contractBehaviourMember CRLF) \"}\";\n\ncontractBehaviourMember = functionDeclaration\n / initializerDeclaration\n / fallbackDeclaration\n / initializerSignatureDeclaration\n / functionSignatureDeclaration;\n\n; ACCESS GROUPS\nstateGroup = \"@\" identifierGroup;\ncallerBinding = identifier WSP \"<-\";\ncallerProtectionGroup = identifierGroup;\nidentifierGroup = \"(\" identifierList \")\";\nidentifierList = identifier *(\",\" WSP identifier)\n\n; FUNCTIONS + INITIALIZER + FALLBACK\nfunctionSignatureDeclaration = functionHead SP identifier parameterList [returnType]\nfunctionDeclaration = functionSignatureDeclaration codeBlock;\ninitializerSignatureDeclaration = initializerHead parameterList\ninitializerDeclaration = initializerSignatureDeclaration codeBlock;\nfallbackDeclaration = fallbackHead parameterList codeBlock;\n\nfunctionHead = [*(attribute SP)] [*(modifier SP)] %s\"func\";\ninitializerHead = [*(attribute SP)] [*(modifier SP)] %s\"init\";\nfallbackHead = [*(modifier SP)] %s\"fallback\";\n\nattribute = \"@\" identifier;\nmodifier = %s\"public\"\n / %s\"mutating\"\n / %s\"visible\";\n\nreturnType = \"->\" type;\n\nparameterList = \"()\"\n / \"(\" parameter *(\",\" parameter) \")\";\n\nparameter = *(parameterModifiers SP) identifier typeAnnotation [WSP \"=\" WSP expression];\nparameterModifiers = %s\"inout\" / %s\"implicit\"\n\n; STATEMENTS\ncodeBlock = \"{\" [CRLF] *(WSP statement CRLF) WSP statement [CRLF]\"}\";\nstatement = expression\n / returnStatement\n / becomeStatement\n / emitStatement\n / forStatement\n / ifStatement\n / doCatchStatement;\n\nreturnStatement = %s\"return\" SP expression\nbecomeStatement = %s\"become\" SP expression\nemitStatement = %s\"emit\" SP functionCall\nforStatement = %s\"for\" SP variableDeclaration SP %s\"in\" SP expression SP codeBlock\ndoCatchStatement = %s\"do\" SP codeBlock SP %s\"catch\" SP \"%s\"is SP type SP codeBlock\n\n; EXPRESSIONS\nexpression = identifier\n / inOutExpression\n / binaryExpression\n / functionCall\n / literal\n / arrayLiteral\n / dictionaryLiteral\n / self\n / variableDeclaration\n / bracketedExpression\n / subscriptExpression\n / rangeExpression\n / attemptExpression\n / externalCall;\n\ninOutExpression = \"&\" expression;\n\nbinaryOp = \"+\" / \"-\" / \"*\" / \"/\" / \"**\"\n / \"&+\" / \"&-\" / \"&*\"\n / \"=\"\n / \"==\" / \"!=\"\n / \"+=\" / \"-=\" / \"*=\" / \"/=\"\n / \"||\" / \"&&\"\n / \">\" / \"<\" / \"<=\" / \">=\"\n / \".\";\n\nbinaryExpression = expression WSP binaryOp WSP expression;\n\nself = %s\"self\"\n\nrangeExpression = \"(\" expression ( \"..<\" / \"...\" ) expression \")\"\n\nbracketedExpression = \"(\" expression \")\";\n\nsubscriptExpression = subscriptExpression \"[\" expression \"]\";\n / identifier \"[\" expression \"]\";\n\nattemptExpression = try expression\ntry = %s\"try\" ( \"!\" / \"?\" )\n\n; FUNCTION CALLS\nfunctionCall = identifier \"(\" [expression] *( \",\" WSP expression ) \")\";\n\n; EXTERNAL CALLS\nexternalCall = %s\"call\" WSP [ \"(\" [expression] *( \",\" WSP expression ) \")\" ] WSP [ \"!\" / \"?\" ] SP functionCall;\n\n; CONDITIONALS\nifStatement = %s\"if\" SP expression SP codeBlock [elseClause];\nelseClause = %s\"else\" SP codeBlock;\n\n; LITERALS\nidentifier = ( ALPHA / \"_\" ) *( ALPHA / DIGIT / \"$\" / \"_\" );\nliteral = numericLiteral\n / stringLiteral\n / booleanLiteral\n / addressLiteral;\n\nnumber = 1*DIGIT;\nnumericLiteral = decimalLiteral;\ndecimalLiteral = number\n / number \".\" number;\n\naddressLiteral = %s\"0x\" 40HEXDIG;\n\narrayLiteral = \"[]\";\ndictionaryLiteral = \"[:]\";\n\nbooleanLiteral = %s\"true\" / %s\"false\";\nstringLiteral = \"\"\" identifier \"\"\";\n" }

{ "content": "#ABNF 1.0 UTF-8;\r\nlanguage zh-CN; \r\nmode voice;\r\n\r\nroot $weekday;\r\n\r\n$weekday = $zday | $lxday;\r\n$zday = 周 ($day | 日);\r\n$lxday = { out = \"7\"; } (礼拜 | 星期) ($day | 天 | 日);\r\n\r\n \r\n\r\n$day = 一{ out = \"1\"; }\r\n\r\n| 二 { out = \"2\"; } \r\n\r\n| 三 { out = \"3\"; } \r\n\r\n| 四 { out = \"4\"; } \r\n\r\n| 五 { out = \"5\"; } \r\n\r\n| 六 { out = \"6\"; };" }

{ "content": "; Author: Tim Reddehase\n; E-Mail: robustus AT rightsrestricted DOT com\n; Last-Changed: 2015-02-22\n; Version: 0.1.2\n;\n; This ABNF for Loc/Ids is based on the definition\n; of IRIs and as such uses Rules from the RFC-Definition\n; of IRIs: http://tools.ietf.org/html/rfc3987#section-2.2\n; Rules that represent an IRI-rule usually start with an\n; i char.\n\nLoc-Id-IRI = li-instance [ li-ref ] Loc-Id [ \"?\" iquery ] [ \"#\" ifragment ]\n\n; Represents an Ontohub-Application instance.\n; Semantically multiple <li-instance> values\n; can be equivalent and thus forming the\n; set of INSTANCE. <scheme> is a rule inside\n; of the IRI RFC.\nli-instance = scheme \"://\" iauthority\n\n; a lone repository is also a Loc/Id\nLoc-Id = \"/\" li-repository [ li-hierarchy [ li-member ] ] [ li-command ]\n\n; Represents the path/directory name of the repository\nli-repository = isegment-nz\n\n; Represents a ref/ special form\nli-ref = \"/\" \"ref/\" isegment-nz\n\n; Represents the path inside the Repository to the ontology\nli-hierarchy = *( \"/\" isegment-nz )\n\n; Represents internal 'path' inside of the ontology\n; where child-ontologies, mappings, symbols and sentences\n; are first-class members.\nli-member = *2( \"//\" isegment-nz )\n\n; Represents a command to be 'executed' on the\n; specific resource\nli-command = *( \"///\" isegment-nz )\n" }

{ "content": "##\n## http://download.microsoft.com/download/3/4/C/34C47498-E69F-4CEF-9B58-5CEB77E1553D/[MS-FSFQL].pdf\n##\n\nfql-expression=(operator-expression / paren-expression / token);\n\noperator-expression=[in-expression] (and / andnot / any / or / rank\n / xrank / near / onear / not / equals / filter / starts-with\n / ends-with / count);\n\nparen-expression = [in-expression] \"(\" fql-expression \")\";\n\ntoken = [in-expression] (datetime-token / float-token / int-token / phrase-token / range-token / string-token);\n\n# Operator expressions\nand = \"and\" \"(\" multiple-fql-params \")\";\nandnot = \"andnot\" \"(\" multiple-fql-params \")\";\nany = \"any\" \"(\" multiple-fql-params \")\";\nor = \"or\" \"(\" multiple-fql-params \")\";\nrank = \"rank\" \"(\" rank-param *(\",\" rank-param) \")\";\nrank-param = token / fql-expression;\nxrank = \"xrank\" \"(\" xrank-param *(\",\" xrank-param) \")\";\nxrank-param = (\"boost\" \"=\" integer-value)\n / (\"boostall\" \"=\" yesno-value)\n / fql-expression;\n\nnear = \"near\" \"(\" near-param *(\",\" near-param) \")\";\nnear-param = (\"N\" \"=\" token-distance) / fql-expression;\nonear = \"onear\" \"(\" onear-param *(\",\" onear-param) \")\";\nonear-param = (\"N\" \"=\" token-distance) / fql-expression;\nnot = \"not\" \"(\" fql-expression \")\";\ncount = (\"count\" \"(\" token\n 1*(\",\" ((\"from\" \"=\" int-token) / (\"to\" \"=\" int-token))) \")\");\nequals = \"equals\" \"(\"\n [in-expression] (string-token / phrase-token) \")\";\nstarts-with = \"starts-with\" \"(\"\n [in-expression] (string-token / phrase-token) \")\";\nends-with = \"ends-with\" \"(\"\n [in-expression] (string-token / phrase-token) \")\";\nfilter = \"filter\" \"(\" fql-expression \")\";\n\n\n\n# Token operator expressions\nphrase-token = \"phrase\" \"(\" phrase-token-param\n *(\",\" phrase-token-param) \")\";\nphrase-token-param = (\"weight\" \"=\" unsigned-integer-value)\n / (\"linguistics\" \"=\" onoff-value)\n / (\"wildcard\" \"=\" onoff-value)\n / token;\nstring-token = explicit-string-token / implicit-string-token;\nexplicit-string-token = \"string\" \"(\" string-token-param\n *(\",\" string-token-param) \")\";\n\n#@ add \"anotation_class\"\n#@ token->string-value\n#@string-token-param = (\"mode\" \"=\" mode-value)\n#@ / (\"N\" \"=\" token-distance)\n#@ / (\"weight\" \"=\" integer-value)\n#@ / (\"linguistics\" \"=\" onoff-value)\n#@ / (\"wildcard\" \"=\" onoff-value)\n#@ / token\nstring-token-param = (\"mode\" \"=\" mode-value)\n / (\"annotation_class\" \"=\" DQUOTE \"user\" DQUOTE)\n / (\"N\" \"=\" token-distance)\n / (\"weight\" \"=\" integer-value)\n / (\"linguistics\" \"=\" onoff-value)\n / (\"wildcard\" \"=\" onoff-value)\n / string-value;\n\nimplicit-string-token = string-value;\nfloat-token = explicit-float-token / implicit-float-token;\nexplicit-float-token = \"float\" \"(\" (float-value\n / (DQUOTE float-value DQUOTE)) \")\";\nimplicit-float-token = *DIGIT \".\" 1*DIGIT;\nint-token = explicit-int-token / implicit-int-token;\nexplicit-int-token = \"int\" \"(\" (integer-value\n / (DQUOTE integer-value DQUOTE)\n / (DQUOTE integer-value *(SP integer-value) DQUOTE \",\"\n numeric-or-mode)\n / (numeric-or-mode \",\" DQUOTE 1*integer-value *(SP integer-value)\n DQUOTE))\n \")\";\nimplicit-int-token = integer-value;\ndatetime-token = explicit-datetime-token / implicit-datetime-token;\nexplicit-datetime-token = \"datetime\" \"(\" (datetime-value\n / (DQUOTE datetime-value DQUOTE)) \")\";\nimplicit-datetime-token = datetime-value;\n\n#@range-token = \"range\" \"(\" range-token-param *(\",\" range-token-param)\n#@ \")\" / \"[\" [min-range-value] \";\" [max-range-value] \"]\"\n#@range-token-param = (\"from\" \"=\" from-condition)\n#@ / (\"to\" \"=\" to-condition)\n#@ / range-limit\n#@range-limit = datetime-token / float-token / int-token\n#@ / \"min\" / \"max\"\n\nrange-token = \"range\" \"(\" min-range-limit \",\" max-range-limit 0*1(\",\" from-range-token-param) 0*1(\",\" to-range-token-param) \")\" / \"[\" [min-range-value] \";\" [max-range-value] \"]\";\nfrom-range-token-param = (\"from\" \"=\" from-condition);\nto-range-token-param = (\"to\" \"=\" to-condition);\nrange-value = datetime-token / float-token / int-token;\n#@range-limit = range-value / \"min\" / \"max\";\nmin-range-limit = min-range-value / \"min\";\nmax-range-limit = max-range-value / \"max\";\nmin-range-value = range-value;\nmax-range-value = range-value;\n\nfrom-condition = unquoted-from-condition\n / (DQUOTE unquoted-from-condition DQUOTE);\nunquoted-from-condition = \"GE\" / \"GT\";\nto-condition = unquoted-to-condition\n / (DQUOTE unquoted-to-condition DQUOTE);\nunquoted-to-condition = \"LE\" / \"LT\";\n\n\n# Data types\nstring-value = quoted-string-value / unquoted-string-value;\n\n# <quoted-string-value> can contain any characters\n# (including wide characters) that are not control\n# characters, except for double quotation marks.\nquoted-string-value = DQUOTE 1*(quoted-escaped-character\n / %x20-21 / %x23-ffffffff) DQUOTE;\nquoted-escaped-character =\n quoted-escaped-backslash\n / quoted-escaped-newline\n / quoted-escaped-carriage-return\n / quoted-escaped-tab\n / quoted-escaped-backspace\n / quoted-escaped-form-feed\n / quoted-escaped-double-quote\n / quoted-escaped-single-quote;\nquoted-escaped-backslash = \"\\\\\";\nquoted-escaped-newline = \"\\n\";\nquoted-escaped-carriage-return = \"\\r\";\nquoted-escaped-tab = \"\\t\";\nquoted-escaped-backspace = \"\\b\";\nquoted-escaped-form-feed = \"\\f\";\nquoted-escaped-double-quote = \"\\\" DQUOTE;\nquoted-escaped-single-quote = \"'\";\n\n# <unquoted-string-value> can contain any characters (including wide\n# characters) that are not control characters, except for spaces,\n# commas, double quotation marks, parentheses,colons, and equals\n# signs.\nunquoted-string-value =\n 1*(%x21 / %x23-27 / %x2a-2b / %x2d-39 / %x3b-3c / %x3e-ffffffff);\n\ninteger-value = [\"-\" / \"+\"] 1*DIGIT;\n\nunsigned-integer-value = 1*DIGIT;\n\nfloat-value = [\"-\" / \"+\"] (*DIGIT \".\" 1*DIGIT) / 1*DIGIT;\n\ndatetime-value = year \"-\" month \"-\" day\n [\"T\" hour \":\" minute \":\" second [\"Z\"]];\n\nyear = 4*DIGIT; # four-digit or longer year (0000-infinity)\n\n# two-digit month (00-09)\n# two-digit month (10-12)\nmonth = (\"0\" DIGIT) \n / (\"1\" %x30-32); \n\n# two-digit day (00-29)\n# two-digit day (30-31)\nday = (%x30-32 DIGIT) \n / (\"3\" %x30-31); \n\n# two-digit hour (00-19)\n# two-digit hour (20-23);\nhour = (%x30-31 DIGIT) \n / (\"2\" %x30-33); \n\nminute = (%x30-35 DIGIT); # two-digit minute (00-59)\n\nsecond = (%x30-35 DIGIT); # two-digit second (00-59)\n\nyesno-value = quoted-yesno-value / unquoted-yesno-value;\n\nquoted-yesno-value = DQUOTE unquoted-yesno-value DQUOTE;\nunquoted-yesno-value = \"YES\" / \"NO\";\nonoff-value = quoted-onoff-value / unquoted-onoff-value;\nquoted-onoff-value = DQUOTE unquoted-onoff-value DQUOTE;\nunquoted-onoff-value = \"ON\" / \"OFF\";\n\n# <mode-value> MUST be inside double quotation marks.\nmode-value = DQUOTE (\"PHRASE\" / \"AND\" / \"OR\" / \"ANY\" / \"NEAR\"\n / \"ONEAR\" / \"SIMPLEANY\" / \"SIMPLEALL\") DQUOTE;\n\n# General syntax elements\n#@in-expression = ((internal-property-name / property-name) \":\")\n#@ / (DQUOTE (internal-property-name / property-name) DQUOTE \":\")\ninternal-in-expression = (internal-property-name / property-name);\nin-expression = (internal-in-expression \":\")\n / (DQUOTE internal-in-expression DQUOTE \":\");\n\nnumeric-or-mode = \"mode\" \"=\" DQUOTE \"OR\" DQUOTE;\n\ntoken-distance = unsigned-integer-value;\n\ninternal-property-name = property-name \".\" property-name;\n\nproperty-name = 1*(ALPHA / DIGIT);\n#@ change 1->0\n#multiple-fql-params = fql-expression 1*(\",\" fql-expression)\nmultiple-fql-params = fql-expression *(\",\" fql-expression);\n\n#Core Rules\nALPHA = %x41-5A / %x61-7A; # A-Z / a-z\nBIT = \"0\" / \"1\";\n\n# any 7-bit US-ASCII character,\n# excluding NUL\nCHAR = %x01-7F;\n# carriage return\nCR = %x0D;\n\n# Internet standard newline\nCRLF = CR LF;\n\n# controls\nCTL = %x00-1F / %x7F;\n\n# 0-9\nDIGIT = %x30-39;\n\n# \" (Double Quote)\nDQUOTE = %x22;\n\nHEXDIG = DIGIT / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\";\n\n# horizontal tab\nHTAB = %x09;\n\n# linefeed\nLF = %x0A;\n\n# Use of this linear-white-space rule\n# permits lines containing only white\n# space that are no longer legal in\n# mail headers and have caused\n# interoperability problems in other\n# contexts.\n# Do not use when defining mail\n# headers and use with caution in\n# other contexts.\nLWSP = *(WSP / CRLF WSP);\n\n# 8 bits of data\nOCTET = %x00-FF;\n\nSP = %x20;\n\n# visible (printing) characters\nVCHAR = %x21-7E;\n\n# white space\nWSP = SP / HTAB;\n\n" }

{ "content": "#ABNF 1.0;\nlanguage pl-pl;\nmode voice;\nroot $root;\ntag-format <semantics/1.0-literals>;\n\n$root = $action;\n\n$action = $out | $check;\n$request = Chciałbym | Chciałabym | Chcę | Proszę;\n\n$out = (([$request] wypłacić | wypłać) {out}) $ammount;\n$check = ([$request] sprawdzić stan konta | sprawdź stan konta) {check};\n\n$ammount = pięćdziesiąt {50} $currency [$tens] |\n sto {100} $currency [$tens | $twenties | $fifties] |\n dwieście {200} $currency [$tens | $twenties | $fifties | $hundreds];\n\n$currency = złotych {PLN} | dolarów {USD}| euro {EUR};\n\n$tens = w dziesiątkach {(10s)};\n$twenties = w dwudziestkach {(20s)};\n$fifties = w pięćdziesiątkach {(50s)};\n$hundreds = w setkach {(100s)};\n\n\n\n\n\n\n" }

{ "content": "; The JavaScript object Notation (JSON) Data Interchange Format\n; https://tools.ietf.org/html/rfc7159\n\nABNF-Actions =\n ; Custom configuration\n to-language 'JSON'\n to-fileTypes ['json']\n to-scopeName 'source.json'\n to-description 'JSON to AST'\n\n ; Specific configuration\n to-locfield 'loc' ; The field-name of location\n to-typefield 'type' ; The field-name of type\n\n ; AST node type described.\n\n ; Structure\n Object (\n ; Fields Description.\n children ARRAY<Property>\n )\n\n Array (\n children ARRAY<Object, Array, Literal>\n )\n\n Literal (\n value <null, BOOL, STRING, INT, FLOAT>\n )\n\n Identifier (\n ; Declaration STRING type with initial value\n value ''\n )\n\n Property (\n key <Identifier>\n value <Object, Array, Literal>\n )\n\nJSON-text = ws value ws\n\nvalue = object--Object(value)\n / array--Array(value)\n / string--Literal(value)\n / number--Literal(value)\n / boolean--Literal(value)\n / null--Literal(value)\n\nobject =\n '{' ws [\n property--Property(children)\n *( ws ',' ws property--Property(children) )\n ] ws '}'\n\nproperty =\n string--Identifier(key) ws ':' ws value\n\narray =\n '[' ws [ value *( ws ',' ws value ) ws ] ']'\n to--move(value, children)\n\nnumber = number-val--pending(value)\n\nnumber-val = [ '-' ] int (\n frac [ exp ] to--type(FLOAT)\n / exp to--type(FLOAT)\n / to--type(INT)\n )\n\nexp = \"E\" [ '-' / '+' ] 1*DIGIT\n\nfrac = '.' 1*DIGIT\n\nint = '0' / ( %x31-39 *DIGIT )\n\nstring = '\"' *char--STRING(value, unescape) '\"'\n\nboolean = 'true' to--true(value) /\n 'false' to--false(value)\n\nnull = 'null' to--null(value)\n\nws = *(\n \t %x20 / ; Space\n \t %x09 / ; Horizontal tab\n \t %x0A / ; Line feed or New line\n \t %x0D ; Carriage return\n )\n\nchar = unescaped /\n '\\' (\n '\"' / ; quotation mark U+0022\n '\\' / ; reverse solidus U+005C\n '/' / ; solidus U+002F\n 'b' / ; backspace U+0008\n 'f' / ; form feed U+000C\n 'n' / ; line feed U+000A\n 'r' / ; carriage return U+000D\n 't' / ; tab U+0009\n 'u' 4HEXDIG ; uXXXX U+XXXX\n )\n\nunescaped = %x20-21 / %x23-5B / %x5D-10FFFF\n\nDIGIT = %x30-39 ; 0-9\n\nHEXDIG = DIGIT / %x41-5A / %x61-7A\n" }

{ "content": "comment = \";\" *ANY\ndeclaration = function-decl / object-decl\n\nobject-decl = object-header *WSP \"{\" LF object-fields \"}\"\nobject-header = \"@object\" 1*WSP name *WSP object-ref\n\nobject-fields = *(object-field LF)\nobject-field = name *WSP \"=\" *WSP constant-value\n\n\nfunction-decl = \"@function\" 1*WSP name \"{\" LF instructions \"}\"\ninstructions = *(instruction LF)\ninstruction = mnemonic [operand]\nmnemonic = ; see mnemonic list\noperand = constant-value\n\nconstant-value = object-ref / function-ref / array-literal / quoted-string / number / index\nobject-ref = \"<\" *WSP [ name ] *WSP \">\"\nfunction-ref = \"%\" name\nname = DQUOTE 1*(CHAR / WSP / DIGIT) DQUOTE\n" }

{ "content": "Language-Tag = langtag / privateuse / grandfathered\n\nlangtag = language [\"-\" script] [\"-\" region] *(\"-\" variant) *(\"-\" extension) [\"-\" privateuse]\n\nlanguage = 2*3ALPHA [\"-\" extlang] / 4ALPHA / 5*8ALPHA\n\nextlang = 3ALPHA *2(\"-\" 3ALPHA)\n\nscript = 4ALPHA\n\nregion = 2ALPHA / 3DIGIT\n\nvariant = 5*8alphanum / (DIGIT 3alphanum)\n\nextension = singleton 1*(\"-\" (2*8alphanum))\n\nsingleton = DIGIT / %x41-57 / %x59-5A / %x61-77 / %x79-7A\n\nprivateuse = \"x\" 1*(\"-\" (1*8alphanum))\n\ngrandfathered = irregular / regular\n\nirregular = \"en-GB-oed\" / \"i-ami\" / \"i-bnn\" / \"i-default\" / \"i-enochian\" / \"i-hak\" / \"i-klingon\" / \"i-lux\" / \"i-mingo\" / \"i-navajo\" / \"i-pwn\" / \"i-tao\" / \"i-tay\" / \"i-tsu\" / \"sgn-BE-FR\" / \"sgn-BE-NL\" / \"sgn-CH-DE\"\n\nregular = \"art-lojban\" / \"cel-gaulish\" / \"no-bok\" / \"no-nyn\" / \"zh-guoyu\" / \"zh-hakka\" / \"zh-min\" / \"zh-min-nan\" / \"zh-xiang\"\n\nalphanum = (ALPHA / DIGIT)\n" }

{ "content": "jillctl-protocol = C:OHAI ( S:OHAI-OK / error )\n / C:IEATED\n / C:WHATIZIT ( S:ITIZ / error )\n / C:PLZTO ( S:PLZTO-OK / error )\n\nerror = S:RTFM / S:WTF\n\n; the client verifies the protocol\nOHAI = signature %x01 protocol version\nsignature = %xCD %xC0\nprotocol = string ; must be \"JILLCTL\"\nstring = *OCTET %x00 ; UTF-8 null terminated string\nversion = %x02\n\n; the server responds to the client's open peering request\nOHAI-OK = signature %x02\n\n; server error: badly formed request (including invalid property or function name)\nRTFM = signature %x03\n\n; server error: error executing action\nWTF = signature %x04 reason\nreason = string\n\n; client sends a status message\nIEATED = signature %x05 client-name timestamp message\nclient-name = string\ntimestamp = sec usec\nsec = 8OCTET ; seconds since epoch, network order\nusec = 8OCTET ; additional microseconds, network order\nmessage = string\n\n; client requests information about a property\nWHATIZIT = signature %x06 client-name property-name\nproperty-name = string\n\n; server replies with property value\nITIZ = signature %x07 property-value\nproperty-value = ( %x01 8OCTET ) ; signed 64-bit integer, network order\n / ( %x02 8OCTET ) ; unsigned 64-bit integer, network\n / ( %x03 8OCTET ) ; double precision IEEE float, network order\n / ( %x04 string ) ; string\n\n; client requests an action (including setting a value)\nPLZTO = signature %x08 client-name function-name *property-value\nfunction-name = string\n\n; server acknowledges completion of action\nPLZTO-OK = signature %x09" }

{ "content": "\n// 语法树的跟【Root是系统内置，必须定义Root作为语法根节点，没有定义会报错】\nRoot = Expression*;\n// 行注释【LineComment是系统内置的行注释语法规则名】\nLineComment : \"/\" = \"//.*\";\n// 块注释【BlockComment是系统内置的块注释语法规则名】\nBlockComment : \"/\" = \"/%*{*/}\";\n\n// 关键字\nKey : \"<\" = \"<[^>]*>\";\n// 字符串\nString : \"'\" = \"'([^'\\\\]|\\\\.)*'\";\n// 正则表达式\nRegex : \"\\\"\" = \"\\\"([^\\\"\\\\]|\\\\.)*\\\"\";\n// 规则名称\nId : \"[_a-zA-Z]\" = \"[_a-zA-Z][_a-zA-Z0-9]*\";\n// 数字\nNumber : \"[0-9]\" = \"[0-9]+\";\n// 规则修饰\nNodeTail = '?' | '*' | '+' | '@' | '#';\n\n// 表达式\nExpression = Id@ (':'@ Regex '@'?)? Color? '='@ Node ';';\n\n// 颜色\nColor = '['@ Number ',' Number ',' Number ']';\n\n// 通用节点\nNode = List | Group;\n\n// 叶子节点\nLeaf = (Id | Key | String | Regex) NodeTail?;\n\n// 节点列表\nList = (Group | Leaf)+ Option*;\n\n// 多选一\nOption = '|'@ (Group | Leaf)+;\n\n// 括号\nGroup = '('@ List ')' NodeTail?;\n\n" }

{ "content": ";; This document describes TOML's syntax, using the ABNF format (defined in\n;; RFC 5234 -- https://www.ietf.org/rfc/rfc5234.txt).\n;;\n;; Although a TOML document must be valid UTF-8, this grammar refers to the\n;; Unicode Code Points you get after you decode the UTF-8 input.\n;;\n;; All valid TOML documents will match this description, however certain\n;; invalid documents would need to be rejected as per the semantics described\n;; in the supporting text description.\n\n;; It is possible to try this grammar interactively, using instaparse.\n;; http://instaparse.mojombo.com/\n;;\n;; To do so, in the lower right, click on Options and change `:input-format` to\n;; ':abnf'. Then paste this entire ABNF document into the grammar entry box\n;; (above the options). Then you can type or paste a sample TOML document into\n;; the beige box on the left. Tada!\n\n;; Overall Structure\n\ntoml = expression *( newline expression )\n\nexpression = ws [ comment ]\nexpression =/ ws keyval ws [ comment ]\nexpression =/ ws table ws [ comment ]\n\n;; Whitespace\n\nws = *wschar\nwschar = %x20 ; Space\nwschar =/ %x09 ; Horizontal tab\n\n;; Newline\n\nnewline = %x0A ; LF\nnewline =/ %x0D.0A ; CRLF\n\n;; Comment\n\ncomment = comment-start-symbol *allowed-comment-char\ncomment-start-symbol = %x23 ; #\nallowed-comment-char = %x01-09 / %x0E-7F / non-ascii\nnon-ascii = %x80-D7FF / %xE000-10FFFF\n\n;; Key-Value pairs\n\nkeyval = key keyval-sep val\nkey = simple-key / dotted-key\nval = string / boolean / array / inline-table / date-time / float / integer\n\nsimple-key = quoted-key / unquoted-key\n\n;; Unquoted key\n\nunquoted-key = 1*unquoted-key-char\nunquoted-key-char = ALPHA / DIGIT / %x2D / %x5F ; a-z A-Z 0-9 - _\nunquoted-key-char =/ %xB2 / %xB3 / %xB9 / %xBC-BE ; superscript digits, fractions\nunquoted-key-char =/ %xC0-D6 / %xD8-F6 / %xF8-37D ; non-symbol chars in Latin block\nunquoted-key-char =/ %x37F-1FFF ; exclude GREEK QUESTION MARK, which is basically a semi-colon\nunquoted-key-char =/ %x200C-200D / %x203F-2040 ; from General Punctuation Block, include the two tie symbols and ZWNJ, ZWJ\nunquoted-key-char =/ %x2070-218F / %x2460-24FF ; include super-/subscripts, letterlike/numberlike forms, enclosed alphanumerics\nunquoted-key-char =/ %x2C00-2FEF / %x3001-D7FF ; skip arrows, math, box drawing etc, skip 2FF0-3000 ideographic up/down markers and spaces\nunquoted-key-char =/ %xF900-FDCF / %xFDF0-FFFD ; skip D800-DFFF surrogate block, E000-F8FF Private Use area, FDD0-FDEF intended for process-internal use (unicode)\nunquoted-key-char =/ %x10000-EFFFF ; all chars outside BMP range, excluding Private Use planes (F0000-10FFFF)\n\n;; Quoted and dotted key\n\nquoted-key = basic-string / literal-string\ndotted-key = simple-key 1*( dot-sep simple-key )\n\ndot-sep = ws %x2E ws ; . Period\nkeyval-sep = ws %x3D ws ; =\n\n;; String\n\nstring = ml-basic-string / basic-string / ml-literal-string / literal-string\n\n;; Basic String\n\nbasic-string = quotation-mark *basic-char quotation-mark\n\nquotation-mark = %x22 ; \"\n\nbasic-char = basic-unescaped / escaped\nbasic-unescaped = wschar / %x21 / %x23-5B / %x5D-7E / non-ascii\nescaped = escape escape-seq-char\n\nescape = %x5C ; \\\nescape-seq-char = %x22 ; \" quotation mark U+0022\nescape-seq-char =/ %x5C ; \\ reverse solidus U+005C\nescape-seq-char =/ %x62 ; b backspace U+0008\nescape-seq-char =/ %x65 ; e escape U+001B\nescape-seq-char =/ %x66 ; f form feed U+000C\nescape-seq-char =/ %x6E ; n line feed U+000A\nescape-seq-char =/ %x72 ; r carriage return U+000D\nescape-seq-char =/ %x74 ; t tab U+0009\nescape-seq-char =/ %x78 2HEXDIG ; xHH U+00HH\nescape-seq-char =/ %x75 4HEXDIG ; uHHHH U+HHHH\nescape-seq-char =/ %x55 8HEXDIG ; UHHHHHHHH U+HHHHHHHH\n\n;; Multiline Basic String\n\nml-basic-string = ml-basic-string-delim [ newline ] ml-basic-body\n ml-basic-string-delim\nml-basic-string-delim = 3quotation-mark\nml-basic-body = *mlb-content *( mlb-quotes 1*mlb-content ) [ mlb-quotes ]\n\nmlb-content = basic-char / newline / mlb-escaped-nl\nmlb-quotes = 1*2quotation-mark\nmlb-escaped-nl = escape ws newline *( wschar / newline )\n\n;; Literal String\n\nliteral-string = apostrophe *literal-char apostrophe\n\napostrophe = %x27 ; ' apostrophe\n\nliteral-char = %x09 / %x20-26 / %x28-7E / non-ascii\n\n;; Multiline Literal String\n\nml-literal-string = ml-literal-string-delim [ newline ] ml-literal-body\n ml-literal-string-delim\nml-literal-string-delim = 3apostrophe\nml-literal-body = *mll-content *( mll-quotes 1*mll-content ) [ mll-quotes ]\n\nmll-content = literal-char / newline\nmll-quotes = 1*2apostrophe\n\n;; Integer\n\ninteger = dec-int / hex-int / oct-int / bin-int\n\nminus = %x2D ; -\nplus = %x2B ; +\nunderscore = %x5F ; _\ndigit1-9 = %x31-39 ; 1-9\ndigit0-7 = %x30-37 ; 0-7\ndigit0-1 = %x30-31 ; 0-1\n\nhex-prefix = %x30.78 ; 0x\noct-prefix = %x30.6F ; 0o\nbin-prefix = %x30.62 ; 0b\n\ndec-int = [ minus / plus ] unsigned-dec-int\nunsigned-dec-int = DIGIT / digit1-9 1*( DIGIT / underscore DIGIT )\n\nhex-int = hex-prefix HEXDIG *( HEXDIG / underscore HEXDIG )\noct-int = oct-prefix digit0-7 *( digit0-7 / underscore digit0-7 )\nbin-int = bin-prefix digit0-1 *( digit0-1 / underscore digit0-1 )\n\n;; Float\n\nfloat = float-int-part ( exp / frac [ exp ] )\nfloat =/ special-float\n\nfloat-int-part = dec-int\nfrac = decimal-point zero-prefixable-int\ndecimal-point = %x2E ; .\nzero-prefixable-int = DIGIT *( DIGIT / underscore DIGIT )\n\nexp = \"e\" float-exp-part\nfloat-exp-part = [ minus / plus ] zero-prefixable-int\n\nspecial-float = [ minus / plus ] ( inf / nan )\ninf = %x69.6E.66 ; inf\nnan = %x6E.61.6E ; nan\n\n;; Boolean\n\nboolean = true / false\n\ntrue = %x74.72.75.65 ; true\nfalse = %x66.61.6C.73.65 ; false\n\n;; Date and Time (as defined in RFC 3339)\n\ndate-time = offset-date-time / local-date-time / local-date / local-time\n\ndate-fullyear = 4DIGIT\ndate-month = 2DIGIT ; 01-12\ndate-mday = 2DIGIT ; 01-28, 01-29, 01-30, 01-31 based on month/year\ntime-delim = \"T\" / %x20 ; T, t, or space\ntime-hour = 2DIGIT ; 00-23\ntime-minute = 2DIGIT ; 00-59\ntime-second = 2DIGIT ; 00-58, 00-59, 00-60 based on leap second rules\ntime-secfrac = \".\" 1*DIGIT\ntime-numoffset = ( \"+\" / \"-\" ) time-hour \":\" time-minute\ntime-offset = \"Z\" / time-numoffset\n\npartial-time = time-hour \":\" time-minute [ \":\" time-second [ time-secfrac ] ]\nfull-date = date-fullyear \"-\" date-month \"-\" date-mday\nfull-time = partial-time time-offset\n\n;; Offset Date-Time\n\noffset-date-time = full-date time-delim full-time\n\n;; Local Date-Time\n\nlocal-date-time = full-date time-delim partial-time\n\n;; Local Date\n\nlocal-date = full-date\n\n;; Local Time\n\nlocal-time = partial-time\n\n;; Array\n\narray = array-open [ array-values ] ws-comment-newline array-close\n\narray-open = %x5B ; [\narray-close = %x5D ; ]\n\narray-values = ws-comment-newline val ws-comment-newline array-sep array-values\narray-values =/ ws-comment-newline val ws-comment-newline [ array-sep ]\n\narray-sep = %x2C ; , Comma\n\nws-comment-newline = *( wschar / [ comment ] newline )\n\n;; Table\n\ntable = std-table / array-table\n\n;; Standard Table\n\nstd-table = std-table-open key std-table-close\n\nstd-table-open = %x5B ws ; [ Left square bracket\nstd-table-close = ws %x5D ; ] Right square bracket\n\n;; Inline Table\n\ninline-table = inline-table-open [ inline-table-keyvals ] ws-comment-newline inline-table-close\n\ninline-table-open = %x7B ; {\ninline-table-close = %x7D ; }\ninline-table-sep = %x2C ; , Comma\n\ninline-table-keyvals = ws-comment-newline keyval ws-comment-newline inline-table-sep inline-table-keyvals\ninline-table-keyvals =/ ws-comment-newline keyval ws-comment-newline [ inline-table-sep ]\n\n;; Array Table\n\narray-table = array-table-open key array-table-close\n\narray-table-open = %x5B.5B ws ; [[ Double left square bracket\narray-table-close = ws %x5D.5D ; ]] Double right square bracket\n\n;; Built-in ABNF terms, reproduced here for clarity\n\nALPHA = %x41-5A / %x61-7A ; A-Z / a-z\nDIGIT = %x30-39 ; 0-9\nHEXDIG = DIGIT / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\"\n" }

{ "content": "; Collected rules from RFC 7234\n; https://tools.ietf.org/html/rfc7234\n\nAge = delta-seconds\n\nCache-Control = *( \",\" OWS ) cache-directive *( OWS \",\" [ OWS cache-directive ] )\n\nExpires = HTTP-date\n\nPragma = *( \",\" OWS ) pragma-directive *( OWS \",\" [ OWS pragma-directive ] )\n\nWarning = *( \",\" OWS ) warning-value *( OWS \",\" [ OWS warning-value ] )\n\ncache-directive = token [ \"=\" ( token / quoted-string ) ]\n\ndelta-seconds = 1*DIGIT\n\nextension-pragma = token [ \"=\" ( token / quoted-string ) ]\n\npragma-directive = \"no-cache\" / extension-pragma\n\nwarn-agent = ( uri-host [ \":\" port ] ) / pseudonym\n\nwarn-code = 3DIGIT\n\nwarn-date = DQUOTE HTTP-date DQUOTE\n\nwarn-text = quoted-string\n\nwarning-value = warn-code SP warn-agent SP warn-text [ SP warn-date ]\n" }

{ "content": "module-stmt = optsep module-keyword sep identifier-arg-str\n optsep\n \"{\" stmtsep\n module-header-stmts\n linkage-stmts\n meta-stmts\n revision-stmts\n body-stmts\n \"}\" optsep\n\nsubmodule-stmt = optsep submodule-keyword sep identifier-arg-str\n optsep\n \"{\" stmtsep\n submodule-header-stmts\n linkage-stmts\n meta-stmts\n revision-stmts\n body-stmts\n \"}\" optsep\n\nmodule-header-stmts = ;; these stmts can appear in any order\n [yang-version-stmt stmtsep]\n namespace-stmt stmtsep\n prefix-stmt stmtsep\n\nsubmodule-header-stmts =\n ;; these stmts can appear in any order\n [yang-version-stmt stmtsep]\n belongs-to-stmt stmtsep\n\nmeta-stmts = ;; these stmts can appear in any order\n [organization-stmt stmtsep]\n [contact-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nlinkage-stmts = ;; these stmts can appear in any order\n *(import-stmt stmtsep)\n *(include-stmt stmtsep)\n\nrevision-stmts = *(revision-stmt stmtsep)\n\nbody-stmts = *((extension-stmt /\n feature-stmt /\n identity-stmt /\n typedef-stmt /\n grouping-stmt /\n data-def-stmt /\n augment-stmt /\n rpc-stmt /\n notification-stmt /\n deviation-stmt) stmtsep)\n\ndata-def-stmt = container-stmt /\n leaf-stmt /\n leaf-list-stmt /\n list-stmt /\n choice-stmt /\n anyxml-stmt /\n uses-stmt\n\nyang-version-stmt = yang-version-keyword sep yang-version-arg-str\n optsep stmtend\n\nyang-version-arg-str = < a string that matches the rule yang-version-arg >\n\nyang-version-arg = \"1\"\n\nimport-stmt = import-keyword sep identifier-arg-str optsep\n \"{\" stmtsep\n prefix-stmt stmtsep\n [revision-date-stmt stmtsep]\n \"}\"\n\ninclude-stmt = include-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n [revision-date-stmt stmtsep]\n \"}\")\n\nnamespace-stmt = namespace-keyword sep uri-str optsep stmtend\n\nuri-str = < a string that matches the rule URI in RFC 3986 >\n\nprefix-stmt = prefix-keyword sep prefix-arg-str\n optsep stmtend\n\nbelongs-to-stmt = belongs-to-keyword sep identifier-arg-str\n optsep\n \"{\" stmtsep\n prefix-stmt stmtsep\n \"}\"\n\norganization-stmt = organization-keyword sep string\n optsep stmtend\n\ncontact-stmt = contact-keyword sep string optsep stmtend\n\ndescription-stmt = description-keyword sep string optsep\n stmtend\n\nreference-stmt = reference-keyword sep string optsep stmtend\n\nunits-stmt = units-keyword sep string optsep stmtend\n\n;; revision-stmt = revision-keyword sep revision-date optsep\n;; (\";\" /\n;; \"{\" stmtsep\n;; [description-stmt stmtsep]\n;; [reference-stmt stmtsep]\n;; \"}\")\n;;\n;; REPLACED with (RFC6020 - Errata ID 3495)\n;;\nrevision-stmt = revision-keyword sep revision-date optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nrevision-date = date-arg-str\n\nrevision-date-stmt = revision-date-keyword sep revision-date stmtend\n\n\nextension-stmt = extension-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [argument-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nargument-stmt = argument-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n [yin-element-stmt stmtsep]\n \"}\")\n\nyin-element-stmt = yin-element-keyword sep yin-element-arg-str\n stmtend\n\nyin-element-arg-str = < a string that matches the rule yin-element-arg >\n\nyin-element-arg = true-keyword / false-keyword\n\nidentity-stmt = identity-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [base-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nbase-stmt = base-keyword sep identifier-ref-arg-str\n optsep stmtend\n\nfeature-stmt = feature-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nif-feature-stmt = if-feature-keyword sep identifier-ref-arg-str\n optsep stmtend\n\ntypedef-stmt = typedef-keyword sep identifier-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n type-stmt stmtsep\n [units-stmt stmtsep]\n [default-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\"\n\ntype-stmt = type-keyword sep identifier-ref-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n type-body-stmts\n \"}\")\n\n;; type-body-stmts = numerical-restrictions /\n;; decimal64-specification /\n;; string-restrictions /\n;; enum-specification /\n;; leafref-specification /\n;; identityref-specification /\n;; instance-identifier-specification /\n;; bits-specification /\n;; union-specification\n;;\n;; REPLACED with (RFC6020 - Errata ID 3835)\n;;\ntype-body-stmts = numerical-restrictions /\n decimal64-specification /\n string-restrictions /\n enum-specification /\n leafref-specification /\n identityref-specification /\n instance-identifier-specification /\n bits-specification /\n union-specification /\n binary-specification\n\nbinary-specification = [length-stmt stmtsep]\n\nnumerical-restrictions = range-stmt stmtsep\n\nrange-stmt = range-keyword sep range-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [error-message-stmt stmtsep]\n [error-app-tag-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\n;; decimal64-specification = fraction-digits-stmt\n;;\n;; REPLACED with (RFC6020 - Errata ID 3290)\n;;\n\n\ndecimal64-specification = ;; these stmts can appear in any order\n fraction-digits-stmt\n [range-stmt stmtsep]\n\nfraction-digits-stmt = fraction-digits-keyword sep\n fraction-digits-arg-str stmtend\n\n\nfraction-digits-arg-str = < a string that matches the rule fraction-digits-arg >\n\nfraction-digits-arg = (\"1\" [\"0\" / \"1\" / \"2\" / \"3\" / \"4\" /\n \"5\" / \"6\" / \"7\" / \"8\"])\n / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"\n\nstring-restrictions = ;; these stmts can appear in any order\n [length-stmt stmtsep]\n *(pattern-stmt stmtsep)\n\nlength-stmt = length-keyword sep length-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [error-message-stmt stmtsep]\n [error-app-tag-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\npattern-stmt = pattern-keyword sep string optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [error-message-stmt stmtsep]\n [error-app-tag-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\ndefault-stmt = default-keyword sep string stmtend\n\nenum-specification = 1*(enum-stmt stmtsep)\n\nenum-stmt = enum-keyword sep string optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [value-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\n;;\n;; leafref-specification =\n;; ;; these stmts can appear in any order\n;; path-stmt stmtsep\n;; [require-instance-stmt stmtsep]\n;; REPLACED with (RFC6020 - Errata ID 2949)\n;;\nleafref-specification = path-stmt stmtsep\n\npath-stmt = path-keyword sep path-arg-str stmtend\n\nrequire-instance-stmt = require-instance-keyword sep\n require-instance-arg-str stmtend\n\nrequire-instance-arg-str = < a string that matches the rule require-instance-arg >\n\nrequire-instance-arg = true-keyword / false-keyword\n\n\ninstance-identifier-specification =\n [require-instance-stmt stmtsep]\n\nidentityref-specification =\n base-stmt stmtsep\n\nunion-specification = 1*(type-stmt stmtsep)\n\nbits-specification = 1*(bit-stmt stmtsep)\n\n;; bit-stmt = bit-keyword sep identifier-arg-str optsep\n;; (\";\" /\n;; \"{\" stmtsep\n;; ;; these stmts can appear in any order\n;; [position-stmt stmtsep]\n;; [status-stmt stmtsep]\n;; [description-stmt stmtsep]\n;; [reference-stmt stmtsep]\n;; \"}\"\n;; \"}\")\n;;\n;; REPLACED with (RFC6020 - Errata ID 3094)\n;;\nbit-stmt = bit-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [position-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\n\nposition-stmt = position-keyword sep\n position-value-arg-str stmtend\n\nposition-value-arg-str = < a string that matches the rule position-value-arg >\n\nposition-value-arg = non-negative-integer-value\n\nstatus-stmt = status-keyword sep status-arg-str stmtend\n\n\nstatus-arg-str = < a string that matches the rule status-arg >\n\nstatus-arg = current-keyword /\n obsolete-keyword /\n deprecated-keyword\n\nconfig-stmt = config-keyword sep\n config-arg-str stmtend\n\nconfig-arg-str = < a string that matches the rule config-arg >\n\nconfig-arg = true-keyword / false-keyword\n\nmandatory-stmt = mandatory-keyword sep\n mandatory-arg-str stmtend\n\nmandatory-arg-str = < a string that matches the rule mandatory-arg >\n\nmandatory-arg = true-keyword / false-keyword\n\npresence-stmt = presence-keyword sep string stmtend\n\nordered-by-stmt = ordered-by-keyword sep\n ordered-by-arg-str stmtend\n\nordered-by-arg-str = < a string that matches the rule ordered-by-arg >\n\nordered-by-arg = user-keyword / system-keyword\n\nmust-stmt = must-keyword sep string optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [error-message-stmt stmtsep]\n [error-app-tag-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nerror-message-stmt = error-message-keyword sep string stmtend\n\nerror-app-tag-stmt = error-app-tag-keyword sep string stmtend\n\n\nmin-elements-stmt = min-elements-keyword sep\n min-value-arg-str stmtend\n\nmin-value-arg-str = < a string that matches the rule min-value-arg >\n\nmin-value-arg = non-negative-integer-value\n\nmax-elements-stmt = max-elements-keyword sep\n max-value-arg-str stmtend\n\nmax-value-arg-str = < a string that matches the rule max-value-arg >\n\nmax-value-arg = unbounded-keyword /\n positive-integer-value\n\n;; value-stmt = value-keyword sep integer-value stmtend\n;;\n;; REPLACED with (RFC6020 - Errata ID 3493)\n;;\nvalue-stmt = value-keyword sep integer-value-arg-str stmtend\n\ninteger-value-arg-str = < a string that matches the rule integer-value-arg >\n\ninteger-value-arg = integer-value\n\ngrouping-stmt = grouping-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n *(data-def-stmt stmtsep)\n \"}\")\n\ncontainer-stmt = container-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n *(must-stmt stmtsep)\n [presence-stmt stmtsep]\n [config-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n *(data-def-stmt stmtsep)\n \"}\")\n\n\nleaf-stmt = leaf-keyword sep identifier-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n type-stmt stmtsep\n [units-stmt stmtsep]\n *(must-stmt stmtsep)\n [default-stmt stmtsep]\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\"\n\nleaf-list-stmt = leaf-list-keyword sep identifier-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n type-stmt stmtsep\n [units-stmt stmtsep]\n *(must-stmt stmtsep)\n [config-stmt stmtsep]\n [min-elements-stmt stmtsep]\n [max-elements-stmt stmtsep]\n [ordered-by-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\"\n\nlist-stmt = list-keyword sep identifier-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n *(must-stmt stmtsep)\n [key-stmt stmtsep]\n *(unique-stmt stmtsep)\n [config-stmt stmtsep]\n [min-elements-stmt stmtsep]\n [max-elements-stmt stmtsep]\n [ordered-by-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n 1*(data-def-stmt stmtsep)\n \"}\"\n\nkey-stmt = key-keyword sep key-arg-str stmtend\n\nkey-arg-str = < a string that matches the rule key-arg >\n\nkey-arg = node-identifier *(sep node-identifier)\n\nunique-stmt = unique-keyword sep unique-arg-str stmtend\n\nunique-arg-str = < a string that matches the rule unique-arg >\n\nunique-arg = descendant-schema-nodeid\n *(sep descendant-schema-nodeid)\n\nchoice-stmt = choice-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n [default-stmt stmtsep]\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *((short-case-stmt / case-stmt) stmtsep)\n \"}\")\n\nshort-case-stmt = container-stmt /\n leaf-stmt /\n leaf-list-stmt /\n list-stmt /\n anyxml-stmt\n\ncase-stmt = case-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *(data-def-stmt stmtsep)\n \"}\")\n\nanyxml-stmt = anyxml-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n *(must-stmt stmtsep)\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nuses-stmt = uses-keyword sep identifier-ref-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *(refine-stmt stmtsep)\n *(uses-augment-stmt stmtsep)\n \"}\")\n\nrefine-stmt = refine-keyword sep refine-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n (refine-container-stmts /\n refine-leaf-stmts /\n refine-leaf-list-stmts /\n refine-list-stmts /\n refine-choice-stmts /\n refine-case-stmts /\n refine-anyxml-stmts)\n \"}\")\n\nrefine-arg-str = < a string that matches the rule refine-arg >\n\nrefine-arg = descendant-schema-nodeid\n\nrefine-container-stmts =\n ;; these stmts can appear in any order\n *(must-stmt stmtsep)\n [presence-stmt stmtsep]\n [config-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nrefine-leaf-stmts = ;; these stmts can appear in any order\n *(must-stmt stmtsep)\n [default-stmt stmtsep]\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nrefine-leaf-list-stmts =\n ;; these stmts can appear in any order\n *(must-stmt stmtsep)\n [config-stmt stmtsep]\n [min-elements-stmt stmtsep]\n [max-elements-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nrefine-list-stmts = ;; these stmts can appear in any order\n *(must-stmt stmtsep)\n [config-stmt stmtsep]\n [min-elements-stmt stmtsep]\n [max-elements-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nrefine-choice-stmts = ;; these stmts can appear in any order\n [default-stmt stmtsep]\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nrefine-case-stmts = ;; these stmts can appear in any order\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\n\nrefine-anyxml-stmts = ;; these stmts can appear in any order\n *(must-stmt stmtsep)\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n\nuses-augment-stmt = augment-keyword sep uses-augment-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n 1*((data-def-stmt stmtsep) /\n (case-stmt stmtsep))\n \"}\"\n\nuses-augment-arg-str = < a string that matches the rule uses-augment-arg >\n\nuses-augment-arg = descendant-schema-nodeid\n\naugment-stmt = augment-keyword sep augment-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [when-stmt stmtsep]\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n 1*((data-def-stmt stmtsep) /\n (case-stmt stmtsep))\n \"}\"\n\naugment-arg-str = < a string that matches the rule augment-arg >\n\naugment-arg = absolute-schema-nodeid\n\nunknown-statement = prefix \":\" identifier [sep string] optsep\n (\";\" / \"{\" *unknown-statement2 \"}\")\n\nunknown-statement2 = [prefix \":\"] identifier [sep string] optsep\n (\";\" / \"{\" *unknown-statement2 \"}\")\n\nwhen-stmt = when-keyword sep string optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n \"}\")\n\nrpc-stmt = rpc-keyword sep identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n [input-stmt stmtsep]\n [output-stmt stmtsep]\n \"}\")\n\ninput-stmt = input-keyword optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n 1*(data-def-stmt stmtsep)\n \"}\"\n\noutput-stmt = output-keyword optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n 1*(data-def-stmt stmtsep)\n \"}\"\n\nnotification-stmt = notification-keyword sep\n identifier-arg-str optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n *(if-feature-stmt stmtsep)\n [status-stmt stmtsep]\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n *((typedef-stmt /\n grouping-stmt) stmtsep)\n *(data-def-stmt stmtsep)\n \"}\")\n\ndeviation-stmt = deviation-keyword sep\n deviation-arg-str optsep\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [description-stmt stmtsep]\n [reference-stmt stmtsep]\n (deviate-not-supported-stmt /\n 1*(deviate-add-stmt /\n deviate-replace-stmt /\n deviate-delete-stmt))\n \"}\"\n\ndeviation-arg-str = < a string that matches the rule deviation-arg >\n\ndeviation-arg = absolute-schema-nodeid\n\ndeviate-not-supported-stmt =\n deviate-keyword sep\n not-supported-keyword optsep\n (\";\" /\n \"{\" stmtsep\n \"}\")\n\n;; deviate-add-stmt = deviate-keyword sep add-keyword optsep\n;; (\";\" /\n;; \"{\" stmtsep\n;; [units-stmt stmtsep]\n;; *(must-stmt stmtsep)\n;; *(unique-stmt stmtsep)\n;; [default-stmt stmtsep]\n;; [config-stmt stmtsep]\n;; [mandatory-stmt stmtsep]\n;; [min-elements-stmt stmtsep]\n;; [max-elements-stmt stmtsep]\n;; \"}\")\n;;\n;; deviate-delete-stmt = deviate-keyword sep delete-keyword optsep\n;; (\";\" /\n;; \"{\" stmtsep\n;; [units-stmt stmtsep]\n;; *(must-stmt stmtsep)\n;; *(unique-stmt stmtsep)\n;; [default-stmt stmtsep]\n;; \"}\")\n;;\n;; deviate-replace-stmt = deviate-keyword sep replace-keyword optsep\n;; (\";\" /\n;; \"{\" stmtsep\n;; [type-stmt stmtsep]\n;; [units-stmt stmtsep]\n;; [default-stmt stmtsep]\n;; [config-stmt stmtsep]\n;; [mandatory-stmt stmtsep]\n;; [min-elements-stmt stmtsep]\n;; [max-elements-stmt stmtsep]\n;; \"}\")\n;;\n;; REPLACED with (RFC6020 - Errata ID 3087)\n;;\n\ndeviate-add-stmt = deviate-keyword sep add-keyword optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [units-stmt stmtsep]\n *(must-stmt stmtsep)\n *(unique-stmt stmtsep)\n [default-stmt stmtsep]\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [min-elements-stmt stmtsep]\n [max-elements-stmt stmtsep]\n \"}\")\n\ndeviate-delete-stmt = deviate-keyword sep delete-keyword optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [units-stmt stmtsep]\n *(must-stmt stmtsep)\n *(unique-stmt stmtsep)\n [default-stmt stmtsep]\n \"}\")\n\ndeviate-replace-stmt = deviate-keyword sep replace-keyword optsep\n (\";\" /\n \"{\" stmtsep\n ;; these stmts can appear in any order\n [type-stmt stmtsep]\n [units-stmt stmtsep]\n [default-stmt stmtsep]\n [config-stmt stmtsep]\n [mandatory-stmt stmtsep]\n [min-elements-stmt stmtsep]\n [max-elements-stmt stmtsep]\n \"}\")\n\n;; Ranges\n\nrange-arg-str = < a string that matches the rule range-arg >\n\nrange-arg = range-part *(optsep \"|\" optsep range-part)\n\nrange-part = range-boundary\n [optsep \"..\" optsep range-boundary]\n\nrange-boundary = min-keyword / max-keyword /\n integer-value / decimal-value\n\n;; Lengths\n\nlength-arg-str = < a string that matches the rule length-arg >\n\nlength-arg = length-part *(optsep \"|\" optsep length-part)\n\nlength-part = length-boundary\n [optsep \"..\" optsep length-boundary]\n\nlength-boundary = min-keyword / max-keyword /\n non-negative-integer-value\n\n;; Date\n\ndate-arg-str = < a string that matches the rule date-arg >\n\ndate-arg = 4DIGIT \"-\" 2DIGIT \"-\" 2DIGIT\n\n;; Schema Node Identifiers\n\nschema-nodeid = absolute-schema-nodeid /\n descendant-schema-nodeid\n\nabsolute-schema-nodeid = 1*(\"/\" node-identifier)\n\n;; descendant-schema-nodeid =\n;; node-identifier\n;; [absolute-schema-nodeid]\n;;\n;; REPLACED with (RFC6020 - Errata ID 3289)\n;;\n\ndescendant-schema-nodeid =\n node-identifier\n absolute-schema-nodeid\n\n\nnode-identifier = [prefix \":\"] identifier\n\n\n;; Instance Identifiers\n\ninstance-identifier = 1*(\"/\" (node-identifier *predicate))\n\npredicate = \"[\" *WSP (predicate-expr / pos) *WSP \"]\"\n\npredicate-expr = (node-identifier / \".\") *WSP \"=\" *WSP\n ((DQUOTE string DQUOTE) /\n (SQUOTE string SQUOTE))\n\npos = non-negative-integer-value\n\n;; leafref path\n\npath-arg-str = < a string that matches the rule path-arg >\n\npath-arg = absolute-path / relative-path\n\nabsolute-path = 1*(\"/\" (node-identifier *path-predicate))\n\nrelative-path = 1*(\"..\" \"/\") descendant-path\n\ndescendant-path = node-identifier\n [*path-predicate absolute-path]\n\npath-predicate = \"[\" *WSP path-equality-expr *WSP \"]\"\n\npath-equality-expr = node-identifier *WSP \"=\" *WSP path-key-expr\n\npath-key-expr = current-function-invocation *WSP \"/\" *WSP\n rel-path-keyexpr\n\nrel-path-keyexpr = 1*(\"..\" *WSP \"/\" *WSP)\n *(node-identifier *WSP \"/\" *WSP)\n node-identifier\n\n;; Keywords, these should be case sensitive\n\n;; statement keywords\nanyxml-keyword = anyxml\nargument-keyword = argument\naugment-keyword = augment\nbase-keyword = base\nbelongs-to-keyword = belongs-to\nbit-keyword = bit\ncase-keyword = case\nchoice-keyword = choice\nconfig-keyword = config\ncontact-keyword = contact\ncontainer-keyword = container\ndefault-keyword = default\ndescription-keyword = description\nenum-keyword = enum\nerror-app-tag-keyword = error-app-tag\nerror-message-keyword = error-message\nextension-keyword = extension\ndeviation-keyword = deviation\ndeviate-keyword = deviate\nfeature-keyword = feature\nfraction-digits-keyword = fraction-digits\ngrouping-keyword = grouping\nidentity-keyword = identity\nif-feature-keyword = if-feature\nimport-keyword = import\ninclude-keyword = include\ninput-keyword = input\nkey-keyword = key\nleaf-keyword = leaf\nleaf-list-keyword = leaf-list\nlength-keyword = length\nlist-keyword = list\nmandatory-keyword = mandatory\nmax-elements-keyword = max-elements\nmin-elements-keyword = min-elements\nmodule-keyword = module\nmust-keyword = must\nnamespace-keyword = namespace\nnotification-keyword= notification\nordered-by-keyword = ordered-by\norganization-keyword= organization\noutput-keyword = output\npath-keyword = path\npattern-keyword = pattern\nposition-keyword = position\nprefix-keyword = prefix\npresence-keyword = presence\nrange-keyword = range\nreference-keyword = reference\nrefine-keyword = refine\nrequire-instance-keyword = require-instance\nrevision-keyword = revision\nrevision-date-keyword = revision-date\nrpc-keyword = rpc\nstatus-keyword = status\nsubmodule-keyword = submodule\ntype-keyword = type\ntypedef-keyword = typedef\nunique-keyword = unique\nunits-keyword = units\nuses-keyword = uses\nvalue-keyword = value\nwhen-keyword = when\nyang-version-keyword= yang-version\nyin-element-keyword = yin-element\n\n;; other keywords\n\nadd-keyword = add\ncurrent-keyword = current\ndelete-keyword = delete\ndeprecated-keyword = deprecated\nfalse-keyword = false\nmax-keyword = max\nmin-keyword = min\nnot-supported-keyword = not-supported\nobsolete-keyword = obsolete\nreplace-keyword = replace\nsystem-keyword = system\ntrue-keyword = true\nunbounded-keyword = unbounded\nuser-keyword = user\n\n\ncurrent-function-invocation = current-keyword *WSP \"(\" *WSP \")\"\n\n;; Basic Rules\n\nprefix-arg-str = < a string that matches the rule prefix-arg >\n\nprefix-arg = prefix\n\nprefix = identifier\n\nidentifier-arg-str = < a string that matches the rule identifier-arg >\n\nidentifier-arg = identifier\n\n;; An identifier MUST NOT start with ((X|x) (M|m) (L|l))\nidentifier = (ALPHA / \"_\")\n *(ALPHA / DIGIT / \"_\" / \"-\" / \".\")\n\nidentifier-ref-arg-str = < a string that matches the rule identifier-ref-arg >\n\nidentifier-ref-arg = [prefix \":\"] identifier\n\nstring = < an unquoted string as returned by the scanner >\n\ninteger-value = (\"-\" non-negative-integer-value) /\n non-negative-integer-value\n\nnon-negative-integer-value = \"0\" / positive-integer-value\n\npositive-integer-value = (non-zero-digit *DIGIT)\n\nzero-integer-value = 1*DIGIT\n\nstmtend = \";\" / \"{\" *unknown-statement \"}\"\n\nsep = 1*(WSP / line-break)\n ; unconditional separator\n\noptsep = *(WSP / line-break)\n\nstmtsep = *(WSP / line-break / unknown-statement)\n\nline-break = CRLF / LF\n\nnon-zero-digit = %x31-39\n\ndecimal-value = integer-value (\".\" zero-integer-value)\n\nSQUOTE = %x27\n ; (Single Quote)\n\n;;\n;; RFC 5234 core rules.\n;;\n\nALPHA = %x41-5A / %x61-7A\n ; A-Z / a-z\n\nCR = %x0D\n ; carriage return\n\nCRLF = CR LF\n ; Internet standard new line\n\nVCHAR = %x30-39\n ; 0-9\n\nDQUOTE = %x22\n ; \" (Double Quote)\n\nHEXDIG = DIGIT /\n %x61 / %x62 / %x63 / %x64 / %x65 / %x66\n ; only lower-case a..f\n\nHTAB = %x09\n ; horizontal tab\n\nLF = %x0A\n ; linefeed\n\nSP = %x20\n ; space\n\nVCHAR = %x21-7E\n ; visible (printing) characters\n\nWSP = SP / HTAB\n ; whitespace\n" }

{ "content": "URI = scheme \":\" hier-part [ \"?\" query ] [ \"#\" fragment ]\n\nhier-part = \"//\" authority path-abempty\n / path-absolute\n / path-rootless\n / path-empty\n\nURI-reference = URI / relative-ref\n\nabsolute-URI = scheme \":\" hier-part [ \"?\" query ]\n\nrelative-ref = relative-part [ \"?\" query ] [ \"#\" fragment ]\n\nrelative-part = \"//\" authority path-abempty\n / path-absolute\n / path-noscheme\n / path-empty\n\nscheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\n\nauthority = [ userinfo \"@\" ] host [ \":\" port ]\nuserinfo = *( unreserved / pct-encoded / sub-delims / \":\" )\nhost = IP-literal / IPv4address / reg-name\nport = *DIGIT\n\nIP-literal = \"[\" ( IPv6address / IPvFuture ) \"]\"\n\nIPvFuture = \"v\" 1*HEXDIG \".\" 1*( unreserved / sub-delims / \":\" )\n\nIPv6address = 6( h16 \":\" ) ls32\n / \"::\" 5( h16 \":\" ) ls32\n / [ h16 ] \"::\" 4( h16 \":\" ) ls32\n / [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n / [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n / [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32\n / [ *4( h16 \":\" ) h16 ] \"::\" ls32\n / [ *5( h16 \":\" ) h16 ] \"::\" h16\n / [ *6( h16 \":\" ) h16 ] \"::\"\n\nh16 = 1*4HEXDIG\nls32 = ( h16 \":\" h16 ) / IPv4address\nIPv4address = dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet\n\ndec-octet = DIGIT\n / %x31-39 DIGIT\n / \"1\" 2DIGIT\n / \"2\" %x30-34 DIGIT\n / \"25\" %x30-35\n\nreg-name = *( unreserved / pct-encoded / sub-delims )\n\npath = path-abempty\n / path-absolute\n / path-noscheme\n / path-rootless\n / path-empty\n\npath-abempty = *( \"/\" segment )\npath-absolute = \"/\" [ segment-nz *( \"/\" segment ) ]\npath-noscheme = segment-nz-nc *( \"/\" segment )\npath-rootless = segment-nz *( \"/\" segment )\npath-empty = 0<pchar>\n\nsegment = *pchar\nsegment-nz = 1*pchar\nsegment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / \"@\" )\n\npchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\"\n\nquery = *( pchar / \"/\" / \"?\" )\n\nfragment = *( pchar / \"/\" / \"?\" )\n\npct-encoded = \"%\" HEXDIG HEXDIG\n\nunreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\nreserved = gen-delims / sub-delims\ngen-delims = \":\" / \"/\" / \"?\" / \"#\" / \"[\" / \"]\" / \"@\"\nsub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\n / \"*\" / \"+\" / \",\" / \";\" / \"=\"\n\nDIGIT = \"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"8\" / \"9\"\n\nALPHA = \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\" / \"g\" / \"h\" / \"i\"\n / \"j\" / \"k\" / \"l\" / \"m\" / \"n\" / \"o\" / \"p\" / \"q\" / \"r\"\n / \"s\" / \"t\" / \"u\" / \"v\" / \"w\" / \"x\" / \"y\" / \"z\"\n\nHEXDIG = \"0\" / \"1\" / \"2\" / \"3\" / \"4\" / \"5\" / \"6\" / \"8\" / \"9\"\n / \"a\" / \"b\" / \"c\" / \"d\" / \"e\" / \"f\"\n\n" }

{ "content": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n;\n; HTTP digest authentication (2617) - ABNF\n;\n;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n\n;;;; 1.2 Access Authentication Framework\nauth-scheme = token\nauth-param = token \"=\" ( token | quoted-string )\n\nchallenge = auth-scheme 1*SP 1#auth-param\n\nrealm = \"realm\" \"=\" realm-value\nrealm-value = quoted-string\n\n;;;; 2 Basic Authentication Scheme\nchallenge = \"Basic\" realm\ncredentials = \"Basic\" basic-credentials\n\nbasic-credentials = base64-user-pass\nbase64-user-pass = token ;<base64 [4] encoding of user-pass, except not limited to 76 char/line>\nuser-pass = userid \":\" password\nuserid = *TEXT ;*<TEXT excluding \":\">\npassword = *TEXT\n\n;;;; 3.2.1 The WWW-Authenticate Response Header\nchallenge = \"Digest\" digest-challenge\n\ndigest-challenge = 1#( realm | [ domain ] | nonce | [ opaque ] |[ stale ] | [ algorithm ] | [ qop-options ] | [auth-param] )\n\ndomain = \"domain\" \"=\" <\"> URI ( 1*SP URI ) <\">\nURI = absoluteURI | abs_path\nnonce = \"nonce\" \"=\" nonce-value\nnonce-value = quoted-string\nopaque = \"opaque\" \"=\" quoted-string\nstale = \"stale\" \"=\" ( \"true\" | \"false\" )\nalgorithm = \"algorithm\" \"=\" ( \"MD5\" | \"MD5-sess\" | token )\nqop-options = \"qop\" \"=\" <\"> 1#qop-value <\">\nqop-value = \"auth\" | \"auth-int\" | token\n\n\n;;;; 3.2.2 The Authorization Request Header\ncredentials = \"Digest\" digest-response\ndigest-response = 1#( username | realm | nonce | digest-url | response | [ algorithm ] | [cnonce] | [opaque] | [message-qop] | [nonce-count] | [auth-param] )\n\nusername = \"username\" \"=\" username-value\nusername-value = quoted-string\ndigest-url = \"url\" \"=\" digest-url-value\ndigest-url-value = request-url ; As specified by HTTP/1.1\nmessage-qop = \"qop\" \"=\" qop-value\ncnonce = \"cnonce\" \"=\" cnonce-value\ncnonce-value = nonce-value\nnonce-count = \"nc\" \"=\" nc-value\nnc-value = 8LHEX\nresponse = \"response\" \"=\" request-digest\nrequest-digest = DQUOTE 32LHEX DQUOTE\nLHEX = \"0\" | \"1\" | \"2\" | \"3\" | \"4\" | \"5\" | \"6\" | \"7\" | \"8\" | \"9\" | \"a\" | \"b\" | \"c\" | \"d\" | \"e\" | \"f\"\n\n\n;;;; 3.2.3 The Authentication-Info Header\nAuthenticationInfo = \"Authentication-Info\" \":\" auth-info\nauth-info = 1#(nextnonce | [ message-qop ] | [ response-auth ] | [ cnonce ] | [nonce-count] )\nnextnonce = \"nextnonce\" \"=\" nonce-value\nresponse-auth = \"rspauth\" \"=\" response-digest\nresponse-digest = DQUOTE *LHEX DQUOTE\n\n" }

{ "content": "; Extracted from RFC 7230\n\n; Copyright (c) 2014 IETF Trust and the persons identified as the\n; document authors. All rights reserved.\n\n; This document is subject to BCP 78 and the IETF Trust's Legal\n; Provisions Relating to IETF Documents\n; (http://trustee.ietf.org/license-info) in effect on the date of\n; publication of this document. Please review these documents\n; carefully, as they describe your rights and restrictions with respect\n; to this document. Code Components extracted from this document must\n; include Simplified BSD License text as described in Section 4.e of\n; the Trust Legal Provisions and are provided without warranty as\n; described in the Simplified BSD License.\n\ntoken = 1*tchar\n\ntchar = \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"'\" / \"*\"\n / \"+\" / \"-\" / \".\" / \"^\" / \"_\" / \"`\" / \"|\" / \"~\"\n / DIGIT / ALPHA\n ; any VCHAR, except delimiters\n\nquoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE\nqdtext = HTAB / SP /%x21 / %x23-5B / %x5D-7E / obs-text\nobs-text = %x80-FF\n\ncomment = \"(\" *( ctext / quoted-pair / comment ) \")\"\nctext = HTAB / SP / %x21-27 / %x2A-5B / %x5D-7E / obs-text\n\nquoted-pair = \"\\\" ( HTAB / SP / VCHAR / obs-text )\n\nOWS = *( SP / HTAB )\n ; optional whitespace\n\nRWS = 1*( SP / HTAB )\n ; required whitespace\n\nBWS = OWS\n ; \"bad\" whitespace\n\nheader-field = field-name \":\" OWS field-value OWS\n\nfield-name = token\nfield-value = *( field-content / obs-fold )\nfield-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]\nfield-vchar = VCHAR / obs-text\n\nobs-fold = CRLF 1*( SP / HTAB )\n ; obsolete line folding\n ; see Section 3.2.4\n" }

{ "content": "#ABNF 1.0;\nlanguage pl-pl;\nmode voice;\nroot $root;\ntag-format <semantics/1.0-literals>;\n\n$root = $komenda | $stawiam $ile;\n\n$komenda = sprawdzam {Sprawdzam} | pas {Pass} | wabank {Vabank} | dokladam {Dokladam};\n$stawiam = stawiam {Stawiam};\n$ile = [$tys] [$sto] [$dzies] $piec |\n [$tys] [$sto] $nascie |\n [$tys] [$sto] $dzies [$piec] |\n [$tys] $sto [($dzies [$piec] | $nascie)] |\n $tys [$sto] [($dzies [$piec] | $nascie)];\n$tys = dwa tysiące {2000} | tysiąc {1000};\n$sto = dziewięćset {900} |\n osiemset {800} |\n siedemset {700} |\n sześćset {600} |\n pięćset {500} |\n czterysta {400} |\n trzysta {300} |\n dwieście {200} |\n sto {100};\n$dzies = dziewięćdziesiąt {90} |\n osiemdziesiąt {80} |\n siedemdziesiąt {70} |\n sześćdziesiąt {60} |\n pięćdziesiąt {50} |\n czterdzieści {40} |\n trzydzieści {30} |\n dwadzieścia {20};\n$piec = pięć {5};\n$nascie = piętnaście {15} | dziesięć {10};" }

{ "content": "regexpliteral = [ regexpatstart ] regexpsequence [ regexpatend ]\n;regexpliteral = \"/\" [ regexpatstart ] regexpsequence *( regexpalternative regexpsequence ) [ regexpatend ] \"/\" regexpoptions\nregexpatstart = \"^\"\nregexpatend = \"$\"\n;regexpoptions = 0*3( \"g\" / \"i\" / \"m\" )\n;regexpchoice = regexpsequence *( regexpalternative regexpsequence )\n;regexpalternative = \"|\"\nregexpsequence = 1*( (regexpclass / regexpgroup / regexpfactorword) [ regexpquantifier ] )\n;regexpsequence = 1*( regexpfactor [ regexpquantifier ] )\n;regexpfactor = regexpclass / regexpgroup / regexpfactorword\nregexpfactorword = 1*( charfactor / regexpescape )\nregexpgroup = \"(\" [ regexpgroupcapture ] regexpsequence \")\"\n;regexpgroup = \"(\" [ regexpgroupcapture ] regexpchoice \")\"\nregexpgroupcapture = \"?\" [ \":\" / \"=\" / \"!\" ]\nregexpclass = regexppredifinedclass / ( \"[\" [ regexpclassnegative ] 1*( regexppredifinedclass / regexpcharrange / regexpclassword ) \"]\" ) \nregexpclassnegative = \"^\"\nregexppredifinedclass = \"\\D\" / \"\\S\" / \"\\W\" / \"\\d\" / \"\\s\" / \"\\w\" / \".\"\nregexpcharrange = regexpcharstart \"-\" regexpcharend\nregexpcharstart = charclass / regexpclassescape\nregexpcharend = charclass / regexpclassescape\nregexpclassword = 1*( charclass / regexpclassescape )\nregexpquantifier = ( \"?\" / \"*\" / \"+\" / \"-\" )\n;regexpquantifier = ( \"?\" / \"*\" / \"+\" / \"-\" / regexpquantifierrange ) [ \"?\" ]\n;regexpquantifierrange = \"{\" min [ \",\" [ max ] ] \"}\"\n\nregexpclassescape = \"%\" (\n \"a\" / \"c\" / \"d\" / \"r\" / \"l\" / \"p\" / \"s\" / \"u\" / \"w\" / \"x\" / \"z\" /\n charspecial / DIGIT )\nregexpescape = \"%\" (\n \"a\" / \"c\" / \"d\" / \"r\" / \"l\" / \"p\" / \"s\" / \"u\" / \"w\" / \"x\" / \"z\" /\n charspecialfactor / DIGIT )\ncharfactor = ALPHA / DIGIT / \"{\" / \"}\" / \"#\" / \"/\" / \"\\\" / \"&\" / \"!\" / \"'\" / \"|\" / \",\" / \":\" / \";\" / \"<\" / \"=\" / \">\" / \"@\" / \"_\" / \"`\" / \"~\" / %x41 ; not %[]()?+-*|.^$ and %x41 is the caractere \"\ncharclass = ALPHA / DIGIT / \"{\" / \"}\" / \"(\" / \")\" / \"$\" / \"+\" / \"*\" / \"?\" / \"|\" / \"#\" / \"/\" / \"\\\" / \"&\" / \"!\" / \"'\" / \",\" / \":\" / \";\" / \"<\" / \"=\" / \">\" / \"@\" / \"_\" / \"`\" / \"~\" / %x41 ; not %[]^-\ncharspecialfactor = \"[\" / \"]\" / \"^\" / \"(\" / \")\" / \"?\" / \"+\" / \"*\" / \".\" /\"^\" / \"$\" / \"%\" / \" \"\ncharspecial = \"-\" / \"[\" / \"%\" / \"]\" / \"^\" / \" \"\n\nmin = 1*DIGIT\nmax = 1*DIGIT\n\nHEXDIG = DIGIT / %x61-65 / %x41-45\nDIGIT = %x30-39\nALPHA = %x41-5A / %x61-7A\n" }

{ "content": "CATEGORIES-param = \"VALUE=text\" / pid-param / pref-param\n / type-param / altid-param / any-param\nCATEGORIES-value = text-list\n" }

{ "content": "; Only one variable is expected to exist after definition\nthree = \"3\"\nThree = \"3\"\nTHREE = \"3\"" }

{ "content": "file-URI = file-scheme \":\" file-hier-part\n\nfile-scheme = \"file\"\n\nfile-hier-part = ( \"//\" auth-path )\n / local-path\n\nauth-path = [ file-auth ] path-absolute\n / [ file-auth ] file-absolute\n / unc-authority path-absolute\n\nlocal-path = [ drive-letter ] path-absolute\n / file-absolute\n\nfile-auth = \"localhost\"\n / [ userinfo \"@\" ] host\n\nunc-authority = 2*3\"/\" file-host\n\nfile-host = inline-IP / IPv4address / reg-name\n\ninline-IP = \"%5B\" ( IPv6address / IPvFuture ) \"%5D\"\n\nfile-absolute = \"/\" drive-letter path-absolute\n\ndrive-letter = ALPHA \":\"\n / ALPHA \"|\"\n" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main =[我] [$want] [$ask] [酒店] [$Irrelevent1] [酒店] [$go] ( $movement | $opera | $location | $content) [$Irrelevent2] ;\n$want = 想 | 需要 | 可以;\n$ask = 知道 | 请问 | 问 | 了解;\n$Irrelevent1 = 怎么 | 在哪里 | 有哪些 | 几点 | 哪里有 | 什么时候 | 如何 ;\n$go = 去 | 要 | 到 | 向 | 走;\n$movement = 前进 |后退 |原地左转| 原地右转 | 前进左转 | 前进右转 ;\n$opera = 点餐服务 | 洗衣服务 | 点餐 | 洗衣 | 用餐 | 退房 | 入住;\n$content = 入住时间 | 退房时间 | 押金 | 房型 | 入住 | 退房 | 用餐时间 | 洗衣时间 | 点餐时间 | 寄存行李;\n$location = 电梯 |楼梯 | 餐厅 | 中餐厅 | 西餐厅 | 健身房 | 会议室 | 失物招领处 | 行李寄存处 | 附近银行 | 附近商场 | 附近机场 | 娱乐中心 | 咖啡馆 | 附近地铁;\n$Irrelevent2 = 怎么走 | 在哪里 | 那里 | 有哪些 |是几点 | 是多少 | 多少钱 | 如何走;\n\n\n" }

{ "content": "//\n// Dialog Grammar: 0\n//\n\n#include <utils>\n\n#start <DID_0_Grm>\n<DID_0_Grm> = \n<!-- DID_0_Grm -->\n <DID_0_Grm_CID_0> \n<!-- DID_0_Grm -->\n;\n\n<!-- CID_0 -->\n\n<DID_0_Grm_CID_0> = \n\tselect <digits> => SETFIELD(0, <digits>)\n | \tdata is <Icao> => SETFIELD(0, <Icao>)\n;\n<!-- CID_0 -->\n" }

{ "content": "IRI = scheme \":\" ihier-part [ \"?\" iquery ]\r\n [ \"#\" ifragment ]\r\n\r\nihier-part = \"//\" iauthority ipath-abempty\r\n / ipath-absolute\r\n / ipath-rootless\r\n / ipath-empty\r\n\r\nIRI-reference = IRI / irelative-ref\r\n\r\nabsolute-IRI = scheme \":\" ihier-part [ \"?\" iquery ]\r\n\r\nirelative-ref = irelative-part [ \"?\" iquery ] [ \"#\" ifragment ]\r\n\r\nirelative-part = \"//\" iauthority ipath-abempty\r\n / ipath-absolute\r\n / ipath-noscheme\r\n / ipath-empty\r\n\r\niauthority = [ iuserinfo \"@\" ] ihost [ \":\" port ]\r\niuserinfo = *( iunreserved / pct-encoded / sub-delims / \":\" )\r\nihost = IP-literal / IPv4address / ireg-name\r\n\r\nireg-name = *( iunreserved / pct-encoded / sub-delims )\r\n\r\nipath = ipath-abempty ; begins with \"/\" or is empty\r\n / ipath-absolute ; begins with \"/\" but not \"//\"\r\n / ipath-noscheme ; begins with a non-colon segment\r\n / ipath-rootless ; begins with a segment\r\n / ipath-empty ; zero characters\r\n\r\nipath-abempty = *( \"/\" isegment )\r\nipath-absolute = \"/\" [ isegment-nz *( \"/\" isegment ) ]\r\nipath-noscheme = isegment-nz-nc *( \"/\" isegment )\r\nipath-rootless = isegment-nz *( \"/\" isegment )\r\nipath-empty = 0ipchar\r\n\r\nisegment = *ipchar\r\nisegment-nz = 1*ipchar\r\nisegment-nz-nc = 1*( iunreserved / pct-encoded / sub-delims\r\n / \"@\" )\r\n ; non-zero-length segment without any colon \":\"\r\n\r\nipchar = iunreserved / pct-encoded / sub-delims / \":\"\r\n / \"@\"\r\n\r\niquery = *( ipchar / iprivate / \"/\" / \"?\" )\r\n\r\nifragment = *( ipchar / \"/\" / \"?\" )\r\n\r\niunreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\" / ucschar\r\n\r\nucschar = %xA0-D7FF / %xF900-FDCF / %xFDF0-FFEF\r\n / %x10000-1FFFD / %x20000-2FFFD / %x30000-3FFFD\r\n / %x40000-4FFFD / %x50000-5FFFD / %x60000-6FFFD\r\n / %x70000-7FFFD / %x80000-8FFFD / %x90000-9FFFD\r\n / %xA0000-AFFFD / %xB0000-BFFFD / %xC0000-CFFFD\r\n / %xD0000-DFFFD / %xE1000-EFFFD\r\n\r\niprivate = %xE000-F8FF / %xF0000-FFFFD / %x100000-10FFFD\r\n\r\nscheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" )\r\n\r\nport = *DIGIT\r\n\r\nIP-literal = \"[\" ( IPv6address / IPvFuture ) \"]\"\r\n\r\nIPvFuture = \"v\" 1*HEXDIG \".\" 1*( unreserved / sub-delims / \":\" )\r\n\r\nIPv6address = 6( h16 \":\" ) ls32\r\n / \"::\" 5( h16 \":\" ) ls32\r\n / [ h16 ] \"::\" 4( h16 \":\" ) ls32\r\n / [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\r\n / [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\r\n / [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32\r\n / [ *4( h16 \":\" ) h16 ] \"::\" ls32\r\n / [ *5( h16 \":\" ) h16 ] \"::\" h16\r\n / [ *6( h16 \":\" ) h16 ] \"::\"\r\n\r\nh16 = 1*4HEXDIG\r\nls32 = ( h16 \":\" h16 ) / IPv4address\r\n\r\nIPv4address = dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet\r\n\r\ndec-octet = DIGIT ; 0-9\r\n / %x31-39 DIGIT ; 10-99\r\n / \"1\" 2DIGIT ; 100-199\r\n / \"2\" %x30-34 DIGIT ; 200-249\r\n / \"25\" %x30-35 ; 250-255\r\n\r\npct-encoded = \"%\" HEXDIG HEXDIG\r\n\r\nunreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\r\nreserved = gen-delims / sub-delims\r\ngen-delims = \":\" / \"/\" / \"?\" / \"#\" / \"[\" / \"]\" / \"@\"\r\nsub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\r\n / \"*\" / \"+\" / \",\" / \";\" / \"=\"\r\n\r\n" }

{ "content": "DIGIT = \"0\" / \"1\" / \"2\" / \"3\" / \"4\" ; DIGIT is a core ABNF rule\n / \"5\" / \"6\" / \"7\" / \"8\" / \"9\"\n\nSIGN = \"+\" / \"-\" ; \"+\" or \"-\"\n\nINTEGER = [ SIGN ] 1*DIGIT ; An optional sign, followed by 1 or more digits" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main = [$call] $name;\n$call = 你好小骑|小骑你好|小骑;\n$name = 拍照|打开相机|打开照相机;" }

{ "content": "#ABNF 1.0;\nlanguage pl-pl;\nmode voice;\nroot $root;\ntag-format <semantics/1.0-literals>;\n\n$root = [$zyczenie] $czasownik [$przymiotnik] [$rzeczownik] {1} | [$zyczenie] $czasownik2 [$przyimek] [$rzeczownik2] [$przymiotnik2] {2};\n\n$zyczenie = chciałbym | chciałabym | chcę;\n$czasownik = dodać | dołożyć | obliczyć | policzyć;\n$przymiotnik = kolejny | następny | dodatkowy | drugi;\n$rzeczownik = produkt | kalorie;\n\n$czasownik2 = wrócić | powrócić | przejść;\n$przymiek = do;\n$rzeczownik2 = menu | meni | opcji;\n$przymiotnik2 = głownego | główne;" }

{ "content": "ubf-b = ubf-b-name ubf-b-vsn [ubf-b-type] *ubf-b-state [ubf-b-anystate]\n\nubf-b-name = \"+\" 'NAME' \"(\" NONEMTPYSTRING \")\" dot\nubf-b-vsn = \"+\" 'VSN' \"(\" NONEMTPYSTRING \")\" dot\nubf-b-type = \"+\" 'TYPES' 1*WSP types dot\nubf-b-state = \"+\" 'STATE' 1*WSP statename 1*WSP transitions dot\nubf-b-anystate = \"+\" 'ANYSTATE' 1*WSP anyrules dot\n\ndot = \".\" *c-wsp c-nl\nsemi = \";\" *c-wsp c-nl\ncomment = \"%\" *(WSP / VCHAR) CRLF\nc-nl = comment / CRLF\nc-wsp = WSP / (c-nl WSP)\n\nstatename = NONEMTPYATOM\ntypename = NONEMTPYATOM\nrecordname = NONEMTPYATOM\nfieldname = NONEMTPYATOM\n\ntypes = typedef\n / (typedef semi types)\n\ntypedef = typeref *c-wsp \"=\" *c-wsp type [1*WSP annotation] *c-wsp\n\ntransitions = transition\n / (transition semi transitions)\n\ntransition = typeref *c-wsp \"=>\" *c-wsp outputs *c-wsp\n / event\n\nanyrules = anyrule\n / (anyrule semi anyrules)\n\nanyrule = typeref *c-wsp \"=>\" *c-wsp typeref *c-wsp\n / event\n\nevent = 'EVENT' *c-wsp (\"=>\" / \"<=\") *c-wsp typeref *c-wsp\n\ntype = primtype\n / (primtype *c-wsp \"|\" *c-wsp type)\n\nannotation = STRING / BINARY\n\noutputs = output\n / (output *c-wsp \"|\" *c-wsp outputs)\n\noutput = typeref *c-wsp \"&\" *c-wsp statename\n\nprimtype = (typeref [ \"?\" ])\n / (\"{\" [typeseq] \"}\")\n / (\"#\" recordname \"{\" [typerec] \"}\")\n / (\"##\" recordname \"{\" [typerec] \"}\")\n / typelist\n / (INTEGER *WSP \"..\" *WSP INTEGER)\n / (\"..\" *WSP INTEGER)\n / (INTEGER *WSP \"..\")\n / ATOM\n / BINARY\n / FLOAT\n / INTEGER\n / STRING\n / (predefinedtype [ \"?\" ])\n\ntypelist = (\"[\" [type] \"]\" [ \"?\" / (\"{\" listrange \"}\") ])\n\ntyperef = typename \"()\"\n\ntypeseq = type\n / (type *WSP \",\" *WSP typeseq)\n\ntyperec = (fieldname *WSP \"=\" *WSP type)\n / (fieldname *WSP \"=\" *WSP type \",\" *WSP typerec)\n\nlistrange = (1*DIGIT)\n / (1*DIGIT *WSP \",\")\n / (1*DIGIT *WSP \",\" *WSP 1*DIGIT)\n\nATOM = (%x61-7A *(ALPHA / DIGIT / \"_\" / \"@\")) ;; a-z\n / (\"'\" *(%x20-26 / %x28-7E) \"'\")\n\nNONEMTPYATOM = (%x61-7A 1*(ALPHA / DIGIT / \"_\" / \"@\")) ;; a-z\n / (\"'\" 1*(%x20-26 / %x28-7E) \"'\")\n\nBINARY = \"<<\" STRING \">>\"\n\nFLOAT = [\"-\"] 1*DIGIT \".\" 1*DIGIT\n\nINTEGER = ([\"-\"] 1*DIGIT)\n / (1*DIGIT \"#\" 1*(DIGIT / 'a' / 'b' / 'c' / 'd' / 'e' / 'f'))\n\nSTRING = DQUOTE *(%x20-21 / %x23-7E) DQUOTE\n\nNONEMTPYSTRING = DQUOTE 1*(%x20-21 / %x23-7E) DQUOTE\n\npredefinedtype = ('atom' \"(\" [atomattrs] \")\")\n / ('binary' \"(\" [binaryattrs] \")\")\n / ('float' \"(\" [floatattrs] \")\")\n / ('integer' \"(\" [integerattrs] \")\")\n / ('list' \"(\" [listattrs] \")\")\n / ('proplist' \"(\" [proplistattrs] \")\")\n / ('string' \"(\" [stringattrs] \")\")\n / ('term' \"(\" [termattrs] \")\")\n / ('tuple' \"(\" [tupleattrs] \")\")\n / ('void' \"(\" [voidattrs] \")\")\n\natomattrs = atomattr\n / (atomattr *WSP \",\" *WSP atomattrs)\n\nbinaryattrs = binaryattr\n / (binaryattr *WSP \",\" *WSP binaryattrs)\n\nfloatattrs = *WSP\n\nintegerattrs = *WSP\n\nlistattrs = listattr\n / (listattr *WSP \",\" *WSP listattrs)\n\nproplistattrs = proplistattr\n / (proplistattr *WSP \",\" *WSP proplistattrs)\n\nstringattrs = stringattr\n / (stringattr *WSP \",\" *WSP stringattrs)\n\ntermattrs = termattr\n / (termattr *WSP \",\" *WSP termattrs)\n\ntupleattrs = tupleattr\n / (tupleattr *WSP \",\" *WSP tupleattrs)\n\nvoidattrs = *WSP\n\natomattr = 'ascii' / 'asciiprintable' / 'nonempty' / 'nonundefined'\nbinaryattr = 'ascii' / 'asciiprintable' / 'nonempty'\nlistattr = 'nonempty'\nproplistattr = 'nonempty'\nstringattr = 'ascii' / 'asciiprintable' / 'nonempty'\ntermattr = 'nonempty' / 'nonundefined'\ntupleattr = 'nonempty' / 'nonundefined'\n" }

{ "content": "sign-in-with-ethereum =\n domain \" wants you to sign in with your Ethereum account:\" LF #%s\n address LF\n LF\n [ statement LF ]\n LF\n \"URI: \" URI LF #%s\n \"Version: \" version LF #%s\n \"Chain ID: \" chain-id LF #%s\n \"Nonce: \" nonce LF #%s\n \"Issued At: \" issued-at #%s\n [ LF \"Expiration Time: \" expiration-time ] #%s\n [ LF \"Not Before: \" not-before ] #%s\n [ LF \"Request ID: \" request-id ] #%s\n [ LF \"Resources:\"\n resources ]; #%s\ndomain = authority;\naddress = \"0x\" 40HEXDIG;\n # Must also conform to captilization\n # checksum encoding specified in EIP-55\n # where applicable (EOAs).\nstatement = *( reserved / unreserved / \" \" );\n # The purpose is to exclude LF (line breaks).\nversion = \"1\";\nnonce = 8*( ALPHA / DIGIT );\nissued-at = date-time;\nexpiration-time = date-time;\nnot-before = date-time;\nrequest-id = *pchar;\nchain-id = 1*DIGIT;\n # See EIP-155 for valid CHAIN_IDs.\nresources = *( LF resource );\nresource = \"- \" URI;\n# ------------------------------------------------------------------------------\n# RFC 3986\nURI = scheme \":\" hier-part [ \"?\" query ] [ \"#\" fragment ];\nhier-part = \"//\" authority path-abempty\n / path-absolute\n / path-rootless\n / path-empty;\nscheme = ALPHA *( ALPHA / DIGIT / \"+\" / \"-\" / \".\" );\nauthority = [ userinfo \"@\" ] host [ \":\" port ];\nuserinfo = *( unreserved / pct-encoded / sub-delims / \":\" );\nhost = IP-literal / IPv4address / reg-name;\nport = *DIGIT;\nIP-literal = \"[\" ( IPv6address / IPvFuture ) \"]\";\nIPvFuture = \"v\" 1*HEXDIG \".\" 1*( unreserved / sub-delims / \":\" );\nIPv6address = 6( h16 \":\" ) ls32\n / \"::\" 5( h16 \":\" ) ls32\n / [ h16 ] \"::\" 4( h16 \":\" ) ls32\n / [ *1( h16 \":\" ) h16 ] \"::\" 3( h16 \":\" ) ls32\n / [ *2( h16 \":\" ) h16 ] \"::\" 2( h16 \":\" ) ls32\n / [ *3( h16 \":\" ) h16 ] \"::\" h16 \":\" ls32\n / [ *4( h16 \":\" ) h16 ] \"::\" ls32\n / [ *5( h16 \":\" ) h16 ] \"::\" h16\n / [ *6( h16 \":\" ) h16 ] \"::\";\nh16 = 1*4HEXDIG;\nls32 = ( h16 \":\" h16 ) / IPv4address;\nIPv4address = dec-octet \".\" dec-octet \".\" dec-octet \".\" dec-octet;\ndec-octet = DIGIT # 0-9\n / %x31-39 DIGIT # 10-99\n / \"1\" 2DIGIT # 100-199\n / \"2\" %x30-34 DIGIT # 200-249\n / \"25\" %x30-35; # 250-255\nreg-name = *( unreserved / pct-encoded / sub-delims );\npath-abempty = *( \"/\" segment );\npath-absolute = \"/\" [ segment-nz *( \"/\" segment ) ];\npath-rootless = segment-nz *( \"/\" segment );\npath-empty = 0pchar;\nsegment = *pchar;\nsegment-nz = 1*pchar;\npchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\";\nquery = *( pchar / \"/\" / \"?\" );\nfragment = *( pchar / \"/\" / \"?\" );\npct-encoded = \"%\" HEXDIG HEXDIG;\nunreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\";\nreserved = gen-delims / sub-delims;\ngen-delims = \":\" / \"/\" / \"?\" / \"#\" / \"[\" / \"]\" / \"@\";\nsub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\n / \"*\" / \"+\" / \",\" / \"#\" / \"=\";\n# ------------------------------------------------------------------------------\n# RFC 3339\ndate-fullyear = 4DIGIT;\ndate-month = 2DIGIT; # 01-12\ndate-mday = 2DIGIT; # 01-28, 01-29, 01-30, 01-31 based on\n # month/year\ntime-hour = 2DIGIT; # 00-23\ntime-minute = 2DIGIT; # 00-59\ntime-second = 2DIGIT; # 00-58, 00-59, 00-60 based on leap second\n # rules\ntime-secfrac = \".\" 1*DIGIT;\ntime-numoffset = (\"+\" / \"-\") time-hour \":\" time-minute;\ntime-offset = \"Z\" / time-numoffset;\npartial-time = time-hour \":\" time-minute \":\" time-second\n [time-secfrac];\nfull-date = date-fullyear \"-\" date-month \"-\" date-mday;\nfull-time = partial-time time-offset;\ndate-time = full-date \"T\" full-time;\n# ------------------------------------------------------------------------------\n# RFC 5234\nALPHA = %x41-5A / %x61-7A; # A-Z / a-z\nLF = %x0A;\n # linefeed\nDIGIT = %x30-39;\n # 0-9\nHEXDIG = DIGIT / \"A\" / \"B\" / \"C\" / \"D\" / \"E\" / \"F\";" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main =[我] [想] [$go] ( $opera1 | $location) ;\n$go = 去 | 要 | 到 | 向 ;\n$opera1 = 左转 | 右转 | 前进 | 后退 | 开灯 | 关灯 | 打电话 | 发短信 | 点外卖;\n$location = 图书馆 | 群英楼 | 中心楼 | 中山院 | 沙糖园 | 香园 | 东南大学;\n\n" }

{ "content": "; Opional angle brackets <> around var name\n<var> = \"Hi\"" }

{ "content": "ALPHA = %x41-5A / %x61-7A ; A-Z / a-z\r\nDIGIT = %x30-39\r\n\r\nanint = 1*DIGIT !!!\r\n {int, \"\"} = Integer.parse to_string(rule)\r\n {:ok, state, int}\r\n!!!\r\n\r\nastring = 1*ALPHA !!!\r\n {:ok, state, to_string(rule)}\r\n!!!\r\n\r\ncomposed = anint astring !!!\r\n [int, string] = values\r\n {:ok, %{state | field: true}, %{\r\n int: hd(:lists.flatten(int)),\r\n string: hd(:lists.flatten(string))\r\n }}\r\n!!!\r\n" }

{ "content": ";source: http://www.boost.org/doc/libs/1_33_1/libs/filesystem/doc/path.htm#Grammar\npath = [root] [relative-path] ;source: http://www.boost.org/doc/libs/1_33_1/libs/filesystem/doc/path.htm#Grammar\n\nroot = [root-name] [root-directory]\n\nroot-directory = separator\n\nrelative-path = path-element *(separator path-element) [separator]\n\npath-element = name / parent-directory / directory-placeholder\n\nname = 1*char\n\ndirectory-placeholder = \".\"\n\nparent-directory = \"..\"\n\nseparator = \"/\" ;an implementation may define additional separators \n\n;added default values:\nroot-name = \"home\";\nchar = %d1-46 / %d48-255;\n" }

{ "content": "test = ([a *\"b\"] [*\"b\"])\na = \"a\"" }

{ "content": "; From: https://raw.githubusercontent.com/ldthomas/apg-js2-examples/master/ini-file/ini-file.bnf\n;\n; Ref: https://en.wikipedia.org: INI File\n;\n; comments begin with the semicolon, \";\" and continue to the end of the line\n; comments may appear on valid section and value lines as well as blank lines\n; line ends may be CRLF, LF or CR\n; tabs, 0x09, may NOT occur in quoted strings\n;\n; keys may have multiple values\n; - multiple values may be given as a comma delimited list on a single line\n; - multiple values may be listed separately on separate lines with the same key name\n;\n; section names are optional\n; - keys need not appear in a named section\n;\n; sections are \"disjoint\",\n; - that is the keys in multiple occurrences of a section name are\n; - simply joined together as if they appeared contiguously in a single section\n;\n; sections end at the beginning of a new section or the end of file\n;\n; section and key names are alphanumeric + underscore (must begin with alpha or underscore)\n; values that are not alphanumeric must be single or double quoted\n;\n; The grammar is designed to accept any string of ASCII characters without failure.\n; The \"error productions\", BadSectionLine, BadValueLine, BadBlankLine are meant to accept all lines\n; that are not otherwise correct blank, section or value lines. This is so that\n; parser callback functions can recognize input errors and report or react to them\n; in an application-dependent manner.\n;\n;\nIniFile := *(BlankLine/ValueLine) *Section\nSection = SectionLine *(BlankLine/ValueLine)\nSectionLine = GoodSectionLine/BadSectionLine\nGoodSectionLine = \"[\" wsp SectionName wsp \"]\" wsp [comment] LineEnd\nBadSectionLine = \"[\" *any LineEnd;\nValueLine := GoodValueLine/BadValueLine\nGoodValueLine = KeyName wsp \"=\" wsp ValueArray wsp [comment] LineEnd\nBadValueLine = (%d33-90/%d92-126) *any LineEnd\nValueArray = Value *(wsp \",\" wsp Value)\nSectionName = (alpha/%d95) *(alpha/digit/%d95)\nKeyName ::= (alpha/%d95) *(alpha/digit/%d95)\nValue ::= DQuotedString/SQuotedString/AlphaDigit\nDQuotedString = %d34 1*(%d32-33/%d35-126) %d34\nSQuotedString = %d39 1*(%d32-38/%d40-126) %d39\nAlphaDigit = 1*(alpha/digit)\nBlankLine = GoodBlankLine/BadBlankLine\nGoodBlankLine = wsp [comment] LineEnd\nBadBlankLine = (%d32/%d9) wsp (%d33-58/%d60-126) *any LineEnd\nLineEnd = %d13.10/%d10/%d13\ncomment = (%d59/%d35) *any\nwsp = *(%d32/%d9)\nalpha = %d65-90/%d97-122\ndigit = %d48-57\nany = %d32-126/%d9\n" }

{ "content": "#ABNF 1.0 ISO-8859-1;\nlanguage en-US;\nmode voice;\nroot $ALL;\n\n$ALL = $dig<1-> ;\n\n$dig = one | two | three | four | five | six | seven | eight | nine | zero | oh ;\n" }

{ "content": "; Collected rules from RFC 8187\n; https://tools.ietf.org/html/rfc8187\n\next-value = charset \"'\" [ language ] \"'\" value-chars\n\ncharset = \"UTF-8\" / mime-charset\n\nmime-charset = 1*mime-charsetc\n\nmime-charsetc = ALPHA / DIGIT / \"!\" / \"#\" / \"$\" / \"%\" / \"&\" / \"+\" / \"-\" / \"^\" / \"_\" / \"`\" / \"{\" / \"}\" / \"~\"\n\nvalue-chars = *( pct-encoded / attr-char )\n\npct-encoded = \"%\" HEXDIG HEXDIG\n\nattr-char = ALPHA / DIGIT / \"!\" / \"#\" / \"$\" / \"&\" / \"+\" / \"-\" / \".\" / \"^\" / \"_\" / \"`\" / \"|\" / \"~\"\n" }

{ "content": "IPv4address =\r\n dec-octet \".\"\r\n dec-octet \".\"\r\n dec-octet \".\"\r\n dec-octet !!!\r\n state = Map.put state, :ipv4address, rule\r\n {:ok, state, \"Your ip address is: #{rule}\"}\r\n !!!\r\n\r\ndec-octet = DIGIT ; 0-9\r\n / %x31-39 DIGIT ; 10-99\r\n / \"1\" 2DIGIT ; 100-199\r\n / \"2\" %x30-34 DIGIT ; 200-249\r\n / \"25\" %x30-35 ; 250-255\r\n\r\nDIGIT = %x30-39\r\n" }

{ "content": "idl =\n ws\n / control_section\n / metadata_section\n / shape_section\n\nws =\n *(sp / newline / line_comment) ; whitespace\n\nsp =\n *(%x20 / %x09) ; \" \" and \\t\n\nbr =\n sp (line_comment / newline) sp ; break\n\nnewline =\n %x0A / %x0D.0A ; \\n and \\r\\n\n\nline_comment =\n \"//\" *not_newline newline\n\nnot_newline =\n %x09 / %x20-10FFFF ; Any character except newline\n\ndocumentation_comment =\n \"///\" *not_newline br\n\ncontrol_section =\n *(control_statement)\n\ncontrol_statement =\n \"$\" ws node_object_key ws \":\" ws node_value br\n\nversion_string =\n 1*DIGIT [ \".\" 1*DIGIT ]\n\nshape_id =\n root_shape_id [shape_id_member]\n\nroot_shape_id =\n absolute_root_shape_id / identifier\n\nabsolute_root_shape_id =\n namespace \"#\" identifier\n\nnamespace =\n identifier *(\".\" identifier)\n\nidentifier =\n (ALPHA / \"_\") *(ALPHA / DIGIT / \"_\")\n\nshape_id_member =\n \"$\" identifier\n\nnode_value =\n node_array\n / node_object\n / number\n / node_keywords\n / shape_id\n / text_block\n / quoted_text\n\nnode_array =\n empty_node_array / populated_node_array\n\nempty_node_array =\n \"[\" ws \"]\"\n\npopulated_node_array =\n \"[\" ws node_value ws\n *(comma node_value ws)\n trailing_comma \"]\"\n\ntrailing_comma =\n [comma]\n\ncomma =\n \",\" ws\n\nnode_object =\n empty_node_object / populated_node_object\n\nempty_node_object =\n \"{\" ws \"}\"\n\npopulated_node_object =\n \"{\" ws node_object_kvp ws\n *(comma node_object_kvp ws)\n trailing_comma \"}\"\n\nnode_object_kvp =\n node_object_key ws \":\" ws node_value\n\nnode_object_key =\n quoted_text / identifier\n\nnumber =\n [minus] int [frac] [exp]\n\ndecimal_point =\n %x2E ; .\n\ndigit1_9 =\n %x31-39 ; 1-9\n\ne =\n %x65 / %x45 ; e E\n\nexp =\n e [minus / plus] 1*DIGIT\n\nfrac =\n decimal_point 1*DIGIT\n\nint =\n zero / (digit1_9 *DIGIT)\n\nminus =\n %x2D ; -\n\nplus =\n %x2B ; +\n\nzero =\n %x30 ; 0\n\nnode_keywords =\n \"true\" / \"false\" / \"null\"\n\nquoted_text =\n DQUOTE *quoted_char DQUOTE\n\nquoted_char =\n %x20-21 ; space - \"!\"\n / %x23-5B ; \"#\" - \"[\"\n / %x5D-10FFFF ; \"]\"+\n / escaped_char\n / preserved_double\n\nescaped_char =\n escape (escape / \"'\" / DQUOTE / \"b\" / \"f\" / \"n\" / \"r\" / \"t\" / \"/\" / unicode_escape)\n\nunicode_escape =\n \"u\" hex hex hex hex\n\nhex =\n DIGIT / %x41-46 / %x61-66\n\npreserved_double =\n escape (%x20-21 / %x23-5B / %x5D-10FFFF)\n\nescape =\n %x5C ; backslash\n\ntext_block =\n three_dquotes br *quoted_char three_dquotes\n\nthree_dquotes =\n DQUOTE DQUOTE DQUOTE\n\nshape_section =\n [namespace_statement [use_section] [shape_statements]]\n\nnamespace_statement =\n \"namespace\" ws namespace br\n\nuse_section =\n *(use_statement)\n\nuse_statement =\n \"use\" ws absolute_root_shape_id br\n\nshape_statements =\n *(shape_statement / apply_statement)\n\nshape_statement =\n [shape_documentation_comments ws]\n trait_statements\n shape_body br\n\nshape_documentation_comments =\n *(documentation_comment)\n\nshape_body =\n simple_shape_statement\n / list_statement\n / set_statement\n / map_statement\n / structure_statement\n / union_statement\n / service_statement\n / operation_statement\n / resource_statement\n\nsimple_shape_statement =\n simple_type_name ws identifier\n\nsimple_type_name =\n \"blob\" / \"boolean\" / \"document\" / \"string\"\n / \"byte\" / \"short\" / \"integer\" / \"long\"\n / \"float\" / \"double\" / \"bigInteger\"\n / \"bigDecimal\" / \"timestamp\"\n\nshape_members =\n empty_shape_members / populated_shape_members\n\nempty_shape_members =\n \"{\" ws \"}\"\n\npopulated_shape_members =\n \"{\" ws shape_member_kvp\n *(comma shape_member_kvp ws) trailing_comma \"}\"\n\nshape_member_kvp =\n [shape_documentation_comments]\n trait_statements\n identifier ws \":\" ws shape_id\n\nlist_statement =\n \"list\" ws identifier ws shape_members\n\nset_statement =\n \"set\" ws identifier ws shape_members\n\nmap_statement =\n \"map\" ws identifier ws shape_members\n\nstructure_statement =\n \"structure\" ws identifier ws shape_members\n\nunion_statement =\n \"union\" ws identifier ws shape_members\n\nservice_statement =\n \"service\" ws identifier ws node_object\n\noperation_statement =\n \"operation\" ws identifier ws node_object\n\nresource_statement =\n \"resource\" ws identifier ws node_object\n\napply_statement =\n \"apply\" ws shape_id ws trait br\n\ntrait_statements =\n *(ws trait) ws\n\ntrait =\n \"@\" shape_id [trait_body]\n\ntrait_body =\n \"(\" ws trait_body_value ws \")\"\n\ntrait_body_value =\n trait_structure / node_value\n\ntrait_structure =\n trait_structure_kvp *(ws comma trait_structure_kvp)\n\ntrait_structure_kvp =\n node_object_key ws \":\" ws node_value\n\nmetadata_section =\n *(metadata_statement)\n\nmetadata_statement =\n \"metadata\" ws node_object_key ws \"=\" ws node_value br" }

{ "content": "$include \"uri.abnf\";\n\ndid-reference = did [ \"/\" did-path ] [ \"#\" did-fragment ];\nscheme = %x64 %x69 %x64;\ndid = scheme \":\" method \":\" specific-idstring;\nmethod = 1*methodchar;\nmethodchar = %x61-7A / DIGIT;\nspecific-idstring = idstring *( \":\" idstring );\nidstring = 1*idchar;\nidchar = ALPHA / DIGIT / \".\" / \"-\";\n\ndid-fragment = *( pchar / \"/\" / \"?\" );\ndid-path = path-abempty\n / path-absolute\n / path-noscheme\n / path-rootless\n / path-empty;\n" }

{ "content": "A = [b] A A\n" }

{ "content": "; grammar for ABNFs taken from RFC 5234 + RFC 7405,\n; slightly adapted and extended to PEGs\n\nrulelist = 1*( rule / (*c-wsp c-nl) )\n\nrule = rulename defined-as elements c-nl\n ; continues if next line starts\n ; with white space\n\nrulename = ALPHA *(ALPHA / DIGIT / \"-\")\n\ndefined-as = *c-wsp (\"=/\" / \"=\") *c-wsp\n ; basic rules definition and\n ; incremental alternatives\n ; different order due to PEG\n\nelements = alternation *c-wsp\n\nc-wsp = WSP / (c-nl WSP)\n\nc-nl = comment / CRLF\n ; comment or newline\n\ncomment = \";\" *(WSP / VCHAR) CRLF\n\nalternation = concatenation\n *(*c-wsp \"/\" *c-wsp concatenation)\n\nconcatenation = predicate *(1*c-wsp predicate)\n\npredicate = [\"&\" / \"!\"] repetition\n ; extension for PEGs\n\nrepetition = [repeat] element\n\nrepeat = (*DIGIT \"*\" *DIGIT) / 1*DIGIT\n ; different order due to PEG\n\nelement = rulename / group / option /\n char-val / num-val / prose-val\n\ngroup = \"(\" *c-wsp alternation *c-wsp \")\"\n\noption = \"[\" *c-wsp alternation *c-wsp \"]\"\n\nchar-val = case-insensitive-string /\n case-sensitive-string\n\ncase-insensitive-string =\n [ \"%i\" ] quoted-string\n\ncase-sensitive-string =\n \"%s\" quoted-string\n\nquoted-string = DQUOTE *(%x20-21 / %x23-7E) DQUOTE\n ; quoted string of SP and VCHAR\n ; without DQUOTE\n\nnum-val = \"%\" (bin-val / dec-val / hex-val)\n\nbin-val = \"b\" 1*BIT\n [ 1*(\".\" 1*BIT) / (\"-\" 1*BIT) ]\n ; series of concatenated bit values\n ; or single ONEOF range\n\ndec-val = \"d\" 1*DIGIT\n [ 1*(\".\" 1*DIGIT) / (\"-\" 1*DIGIT) ]\n\nhex-val = \"x\" 1*HEXDIG\n [ 1*(\".\" 1*HEXDIG) / (\"-\" 1*HEXDIG) ]\n\nprose-val = \"<\" *(%x20-3D / %x3F-7E) \">\"\n ; bracketed string of SP and VCHAR\n ; without angles\n ; prose description, to be used as\n ; last resort\n" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main = $command;\n$command = 唱歌|讲故事|播放歌曲|儿童故事|古诗词;\n" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN;\nmode voice;\n\nroot $main;\n$main = $order 给 $person;\n$order = 打电话;\n$person =" }

{ "content": "#ABNF 1.0 UTF-8;\nlanguage zh-CN; \nmode voice;\n\nroot $main;\n$main = 1|2|3|4|5|6|7|8|9|0;" }