ebnf 2.0.0 → 2.1.0

data/etc/iso-ebnf.isoebnf

@@ -0,0 +1,138 @@
+(* W3C EBNF for ISO/IEC 14977 : 1996 EBNF *)
+(* Scoured from https://www.cl.cam.ac.uk/~mgk25/iso-14977.pdf *)
+
+syntax            = syntax_rule, {syntax_rule} ;
+
+syntax_rule       = meta_identifier, defining_symbol, definitions_list, terminator_symbol
+                    (* A <syntax rule> defines the sequences of
+                       symbols represented by a <meta identifier> *);
+
+definitions_list  = single_definition, {definition_separator_symbol, definitions_list}
+                    (* | separates alternative <single definitions> *);
+
+single_definition = term, {',', term}
+                    (* , separates successive <terms> *);
+
+term              = factor, ['-', exception]
+                    (* A <term> represents any sequence of symbols that is defined by the <factor> but
+                       not defined by the <exception> *);
+
+exception         = factor
+                    (* A <factor> may be used as an <exception>
+                       if it could be replaced by a <factor>
+                        containingno<metaidentifiers> *);
+
+factor            = [integer, '*'], primary
+                    (* The <integer> specifies the number of repetitions of the <primary> *);
+
+primary           = optional_sequence
+                  | repeated_sequence
+                  | special_sequence
+                  | grouped_sequence
+                  | meta_identifier
+                  | terminal_string
+                  | empty
+                  ;
+
+optional_sequence = start_option_symbol, definitions_list, end_option_symbol
+                    (* The brackets [ and ] enclose symbols which are optional *);
+
+repeated_sequence = start_repeat_symbol, definitions_list, end_repeat_symbol
+                    (* The brackets { and } enclose symbols
+                       which may be repeated any number of times *);
+
+grouped_sequence  = '(', definitions_list, ')'
+                    (* The brackets ( and ) allow any <definitions list> to be a <primary> *);
+
+terminal_string             = ("'", first_terminal_character, {first_terminal_character}, "'")
+                            | ('"', second_terminal_character, {second_terminal_character}, '"')
+                              (* A <terminal string> represents the
+                                 <characters> between the quote symbols '_' or "_" *);
+
+meta_identifier   = letter, {meta_identifier_character}
+                    (* A <meta identifier> is the name of a syntactic element of the language being defined *);
+
+integer           = decimal_digit, {decimal_digit} ;
+
+special_sequence  = '?', {special_sequence_character}, '?'
+                    (* The meaning of a <special sequence> is not defined in the standard metalanguage. *);
+
+comment           = '(*', {comment_symbol}, '*)'
+                    (* A comment is allowed anywhere outside a
+                       <terminal string>, <meta identifier>,
+                       <integer> or <special sequence> *);
+
+comment_symbol    = comment | commentless_symbol | other_character ;
+
+commentless_symbol = terminal_character | meta_identifier | integer
+                   | terminal_string | special_sequence
+                   ;
+
+letter = "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" | "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"
+       ;
+
+decimal_digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+
+(* Extended to allow '_' *)
+meta_identifier_character   = letter | decimal_digit | '_' ;
+
+first_terminal_character    = terminal_character - "'" ;
+
+second_terminal_character   = terminal_character - '"' ;
+
+special_sequence_character  = terminal_character - '?' ;
+
+terminal_character          = letter
+                            | decimal_digit
+                            | concatenate_symbol
+                            | defining_symbol
+                            | definition_separator_symbol
+                            | end_comment_symbol
+                            | end_group_symbol
+                            | end_option_symbol
+                            | end_repeat_symbol
+                            | except_symbol
+                            | first_quote_symbol
+                            | repetition_symbol
+                            | second_quote_symbol
+                            | special_sequence_symbol
+                            | start_comment_symbol
+                            | start_group_symbol
+                            | start_option_symbol
+                            | start_repeat_symbol
+                            | terminator_symbol
+                            | other_character
+                            ;
+
+other_character            = ' ' | ':' | '+' | '_' | '%' | '@' | '&'
+                           | '#' | '$' | '<' | '>' | '\' | '^' | '`'
+                           | '~' ;
+
+empty                      = ;
+
+concatenate_symbol         = ',' ;
+repetition_symbol          = '*' ;
+except_symbol              = '-' ;
+first_quote_symbol         = "'" ;
+second_quote_symbol        = '"' ;
+start_comment_symbol       = '(*' ;
+end_comment_symbol         = '*)' ;
+start_group_symbol         = '(' ;
+end_group_symbol           = ')' ;
+special_sequence_symbol    = '?' ;
+
+(* Simple terminals that are often extended *)
+defining_symbol             = '=' | ':' ;
+definition_separator_symbol = '|' | '/' | '!' ;
+terminator_symbol           = ';' | '.' ;
+start_option_symbol         = '[' ;
+end_option_symbol           = ']' ;
+start_repeat_symbol         = '{' | '(:' ;
+end_repeat_symbol           = '}' | ':)' ;

data/etc/iso-ebnf.sxp

@@ -0,0 +1,65 @@
+    (
+     (rule syntax (star syntax_rule))
+     (rule syntax_rule
+      (seq meta_identifier defining_symbol definitions_list terminator_symbol))
+     (rule definitions_list
+      (seq single_definition (star (seq definition_separator_symbol definitions_list))))
+     (rule single_definition (seq term (star (seq "," term))))
+     (rule term (seq factor (opt (seq "-" exception))))
+     (rule exception (seq factor))
+     (rule factor (seq (opt (seq integer "*")) primary))
+     (rule primary
+      (alt optional_sequence repeated_sequence special_sequence grouped_sequence
+       meta_identifier terminal_string empty ))
+     (rule optional_sequence
+      (seq start_option_symbol definitions_list end_option_symbol))
+     (rule repeated_sequence
+      (seq start_repeat_symbol definitions_list end_repeat_symbol))
+     (rule grouped_sequence (seq "(" definitions_list ")"))
+     (terminals _terminals (seq))
+     (terminal terminal_string
+      (alt
+       (seq "'" (plus first_terminal_character) "'")
+       (seq "\"" (plus second_terminal_character) "\"")) )
+     (terminal meta_identifier (seq letter (star meta_identifier_character)))
+     (terminal integer (plus decimal_digit))
+     (terminal special_sequence (seq "?" (star special_sequence_character) "?"))
+     (terminal comment (seq start_comment_symbol (star comment_symbol) end_comment_symbol))
+     (terminal comment_symbol (alt comment commentless_symbol other_character))
+     (terminal commentless_symbol
+      (alt terminal_character meta_identifier integer terminal_string special_sequence))
+     (terminal letter (range "a-zA-Z"))
+     (terminal decimal_digit (range "0-9"))
+     (terminal meta_identifier_character (alt letter decimal_digit "_"))
+     (terminal first_terminal_character (diff terminal_character "'"))
+     (terminal second_terminal_character (diff terminal_character "\""))
+     (terminal special_sequence_character (diff terminal_character "?"))
+     (terminal terminal_character
+      (alt letter decimal_digit concatenate_symbol defining_symbol
+       definition_separator_symbol end_comment_symbol end_group_symbol
+       end_option_symbol end_repeat_symbol except_symbol first_quote_symbol
+       repetition_symbol second_quote_symbol special_sequence_symbol
+       start_comment_symbol start_group_symbol start_option_symbol
+       start_repeat_symbol terminator_symbol other_character ))
+     (terminal other_character (alt (range ":+_%@&$<>^` ̃#x20#x23") "\\"))
+     (terminal gap_separator (range "#x9#xa#xb#xc#xd#x20"))
+     (pass _pass (alt (plus gap_separator) comment))
+     (terminal empty (seq ""))
+     (terminal concatenate_symbol (seq ","))
+     (terminal repetition_symbol (seq "*"))
+     (terminal except_symbol (seq "-"))
+     (terminal first_quote_symbol (seq "'"))
+     (terminal second_quote_symbol (seq "\""))
+     (terminal start_comment_symbol (seq "(*"))
+     (terminal end_comment_symbol (seq "*)"))
+     (terminal start_group_symbol (seq "("))
+     (terminal end_group_symbol (seq ")"))
+     (terminal special_sequence_symbol (seq "?"))
+     (terminal defining_symbol (alt "=" ":"))
+     (terminal definition_separator_symbol (alt "|" "/" "!"))
+     (terminal terminator_symbol (alt ";" "."))
+     (terminal start_option_symbol (seq "["))
+     (terminal end_option_symbol (seq "]"))
+     (terminal start_repeat_symbol (alt "{" "(:"))
+     (terminal end_repeat_symbol (alt "}" ":)"))
+     (terminal gap_free_symbol (alt (diff terminal_character (range "'\"")) terminal_string)))

data/etc/sparql.ebnf

@@ -243,13 +243,13 @@
 
     @terminals
 
-    [139] IRIREF                  ::= '<' ([^#x00-#x20<>"{}|^`\] | UCHAR)* '>'
+    [139] IRIREF                  ::= '<' ([^<>"{}|^`\]-[#x00-#x20])* '>'
     [140] PNAME_NS                ::= PN_PREFIX? ':'
     [141] PNAME_LN                ::= PNAME_NS PN_LOCAL
     [142] BLANK_NODE_LABEL        ::= '_:' ( PN_CHARS_U | [0-9] ) ((PN_CHARS|'.')* PN_CHARS)?
     [143] VAR1                    ::= '?' VARNAME
     [144] VAR2                    ::= '$' VARNAME
-    [145] LANGTAG                 ::= '@' [a-zA-Z]+ ('-' [a-zA-Z0-9]+)*
+    [145] LANGTAG                 ::= '@' ([a-zA-Z])+ ('-' ([a-zA-Z0-9])+)*
     [146] INTEGER                 ::= [0-9]+
     [147] DECIMAL                 ::= [0-9]* '.' [0-9]+
     [148] DOUBLE                  ::= [0-9]+ '.' [0-9]* EXPONENT
@@ -269,7 +269,7 @@
     [161] NIL                     ::= '(' WS* ')'
     [162] WS                      ::= #x20 | #x9 | #xD | #xA
     [163] ANON                    ::= '[' WS* ']'
-    [164] PN_CHARS_BASE           ::= [A-Z] | [a-z] | [#x00C0-#x00D6]
+    [164] PN_CHARS_BASE           ::= [A-Za-z] | [#x00C0-#x00D6]
                                     | [#x00D8-#x00F6] | [#x00F8-#x02FF] | [#x0370-#x037D]
                                     | [#x037F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F]
                                     | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF]
@@ -283,6 +283,6 @@
     [169] PN_LOCAL                ::= ( PN_CHARS_U | [0-9] ) ((PN_CHARS|'.')* PN_CHARS)?
     [170] PLX                     ::= PERCENT | PN_LOCAL_ESC
     [171] PERCENT                 ::= '%' HEX HEX
-    [172] HEX                     ::= [0-9] | [A-F] | [a-f]
+    [172] HEX                     ::= [0-9A-Fa-f]
     [173] PN_LOCAL_ESC            ::= '\' ( '_' | '~' | '.' | '-' | '!' | '$' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | ';' | '='
                                     | '/' | '?' | '#' | '@' | '%' )

data/etc/sparql.sxp

@@ -282,7 +282,9 @@
      (rule iri "136" (alt IRIREF PrefixedName))
      (rule PrefixedName "137" (alt PNAME_LN PNAME_NS))
      (rule BlankNode "138" (alt BLANK_NODE_LABEL ANON))
-     (terminal IRIREF "139" (seq "<" (range "^#x00-#x20<>\"{}|^`] | UCHAR)* '>'")))
+     (terminals _terminals (seq))
+     (terminal IRIREF "139"
+      (seq "<" (star (diff (range "^<>\"{}|^`\\") (range "#x00-#x20"))) ">"))
      (terminal PNAME_NS "140" (seq (opt PN_PREFIX) ":"))
      (terminal PNAME_LN "141" (seq PNAME_NS PN_LOCAL))
      (terminal BLANK_NODE_LABEL "142"
@@ -310,17 +312,16 @@
      (terminal STRING_LITERAL2 "157"
       (seq "\"" (star (alt (range "^#x22#x5C#xA#xD") ECHAR)) "\""))
      (terminal STRING_LITERAL_LONG1 "158"
-      (seq "'''" (seq (opt (alt "'" "''")) (range "^'] | ECHAR ))* \"'''\""))))
+      (seq "'''" (star (seq (opt (alt "'" "''")) (alt (range "^'\\") ECHAR))) "'''"))
      (terminal STRING_LITERAL_LONG2 "159"
-      (seq "\"\"\"" (seq (opt (alt "\"" "\"\"")) (range "^\"] | ECHAR ))* '\"\"\"'"))))
-     (terminal ECHAR "160" (seq "\\" (range "tbnrf\"'")))
+      (seq "\"\"\"" (star (seq (opt (alt "\"" "\"\"")) (alt (range "^\"\\") ECHAR))) "\"\"\""))
+     (terminal ECHAR "160" (seq "\\" (range "tbnrf\\\"'")))
      (terminal NIL "161" (seq "(" (star WS) ")"))
      (terminal WS "162" (alt (hex "#x20") (hex "#x9") (hex "#xD") (hex "#xA")))
      (terminal ANON "163" (seq "[" (star WS) "]"))
      (terminal PN_CHARS_BASE "164"
       (alt
-       (range "A-Z")
-       (range "a-z")
+       (range "A-Za-z")
        (range "#x00C0-#x00D6")
        (range "#x00D8-#x00F6")
        (range "#x00F8-#x02FF")
@@ -355,7 +356,7 @@
       (seq (alt PN_CHARS_U (range "0-9")) (opt (seq (star (alt PN_CHARS ".")) PN_CHARS))))
      (terminal PLX "170" (alt PERCENT PN_LOCAL_ESC))
      (terminal PERCENT "171" (seq "%" HEX HEX))
-     (terminal HEX "172" (alt (range "0-9") (range "A-F") (range "a-f")))
+     (terminal HEX "172" (range "0-9A-Fa-f"))
      (terminal PN_LOCAL_ESC "173"
       (seq "\\"
        (alt "_" "~" "." "-" "!" "$" "&" "'" "(" ")" "*" "+" "," ";" "=" "/" "?" "#"

data/etc/turtle.ebnf

@@ -26,11 +26,11 @@
 
 @terminals
 
-[18] IRIREF                           ::=  '<' ([^#x00-#x20<>"{}|^`\] | UCHAR)* '>'
+[18] IRIREF                           ::= '<' ([^<>"{}|^`\]-[#x00-#x20] | UCHAR)* '>'
 [139s] PNAME_NS                       ::= PN_PREFIX? ":" 
 [140s] PNAME_LN                       ::= PNAME_NS PN_LOCAL 
 [141s] BLANK_NODE_LABEL               ::= '_:' ( PN_CHARS_U | [0-9] ) ((PN_CHARS|'.')* PN_CHARS)?
-[144s] LANGTAG                        ::= "@" [a-zA-Z]+ ( "-" [a-zA-Z0-9]+ )* 
+[144s] LANGTAG                        ::= "@" ([a-zA-Z])+ ( "-" ([a-zA-Z0-9])+ )* 
 [19] INTEGER                          ::= [+-]? [0-9]+
 [20] DECIMAL                          ::= [+-]?  ( ([0-9])* '.' ([0-9])+  )
 [21] DOUBLE                           ::= [+-]? ( [0-9]+ '.' [0-9]* EXPONENT | '.' ([0-9])+ EXPONENT | ([0-9])+ EXPONENT )
@@ -65,6 +65,6 @@
 [168s] PN_LOCAL                       ::= ( PN_CHARS_U | ':' | [0-9] | PLX ) ( ( PN_CHARS | '.' | ':' | PLX )*  ( PN_CHARS | ':' | PLX ) ) ?
 [169s] PLX                            ::= PERCENT | PN_LOCAL_ESC
 [170s] PERCENT                        ::= '%' HEX HEX
-[171s] HEX                            ::= [0-9] | [A-F] | [a-f]
+[171s] HEX                            ::= [0-9A-Fa-f]
 [172s] PN_LOCAL_ESC                   ::= '\' ( '_' | '~' | '.' | '-' | '!' | '$' | '&' | "'" | '(' | ')' | '*' | '+' | ',' | ';' | '='
                                         | '/' | '?' | '#' | '@' | '%' )

data/etc/turtle.sxp

@@ -4,6 +4,8 @@
      (rule directive "3" (alt prefixID base sparqlPrefix sparqlBase))
      (rule prefixID "4" (seq "@prefix" PNAME_NS IRIREF "."))
      (rule base "5" (seq "@base" IRIREF "."))
+     (rule sparqlPrefix "28s" (seq SPARQL_PREFIX PNAME_NS IRIREF))
+     (rule sparqlBase "29s" (seq SPARQL_BASE IRIREF))
      (rule triples "6"
       (alt
        (seq subject predicateObjectList)
@@ -19,10 +21,23 @@
      (rule blankNodePropertyList "14" (seq "[" predicateObjectList "]"))
      (rule collection "15" (seq "(" (star object) ")"))
      (rule NumericLiteral "16" (alt INTEGER DECIMAL DOUBLE))
+     (rule RDFLiteral "128s" (seq String (opt (alt LANGTAG (seq "^^" iri)))))
+     (rule BooleanLiteral "133s" (alt "true" "false"))
      (rule String "17"
       (alt STRING_LITERAL_QUOTE STRING_LITERAL_SINGLE_QUOTE
        STRING_LITERAL_LONG_SINGLE_QUOTE STRING_LITERAL_LONG_QUOTE ))
-     (terminal IRIREF "18" (seq "<" (range "^#x00-#x20<>\"{}|^`] | UCHAR)* '>'")))
+     (rule iri "135s" (alt IRIREF PrefixedName))
+     (rule PrefixedName "136s" (alt PNAME_LN PNAME_NS))
+     (rule BlankNode "137s" (alt BLANK_NODE_LABEL ANON))
+     (terminals _terminals (seq))
+     (terminal IRIREF "18"
+      (seq "<" (star (alt (diff (range "^<>\"{}|^`\\") (range "#x00-#x20")) UCHAR)) ">"))
+     (terminal PNAME_NS "139s" (seq (opt PN_PREFIX) ":"))
+     (terminal PNAME_LN "140s" (seq PNAME_NS PN_LOCAL))
+     (terminal BLANK_NODE_LABEL "141s"
+      (seq "_:" (alt PN_CHARS_U (range "0-9")) (opt (seq (star (alt PN_CHARS ".")) PN_CHARS))))
+     (terminal LANGTAG "144s"
+      (seq "@" (plus (range "a-zA-Z")) (star (seq "-" (plus (range "a-zA-Z0-9"))))))
      (terminal INTEGER "19" (seq (opt (range "+-")) (plus (range "0-9"))))
      (terminal DECIMAL "20"
       (seq (opt (range "+-")) (seq (star (range "0-9")) "." (plus (range "0-9")))))
@@ -33,34 +48,21 @@
         (seq (plus (range "0-9")) "." (star (range "0-9")) EXPONENT)
         (seq "." (plus (range "0-9")) EXPONENT)
         (seq (plus (range "0-9")) EXPONENT)) ))
+     (terminal EXPONENT "154s" (seq (range "eE") (opt (range "+-")) (plus (range "0-9"))))
      (terminal STRING_LITERAL_QUOTE "22"
       (seq "\"" (star (alt (range "^#x22#x5C#xA#xD") ECHAR UCHAR)) "\""))
      (terminal STRING_LITERAL_SINGLE_QUOTE "23"
       (seq "'" (star (alt (range "^#x27#x5C#xA#xD") ECHAR UCHAR)) "'"))
      (terminal STRING_LITERAL_LONG_SINGLE_QUOTE "24"
-      (seq "'''" (seq (opt (alt "'" "''")) (range "^'] | ECHAR | UCHAR ))* \"'''\""))))
+      (seq "'''" (star (seq (opt (alt "'" "''")) (alt (range "^'\\") ECHAR UCHAR))) "'''"))
      (terminal STRING_LITERAL_LONG_QUOTE "25"
-      (seq "\"\"\"" (seq (opt (alt "\"" "\"\"")) (range "^\"] | ECHAR | UCHAR ))* '\"\"\"'"))))
+      (seq "\"\"\"" (star (seq (opt (alt "\"" "\"\"")) (alt (range "^\"\\") ECHAR UCHAR))) "\"\"\""))
      (terminal UCHAR "26"
-      (alt (seq "u" HEX HEX HEX HEX) (seq "U" HEX HEX HEX HEX HEX HEX HEX HEX)))
-     (rule sparqlPrefix "28s" (seq SPARQL_PREFIX PNAME_NS IRIREF))
+      (alt (seq "\\u" HEX HEX HEX HEX) (seq "\\U" HEX HEX HEX HEX HEX HEX HEX HEX)))
+     (terminal ECHAR "159s" (seq "\\" (range "tbnrf\\\"'")))
      (terminal SPARQL_PREFIX "28t"
       (seq (range "Pp") (range "Rr") (range "Ee") (range "Ff") (range "Ii") (range "Xx")))
      (terminal SPARQL_BASE "29t" (seq (range "Bb") (range "Aa") (range "Ss") (range "Ee")))
-     (rule sparqlBase "29s" (seq SPARQL_BASE IRIREF))
-     (rule RDFLiteral "128s" (seq String (opt (alt LANGTAG (seq "^^" iri)))))
-     (rule BooleanLiteral "133s" (alt "true" "false"))
-     (rule iri "135s" (alt IRIREF PrefixedName))
-     (rule PrefixedName "136s" (alt PNAME_LN PNAME_NS))
-     (rule BlankNode "137s" (alt BLANK_NODE_LABEL ANON))
-     (terminal PNAME_NS "139s" (seq (opt PN_PREFIX) ":"))
-     (terminal PNAME_LN "140s" (seq PNAME_NS PN_LOCAL))
-     (terminal BLANK_NODE_LABEL "141s"
-      (seq "_:" (alt PN_CHARS_U (range "0-9")) (opt (seq (star (alt PN_CHARS ".")) PN_CHARS))))
-     (terminal LANGTAG "144s"
-      (seq "@" (plus (range "a-zA-Z")) (star (seq "-" (plus (range "a-zA-Z0-9"))))))
-     (terminal EXPONENT "154s" (seq (range "eE") (opt (range "+-")) (plus (range "0-9"))))
-     (terminal ECHAR "159s" (seq "\\" (range "tbnrf\"'")))
      (terminal WS "161s" (alt (hex "#x20") (hex "#x9") (hex "#xD") (hex "#xA")))
      (terminal ANON "162s" (seq "[" (star WS) "]"))
      (terminal PN_CHARS_BASE "163s"
@@ -94,7 +96,7 @@
        (opt (seq (star (alt PN_CHARS "." ":" PLX)) (alt PN_CHARS ":" PLX)))) )
      (terminal PLX "169s" (alt PERCENT PN_LOCAL_ESC))
      (terminal PERCENT "170s" (seq "%" HEX HEX))
-     (terminal HEX "171s" (alt (range "0-9") (range "A-F") (range "a-f")))
+     (terminal HEX "171s" (range "0-9A-Fa-f"))
      (terminal PN_LOCAL_ESC "172s"
       (seq "\\"
        (alt "_" "~" "." "-" "!" "$" "&" "'" "(" ")" "*" "+" "," ";" "=" "/" "?" "#"

data/lib/ebnf.rb

@@ -1,7 +1,10 @@
 module EBNF
+  autoload :ABNF,     "ebnf/abnf"
   autoload :Base,     "ebnf/base"
   autoload :BNF,      "ebnf/bnf"
+  autoload :ISOEBNF,  "ebnf/isoebnf"
   autoload :LL1,      "ebnf/ll1"
+  autoload :Native,   "ebnf/native"
   autoload :Parser,   "ebnf/parser"
   autoload :PEG,      "ebnf/peg"
   autoload :Rule,     "ebnf/rule"

data/lib/ebnf/abnf.rb

@@ -0,0 +1,301 @@
+require_relative 'abnf/core'
+require_relative 'abnf/meta'
+require 'logger'
+
+# ABNF parser
+# Parses ABNF into an array of {EBNF::Rule}.
+module EBNF
+  class ABNF
+    include EBNF::PEG::Parser
+
+    # Regular expressions for both "Core" and ABNF-specific terminals.
+    ALPHA = %r{[\x41-\x5A\x61-\x7A]}
+    VCHAR = %r{[\x20-\x7E]}
+    WSP = %r{[\x20\x09]}
+    CRLF = %r{\x0D?\x0A}
+    COMMENT = %r{;(?:#{WSP}|#{VCHAR})*#{CRLF}}
+    C_NL = %r{#{COMMENT}|#{CRLF}}
+    C_WSP = %r{#{WSP}|(?:#{C_NL}#{WSP})}
+
+    ##
+    # Hash of generated {EBNF::Rule} objects by symbol
+    #
+    # @return [Hash{Symbol => EBNF::Rule}]
+    attr_reader :parsed_rules
+
+    ##
+    # The following ABNF grammar rules are treated as terminals.
+
+    # `rulename     ::=  ALPHA (ALPHA | DIGIT | "-")*`
+    terminal(:rulename, /#{ALPHA}(?:#{ALPHA}|[0-9-])*/) do |value|
+      value.to_sym
+    end
+
+    # `defined_as   ::=  c_wsp* ("=" | "=/") c_wsp*`
+    terminal(:defined_as, /#{C_WSP}*=\/?#{C_WSP}*/) {|value| value.strip}
+
+    # `quoted_string::=  DQUOTE [#x20-#x21#x23-#x7E]* DQUOTE`
+    terminal(:quoted_string, /"[\x20-\x21\x23-\x7E]*"/) do |value|
+      value[1..-2]
+    end
+
+    # `bin_val      ::=  "b" BIT+ (("." BIT+)+ | ("-" BIT+))?`
+    terminal(:bin_val, /b[01]+(?:(?:(?:\.[01]+)+)|(?:-[01]+))?/) do |value|
+      if value.include?('.')
+        # Interpret segments in binary creating a sequence of hex characters or a string
+        hex_or_string(value[1..-1].split('.').map {|b| b.to_i(base=2).chr(Encoding::UTF_8)})
+      elsif value.include?('-')
+        # Interpret as a range
+        [:range, value[1..-1].split('-').map {|b| "#x%x" % b.to_i(base=2)}.join("-")]
+      else
+        # Interpret as a single HEX character
+        [:hex, "#x%x" % value[1..-1].to_i(base=2)]
+      end
+    end
+
+    # `dec_val      ::=  "d" DIGIT+ (("." DIGIT+)+ | ("-" DIGIT+))?`
+    terminal(:dec_val, /d[0-9]+(?:(?:(?:\.[0-9]+)+)|(?:-[0-9]+))?/) do |value|
+      if value.include?('.')
+        # Interpret segments in decimal creating a sequence of hex characters or a string
+        hex_or_string(value[1..-1].split('.').map {|b| b.to_i.chr(Encoding::UTF_8)})
+      elsif value.include?('-')
+        # Interpret as a range
+        [:range, value[1..-1].split('-').map {|d| "#x%x" % d.to_i}.join("-")]
+      else
+        # Interpret as a single HEX character
+        [:hex, "#x%x" % value[1..-1].to_i]
+      end
+    end
+
+    # `hex_val      ::=  "x" HEXDIG+  (("." HEXDIG+)+ | ("-" HEXDIG+))?`
+    terminal(:hex_val, /x[0-9A-F]+(?:(?:(?:\.[0-9A-F]+)+)|(?:-[0-9A-F]+))?/i) do |value|
+      if value.include?('.')
+        # Interpret segments in hexadecimal creating a sequence of hex characters or a string
+        hex_or_string(value[1..-1].split('.').map {|b| b.to_i(base=16).chr(Encoding::UTF_8)})
+      elsif value.include?('-')
+        # Interpret as a range
+        [:range, value[1..-1].split('-').map {|h| "#x%x" % h.to_i(base=16)}.join("-")]
+      else
+        # Interpret as a single HEX character
+        [:hex, "#x#{value[1..-1]}"]
+      end
+    end
+
+    # `c_wsp        ::=  WSP | (c_nl WSP)`
+    terminal(:c_wsp, C_WSP)
+
+    # `c_nl         ::=  comment | CRLF`
+    terminal(:c_nl, C_NL)
+
+    # `DIGIT        ::=  [#x30-#x39]`
+    terminal(:DIGIT, /\d/)
+
+    # ## Non-terminal productions
+
+    # The `start_production` on `:rule` allows the parser to present the value as a single Hash, rather than an array of individual hashes.
+    start_production(:rule, as_hash: true)
+
+    # `rule         ::=  rulename defined_as elements c_nl`
+    production(:rule) do |value|
+      # value contains an expression.
+      # Invoke callback
+      sym = value[:rulename]
+      elements = value[:elements]
+
+      if value[:defined_as] == "=/"
+        # append to rule alternate
+        rule = parsed_rules.fetch(sym) {raise "No existing rule found for #{sym}"}
+        rule.expr = [:alt, rule.expr] unless rule.alt?
+        if elements.is_a?(Array) && elements.first == :alt
+          # append alternatives to rule
+          rule.expr.concat(elements[1..-1])
+        else
+          # add elements as last alternative
+          rule.expr.push(elements)
+        end
+      else
+        # There shouldn't be an existing rule
+        raise "Redefining rule #{sym}" if parsed_rules.has_key?(sym)
+        parsed_rules[sym] = EBNF::Rule.new(sym.to_sym, nil, elements)
+      end
+      progress(:rule, level: 2) {parsed_rules[sym].to_sxp}
+      sym
+    end
+
+    # `elements     ::=  alternation c_wsp*`
+    production(:elements) do |value|
+      value.first[:alternation]
+    end
+
+    # `alternation  ::=  concatenation (c_wsp* "/" c_wsp* concatenation)*`
+    production(:alternation) do |value|
+      unless value.last[:_alternation_1].empty?
+        [:alt, value.first[:concatenation]] + value.last[:_alternation_1]
+      else
+        value.first[:concatenation]
+      end
+    end
+
+    # The `_aleteration_2` rule comes from the expanded PEG grammar and serves as an opportunity to custommize the values presented to the `aleteration` rule.
+    production(:_alternation_2) do |value|
+      if Array(value.last[:concatenation]).first == :alt
+        value.last[:concatenation][1..-1]
+      else
+        [value.last[:concatenation]]
+      end
+      value.last[:concatenation]
+    end
+
+    # `concatenation::=  repetition (c_wsp+ repetition)*`
+    production(:concatenation) do |value|
+      unless value.last[:_concatenation_1].empty?
+        [:seq, value.first[:repetition]] + value.last[:_concatenation_1]
+      else
+        value.first[:repetition]
+      end
+    end
+    start_production(:_concatenation_2, as_hash: true)
+    production(:_concatenation_2) do |value|
+      value[:repetition]
+    end
+
+    # `repetition   ::=  repeat? element`
+    production(:repetition) do |value|
+      rept = value.first[:_repetition_1]
+      elt = value.last[:element]
+      case rept
+      when [0, '*'] then [:star, elt]
+      when [1, '*'] then [:plus, elt]
+      when nil      then elt
+      else
+        [:rept, rept.first, rept.last, elt]
+      end
+    end
+
+    # `repeat       ::=  DIGIT+ | (DIGIT* "*" DIGIT*)`
+    production(:repeat) do |value|
+      if value.is_a?(Integer)
+        [value, value]
+      else
+        [value.first, value.last]
+      end
+    end
+    start_production(:_repeat_1, as_hash: true)
+    production(:_repeat_1) {|value| value.values}
+    production(:_repeat_2) {|value| value.join("").to_i}
+    production(:_repeat_3) {|value| value.join("").to_i}
+    production(:_repeat_4) {|value| value.length > 0 ? value.join("").to_i : '*'}
+
+    # `element      ::=  rulename | group | option | char_val | num_val | prose_val`
+    production(:element) do |value|
+      value
+    end
+
+    # `group        ::=  "(" c_wsp* alternation c_wsp* ")"`
+    start_production(:group, as_hash: true)
+    production(:group) do |value|
+      value[:alternation]
+    end
+
+    # `option       ::=  "[" c_wsp* alternation c_wsp* "]"`
+    start_production(:option, as_hash: true)
+    production(:option) do |value|
+      [:opt, value[:alternation]]
+    end
+
+    # `case_insensitive_string ::= "%i"? quoted_string`
+    production(:case_insensitive_string) do |value|
+      str = value.last[:quoted_string]
+      if str.match?(/[[:alpha:]]/)
+        # Only need to use case-insensitive if there are alphabetic characters in the string.
+        [:istr, value.last[:quoted_string]]
+      else
+        value.last[:quoted_string]
+      end
+    end
+
+    # `case_sensitive_string ::= "%s" quoted_string`
+    production(:case_sensitive_string) do |value|
+      value.last[:quoted_string]
+    end
+
+    # `num_val      ::=  "%" (bin_val | dec_val | hex_val)`
+    production(:num_val) do |value|
+      value.last[:_num_val_1]
+    end
+
+    # ## Parser invocation.
+    # On start, yield ourselves if a block is given, otherwise, return this parser instance
+    #
+    # @param  [#read, #to_s]          input
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Boolean] :level
+    #   Trace level. 0(debug), 1(info), 2(warn), 3(error).
+    # @return [EBNFParser]
+    def initialize(input, **options)
+      # If the `level` option is set, instantiate a logger for collecting trace information.
+      if options.has_key?(:level)
+        options[:logger] = Logger.new(STDERR)
+        options[:logger].level = options[:level]
+        options[:logger].formatter = lambda {|severity, datetime, progname, msg| "#{severity} #{msg}\n"}
+      end
+
+      # Read input, if necessary, which will be used in a Scanner.
+      @input = input.respond_to?(:read) ? input.read : input.to_s
+
+      @parsed_rules = {}
+
+      # Parses into `@parsed_rules`
+      parse(@input,
+            :rulelist,        # Starting rule
+            ABNFMeta::RULES,  # PEG rules
+            whitespace: '',   # No implicit whitespace
+            **options)
+    rescue EBNF::PEG::Parser::Error => e
+      raise SyntaxError, e.message
+    end
+
+    ##
+    # The AST includes the parsed rules along with built-in rules for ABNF used within the parsed grammar.
+    #
+    # @return [Array<EBNF::Rule>]
+    def ast
+      # Add built-in rules for standard ABNF rules not 
+      parsed_rules.values.map(&:symbols).flatten.uniq.each do |sym|
+        rule = ABNFCore::RULES.detect {|r| r.sym == sym}
+        parsed_rules[sym] ||= rule if rule
+      end
+
+      parsed_rules.values
+    end
+
+  private
+    # Generate a combination of seq and string to represent a sequence of characters
+    #
+    # @param [Array<String>] characters
+    # @return [String,Array]
+    def hex_or_string(characters)
+      seq = [:seq]
+      str_result = ""
+      characters.each do |c|
+        if VCHAR.match?(c)
+          str_result << c
+        else
+          if str_result.length > 0
+            seq << str_result
+            str_result = ""
+          end
+          seq << [:hex, "#x%x" % c.codepoints.first]
+        end
+      end
+      seq << str_result if str_result.length > 0
+
+      # Either return the sequence, or a string
+      if seq.length == 2 && seq.last.is_a?(String)
+        seq.last
+      else
+        seq
+      end
+    end
+  end
+end