edn-abnf 0.5.20 → 0.5.21

data/lib/parser/edngrammar.rb

@@ -2344,6 +2344,28 @@ module EDNGRAMMAR
     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
+
   def _nt_bstr
     start_index = index
     if node_cache[:bstr].has_key?(index)
@@ -2416,38 +2438,100 @@ module EDNGRAMMAR
         r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
         r0 = r5
       else
-        r9 = _nt_app_string
+        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
-          r10 = _nt_sqstr
-          if r10
-            r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
-            r0 = r10
+          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
-            r11 = _nt_app_rstring
-            if r11
-              r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
-              r0 = r11
+            @index = i13
+            r13 = nil
+          end
+          if r13
+            r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
+            r0 = r13
+          else
+            r17 = _nt_app_string
+            if r17
+              r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
+              r0 = r17
             else
-              r12 = _nt_rawstring
-              if r12
-                r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
-                r0 = r12
+              r18 = _nt_sqstr
+              if r18
+                r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
+                r0 = r18
               else
-                r13 = _nt_app_sequence
-                if r13
-                  r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
-                  r0 = r13
+                r19 = _nt_app_rstring
+                if r19
+                  r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
+                  r0 = r19
                 else
-                  r14 = _nt_embedded
-                  if r14
-                    r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
-                    r0 = r14
+                  r20 = _nt_rawstring
+                  if r20
+                    r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
+                    r0 = r20
                   else
-                    @index = i0
-                    r0 = nil
+                    r21 = _nt_app_sequence
+                    if r21
+                      r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
+                      r0 = r21
+                    else
+                      r22 = _nt_embedded
+                      if r22
+                        r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
+                        r0 = r22
+                      else
+                        @index = i0
+                        r0 = nil
+                      end
+                    end
                   end
                 end
               end
@@ -7913,6 +7997,86 @@ module EDNGRAMMAR
     r0
   end
 
+  def _nt_r_non_lf
+    start_index = index
+    if node_cache[:r_non_lf].has_key?(index)
+      cached = node_cache[:r_non_lf][index]
+      if cached
+        node_cache[:r_non_lf][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    if (match_len = has_terminal?("\t", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"\\t"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("\r", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"\\r"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if has_terminal?(@regexps[gr = '\A[\\ -_]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[\\ -_]')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if has_terminal?(@regexps[gr = '\A[a-]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = true
+            @index += 1
+          else
+            terminal_parse_failure('[a-]')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            r5 = _nt_NONASCII
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              r6 = _nt_shortrawdelim
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:r_non_lf][start_index] = r0
+
+    r0
+  end
+
   module SqAppStringH0
     def app_string_h
       elements[1]
@@ -8475,153 +8639,1329 @@ module EDNGRAMMAR
     r0
   end
 
-  module SqAppStringB640
-    def app_string_b64
-      elements[1]
+  module Fitrawdelim0
+    def rawdelim
+      elements[0]
     end
 
   end
 
-  module SqAppStringB641
-    def ast; app_string_b64.ast end
-  end
-
-  def _nt_sq_app_string_b64
+  def _nt_fitrawdelim
     start_index = index
-    if node_cache[:sq_app_string_b64].has_key?(index)
-      cached = node_cache[:sq_app_string_b64][index]
+    if node_cache[:fitrawdelim].has_key?(index)
+      cached = node_cache[:fitrawdelim][index]
       if cached
-        node_cache[:sq_app_string_b64][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        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, []
-    if (match_len = has_terminal?("b64'", false, index))
-      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-      @index += match_len
-    else
-      terminal_parse_failure('"b64\'"')
-      r1 = nil
-    end
+    r1 = _nt_rawdelim
     s0 << r1
     if r1
-      r2 = _nt_app_string_b64
-      s0 << r2
-      if r2
-        if (match_len = has_terminal?("'", false, index))
-          r3 = true
-          @index += match_len
-        else
-          terminal_parse_failure('"\'"')
-          r3 = nil
-        end
-        s0 << r3
+      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(SqAppStringB640)
-      r0.extend(SqAppStringB641)
+      r0.extend(Fitrawdelim0)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:sq_app_string_b64][start_index] = r0
+    node_cache[:fitrawdelim][start_index] = r0
 
     r0
   end
 
-  module AppStringB640
-    def b64dig
-      elements[0]
-    end
-
-    def b64_S
-      elements[1]
-    end
-  end
-
-  module AppStringB641
-    def b64_S
-      elements[1]
-    end
-
-  end
-
-  module AppStringB642
-    def b64dig
-      elements[0]
-    end
-
-    def b64_S
-      elements[1]
-    end
-
-  end
-
-  module AppStringB643
-    def b64dig1
-      elements[0]
-    end
-
-    def b64_S1
-      elements[1]
-    end
-
-    def b64dig2
-      elements[2]
-    end
-
-    def b64_S2
-      elements[3]
-    end
-
-    def b64_S3
-      elements[5]
-    end
-  end
-
-  module AppStringB644
-  end
-
-  module AppStringB645
-    def b64_S
+  module RhS0
+    def rh_comment
       elements[0]
     end
 
   end
 
-  module AppStringB646
-    def ast
-      t = text_value.gsub(/\s|#[^\n]*(?:\n|\z)/, '').chars.each_slice(4).map(&:join)
-      if last = t[-1]
-        last << "=" * (4 - last.size)
-      end
-      b = t.join.tr("-_", "+/")
-      begin
-        b.unpack("m0")[0]
-      rescue ArgumentError
-        raise ArgumentError, "cbor-diagnostic: invalid base64 #{b.inspect}", caller[1..-1]
-      end
-    end
+  module RhS1
   end
 
-  def _nt_app_string_b64
+  def _nt_rh_S
     start_index = index
-    if node_cache[:app_string_b64].has_key?(index)
-      cached = node_cache[:app_string_b64][index]
+    if node_cache[:rh_S].has_key?(index)
+      cached = node_cache[:rh_S][index]
       if cached
-        node_cache[:app_string_b64][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:rh_S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
     end
 
     i0, s0 = index, []
-    r1 = _nt_b64_S
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_blank
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      s3, i3 = [], index
+      loop do
+        i4, s4 = index, []
+        r5 = _nt_rh_comment
+        s4 << r5
+        if r5
+          s6, i6 = [], index
+          loop do
+            r7 = _nt_blank
+            if r7
+              s6 << r7
+            else
+              break
+            end
+          end
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          s4 << r6
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(RhS0)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(RhS1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:rh_S][start_index] = r0
+
+    r0
+  end
+
+  def _nt_rh_non_slash
+    start_index = index
+    if node_cache[:rh_non_slash].has_key?(index)
+      cached = node_cache[:rh_non_slash][index]
+      if cached
+        node_cache[:rh_non_slash][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_blank
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if has_terminal?(@regexps[gr = '\A[!-\\.]'] ||= Regexp.new(gr), :regexp, index)
+        r2 = true
+        @index += 1
+      else
+        terminal_parse_failure('[!-\\.]')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if has_terminal?(@regexps[gr = '\A[0-_]'] ||= Regexp.new(gr), :regexp, index)
+          r3 = true
+          @index += 1
+        else
+          terminal_parse_failure('[0-_]')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if has_terminal?(@regexps[gr = '\A[a-]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = true
+            @index += 1
+          else
+            terminal_parse_failure('[a-]')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            r5 = _nt_NONASCII
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              r6 = _nt_shortrawdelim
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:rh_non_slash][start_index] = r0
+
+    r0
+  end
+
+  module RhComment0
+  end
+
+  module RhComment1
+  end
+
+  def _nt_rh_comment
+    start_index = index
+    if node_cache[:rh_comment].has_key?(index)
+      cached = node_cache[:rh_comment][index]
+      if cached
+        node_cache[:rh_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    if (match_len = has_terminal?("/", false, index))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"/"')
+      r2 = nil
+    end
+    s1 << r2
+    if r2
+      s3, i3 = [], index
+      loop do
+        r4 = _nt_rh_non_slash
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s1 << r3
+      if r3
+        if (match_len = has_terminal?("/", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"/"')
+          r5 = nil
+        end
+        s1 << r5
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(RhComment0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i6, s6 = index, []
+      if (match_len = has_terminal?("#", false, index))
+        r7 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"#"')
+        r7 = nil
+      end
+      s6 << r7
+      if r7
+        s8, i8 = [], index
+        loop do
+          r9 = _nt_r_non_lf
+          if r9
+            s8 << r9
+          else
+            break
+          end
+        end
+        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+        s6 << r8
+        if r8
+          if (match_len = has_terminal?("\n", false, index))
+            r10 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"\\n"')
+            r10 = nil
+          end
+          s6 << r10
+        end
+      end
+      if s6.last
+        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+        r6.extend(RhComment1)
+      else
+        @index = i6
+        r6 = nil
+      end
+      if r6
+        r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+        r0 = r6
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:rh_comment][start_index] = r0
+
+    r0
+  end
+
+  module RawAppStringH0
+    def startrawdelim
+      elements[1]
+    end
+
+    def r_app_string_h
+      elements[2]
+    end
+  end
+
+  module RawAppStringH1
+    def ast; r_app_string_h.ast end
+  end
+
+  def _nt_raw_app_string_h
+    start_index = index
+    if node_cache[:raw_app_string_h].has_key?(index)
+      cached = node_cache[:raw_app_string_h][index]
+      if cached
+        node_cache[:raw_app_string_h][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("h", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"h"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_startrawdelim
+      s0 << r2
+      if r2
+        r3 = _nt_r_app_string_h
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(RawAppStringH0)
+      r0.extend(RawAppStringH1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:raw_app_string_h][start_index] = r0
+
+    r0
+  end
+
+  module RAppStringH0
+    def HEXDIG1
+      elements[0]
+    end
+
+    def rh_S1
+      elements[1]
+    end
+
+    def HEXDIG2
+      elements[2]
+    end
+
+    def rh_S2
+      elements[3]
+    end
+  end
+
+  module RAppStringH1
+    def ast
+      Integer(elements[0].text_value + elements[2].text_value, 16).chr("BINARY")
+    end
+  end
+
+  module RAppStringH2
+    def ellipsis
+      elements[0]
+    end
+
+    def h_S
+      elements[1]
+    end
+  end
+
+  module RAppStringH3
+    def ast; ellipsis.ast end
+  end
+
+  module RAppStringH4
+    def matchrawdelim
+      elements[2]
+    end
+  end
+
+  module RAppStringH5
+    def rh_S
+      elements[0]
+    end
+
+  end
+
+  module RAppStringH6
+    def unpack_thread(s)
+      case s[0]
+      when CBOR::Tagged
+        s[0]
+      when String
+        s.join
+      else
+        raise "@@@ unpack_thread #{s.inspect}"
+      end
+    end
+    def ast
+      e1 = elements[1].elements.map {|e| e.ast}
+      out = []
+      curr = []
+      e1.each { |el|
+        if curr.size == 0 || curr[0].class == el.class
+          curr << el
+        else
+          out << curr
+          curr = [el]
+        end
+      }
+      if out.size == 0 && (curr.size == 0 || String === curr[0])
+        curr.join.b # unpack_thread(curr)
+      else
+        CBOR::Tagged.new(888, (out << curr).map {|x| unpack_thread(x)})
+      end
+    end
+  end
+
+  def _nt_r_app_string_h
+    start_index = index
+    if node_cache[:r_app_string_h].has_key?(index)
+      cached = node_cache[:r_app_string_h][index]
+      if cached
+        node_cache[:r_app_string_h][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_rh_S
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3 = index
+        i4, s4 = index, []
+        r5 = _nt_HEXDIG
+        s4 << r5
+        if r5
+          r6 = _nt_rh_S
+          s4 << r6
+          if r6
+            r7 = _nt_HEXDIG
+            s4 << r7
+            if r7
+              r8 = _nt_rh_S
+              s4 << r8
+            end
+          end
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(RAppStringH0)
+          r4.extend(RAppStringH1)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r3 = r4
+        else
+          i9, s9 = index, []
+          r10 = _nt_ellipsis
+          s9 << r10
+          if r10
+            r11 = _nt_h_S
+            s9 << r11
+          end
+          if s9.last
+            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+            r9.extend(RAppStringH2)
+            r9.extend(RAppStringH3)
+          else
+            @index = i9
+            r9 = nil
+          end
+          if r9
+            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
+            r3 = r9
+          else
+            @index = i3
+            r3 = nil
+          end
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        i12 = index
+        i13, s13 = index, []
+        if (match_len = has_terminal?("#", false, index))
+          r14 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"#"')
+          r14 = nil
+        end
+        s13 << r14
+        if r14
+          s15, i15 = [], index
+          loop do
+            r16 = _nt_r_non_lf
+            if r16
+              s15 << r16
+            else
+              break
+            end
+          end
+          r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+          s13 << r15
+          if r15
+            r17 = _nt_matchrawdelim
+            s13 << r17
+          end
+        end
+        if s13.last
+          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+          r13.extend(RAppStringH4)
+        else
+          @index = i13
+          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
+        end
+        s0 << r12
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(RAppStringH5)
+      r0.extend(RAppStringH6)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:r_app_string_h][start_index] = r0
+
+    r0
+  end
+
+  module SqAppStringB640
+    def app_string_b64
+      elements[1]
+    end
+
+  end
+
+  module SqAppStringB641
+    def ast; app_string_b64.ast end
+  end
+
+  def _nt_sq_app_string_b64
+    start_index = index
+    if node_cache[:sq_app_string_b64].has_key?(index)
+      cached = node_cache[:sq_app_string_b64][index]
+      if cached
+        node_cache[:sq_app_string_b64][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("b64'", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"b64\'"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_app_string_b64
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?("'", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\'"')
+          r3 = nil
+        end
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(SqAppStringB640)
+      r0.extend(SqAppStringB641)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:sq_app_string_b64][start_index] = r0
+
+    r0
+  end
+
+  module AppStringB640
+    def b64dig
+      elements[0]
+    end
+
+    def b64_S
+      elements[1]
+    end
+  end
+
+  module AppStringB641
+    def b64_S
+      elements[1]
+    end
+
+  end
+
+  module AppStringB642
+    def b64dig
+      elements[0]
+    end
+
+    def b64_S
+      elements[1]
+    end
+
+  end
+
+  module AppStringB643
+    def b64dig1
+      elements[0]
+    end
+
+    def b64_S1
+      elements[1]
+    end
+
+    def b64dig2
+      elements[2]
+    end
+
+    def b64_S2
+      elements[3]
+    end
+
+    def b64_S3
+      elements[5]
+    end
+  end
+
+  module AppStringB644
+  end
+
+  module AppStringB645
+    def b64_S
+      elements[0]
+    end
+
+  end
+
+  module AppStringB646
+    def ast
+      t = text_value.gsub(/\s|#[^\n]*(?:\n|\z)/, '').chars.each_slice(4).map(&:join)
+      if last = t[-1]
+        last << "=" * (4 - last.size)
+      end
+      b = t.join.tr("-_", "+/")
+      begin
+        b.unpack("m0")[0]
+      rescue ArgumentError
+        raise ArgumentError, "cbor-diagnostic: invalid base64 #{b.inspect}", caller[1..-1]
+      end
+    end
+  end
+
+  def _nt_app_string_b64
+    start_index = index
+    if node_cache[:app_string_b64].has_key?(index)
+      cached = node_cache[:app_string_b64][index]
+      if cached
+        node_cache[:app_string_b64][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_b64_S
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        s3, i3 = [], index
+        loop do
+          i4, s4 = index, []
+          r5 = _nt_b64dig
+          s4 << r5
+          if r5
+            r6 = _nt_b64_S
+            s4 << r6
+          end
+          if s4.last
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            r4.extend(AppStringB640)
+          else
+            @index = i4
+            r4 = nil
+          end
+          if r4
+            s3 << r4
+          else
+            break
+          end
+          if s3.size == 4
+            break
+          end
+        end
+        if s3.size < 4
+          @index = i3
+          r3 = nil
+        else
+          if s3.size < 4
+            @terminal_failures.pop
+          end
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        i8, s8 = index, []
+        r9 = _nt_b64dig
+        s8 << r9
+        if r9
+          r10 = _nt_b64_S
+          s8 << r10
+          if r10
+            r11 = _nt_b64dig
+            s8 << r11
+            if r11
+              r12 = _nt_b64_S
+              s8 << r12
+              if r12
+                i14 = index
+                i15, s15 = index, []
+                if (match_len = has_terminal?("=", false, index))
+                  r16 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('"="')
+                  r16 = nil
+                end
+                s15 << r16
+                if r16
+                  r17 = _nt_b64_S
+                  s15 << r17
+                  if r17
+                    if (match_len = has_terminal?("=", false, index))
+                      r18 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('"="')
+                      r18 = nil
+                    end
+                    s15 << r18
+                  end
+                end
+                if s15.last
+                  r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+                  r15.extend(AppStringB641)
+                else
+                  @index = i15
+                  r15 = nil
+                end
+                if r15
+                  r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
+                  r14 = r15
+                else
+                  i19, s19 = index, []
+                  r20 = _nt_b64dig
+                  s19 << r20
+                  if r20
+                    r21 = _nt_b64_S
+                    s19 << r21
+                    if r21
+                      if (match_len = has_terminal?("=", false, index))
+                        r23 = true
+                        @index += match_len
+                      else
+                        terminal_parse_failure('"="')
+                        r23 = nil
+                      end
+                      if r23
+                        r22 = r23
+                      else
+                        r22 = instantiate_node(SyntaxNode,input, index...index)
+                      end
+                      s19 << r22
+                    end
+                  end
+                  if s19.last
+                    r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
+                    r19.extend(AppStringB642)
+                  else
+                    @index = i19
+                    r19 = nil
+                  end
+                  if r19
+                    r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
+                    r14 = r19
+                  else
+                    @index = i14
+                    r14 = nil
+                  end
+                end
+                if r14
+                  r13 = r14
+                else
+                  r13 = instantiate_node(SyntaxNode,input, index...index)
+                end
+                s8 << r13
+                if r13
+                  r24 = _nt_b64_S
+                  s8 << r24
+                end
+              end
+            end
+          end
+        end
+        if s8.last
+          r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+          r8.extend(AppStringB643)
+        else
+          @index = i8
+          r8 = nil
+        end
+        if r8
+          r7 = r8
+        else
+          r7 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r7
+        if r7
+          i26, s26 = index, []
+          if (match_len = has_terminal?("#", false, index))
+            r27 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"#"')
+            r27 = nil
+          end
+          s26 << r27
+          if r27
+            s28, i28 = [], index
+            loop do
+              r29 = _nt_i_non_lf
+              if r29
+                s28 << r29
+              else
+                break
+              end
+            end
+            r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
+            s26 << r28
+          end
+          if s26.last
+            r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
+            r26.extend(AppStringB644)
+          else
+            @index = i26
+            r26 = nil
+          end
+          if r26
+            r25 = r26
+          else
+            r25 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r25
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppStringB645)
+      r0.extend(AppStringB646)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:app_string_b64][start_index] = r0
+
+    r0
+  end
+
+  def _nt_b64dig
+    start_index = index
+    if node_cache[:b64dig].has_key?(index)
+      cached = node_cache[:b64dig][index]
+      if cached
+        node_cache[:b64dig][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_ALPHA
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_DIGIT
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        if (match_len = has_terminal?("-", false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"-"')
+          r3 = nil
+        end
+        if r3
+          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+          r0 = r3
+        else
+          if (match_len = has_terminal?("_", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"_"')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r0 = r4
+          else
+            if (match_len = has_terminal?("+", false, index))
+              r5 = true
+              @index += match_len
+            else
+              terminal_parse_failure('"+"')
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r0 = r5
+            else
+              if (match_len = has_terminal?("/", false, index))
+                r6 = true
+                @index += match_len
+              else
+                terminal_parse_failure('"/"')
+                r6 = nil
+              end
+              if r6
+                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+                r0 = r6
+              else
+                @index = i0
+                r0 = nil
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:b64dig][start_index] = r0
+
+    r0
+  end
+
+  module B64S0
+    def b64_comment
+      elements[0]
+    end
+
+  end
+
+  module B64S1
+  end
+
+  def _nt_b64_S
+    start_index = index
+    if node_cache[:b64_S].has_key?(index)
+      cached = node_cache[:b64_S][index]
+      if cached
+        node_cache[:b64_S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    s1, i1 = [], index
+    loop do
+      r2 = _nt_i_blank
+      if r2
+        s1 << r2
+      else
+        break
+      end
+    end
+    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+    s0 << r1
+    if r1
+      s3, i3 = [], index
+      loop do
+        i4, s4 = index, []
+        r5 = _nt_b64_comment
+        s4 << r5
+        if r5
+          s6, i6 = [], index
+          loop do
+            r7 = _nt_i_blank
+            if r7
+              s6 << r7
+            else
+              break
+            end
+          end
+          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+          s4 << r6
+        end
+        if s4.last
+          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+          r4.extend(B64S0)
+        else
+          @index = i4
+          r4 = nil
+        end
+        if r4
+          s3 << r4
+        else
+          break
+        end
+      end
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(B64S1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:b64_S][start_index] = r0
+
+    r0
+  end
+
+  module B64Comment0
+  end
+
+  def _nt_b64_comment
+    start_index = index
+    if node_cache[:b64_comment].has_key?(index)
+      cached = node_cache[:b64_comment][index]
+      if cached
+        node_cache[:b64_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("#", false, index))
+      r1 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"#"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        r3 = _nt_i_non_lf
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?("\n", false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\\n"')
+          r4 = nil
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(B64Comment0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:b64_comment][start_index] = r0
+
+    r0
+  end
+
+  module RawAppStringB640
+    def startrawdelim
+      elements[1]
+    end
+
+    def r_app_string_b64
+      elements[2]
+    end
+  end
+
+  module RawAppStringB641
+    def ast; r_app_string_b64.ast end
+  end
+
+  def _nt_raw_app_string_b64
+    start_index = index
+    if node_cache[:raw_app_string_b64].has_key?(index)
+      cached = node_cache[:raw_app_string_b64][index]
+      if cached
+        node_cache[:raw_app_string_b64][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if (match_len = has_terminal?("b64", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"b64"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      r2 = _nt_startrawdelim
+      s0 << r2
+      if r2
+        r3 = _nt_r_app_string_b64
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(RawAppStringB640)
+      r0.extend(RawAppStringB641)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:raw_app_string_b64][start_index] = r0
+
+    r0
+  end
+
+  module RAppStringB640
+    def b64dig
+      elements[0]
+    end
+
+    def b64_S
+      elements[1]
+    end
+  end
+
+  module RAppStringB641
+    def rb64_S
+      elements[1]
+    end
+
+  end
+
+  module RAppStringB642
+    def b64dig
+      elements[0]
+    end
+
+    def rb64_S
+      elements[1]
+    end
+
+  end
+
+  module RAppStringB643
+    def b64dig1
+      elements[0]
+    end
+
+    def rb64_S1
+      elements[1]
+    end
+
+    def b64dig2
+      elements[2]
+    end
+
+    def rb64_S2
+      elements[3]
+    end
+
+    def rb64_S3
+      elements[5]
+    end
+  end
+
+  module RAppStringB644
+    def matchrawdelim
+      elements[2]
+    end
+  end
+
+  module RAppStringB645
+    def b64_S
+      elements[0]
+    end
+
+  end
+
+  module RAppStringB646
+    def ast
+      t = text_value.gsub(/\s|#[^\n]*(?:\n|\z)/, '').chars.each_slice(4).map(&:join)
+      if last = t[-1]
+        last << "=" * (4 - last.size)
+      end
+      b = t.join.tr("-_", "+/")
+      begin
+        b.unpack("m0")[0]
+      rescue ArgumentError
+        raise ArgumentError, "cbor-diagnostic: invalid base64 #{b.inspect}", caller[1..-1]
+      end
+    end
+  end
+
+  def _nt_r_app_string_b64
+    start_index = index
+    if node_cache[:r_app_string_b64].has_key?(index)
+      cached = node_cache[:r_app_string_b64][index]
+      if cached
+        node_cache[:r_app_string_b64][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_b64_S
     s0 << r1
     if r1
       s2, i2 = [], index
@@ -8637,7 +9977,7 @@ module EDNGRAMMAR
           end
           if s4.last
             r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-            r4.extend(AppStringB640)
+            r4.extend(RAppStringB640)
           else
             @index = i4
             r4 = nil
@@ -8673,13 +10013,13 @@ module EDNGRAMMAR
         r9 = _nt_b64dig
         s8 << r9
         if r9
-          r10 = _nt_b64_S
+          r10 = _nt_rb64_S
           s8 << r10
           if r10
             r11 = _nt_b64dig
             s8 << r11
             if r11
-              r12 = _nt_b64_S
+              r12 = _nt_rb64_S
               s8 << r12
               if r12
                 i14 = index
@@ -8693,7 +10033,7 @@ module EDNGRAMMAR
                 end
                 s15 << r16
                 if r16
-                  r17 = _nt_b64_S
+                  r17 = _nt_rb64_S
                   s15 << r17
                   if r17
                     if (match_len = has_terminal?("=", false, index))
@@ -8708,7 +10048,7 @@ module EDNGRAMMAR
                 end
                 if s15.last
                   r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
-                  r15.extend(AppStringB641)
+                  r15.extend(RAppStringB641)
                 else
                   @index = i15
                   r15 = nil
@@ -8721,7 +10061,7 @@ module EDNGRAMMAR
                   r20 = _nt_b64dig
                   s19 << r20
                   if r20
-                    r21 = _nt_b64_S
+                    r21 = _nt_rb64_S
                     s19 << r21
                     if r21
                       if (match_len = has_terminal?("=", false, index))
@@ -8741,7 +10081,7 @@ module EDNGRAMMAR
                   end
                   if s19.last
                     r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
-                    r19.extend(AppStringB642)
+                    r19.extend(RAppStringB642)
                   else
                     @index = i19
                     r19 = nil
@@ -8761,7 +10101,7 @@ module EDNGRAMMAR
                 end
                 s8 << r13
                 if r13
-                  r24 = _nt_b64_S
+                  r24 = _nt_rb64_S
                   s8 << r24
                 end
               end
@@ -8770,7 +10110,7 @@ module EDNGRAMMAR
         end
         if s8.last
           r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
-          r8.extend(AppStringB643)
+          r8.extend(RAppStringB643)
         else
           @index = i8
           r8 = nil
@@ -8782,6 +10122,7 @@ module EDNGRAMMAR
         end
         s0 << r7
         if r7
+          i25 = index
           i26, s26 = index, []
           if (match_len = has_terminal?("#", false, index))
             r27 = true
@@ -8794,7 +10135,7 @@ module EDNGRAMMAR
           if r27
             s28, i28 = [], index
             loop do
-              r29 = _nt_i_non_lf
+              r29 = _nt_r_non_lf
               if r29
                 s28 << r29
               else
@@ -8803,18 +10144,30 @@ module EDNGRAMMAR
             end
             r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
             s26 << r28
+            if r28
+              r30 = _nt_matchrawdelim
+              s26 << r30
+            end
           end
           if s26.last
             r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
-            r26.extend(AppStringB644)
+            r26.extend(RAppStringB644)
           else
             @index = i26
             r26 = nil
           end
           if r26
+            r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
             r25 = r26
           else
-            r25 = instantiate_node(SyntaxNode,input, index...index)
+            r31 = _nt_fitrawdelim
+            if r31
+              r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
+              r25 = r31
+            else
+              @index = i25
+              r25 = nil
+            end
           end
           s0 << r25
         end
@@ -8822,114 +10175,34 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(AppStringB645)
-      r0.extend(AppStringB646)
+      r0.extend(RAppStringB645)
+      r0.extend(RAppStringB646)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:app_string_b64][start_index] = r0
-
-    r0
-  end
-
-  def _nt_b64dig
-    start_index = index
-    if node_cache[:b64dig].has_key?(index)
-      cached = node_cache[:b64dig][index]
-      if cached
-        node_cache[:b64dig][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0 = index
-    r1 = _nt_ALPHA
-    if r1
-      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
-      r0 = r1
-    else
-      r2 = _nt_DIGIT
-      if r2
-        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
-        r0 = r2
-      else
-        if (match_len = has_terminal?("-", false, index))
-          r3 = true
-          @index += match_len
-        else
-          terminal_parse_failure('"-"')
-          r3 = nil
-        end
-        if r3
-          r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
-          r0 = r3
-        else
-          if (match_len = has_terminal?("_", false, index))
-            r4 = true
-            @index += match_len
-          else
-            terminal_parse_failure('"_"')
-            r4 = nil
-          end
-          if r4
-            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
-            r0 = r4
-          else
-            if (match_len = has_terminal?("+", false, index))
-              r5 = true
-              @index += match_len
-            else
-              terminal_parse_failure('"+"')
-              r5 = nil
-            end
-            if r5
-              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
-              r0 = r5
-            else
-              if (match_len = has_terminal?("/", false, index))
-                r6 = true
-                @index += match_len
-              else
-                terminal_parse_failure('"/"')
-                r6 = nil
-              end
-              if r6
-                r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
-                r0 = r6
-              else
-                @index = i0
-                r0 = nil
-              end
-            end
-          end
-        end
-      end
-    end
-
-    node_cache[:b64dig][start_index] = r0
+    node_cache[:r_app_string_b64][start_index] = r0
 
     r0
   end
 
-  module B64S0
-    def b64_comment
+  module Rb64S0
+    def rb64_comment
       elements[0]
     end
 
   end
 
-  module B64S1
+  module Rb64S1
   end
 
-  def _nt_b64_S
+  def _nt_rb64_S
     start_index = index
-    if node_cache[:b64_S].has_key?(index)
-      cached = node_cache[:b64_S][index]
+    if node_cache[:rb64_S].has_key?(index)
+      cached = node_cache[:rb64_S][index]
       if cached
-        node_cache[:b64_S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:rb64_S][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -8938,7 +10211,7 @@ module EDNGRAMMAR
     i0, s0 = index, []
     s1, i1 = [], index
     loop do
-      r2 = _nt_i_blank
+      r2 = _nt_blank
       if r2
         s1 << r2
       else
@@ -8951,12 +10224,12 @@ module EDNGRAMMAR
       s3, i3 = [], index
       loop do
         i4, s4 = index, []
-        r5 = _nt_b64_comment
+        r5 = _nt_rb64_comment
         s4 << r5
         if r5
           s6, i6 = [], index
           loop do
-            r7 = _nt_i_blank
+            r7 = _nt_blank
             if r7
               s6 << r7
             else
@@ -8968,7 +10241,7 @@ module EDNGRAMMAR
         end
         if s4.last
           r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-          r4.extend(B64S0)
+          r4.extend(Rb64S0)
         else
           @index = i4
           r4 = nil
@@ -8984,26 +10257,26 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(B64S1)
+      r0.extend(Rb64S1)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:b64_S][start_index] = r0
+    node_cache[:rb64_S][start_index] = r0
 
     r0
   end
 
-  module B64Comment0
+  module Rb64Comment0
   end
 
-  def _nt_b64_comment
+  def _nt_rb64_comment
     start_index = index
-    if node_cache[:b64_comment].has_key?(index)
-      cached = node_cache[:b64_comment][index]
+    if node_cache[:rb64_comment].has_key?(index)
+      cached = node_cache[:rb64_comment][index]
       if cached
-        node_cache[:b64_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:rb64_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -9021,7 +10294,7 @@ module EDNGRAMMAR
     if r1
       s2, i2 = [], index
       loop do
-        r3 = _nt_i_non_lf
+        r3 = _nt_r_non_lf
         if r3
           s2 << r3
         else
@@ -9043,13 +10316,13 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(B64Comment0)
+      r0.extend(Rb64Comment0)
     else
       @index = i0
       r0 = nil
     end
 
-    node_cache[:b64_comment][start_index] = r0
+    node_cache[:rb64_comment][start_index] = r0
 
     r0
   end