cddlc 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 441f617191e302fe38e2a0622ab0cc7e218ab88b5753565b7d156e0d4648da8e
-  data.tar.gz: 4a79ff5132f0a0c92a011a50ea238f9c58472cea52f27c7edd502e057f4dd570
+  metadata.gz: e4755090b14758b52954844be6c4fd916c2059758e60d06973e662796dc67f02
+  data.tar.gz: bbf25920e39e2dc432a77bd72e30007b608a4fb8e0d0c3e696e6dceeb1f35fa8
 SHA512:
-  metadata.gz: 631b1d41853d7b8f6a1df2a0ba47c8a474d3142daa8282bb83dbc86434a824b188a033cebdb892b8e7e5b4c08fec7e24dd88933e6de11e210b077a5ff666ce88
-  data.tar.gz: 1c2f44dbc2a98c1716b0758be614f8872b8a1921a2ffd9061099425d5e84d8861785204f1c80d1f9dd5f77f8583138a95d44489978834e0df83e4dacd7686624
+  metadata.gz: baf2caf2e3bdfffe7313b20f5f28352b16c8fa90e94be4a8842367e6c469a11dcdd5e44b40eae728fdf9d31a2e5467b91d537dfeb45ffa8a7d38c628afa4251b
+  data.tar.gz: 40cb808432a3c6ef55061323c04712eebd884eeafa23f85e6b78946006e7e78e04a325c1e090bcb78c22f5a9f1856a46b69f54497757cda73028f3ddd2cd2030

data/cddlc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "cddlc"
-  s.version = "0.0.3"
+  s.version = "0.0.4"
   s.summary = "CDDL (Concise Data Definition Language) converters and miscellaneous tools"
   s.description = %q{cddlc implements converters and miscellaneous tools for CDDL, RFC 8610}
   s.author = "Carsten Bormann"

data/lib/parser/cddlgrammar.rb

@@ -3280,23 +3280,92 @@ module CDDLGRAMMAR
   end
 
   module Hexchar0
+    def high_surrogate
+      elements[0]
+    end
+
+    def low_surrogate
+      elements[3]
+    end
   end
 
-  module Hexchar1
+  def _nt_hexchar
+    start_index = index
+    if node_cache[:hexchar].has_key?(index)
+      cached = node_cache[:hexchar][index]
+      if cached
+        node_cache[:hexchar][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_non_surrogate
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i2, s2 = index, []
+      r3 = _nt_high_surrogate
+      s2 << r3
+      if r3
+        if (match_len = has_terminal?("\\", false, index))
+          r4 = true
+          @index += match_len
+        else
+          terminal_parse_failure('"\\\\"')
+          r4 = nil
+        end
+        s2 << r4
+        if r4
+          if (match_len = has_terminal?("u", false, index))
+            r5 = true
+            @index += match_len
+          else
+            terminal_parse_failure('"u"')
+            r5 = nil
+          end
+          s2 << r5
+          if r5
+            r6 = _nt_low_surrogate
+            s2 << r6
+          end
+        end
+      end
+      if s2.last
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        r2.extend(Hexchar0)
+      else
+        @index = i2
+        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[:hexchar][start_index] = r0
+
+    r0
   end
 
-  module Hexchar2
+  module NonSurrogate0
   end
 
-  module Hexchar3
+  module NonSurrogate1
   end
 
-  def _nt_hexchar
+  def _nt_non_surrogate
     start_index = index
-    if node_cache[:hexchar].has_key?(index)
-      cached = node_cache[:hexchar][index]
+    if node_cache[:non_surrogate].has_key?(index)
+      cached = node_cache[:non_surrogate][index]
       if cached
-        node_cache[:hexchar][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:non_surrogate][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -3400,7 +3469,7 @@ module CDDLGRAMMAR
     end
     if s1.last
       r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(Hexchar0)
+      r1.extend(NonSurrogate0)
     else
       @index = i1
       r1 = nil
@@ -3419,270 +3488,284 @@ module CDDLGRAMMAR
       end
       s11 << r12
       if r12
-        i13 = index
-        i14, s14 = index, []
         if has_terminal?(@regexps[gr = '\A[0-7]'] ||= Regexp.new(gr), :regexp, index)
-          r15 = true
+          r13 = true
           @index += 1
         else
           terminal_parse_failure('[0-7]')
-          r15 = nil
+          r13 = nil
         end
-        s14 << r15
-        if r15
-          s16, i16 = [], index
+        s11 << r13
+        if r13
+          s14, i14 = [], index
           loop do
-            r17 = _nt_HEXDIG
-            if r17
-              s16 << r17
+            r15 = _nt_HEXDIG
+            if r15
+              s14 << r15
             else
               break
             end
-            if s16.size == 2
+            if s14.size == 2
               break
             end
           end
-          if s16.size < 2
-            @index = i16
-            r16 = nil
+          if s14.size < 2
+            @index = i14
+            r14 = nil
           else
-            if s16.size < 2
+            if s14.size < 2
               @terminal_failures.pop
             end
-            r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
+            r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
           end
-          s14 << r16
+          s11 << r14
         end
-        if s14.last
-          r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
-          r14.extend(Hexchar1)
+      end
+      if s11.last
+        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+        r11.extend(NonSurrogate1)
+      else
+        @index = i11
+        r11 = nil
+      end
+      if r11
+        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
+        r0 = r11
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:non_surrogate][start_index] = r0
+
+    r0
+  end
+
+  module HighSurrogate0
+  end
+
+  def _nt_high_surrogate
+    start_index = index
+    if node_cache[:high_surrogate].has_key?(index)
+      cached = node_cache[:high_surrogate][index]
+      if cached
+        node_cache[:high_surrogate][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?("d", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"D"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      i2 = index
+      if (match_len = has_terminal?("8", false, index))
+        r3 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"8"')
+        r3 = nil
+      end
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
+      else
+        if (match_len = has_terminal?("9", false, index))
+          r4 = true
+          @index += match_len
         else
-          @index = i14
-          r14 = nil
+          terminal_parse_failure('"9"')
+          r4 = nil
         end
-        if r14
-          r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
-          r13 = r14
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
         else
-          i18, s18 = index, []
-          i19 = index
-          if (match_len = has_terminal?("8", false, index))
-            r20 = true
+          if (match_len = has_terminal?("a", :insens, index))
+            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
             @index += match_len
           else
-            terminal_parse_failure('"8"')
-            r20 = nil
+            terminal_parse_failure('"A"')
+            r5 = nil
           end
-          if r20
-            r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
-            r19 = r20
+          if r5
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r2 = r5
           else
-            if (match_len = has_terminal?("9", false, index))
-              r21 = true
+            if (match_len = has_terminal?("b", :insens, index))
+              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
               @index += match_len
             else
-              terminal_parse_failure('"9"')
-              r21 = nil
-            end
-            if r21
-              r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
-              r19 = r21
-            else
-              if (match_len = has_terminal?("a", :insens, index))
-                r22 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                @index += match_len
-              else
-                terminal_parse_failure('"A"')
-                r22 = nil
-              end
-              if r22
-                r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
-                r19 = r22
-              else
-                if (match_len = has_terminal?("b", :insens, index))
-                  r23 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                  @index += match_len
-                else
-                  terminal_parse_failure('"B"')
-                  r23 = nil
-                end
-                if r23
-                  r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
-                  r19 = r23
-                else
-                  @index = i19
-                  r19 = nil
-                end
-              end
-            end
-          end
-          s18 << r19
-          if r19
-            s24, i24 = [], index
-            loop do
-              r25 = _nt_HEXDIG
-              if r25
-                s24 << r25
-              else
-                break
-              end
-              if s24.size == 2
-                break
-              end
+              terminal_parse_failure('"B"')
+              r6 = nil
             end
-            if s24.size < 2
-              @index = i24
-              r24 = nil
+            if r6
+              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+              r2 = r6
             else
-              if s24.size < 2
-                @terminal_failures.pop
-              end
-              r24 = instantiate_node(SyntaxNode,input, i24...index, s24)
-            end
-            s18 << r24
-            if r24
-              if (match_len = has_terminal?("\\", false, index))
-                r26 = true
-                @index += match_len
-              else
-                terminal_parse_failure('"\\\\"')
-                r26 = nil
-              end
-              s18 << r26
-              if r26
-                if (match_len = has_terminal?("u", false, index))
-                  r27 = true
-                  @index += match_len
-                else
-                  terminal_parse_failure('"u"')
-                  r27 = nil
-                end
-                s18 << r27
-                if r27
-                  if (match_len = has_terminal?("d", :insens, index))
-                    r28 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                    @index += match_len
-                  else
-                    terminal_parse_failure('"D"')
-                    r28 = nil
-                  end
-                  s18 << r28
-                  if r28
-                    i29 = index
-                    if (match_len = has_terminal?("c", :insens, index))
-                      r30 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                      @index += match_len
-                    else
-                      terminal_parse_failure('"C"')
-                      r30 = nil
-                    end
-                    if r30
-                      r30 = SyntaxNode.new(input, (index-1)...index) if r30 == true
-                      r29 = r30
-                    else
-                      if (match_len = has_terminal?("d", :insens, index))
-                        r31 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                        @index += match_len
-                      else
-                        terminal_parse_failure('"D"')
-                        r31 = nil
-                      end
-                      if r31
-                        r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
-                        r29 = r31
-                      else
-                        if (match_len = has_terminal?("e", :insens, index))
-                          r32 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                          @index += match_len
-                        else
-                          terminal_parse_failure('"E"')
-                          r32 = nil
-                        end
-                        if r32
-                          r32 = SyntaxNode.new(input, (index-1)...index) if r32 == true
-                          r29 = r32
-                        else
-                          if (match_len = has_terminal?("f", :insens, index))
-                            r33 = instantiate_node(SyntaxNode,input, index...(index + match_len))
-                            @index += match_len
-                          else
-                            terminal_parse_failure('"F"')
-                            r33 = nil
-                          end
-                          if r33
-                            r33 = SyntaxNode.new(input, (index-1)...index) if r33 == true
-                            r29 = r33
-                          else
-                            @index = i29
-                            r29 = nil
-                          end
-                        end
-                      end
-                    end
-                    s18 << r29
-                    if r29
-                      s34, i34 = [], index
-                      loop do
-                        r35 = _nt_HEXDIG
-                        if r35
-                          s34 << r35
-                        else
-                          break
-                        end
-                        if s34.size == 2
-                          break
-                        end
-                      end
-                      if s34.size < 2
-                        @index = i34
-                        r34 = nil
-                      else
-                        if s34.size < 2
-                          @terminal_failures.pop
-                        end
-                        r34 = instantiate_node(SyntaxNode,input, i34...index, s34)
-                      end
-                      s18 << r34
-                    end
-                  end
-                end
-              end
+              @index = i2
+              r2 = nil
             end
           end
-          if s18.last
-            r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
-            r18.extend(Hexchar2)
+        end
+      end
+      s0 << r2
+      if r2
+        s7, i7 = [], index
+        loop do
+          r8 = _nt_HEXDIG
+          if r8
+            s7 << r8
           else
-            @index = i18
-            r18 = nil
+            break
           end
-          if r18
-            r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
-            r13 = r18
-          else
-            @index = i13
-            r13 = nil
+          if s7.size == 2
+            break
           end
         end
-        s11 << r13
+        if s7.size < 2
+          @index = i7
+          r7 = nil
+        else
+          if s7.size < 2
+            @terminal_failures.pop
+          end
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+        end
+        s0 << r7
       end
-      if s11.last
-        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-        r11.extend(Hexchar3)
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(HighSurrogate0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:high_surrogate][start_index] = r0
+
+    r0
+  end
+
+  module LowSurrogate0
+  end
+
+  def _nt_low_surrogate
+    start_index = index
+    if node_cache[:low_surrogate].has_key?(index)
+      cached = node_cache[:low_surrogate][index]
+      if cached
+        node_cache[:low_surrogate][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?("d", :insens, index))
+      r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+      @index += match_len
+    else
+      terminal_parse_failure('"D"')
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      i2 = index
+      if (match_len = has_terminal?("c", :insens, index))
+        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+        @index += match_len
       else
-        @index = i11
-        r11 = nil
+        terminal_parse_failure('"C"')
+        r3 = nil
       end
-      if r11
-        r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
-        r0 = r11
+      if r3
+        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+        r2 = r3
       else
-        @index = i0
-        r0 = nil
+        if (match_len = has_terminal?("d", :insens, index))
+          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          @index += match_len
+        else
+          terminal_parse_failure('"D"')
+          r4 = nil
+        end
+        if r4
+          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+          r2 = r4
+        else
+          if (match_len = has_terminal?("e", :insens, index))
+            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('"E"')
+            r5 = nil
+          end
+          if r5
+            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+            r2 = r5
+          else
+            if (match_len = has_terminal?("f", :insens, index))
+              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+              @index += match_len
+            else
+              terminal_parse_failure('"F"')
+              r6 = nil
+            end
+            if r6
+              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
+              r2 = r6
+            else
+              @index = i2
+              r2 = nil
+            end
+          end
+        end
+      end
+      s0 << r2
+      if r2
+        s7, i7 = [], index
+        loop do
+          r8 = _nt_HEXDIG
+          if r8
+            s7 << r8
+          else
+            break
+          end
+          if s7.size == 2
+            break
+          end
+        end
+        if s7.size < 2
+          @index = i7
+          r7 = nil
+        else
+          if s7.size < 2
+            @terminal_failures.pop
+          end
+          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+        end
+        s0 << r7
       end
     end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(LowSurrogate0)
+    else
+      @index = i0
+      r0 = nil
+    end
 
-    node_cache[:hexchar][start_index] = r0
+    node_cache[:low_surrogate][start_index] = r0
 
     r0
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddlc
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-13 00:00:00.000000000 Z
+date: 2021-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler