edn-abnf 0.5.40 → 0.5.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de28a614a741d47c75211e7ce766b896eebba945650b50064c1396113ebedab5
-  data.tar.gz: d41d07de68ab73180ce660292ec6de440611f77053606a4d9288decd833b0190
+  metadata.gz: 0fdf950deb0a96865e863046f39d4071d3856ce24fc476c1f96077457002b8d8
+  data.tar.gz: 3920f2ebfb1b4dacc025d86f8bcb6fc2ed3e59694ec174ba6c1f50ccd5650dc6
 SHA512:
-  metadata.gz: 584bd20fd1b50db4a40e8cef5200ad70957e4420cb2c593ea228e309102c4ae25c00632246f411c0bb9046571206239b1360180b5b7d467f9ef0f6eee9ad14f4
-  data.tar.gz: e8bdb98fcf3be1ef80d67738154cc4428e8420964e3f3492dcf478c4a95f46fe16663780a1ba6f4065e2caaac66d76c9c8b559e4ef9431f41a080faf346f13b3
+  metadata.gz: 14148161150b25960f24543bb03c673632af5c8302a5773e15863b88ade9c3a9ef20e6db2ec67bbb3a58bada47c673d8f32d877df11bd0a79d9619ab43e42c1f
+  data.tar.gz: 2ad6f10909561f0a87e59c87efdbecedb1b6bbf14a559fa59c6154d9d45d550a91e2e36850457c415118d6de93b8968a9b3053e65ad1d25de368e60e54aee350

data/edn-abnf.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "edn-abnf"
-  s.version = "0.5.40"
+  s.version = "0.5.41"
   s.summary = "CBOR Extended Diagnostic Notation (EDN) implemented in ABNF"
   s.description = %q{edn-abnf implements converters and miscellaneous tools for CBOR EDN's ABNF}
   s.author = "Carsten Bormann"

data/lib/parser/edngrammar.rb

@@ -127,6 +127,23 @@ module EDNGRAMMAR
     r0
   end
 
+  module Item0
+    def spec
+      elements[1]
+    end
+  end
+
+  module Item1
+    def ast
+        val = elements[0].ast
+        if ei = spec.text_value[1..-1]
+           # warn "*** implementing encoding indicator #{ei.inspect} for #{elements[0].text_value}"
+           val = CBOR::Box.from_instance(val, {ei: ei})
+        end
+        val
+      end
+  end
+
   def _nt_item
     start_index = index
     if node_cache[:item].has_key?(index)
@@ -154,25 +171,59 @@ module EDNGRAMMAR
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
         else
-          r4 = _nt_number
+          i4, s4 = index, []
+          i5 = index
+          r6 = _nt_number
+          if r6
+            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+            r5 = r6
+          else
+            r7 = _nt_string
+            if r7
+              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+              r5 = r7
+            else
+              r8 = _nt_prefixed
+              if r8
+                r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+                r5 = r8
+              else
+                @index = i5
+                r5 = nil
+              end
+            end
+          end
+          s4 << r5
+          if r5
+            r9 = _nt_spec
+            s4 << r9
+          end
+          if s4.last
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            r4.extend(Item0)
+            r4.extend(Item1)
+          else
+            @index = i4
+            r4 = nil
+          end
           if r4
             r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
             r0 = r4
           else
-            r5 = _nt_simple
-            if r5
-              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
-              r0 = r5
+            r10 = _nt_simple
+            if r10
+              r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
+              r0 = r10
             else
-              r6 = _nt_string
-              if r6
-                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
-                r0 = r6
+              r11 = _nt_ellipsis
+              if r11
+                r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+                r0 = r11
               else
-                r7 = _nt_streamstring
-                if r7
-                  r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
-                  r0 = r7
+                r12 = _nt_streamstring
+                if r12
+                  r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+                  r0 = r12
                 else
                   @index = i0
                   r0 = nil
@@ -189,227 +240,56 @@ module EDNGRAMMAR
     r0
   end
 
-  module String10
-    def spec
-      elements[1]
-    end
-  end
-
-  module String11
-    def ast
-      val = elements[0].ast
-      if ei = spec.text_value[1..-1]
-         # warn "*** implementing encoding indicator #{ei.inspect} for #{elements[0].text_value}"
-         val = CBOR::Box.from_instance(val, {ei: ei})
-      end
-      val
-    end
-  end
-
-  def _nt_string1
-    start_index = index
-    if node_cache[:string1].has_key?(index)
-      cached = node_cache[:string1][index]
-      if cached
-        node_cache[:string1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    i1 = index
-    r2 = _nt_tstr
-    if r2
-      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-      r1 = r2
-    else
-      r3 = _nt_bstr
-      if r3
-        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-        r1 = r3
-      else
-        @index = i1
-        r1 = nil
-      end
-    end
-    s0 << r1
-    if r1
-      r4 = _nt_spec
-      s0 << r4
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(String10)
-      r0.extend(String11)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:string1][start_index] = r0
-
-    r0
-  end
-
-  def _nt_string
+  def _nt_number
     start_index = index
-    if node_cache[:string].has_key?(index)
-      cached = node_cache[:string][index]
+    if node_cache[:number].has_key?(index)
+      cached = node_cache[:number][index]
       if cached
-        node_cache[:string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0 = index
-    r1 = _nt_string1
+    r1 = _nt_hexfloat
     if r1
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
     else
-      r2 = _nt_ellipsis
+      r2 = _nt_hexint
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:string][start_index] = r0
-
-    r0
-  end
-
-  module Ellipsis0
-    def ast; CBOR::Tagged.new(888, nil) end
-  end
-
-  def _nt_ellipsis
-    start_index = index
-    if node_cache[:ellipsis].has_key?(index)
-      cached = node_cache[:ellipsis][index]
-      if cached
-        node_cache[:ellipsis][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      if (match_len = has_terminal?(".", false, index))
-        r1 = true
-        @index += match_len
-      else
-        terminal_parse_failure('"."')
-        r1 = nil
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    if s0.size < 3
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Ellipsis0)
-      r0.extend(Ellipsis0)
-    end
-
-    node_cache[:ellipsis][start_index] = r0
-
-    r0
-  end
-
-  module Number0
-    def spec
-      elements[1]
-    end
-  end
-
-  module Number1
-    def ast
-      val = elements[0].ast
-  
-      if ei = spec.text_value[1..-1]
-         # warn "*** implementing encoding indicator #{ei.inspect} for #{elements[0].text_value}"
-         val = CBOR::Box.from_instance(val, {ei: ei})
-      end
-      val
-    end
-  end
-
-  def _nt_number
-    start_index = index
-    if node_cache[:number].has_key?(index)
-      cached = node_cache[:number][index]
-      if cached
-        node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    i1 = index
-    r2 = _nt_hexfloat
-    if r2
-      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-      r1 = r2
-    else
-      r3 = _nt_hexint
-      if r3
-        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-        r1 = r3
-      else
-        r4 = _nt_octint
-        if r4
-          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
-          r1 = r4
+        r3 = _nt_octint
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
         else
-          r5 = _nt_binint
-          if r5
-            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
-            r1 = r5
+          r4 = _nt_binint
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
           else
-            r6 = _nt_decnumber
-            if r6
-              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
-              r1 = r6
+            r5 = _nt_decnumber
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
             else
-              r7 = _nt_nonfin
-              if r7
-                r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
-                r1 = r7
+              r6 = _nt_nonfin
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
               else
-                @index = i1
-                r1 = nil
+                @index = i0
+                r0 = nil
               end
             end
           end
         end
       end
     end
-    s0 << r1
-    if r1
-      r8 = _nt_spec
-      s0 << r8
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Number0)
-      r0.extend(Number1)
-    else
-      @index = i0
-      r0 = nil
-    end
 
     node_cache[:number][start_index] = r0
 
@@ -1166,36 +1046,124 @@ module EDNGRAMMAR
     r0
   end
 
-  module Simple0
-    def ast; false end
-  end
-
-  module Simple1
-    def ast; true end
-  end
-
-  module Simple2
-    def ast; nil end
-  end
-
-  module Simple3
-    def ast; CBOR::Simple.new(23) end
-  end
-
-  module Simple4
-    def S1
-      elements[1]
-    end
-
-    def simple_number
-      elements[2]
-    end
-
-    def S2
-      elements[3]
+  def _nt_string
+    start_index = index
+    if node_cache[:string].has_key?(index)
+      cached = node_cache[:string][index]
+      if cached
+        node_cache[:string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
     end
 
-  end
+    i0 = index
+    r1 = _nt_dqstr
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_rawstring
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        r3 = _nt_sqstr
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          r4 = _nt_embedded
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:string][start_index] = r0
+
+    r0
+  end
+
+  module Ellipsis0
+    def ast; CBOR::Tagged.new(888, nil) end
+  end
+
+  def _nt_ellipsis
+    start_index = index
+    if node_cache[:ellipsis].has_key?(index)
+      cached = node_cache[:ellipsis][index]
+      if cached
+        node_cache[:ellipsis][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if (match_len = has_terminal?(".", false, index))
+        r1 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"."')
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.size < 3
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Ellipsis0)
+      r0.extend(Ellipsis0)
+    end
+
+    node_cache[:ellipsis][start_index] = r0
+
+    r0
+  end
+
+  module Simple0
+    def ast; false end
+  end
+
+  module Simple1
+    def ast; true end
+  end
+
+  module Simple2
+    def ast; nil end
+  end
+
+  module Simple3
+    def ast; CBOR::Simple.new(23) end
+  end
+
+  module Simple4
+    def S1
+      elements[1]
+    end
+
+    def simple_number
+      elements[2]
+    end
+
+    def S2
+      elements[3]
+    end
+
+  end
 
   module Simple5
     def ast; CBOR::Simple(simple_number.text_value.to_i) end
@@ -1768,26 +1736,26 @@ module EDNGRAMMAR
     r0
   end
 
-  module AppPrefix0
+  module Prefix0
     def lcalpha
       elements[0]
     end
 
   end
 
-  module AppPrefix1
+  module Prefix1
     def ucalpha
       elements[0]
     end
 
   end
 
-  def _nt_app_prefix
+  def _nt_prefix
     start_index = index
-    if node_cache[:app_prefix].has_key?(index)
-      cached = node_cache[:app_prefix][index]
+    if node_cache[:prefix].has_key?(index)
+      cached = node_cache[:prefix][index]
       if cached
-        node_cache[:app_prefix][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:prefix][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -1812,7 +1780,7 @@ module EDNGRAMMAR
     end
     if s1.last
       r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(AppPrefix0)
+      r1.extend(Prefix0)
     else
       @index = i1
       r1 = nil
@@ -1839,7 +1807,7 @@ module EDNGRAMMAR
       end
       if s5.last
         r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        r5.extend(AppPrefix1)
+        r5.extend(Prefix1)
       else
         @index = i5
         r5 = nil
@@ -1853,248 +1821,167 @@ module EDNGRAMMAR
       end
     end
 
-    node_cache[:app_prefix][start_index] = r0
+    node_cache[:prefix][start_index] = r0
 
     r0
   end
 
-  module AppString0
-    def app_prefix
-      elements[0]
-    end
-
-    def sqstr
-      elements[1]
+  module Prefixed0
+    def ast1(pref)
+           data = ast.force_encoding(Encoding::UTF_8) # XXX undo .b
+           begin
+             ::EDNGRAMMAR::APPS[pref].decode(pref, data)
+           rescue CBOR_DIAG::AppParseError => e
+             app_parser_level1_diagnostics(e, elements[1])
+             raise e
+           end
     end
   end
 
-  module AppString1
-  end
-
-  module AppString2
-    def ast                       # XXX ignoring h and b64
-      data = elements[0].sqstr.ast.force_encoding(Encoding::UTF_8) # XXX undo .b
-      app = elements[0].app_prefix.text_value
-      begin
-        ::EDNGRAMMAR::APPS[app].decode(app, data)
-      rescue CBOR_DIAG::AppParseError => e
-        app_parser_level1_diagnostics(e, elements[0].elements[1].elements[1])
-        raise e
-      end
+  module Prefixed1
+    def ast1(pref)
+           data = ast.force_encoding(Encoding::UTF_8) # XXX undo .b
+           begin
+             ::EDNGRAMMAR::APPS[pref].decode(pref, data)
+           rescue CBOR_DIAG::AppParseError => e
+             app_parser_level1_raw_diagnostics(e, elements[1])
+             raise e
+           end
     end
   end
 
-  def _nt_app_string
-    start_index = index
-    if node_cache[:app_string].has_key?(index)
-      cached = node_cache[:app_string][index]
-      if cached
-        node_cache[:app_string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    i1, s1 = index, []
-    r2 = _nt_app_prefix
-    s1 << r2
-    if r2
-      r3 = _nt_sqstr
-      s1 << r3
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(AppString0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      i4 = index
-      r5 = lambda {|x| pref = x[0].app_prefix.text_value
-                           ret = !$options.integrated || !["h", "b64", "dt"].include?(pref)
-                           ret}.call(s0)
-      if !r5
-        terminal_parse_failure("<semantic predicate>")
+  module Prefixed2
+    def ast1(pref)
+        args = seq.ast
+        ::EDNGRAMMAR::APPS[pref].decode(pref, args)
       end
-      if r5
-        @index = i4
-        r4 = instantiate_node(SyntaxNode,input, index...index)
-      else
-        @index = i4
-        r4 = nil
-      end
-      s0 << r4
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(AppString1)
-      r0.extend(AppString2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:app_string][start_index] = r0
-
-    r0
   end
 
-  module AppSequence0
-    def app_prefix
+  module Prefixed3
+    def prefix
       elements[0]
     end
 
-    def seq
-      elements[2]
-    end
-
   end
 
-  module AppSequence1
-    def ast
-      args = seq.ast
-      app = app_prefix.text_value
-      # Find a better place to put a default initialization
-      ::EDNGRAMMAR::APPS[app].decode(app, args)
-    end
+  module Prefixed4
+    def ast; elements[2].ast1(prefix.text_value); end
   end
 
-  def _nt_app_sequence
+  def _nt_prefixed
     start_index = index
-    if node_cache[:app_sequence].has_key?(index)
-      cached = node_cache[:app_sequence][index]
+    if node_cache[:prefixed].has_key?(index)
+      cached = node_cache[:prefixed][index]
       if cached
-        node_cache[:app_sequence][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:prefixed][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
-    i0, s0 = index, []
-    r1 = _nt_app_prefix
-    s0 << r1
-    if r1
-      if (match_len = has_terminal?("<<", false, index))
-        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-        @index += match_len
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_prefix
+    s1 << r2
+    if r2
+      i3 = index
+      r4 = lambda {|(pr)| @pref = pr.text_value;
+                          !$options.integrated || !["h", "b64", "dt"].include?(@pref)}.call(s1)
+      if !r4
+        terminal_parse_failure("<semantic predicate>")
+      end
+      if r4
+        @index = i3
+        r3 = instantiate_node(SyntaxNode,input, index...index)
       else
-        terminal_parse_failure('"<<"')
-        r2 = nil
+        @index = i3
+        r3 = nil
       end
-      s0 << r2
-      if r2
-        r3 = _nt_seq
-        s0 << r3
-        if r3
-          if (match_len = has_terminal?(">>", false, index))
-            r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-            @index += match_len
+      s1 << r3
+      if r3
+        i5 = index
+        r6 = _nt_sqstr
+        r6.extend(Prefixed0)
+        r6.extend(Prefixed0)
+        if r6
+          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+          r5 = r6
+        else
+          r7 = _nt_rawstring
+          r7.extend(Prefixed1)
+          r7.extend(Prefixed1)
+          if r7
+            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+            r5 = r7
           else
-            terminal_parse_failure('">>"')
-            r4 = nil
+            r8 = _nt_embedded
+            r8.extend(Prefixed2)
+            r8.extend(Prefixed2)
+            if r8
+              r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
+              r5 = r8
+            else
+              @index = i5
+              r5 = nil
+            end
           end
-          s0 << r4
         end
+        s1 << r5
       end
     end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(AppSequence0)
-      r0.extend(AppSequence1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:app_sequence][start_index] = r0
-
-    r0
-  end
-
-  module AppRstring0
-    def app_prefix
-      elements[0]
-    end
-
-    def rawstring
-      elements[1]
-    end
-  end
-
-  module AppRstring1
-  end
-
-  module AppRstring2
-  
-    def ast                       # XXX ignoring h and b64
-      data = elements[0].rawstring.ast.force_encoding(Encoding::UTF_8) # XXX undo .b
-      app = elements[0].app_prefix.text_value
-      begin
-        ::EDNGRAMMAR::APPS[app].decode(app, data)
-      rescue CBOR_DIAG::AppParseError => e
-        app_parser_level1_raw_diagnostics(e, elements[0].elements[1].elements[1])
-        raise e
-      end
-    end
-  end
-
-  def _nt_app_rstring
-    start_index = index
-    if node_cache[:app_rstring].has_key?(index)
-      cached = node_cache[:app_rstring][index]
-      if cached
-        node_cache[:app_rstring][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    i1, s1 = index, []
-    r2 = _nt_app_prefix
-    s1 << r2
-    if r2
-      r3 = _nt_rawstring
-      s1 << r3
-    end
     if s1.last
       r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(AppRstring0)
+      r1.extend(Prefixed3)
+      r1.extend(Prefixed4)
     else
       @index = i1
       r1 = nil
     end
-    s0 << r1
     if r1
-      i4 = index
-      r5 = lambda {|x| pref = x[0].app_prefix.text_value
-                           ret = !$options.integrated || !["h", "b64", "dt"].include?(pref)
-                           ret}.call(s0)
-      if !r5
-        terminal_parse_failure("<semantic predicate>")
-      end
-      if r5
-        @index = i4
-        r4 = instantiate_node(SyntaxNode,input, index...index)
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r9 = _nt_sq_app_string_h
+      if r9
+        r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+        r0 = r9
       else
-        @index = i4
-        r4 = nil
+        r10 = _nt_sq_app_string_b64
+        if r10
+          r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
+          r0 = r10
+        else
+          r11 = _nt_sq_app_string_dt
+          if r11
+            r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+            r0 = r11
+          else
+            r12 = _nt_raw_app_string_h
+            if r12
+              r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
+              r0 = r12
+            else
+              r13 = _nt_raw_app_string_b64
+              if r13
+                r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+                r0 = r13
+              else
+                r14 = _nt_raw_app_string_dt
+                if r14
+                  r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
+                  r0 = r14
+                else
+                  @index = i0
+                  r0 = nil
+                end
+              end
+            end
+          end
+        end
       end
-      s0 << r4
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(AppRstring1)
-      r0.extend(AppRstring2)
-    else
-      @index = i0
-      r0 = nil
     end
 
-    node_cache[:app_rstring][start_index] = r0
+    node_cache[:prefixed][start_index] = r0
 
     r0
   end
@@ -2481,40 +2368,40 @@ module EDNGRAMMAR
     r0
   end
 
-  module Sqstr0
-    def SQUOTE1
+  module Dqstr0
+    def DQUOTE1
       elements[0]
     end
 
-    def SQUOTE2
+    def DQUOTE2
       elements[2]
     end
   end
 
-  module Sqstr1
+  module Dqstr1
     def ast
-      elements[1].elements.map {|x| x.ast}.join.b # XXX .b
+      elements[1].elements.map {|x| x.ast}.join
     end
   end
 
-  def _nt_sqstr
+  def _nt_dqstr
     start_index = index
-    if node_cache[:sqstr].has_key?(index)
-      cached = node_cache[:sqstr][index]
+    if node_cache[:dqstr].has_key?(index)
+      cached = node_cache[:dqstr][index]
       if cached
-        node_cache[:sqstr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:dqstr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0, s0 = index, []
-    r1 = _nt_SQUOTE
+    r1 = _nt_DQUOTE
     s0 << r1
     if r1
       s2, i2 = [], index
       loop do
-        r3 = _nt_single_quoted
+        r3 = _nt_double_quoted
         if r3
           s2 << r3
         else
@@ -2524,366 +2411,58 @@ module EDNGRAMMAR
       r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
       s0 << r2
       if r2
-        r4 = _nt_SQUOTE
+        r4 = _nt_DQUOTE
         s0 << r4
       end
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Sqstr0)
-      r0.extend(Sqstr1)
+      r0.extend(Dqstr0)
+      r0.extend(Dqstr1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:sqstr][start_index] = r0
-
-    r0
-  end
-
-  module Bstr0
-    def sq_app_string_h
-      elements[0]
-    end
-
-  end
-
-  module Bstr1
-    def ast; elements[0].ast end
-  end
-
-  module Bstr2
-    def sq_app_string_b64
-      elements[0]
-    end
-
-  end
-
-  module Bstr3
-    def ast; elements[0].ast end
-  end
-
-  module Bstr4
-    def raw_app_string_h
-      elements[0]
-    end
-
-  end
-
-  module Bstr5
-    def ast; elements[0].ast end
-  end
-
-  module Bstr6
-    def raw_app_string_b64
-      elements[0]
-    end
-
-  end
-
-  module Bstr7
-    def ast; elements[0].ast end
-  end
-
-  module Bstr8
-    def sq_app_string_dt
-      elements[0]
-    end
-
-  end
-
-  module Bstr9
-    def ast; elements[0].ast end
-  end
-
-  module Bstr10
-    def raw_app_string_dt
-      elements[0]
-    end
-
-  end
-
-  module Bstr11
-    def ast; elements[0].ast end
-  end
-
-  def _nt_bstr
-    start_index = index
-    if node_cache[:bstr].has_key?(index)
-      cached = node_cache[:bstr][index]
-      if cached
-        node_cache[:bstr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_sq_app_string_h
-    s1 << r2
-    if r2
-      i3 = index
-      r4 = lambda {|x|$options.integrated}.call(s1)
-      if !r4
-        terminal_parse_failure("<semantic predicate>")
-      end
-      if r4
-        @index = i3
-        r3 = instantiate_node(SyntaxNode,input, index...index)
-      else
-        @index = i3
-        r3 = nil
-      end
-      s1 << r3
-    end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Bstr0)
-      r1.extend(Bstr1)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
-      r0 = r1
-    else
-      i5, s5 = index, []
-      r6 = _nt_sq_app_string_b64
-      s5 << r6
-      if r6
-        i7 = index
-        r8 = lambda {|x|$options.integrated}.call(s5)
-        if !r8
-          terminal_parse_failure("<semantic predicate>")
-        end
-        if r8
-          @index = i7
-          r7 = instantiate_node(SyntaxNode,input, index...index)
-        else
-          @index = i7
-          r7 = nil
-        end
-        s5 << r7
-      end
-      if s5.last
-        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        r5.extend(Bstr2)
-        r5.extend(Bstr3)
-      else
-        @index = i5
-        r5 = nil
-      end
-      if r5
-        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
-        r0 = r5
-      else
-        i9, s9 = index, []
-        r10 = _nt_raw_app_string_h
-        s9 << r10
-        if r10
-          i11 = index
-          r12 = lambda {|x|$options.integrated}.call(s9)
-          if !r12
-            terminal_parse_failure("<semantic predicate>")
-          end
-          if r12
-            @index = i11
-            r11 = instantiate_node(SyntaxNode,input, index...index)
-          else
-            @index = i11
-            r11 = nil
-          end
-          s9 << r11
-        end
-        if s9.last
-          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
-          r9.extend(Bstr4)
-          r9.extend(Bstr5)
-        else
-          @index = i9
-          r9 = nil
-        end
-        if r9
-          r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
-          r0 = r9
-        else
-          i13, s13 = index, []
-          r14 = _nt_raw_app_string_b64
-          s13 << r14
-          if r14
-            i15 = index
-            r16 = lambda {|x|$options.integrated}.call(s13)
-            if !r16
-              terminal_parse_failure("<semantic predicate>")
-            end
-            if r16
-              @index = i15
-              r15 = instantiate_node(SyntaxNode,input, index...index)
-            else
-              @index = i15
-              r15 = nil
-            end
-            s13 << r15
-          end
-          if s13.last
-            r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
-            r13.extend(Bstr6)
-            r13.extend(Bstr7)
-          else
-            @index = i13
-            r13 = nil
-          end
-          if r13
-            r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
-            r0 = r13
-          else
-            i17, s17 = index, []
-            r18 = _nt_sq_app_string_dt
-            s17 << r18
-            if r18
-              i19 = index
-              r20 = lambda {|x|$options.integrated}.call(s17)
-              if !r20
-                terminal_parse_failure("<semantic predicate>")
-              end
-              if r20
-                @index = i19
-                r19 = instantiate_node(SyntaxNode,input, index...index)
-              else
-                @index = i19
-                r19 = nil
-              end
-              s17 << r19
-            end
-            if s17.last
-              r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
-              r17.extend(Bstr8)
-              r17.extend(Bstr9)
-            else
-              @index = i17
-              r17 = nil
-            end
-            if r17
-              r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
-              r0 = r17
-            else
-              i21, s21 = index, []
-              r22 = _nt_raw_app_string_dt
-              s21 << r22
-              if r22
-                i23 = index
-                r24 = lambda {|x|$options.integrated}.call(s21)
-                if !r24
-                  terminal_parse_failure("<semantic predicate>")
-                end
-                if r24
-                  @index = i23
-                  r23 = instantiate_node(SyntaxNode,input, index...index)
-                else
-                  @index = i23
-                  r23 = nil
-                end
-                s21 << r23
-              end
-              if s21.last
-                r21 = instantiate_node(SyntaxNode,input, i21...index, s21)
-                r21.extend(Bstr10)
-                r21.extend(Bstr11)
-              else
-                @index = i21
-                r21 = nil
-              end
-              if r21
-                r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
-                r0 = r21
-              else
-                r25 = _nt_app_string
-                if r25
-                  r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
-                  r0 = r25
-                else
-                  r26 = _nt_sqstr
-                  if r26
-                    r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
-                    r0 = r26
-                  else
-                    r27 = _nt_app_rstring
-                    if r27
-                      r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
-                      r0 = r27
-                    else
-                      r28 = _nt_rawstring
-                      if r28
-                        r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
-                        r0 = r28
-                      else
-                        r29 = _nt_app_sequence
-                        if r29
-                          r29 = SyntaxNode.new(input, (index-1)...index) if r29 == true
-                          r0 = r29
-                        else
-                          r30 = _nt_embedded
-                          if r30
-                            r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
-                            r0 = r30
-                          else
-                            @index = i0
-                            r0 = nil
-                          end
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-    node_cache[:bstr][start_index] = r0
+    node_cache[:dqstr][start_index] = r0
 
     r0
   end
 
-  module Tstr0
-    def DQUOTE1
+  module Sqstr0
+    def SQUOTE1
       elements[0]
     end
 
-    def DQUOTE2
+    def SQUOTE2
       elements[2]
     end
   end
 
-  module Tstr1
+  module Sqstr1
     def ast
-      elements[1].elements.map {|x| x.ast}.join
+      elements[1].elements.map {|x| x.ast}.join.b # XXX .b
     end
   end
 
-  def _nt_tstr
+  def _nt_sqstr
     start_index = index
-    if node_cache[:tstr].has_key?(index)
-      cached = node_cache[:tstr][index]
+    if node_cache[:sqstr].has_key?(index)
+      cached = node_cache[:sqstr][index]
       if cached
-        node_cache[:tstr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:sqstr][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0, s0 = index, []
-    r1 = _nt_DQUOTE
+    r1 = _nt_SQUOTE
     s0 << r1
     if r1
       s2, i2 = [], index
       loop do
-        r3 = _nt_double_quoted
+        r3 = _nt_single_quoted
         if r3
           s2 << r3
         else
@@ -2893,20 +2472,20 @@ module EDNGRAMMAR
       r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
       s0 << r2
       if r2
-        r4 = _nt_DQUOTE
+        r4 = _nt_SQUOTE
         s0 << r4
       end
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Tstr0)
-      r0.extend(Tstr1)
+      r0.extend(Sqstr0)
+      r0.extend(Sqstr1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:tstr][start_index] = r0
+    node_cache[:sqstr][start_index] = r0
 
     r0
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edn-abnf
 version: !ruby/object:Gem::Version
-  version: 0.5.40
+  version: 0.5.41
 platform: ruby
 authors:
 - Carsten Bormann