edn-abnf 0.5.39 → 0.5.41

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,341 +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_string1e
+  def _nt_number
     start_index = index
-    if node_cache[:string1e].has_key?(index)
-      cached = node_cache[:string1e][index]
+    if node_cache[:number].has_key?(index)
+      cached = node_cache[:number][index]
       if cached
-        node_cache[:string1e][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[:string1e][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 String0
-    def S1
-      elements[0]
-    end
-
-    def S2
-      elements[2]
-    end
-
-    def string1e
-      elements[3]
-    end
-  end
-
-  module String1
-    def string1e
-      elements[0]
-    end
-
-  end
-
-  module String2
-    def join1(s)
-      s.join # XXX -- look at encoding and ei
-    end
-    def unpack_chunk(c, s)
-      if c == String
-        join1(s)
-      else
-        unless c == CBOR::Tagged && s.first.tag == 888 && s.first.value == nil # XXX check all values?
-          raise ArgumentError, "*** unjoinable chunks #{c.inspect} #{s.inspect}" if s.size != 1
-        end
-        s.first
-      end
-    end
-    def ast
-      arr = [elements[0].ast] + elements[1].elements.map {|x| x.elements[3].ast}
-      charr = arr.chunk(&:class).to_a
-      if charr.size == 1
-        unpack_chunk(*charr.first)
-      else
-        CBOR::Tagged.new(888, charr.map {|x| unpack_chunk(*x)})
-      end
-    end
-  end
-
-  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
-
-    i0, s0 = index, []
-    r1 = _nt_string1e
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r4 = _nt_S
-        s3 << r4
-        if r4
-          if (match_len = has_terminal?("+", false, index))
-            r5 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"+"')
-            r5 = nil
-          end
-          s3 << r5
-          if r5
-            r6 = _nt_S
-            s3 << r6
-            if r6
-              r7 = _nt_string1e
-              s3 << r7
-            end
-          end
-        end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(String0)
-        else
-          @index = i3
-          r3 = nil
-        end
+        r3 = _nt_octint
         if r3
-          s2 << r3
-        else
-          break
-        end
-      end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(String1)
-      r0.extend(String2)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:string][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 = 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
 
@@ -1275,7 +1041,95 @@ module EDNGRAMMAR
       end
     end
 
-    node_cache[:nonfin][start_index] = r0
+    node_cache[:nonfin][start_index] = r0
+
+    r0
+  end
+
+  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
+
+    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
@@ -1882,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
@@ -1926,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
@@ -1953,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
@@ -1967,277 +1821,196 @@ 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>")
-      end
-      if r5
-        @index = i4
-        r4 = instantiate_node(SyntaxNode,input, index...index)
-      else
-        @index = i4
-        r4 = nil
+  module Prefixed2
+    def ast1(pref)
+        args = seq.ast
+        ::EDNGRAMMAR::APPS[pref].decode(pref, args)
       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
 
   module Rawstring0
-    def rawcontent0
-      elements[1]
+    def startrawdelim
+      elements[0]
     end
 
-  end
-
-  module Rawstring1
-    def rawcontent
+    def raw_inner
       elements[1]
     end
-  end
-
-  module Rawstring2
-    def startrawdelim
-      elements[0]
-    end
 
     def alikerawdelim
       elements[2]
     end
   end
 
-  module Rawstring3
-    def ast; elements[1].elements[1].text_value.gsub("\r", "") end
+  module Rawstring1
+    def ast
+                                     val = raw_inner.text_value.gsub("\r", "")
+                                     if val[0] == ' ' && val[-1] == ' '
+                                       val[1...-1]
+                                     elsif val[0] == "\n"
+                                       val[1..-1]
+                                     else
+                                       val
+                                     end
+                                   end
   end
 
   def _nt_rawstring
@@ -2246,87 +2019,26 @@ module EDNGRAMMAR
       cached = node_cache[:rawstring][index]
       if cached
         node_cache[:rawstring][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_startrawdelim
-    s0 << r1
-    if r1
-      i2 = index
-      i3, s3 = index, []
-      if (match_len = has_terminal?(" ", false, index))
-        r4 = true
-        @index += match_len
-      else
-        terminal_parse_failure('" "')
-        r4 = nil
-      end
-      s3 << r4
-      if r4
-        r5 = _nt_rawcontent0
-        s3 << r5
-        if r5
-          if (match_len = has_terminal?(" ", false, index))
-            r6 = true
-            @index += match_len
-          else
-            terminal_parse_failure('" "')
-            r6 = nil
-          end
-          s3 << r6
-        end
-      end
-      if s3.last
-        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-        r3.extend(Rawstring0)
-      else
-        @index = i3
-        r3 = nil
-      end
-      if r3
-        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-        r2 = r3
-      else
-        i7, s7 = index, []
-        r9 = _nt_newline
-        if r9
-          r8 = r9
-        else
-          r8 = instantiate_node(SyntaxNode,input, index...index)
-        end
-        s7 << r8
-        if r8
-          r10 = _nt_rawcontent
-          s7 << r10
-        end
-        if s7.last
-          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
-          r7.extend(Rawstring1)
-        else
-          @index = i7
-          r7 = nil
-        end
-        if r7
-          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
-          r2 = r7
-        else
-          @index = i2
-          r2 = nil
-        end
+        @index = cached.interval.end
       end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_startrawdelim
+    s0 << r1
+    if r1
+      r2 = _nt_raw_inner
       s0 << r2
       if r2
-        r11 = _nt_alikerawdelim
-        s0 << r11
+        r3 = _nt_alikerawdelim
+        s0 << r3
       end
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Rawstring2)
-      r0.extend(Rawstring3)
+      r0.extend(Rawstring0)
+      r0.extend(Rawstring1)
     else
       @index = i0
       r0 = nil
@@ -2610,100 +2322,12 @@ module EDNGRAMMAR
     r0
   end
 
-  def _nt_rawchars0
-    start_index = index
-    if node_cache[:rawchars0].has_key?(index)
-      cached = node_cache[:rawchars0][index]
-      if cached
-        node_cache[:rawchars0][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      i1 = index
-      if (match_len = has_terminal?("\n", false, index))
-        r2 = true
-        @index += match_len
-      else
-        terminal_parse_failure('"\\n"')
-        r2 = nil
-      end
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r1 = r2
-      else
-        if (match_len = has_terminal?("\r", false, index))
-          r3 = true
-          @index += match_len
-        else
-          terminal_parse_failure('"\\r"')
-          r3 = nil
-        end
-        if r3
-          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-          r1 = r3
-        else
-          if has_terminal?(@regexps[gr = '\A[!-_]'] ||= Regexp.new(gr), :regexp, index)
-            r4 = true
-            @index += 1
-          else
-            terminal_parse_failure('[!-_]')
-            r4 = nil
-          end
-          if r4
-            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
-            r1 = r4
-          else
-            if has_terminal?(@regexps[gr = '\A[a-~]'] ||= Regexp.new(gr), :regexp, index)
-              r5 = true
-              @index += 1
-            else
-              terminal_parse_failure('[a-~]')
-              r5 = nil
-            end
-            if r5
-              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
-              r1 = r5
-            else
-              r6 = _nt_NONASCII
-              if r6
-                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
-                r1 = r6
-              else
-                @index = i1
-                r1 = nil
-              end
-            end
-          end
-        end
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    end
-
-    node_cache[:rawchars0][start_index] = r0
-
-    r0
-  end
-
-  def _nt_rawcontent
+  def _nt_raw_inner
     start_index = index
-    if node_cache[:rawcontent].has_key?(index)
-      cached = node_cache[:rawcontent][index]
+    if node_cache[:raw_inner].has_key?(index)
+      cached = node_cache[:raw_inner][index]
       if cached
-        node_cache[:rawcontent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:raw_inner][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -2730,528 +2354,115 @@ module EDNGRAMMAR
         s0 << r1
       else
         break
-      end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    end
-
-    node_cache[:rawcontent][start_index] = r0
-
-    r0
-  end
-
-  module Rawcontent00
-    def shortrawdelim
-      elements[1]
-    end
-  end
-
-  module Rawcontent01
-  end
-
-  def _nt_rawcontent0
-    start_index = index
-    if node_cache[:rawcontent0].has_key?(index)
-      cached = node_cache[:rawcontent0][index]
-      if cached
-        node_cache[:rawcontent0][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      i1 = index
-      r2 = _nt_rawchars0
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r1 = r2
-      else
-        i3, s3 = index, []
-        s4, i4 = [], index
-        loop do
-          r5 = _nt_rawchars
-          if r5
-            s4 << r5
-          else
-            break
-          end
-        end
-        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        s3 << r4
-        if r4
-          r6 = _nt_shortrawdelim
-          s3 << r6
-        end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Rawcontent00)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-          r1 = r3
-        else
-          i7, s7 = index, []
-          if (match_len = has_terminal?(" ", false, index))
-            r8 = true
-            @index += match_len
-          else
-            terminal_parse_failure('" "')
-            r8 = nil
-          end
-          s7 << r8
-          if r8
-            i9 = index
-            r10 = _nt_alikerawdelim
-            if r10
-              @index = i9
-              r9 = nil
-            else
-              @index = i9
-              r9 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s7 << r9
-          end
-          if s7.last
-            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
-            r7.extend(Rawcontent01)
-          else
-            @index = i7
-            r7 = nil
-          end
-          if r7
-            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
-            r1 = r7
-          else
-            @index = i1
-            r1 = nil
-          end
-        end
-      end
-      if r1
-        s0 << r1
-      else
-        break
-      end
-    end
-    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-
-    node_cache[:rawcontent0][start_index] = r0
-
-    r0
-  end
-
-  module Sqstr0
-    def SQUOTE1
-      elements[0]
-    end
-
-    def SQUOTE2
-      elements[2]
-    end
-  end
-
-  module Sqstr1
-    def ast
-      elements[1].elements.map {|x| x.ast}.join.b # XXX .b
-    end
-  end
-
-  def _nt_sqstr
-    start_index = index
-    if node_cache[:sqstr].has_key?(index)
-      cached = node_cache[:sqstr][index]
-      if cached
-        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_SQUOTE
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        r3 = _nt_single_quoted
-        if r3
-          s2 << r3
-        else
-          break
-        end
-      end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-      if r2
-        r4 = _nt_SQUOTE
-        s0 << r4
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Sqstr0)
-      r0.extend(Sqstr1)
-    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
-
-  end
-
-  module Bstr5
-    def ast; elements[0].ast end
-  end
-
-  module Bstr6
-    def raw_app_string_b64
-      elements[0]
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
     end
 
-  end
+    node_cache[:raw_inner][start_index] = r0
 
-  module Bstr7
-    def ast; elements[0].ast end
+    r0
   end
 
-  module Bstr8
-    def sq_app_string_dt
+  module Dqstr0
+    def DQUOTE1
       elements[0]
     end
 
-  end
-
-  module Bstr9
-    def ast; elements[0].ast end
-  end
-
-  module Bstr10
-    def raw_app_string_dt
-      elements[0]
+    def DQUOTE2
+      elements[2]
     end
-
   end
 
-  module Bstr11
-    def ast; elements[0].ast end
+  module Dqstr1
+    def ast
+      elements[1].elements.map {|x| x.ast}.join
+    end
   end
 
-  def _nt_bstr
+  def _nt_dqstr
     start_index = index
-    if node_cache[:bstr].has_key?(index)
-      cached = node_cache[:bstr][index]
+    if node_cache[:dqstr].has_key?(index)
+      cached = node_cache[:dqstr][index]
       if cached
-        node_cache[:bstr][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 = 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
+    i0, s0 = index, []
+    r1 = _nt_DQUOTE
+    s0 << r1
     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)
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_double_quoted
+        if r3
+          s2 << r3
         else
-          @index = i7
-          r7 = nil
+          break
         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
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        r4 = _nt_DQUOTE
+        s0 << r4
       end
     end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Dqstr0)
+      r0.extend(Dqstr1)
+    else
+      @index = i0
+      r0 = nil
+    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
@@ -3261,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
@@ -10030,55 +9241,6 @@ module EDNGRAMMAR
     r0
   end
 
-  module Fitrawdelim0
-    def rawdelim
-      elements[0]
-    end
-
-  end
-
-  def _nt_fitrawdelim
-    start_index = index
-    if node_cache[:fitrawdelim].has_key?(index)
-      cached = node_cache[:fitrawdelim][index]
-      if cached
-        node_cache[:fitrawdelim][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0, s0 = index, []
-    r1 = _nt_rawdelim
-    s0 << r1
-    if r1
-      i2 = index
-      r3 = lambda {|(rd)|rd.text_value.length == @rawdelimlength}.call(s0)
-      if !r3
-        terminal_parse_failure("<semantic predicate>")
-      end
-      if r3
-        @index = i2
-        r2 = instantiate_node(SyntaxNode,input, index...index)
-      else
-        @index = i2
-        r2 = nil
-      end
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Fitrawdelim0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:fitrawdelim][start_index] = r0
-
-    r0
-  end
-
   module RhS0
     def rh_comment
       elements[0]
@@ -10744,9 +9906,6 @@ module EDNGRAMMAR
       elements[0]
     end
 
-    def alikerawdelim
-      elements[2]
-    end
   end
 
   module RAppStringH5
@@ -10754,6 +9913,9 @@ module EDNGRAMMAR
       elements[0]
     end
 
+    def alikerawdelim
+      elements[3]
+    end
   end
 
   module RAppStringH6
@@ -10864,7 +10026,6 @@ module EDNGRAMMAR
       r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
       s0 << r2
       if r2
-        i12 = index
         i13, s13 = index, []
         r14 = _nt_eol_comment
         s13 << r14
@@ -10880,10 +10041,6 @@ module EDNGRAMMAR
           end
           r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
           s13 << r15
-          if r15
-            r17 = _nt_alikerawdelim
-            s13 << r17
-          end
         end
         if s13.last
           r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
@@ -10893,19 +10050,15 @@ module EDNGRAMMAR
           r13 = nil
         end
         if r13
-          r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
           r12 = r13
         else
-          r18 = _nt_fitrawdelim
-          if r18
-            r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
-            r12 = r18
-          else
-            @index = i12
-            r12 = nil
-          end
+          r12 = instantiate_node(SyntaxNode,input, index...index)
         end
         s0 << r12
+        if r12
+          r17 = _nt_alikerawdelim
+          s0 << r17
+        end
       end
     end
     if s0.last
@@ -11608,9 +10761,6 @@ module EDNGRAMMAR
   end
 
   module RAppStringB644
-    def alikerawdelim
-      elements[2]
-    end
   end
 
   module RAppStringB645
@@ -11618,9 +10768,13 @@ module EDNGRAMMAR
       elements[0]
     end
 
+    def alikerawdelim
+      elements[4]
+    end
   end
 
   module RAppStringB646
+
     def ast
       v = elements[0..2].map {|part| part.text_value}.join
       t = v.gsub(/\s|#[^\n]*(?:\n|\z)/, '').chars.each_slice(4).map(&:join)
@@ -11809,7 +10963,6 @@ module EDNGRAMMAR
         end
         s0 << r7
         if r7
-          i25 = index
           i26, s26 = index, []
           if (match_len = has_terminal?("#", false, index))
             r27 = true
@@ -11831,10 +10984,6 @@ module EDNGRAMMAR
             end
             r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
             s26 << r28
-            if r28
-              r30 = _nt_alikerawdelim
-              s26 << r30
-            end
           end
           if s26.last
             r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
@@ -11844,19 +10993,15 @@ module EDNGRAMMAR
             r26 = nil
           end
           if r26
-            r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
             r25 = r26
           else
-            r31 = _nt_fitrawdelim
-            if r31
-              r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
-              r25 = r31
-            else
-              @index = i25
-              r25 = nil
-            end
+            r25 = instantiate_node(SyntaxNode,input, index...index)
           end
           s0 << r25
+          if r25
+            r30 = _nt_alikerawdelim
+            s0 << r30
+          end
         end
       end
     end