edn-abnf 0.5.32 → 0.5.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 526056ed796bf81ffc83f6042d90706a446955e4069c10382f253e68b29fe587
-  data.tar.gz: 9f0221ad1617fcdf26411960ded59fb620a7a3a66175d15547a3b24f4e24885a
+  metadata.gz: dc4cf907d32b47cc51a4326a110558a79a25ba4733873a5d6d84fd52f4e54903
+  data.tar.gz: 5424613f24e9fb8defca526961a428bba49832c57e952e848d8cbdd1b7a06f99
 SHA512:
-  metadata.gz: fdf3bda3807bbf83935287d370927b2c10d02b667a72468b620ad7745e7ecdbca275a519b574133f5107cfd4fbe17d4b9bdcb81acc59df61e082d40c0e6c91e9
-  data.tar.gz: f7a0085dc92fe04f4b11e6872b518ff6bc7382813195cbf7d929fcf7281152c388c3790f09d57c71a2971e6fae5b0b4b28448474fbabea55e656c715cbcde045
+  metadata.gz: a0b733fbad7e31b0f371fb832c86e958476ee29da4a83d06673b216829cca62a7262f719d378480a9f315997554883df44b1fddbe47082c4af28c14727e630d1
+  data.tar.gz: 54abb14762231cfb8dbfd87a21b4f86594f0cbcc666f3333920dd2922f104f41a4cb9fc9277376dee952b831a92c563a056c6485dbf79e3a6e7e088272d1e39e

data/edn-abnf.gemspec

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

data/lib/parser/edngrammar.rb

@@ -2634,6 +2634,28 @@ module EDNGRAMMAR
     def ast; elements[0].ast end
   end
 
+  module Bstr8
+    def sq_app_string_dt
+      elements[0]
+    end
+
+  end
+
+  module Bstr9
+    def ast; elements[0].ast end
+  end
+
+  module Bstr10
+    def raw_app_string_dt
+      elements[0]
+    end
+
+  end
+
+  module Bstr11
+    def ast; elements[0].ast end
+  end
+
   def _nt_bstr
     start_index = index
     if node_cache[:bstr].has_key?(index)
@@ -2766,38 +2788,100 @@ module EDNGRAMMAR
             r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
             r0 = r13
           else
-            r17 = _nt_app_string
+            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
-              r18 = _nt_sqstr
-              if r18
-                r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
-                r0 = r18
+              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
-                r19 = _nt_app_rstring
-                if r19
-                  r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
-                  r0 = r19
+                @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
-                  r20 = _nt_rawstring
-                  if r20
-                    r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
-                    r0 = r20
+                  r26 = _nt_sqstr
+                  if r26
+                    r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
+                    r0 = r26
                   else
-                    r21 = _nt_app_sequence
-                    if r21
-                      r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
-                      r0 = r21
+                    r27 = _nt_app_rstring
+                    if r27
+                      r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
+                      r0 = r27
                     else
-                      r22 = _nt_embedded
-                      if r22
-                        r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
-                        r0 = r22
+                      r28 = _nt_rawstring
+                      if r28
+                        r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
+                        r0 = r28
                       else
-                        @index = i0
-                        r0 = nil
+                        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
@@ -11603,6 +11687,943 @@ module EDNGRAMMAR
     r0
   end
 
+  def _nt_app_string_dt_prefix
+    start_index = index
+    if node_cache[:app_string_dt_prefix].has_key?(index)
+      cached = node_cache[:app_string_dt_prefix][index]
+      if cached
+        node_cache[:app_string_dt_prefix][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?("dt", false, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"dt"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      if (match_len = has_terminal?("DT", false, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"DT"')
+        r2 = nil
+      end
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:app_string_dt_prefix][start_index] = r0
+
+    r0
+  end
+
+  module SqAppStringDt0
+    def app_string_dt_prefix
+      elements[0]
+    end
+
+    def SQUOTE1
+      elements[1]
+    end
+
+    def app_string_dt
+      elements[2]
+    end
+
+    def SQUOTE2
+      elements[3]
+    end
+  end
+
+  module SqAppStringDt1
+    def ast
+        CBOR_DIAG::App_dt.decode(app_string_dt_prefix.text_value, app_string_dt.ast)
+      end
+  end
+
+  def _nt_sq_app_string_dt
+    start_index = index
+    if node_cache[:sq_app_string_dt].has_key?(index)
+      cached = node_cache[:sq_app_string_dt][index]
+      if cached
+        node_cache[:sq_app_string_dt][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_string_dt_prefix
+    s0 << r1
+    if r1
+      r2 = _nt_SQUOTE
+      s0 << r2
+      if r2
+        r3 = _nt_app_string_dt
+        s0 << r3
+        if r3
+          r4 = _nt_SQUOTE
+          s0 << r4
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(SqAppStringDt0)
+      r0.extend(SqAppStringDt1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:sq_app_string_dt][start_index] = r0
+
+    r0
+  end
+
+  module RawAppStringDt0
+    def app_string_dt_prefix
+      elements[0]
+    end
+
+    def app_string_dt_raw1
+      elements[1]
+    end
+  end
+
+  module RawAppStringDt1
+    def ast
+        CBOR_DIAG::App_dt.decode(app_string_dt_prefix.text_value, app_string_dt_raw1.ast)
+      end
+  end
+
+  def _nt_raw_app_string_dt
+    start_index = index
+    if node_cache[:raw_app_string_dt].has_key?(index)
+      cached = node_cache[:raw_app_string_dt][index]
+      if cached
+        node_cache[:raw_app_string_dt][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_string_dt_prefix
+    s0 << r1
+    if r1
+      r2 = _nt_app_string_dt_raw1
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(RawAppStringDt0)
+      r0.extend(RawAppStringDt1)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:raw_app_string_dt][start_index] = r0
+
+    r0
+  end
+
+  module AppStringDtRaw10
+  end
+
+  module AppStringDtRaw11
+    def ast; elements[1].ast; end
+  end
+
+  def _nt_app_string_dt_raw1
+    start_index = index
+    if node_cache[:app_string_dt_raw1].has_key?(index)
+      cached = node_cache[:app_string_dt_raw1][index]
+      if cached
+        node_cache[:app_string_dt_raw1][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
+      i2 = index
+      r3 = _nt_app_string_dt_raw2
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
+      else
+        r4 = _nt_app_string_dt_raw1
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
+        else
+          @index = i2
+          r2 = nil
+        end
+      end
+      s0 << r2
+      if r2
+        if (match_len = has_terminal?("`", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"`"')
+          r5 = nil
+        end
+        s0 << r5
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppStringDtRaw10)
+      r0.extend(AppStringDtRaw11)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:app_string_dt_raw1][start_index] = r0
+
+    r0
+  end
+
+  module AppStringDtRaw20
+    def app_string_dt
+      elements[1]
+    end
+  end
+
+  module AppStringDtRaw21
+    def ast; elements[1].ast; end
+  end
+
+  def _nt_app_string_dt_raw2
+    start_index = index
+    if node_cache[:app_string_dt_raw2].has_key?(index)
+      cached = node_cache[:app_string_dt_raw2][index]
+      if cached
+        node_cache[:app_string_dt_raw2][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r2 = _nt_newline
+    if r2
+      r1 = r2
+    else
+      r1 = instantiate_node(SyntaxNode,input, index...index)
+    end
+    s0 << r1
+    if r1
+      r3 = _nt_app_string_dt
+      s0 << r3
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(AppStringDtRaw20)
+      r0.extend(AppStringDtRaw21)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:app_string_dt_raw2][start_index] = r0
+
+    r0
+  end
+
+  module AppStringDt0
+    def ast; text_value; end
+  end
+
+  def _nt_app_string_dt
+    start_index = index
+    if node_cache[:app_string_dt].has_key?(index)
+      cached = node_cache[:app_string_dt][index]
+      if cached
+        node_cache[:app_string_dt][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    r0 = _nt_date_time
+    r0.extend(AppStringDt0)
+    r0.extend(AppStringDt0)
+
+    node_cache[:app_string_dt][start_index] = r0
+
+    r0
+  end
+
+  def _nt_date_fullyear
+    start_index = index
+    if node_cache[:date_fullyear].has_key?(index)
+      cached = node_cache[:date_fullyear][index]
+      if cached
+        node_cache[:date_fullyear][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 4
+        break
+      end
+    end
+    if s0.size < 4
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 4
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:date_fullyear][start_index] = r0
+
+    r0
+  end
+
+  def _nt_date_month
+    start_index = index
+    if node_cache[:date_month].has_key?(index)
+      cached = node_cache[:date_month][index]
+      if cached
+        node_cache[:date_month][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:date_month][start_index] = r0
+
+    r0
+  end
+
+  def _nt_date_mday
+    start_index = index
+    if node_cache[:date_mday].has_key?(index)
+      cached = node_cache[:date_mday][index]
+      if cached
+        node_cache[:date_mday][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:date_mday][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_hour
+    start_index = index
+    if node_cache[:time_hour].has_key?(index)
+      cached = node_cache[:time_hour][index]
+      if cached
+        node_cache[:time_hour][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:time_hour][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_minute
+    start_index = index
+    if node_cache[:time_minute].has_key?(index)
+      cached = node_cache[:time_minute][index]
+      if cached
+        node_cache[:time_minute][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:time_minute][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_second
+    start_index = index
+    if node_cache[:time_second].has_key?(index)
+      cached = node_cache[:time_second][index]
+      if cached
+        node_cache[:time_second][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      r1 = _nt_DIGIT
+      if r1
+        s0 << r1
+      else
+        break
+      end
+      if s0.size == 2
+        break
+      end
+    end
+    if s0.size < 2
+      @index = i0
+      r0 = nil
+    else
+      if s0.size < 2
+        @terminal_failures.pop
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:time_second][start_index] = r0
+
+    r0
+  end
+
+  module TimeSecfrac0
+  end
+
+  def _nt_time_secfrac
+    start_index = index
+    if node_cache[:time_secfrac].has_key?(index)
+      cached = node_cache[:time_secfrac][index]
+      if cached
+        node_cache[:time_secfrac][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_DIGIT
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeSecfrac0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_secfrac][start_index] = r0
+
+    r0
+  end
+
+  module TimeNumoffset0
+    def time_hour
+      elements[1]
+    end
+
+    def time_minute
+      elements[3]
+    end
+  end
+
+  def _nt_time_numoffset
+    start_index = index
+    if node_cache[:time_numoffset].has_key?(index)
+      cached = node_cache[:time_numoffset][index]
+      if cached
+        node_cache[:time_numoffset][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    i1 = index
+    if (match_len = has_terminal?("+", false, index))
+      r2 = true
+      @index += match_len
+    else
+      terminal_parse_failure('"+"')
+      r2 = nil
+    end
+    if r2
+      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+      r1 = 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
+        r1 = r3
+      else
+        @index = i1
+        r1 = nil
+      end
+    end
+    s0 << r1
+    if r1
+      r4 = _nt_time_hour
+      s0 << r4
+      if r4
+        if (match_len = has_terminal?(":", false, index))
+          r5 = true
+          @index += match_len
+        else
+          terminal_parse_failure('":"')
+          r5 = nil
+        end
+        s0 << r5
+        if r5
+          r6 = _nt_time_minute
+          s0 << r6
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(TimeNumoffset0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:time_numoffset][start_index] = r0
+
+    r0
+  end
+
+  def _nt_time_offset
+    start_index = index
+    if node_cache[:time_offset].has_key?(index)
+      cached = node_cache[:time_offset][index]
+      if cached
+        node_cache[:time_offset][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?("z", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"Z"')
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_time_numoffset
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:time_offset][start_index] = r0
+
+    r0
+  end
+
+  module PartialTime0
+    def time_hour
+      elements[0]
+    end
+
+    def time_minute
+      elements[2]
+    end
+
+    def time_second
+      elements[4]
+    end
+
+  end
+
+  def _nt_partial_time
+    start_index = index
+    if node_cache[:partial_time].has_key?(index)
+      cached = node_cache[:partial_time][index]
+      if cached
+        node_cache[:partial_time][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_time_hour
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?(":", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('":"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_time_minute
+        s0 << r3
+        if r3
+          if (match_len = has_terminal?(":", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('":"')
+            r4 = nil
+          end
+          s0 << r4
+          if r4
+            r5 = _nt_time_second
+            s0 << r5
+            if r5
+              r7 = _nt_time_secfrac
+              if r7
+                r6 = r7
+              else
+                r6 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s0 << r6
+            end
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(PartialTime0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:partial_time][start_index] = r0
+
+    r0
+  end
+
+  module FullDate0
+    def date_fullyear
+      elements[0]
+    end
+
+    def date_month
+      elements[2]
+    end
+
+    def date_mday
+      elements[4]
+    end
+  end
+
+  def _nt_full_date
+    start_index = index
+    if node_cache[:full_date].has_key?(index)
+      cached = node_cache[:full_date][index]
+      if cached
+        node_cache[:full_date][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_date_fullyear
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("-", false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"-"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_date_month
+        s0 << r3
+        if r3
+          if (match_len = has_terminal?("-", false, index))
+            r4 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"-"')
+            r4 = nil
+          end
+          s0 << r4
+          if r4
+            r5 = _nt_date_mday
+            s0 << r5
+          end
+        end
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(FullDate0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:full_date][start_index] = r0
+
+    r0
+  end
+
+  module FullTime0
+    def partial_time
+      elements[0]
+    end
+
+    def time_offset
+      elements[1]
+    end
+  end
+
+  def _nt_full_time
+    start_index = index
+    if node_cache[:full_time].has_key?(index)
+      cached = node_cache[:full_time][index]
+      if cached
+        node_cache[:full_time][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_partial_time
+    s0 << r1
+    if r1
+      r2 = _nt_time_offset
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(FullTime0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:full_time][start_index] = r0
+
+    r0
+  end
+
+  module DateTime0
+    def full_date
+      elements[0]
+    end
+
+    def full_time
+      elements[2]
+    end
+  end
+
+  def _nt_date_time
+    start_index = index
+    if node_cache[:date_time].has_key?(index)
+      cached = node_cache[:date_time][index]
+      if cached
+        node_cache[:date_time][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_full_date
+    s0 << r1
+    if r1
+      if (match_len = has_terminal?("t", :insens, index))
+        r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
+      else
+        terminal_parse_failure('"T"')
+        r2 = nil
+      end
+      s0 << r2
+      if r2
+        r3 = _nt_full_time
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(DateTime0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:date_time][start_index] = r0
+
+    r0
+  end
+
 
   class Parser < Treetop::Runtime::CompiledParser
     include EDNGRAMMAR

metadata

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