edn-abnf 0.0.10 → 0.0.12

data/lib/parser/edn-util.rb

@@ -19,5 +19,6 @@ end
 
 
 require 'cbor-diagnostic-app/dt'
+require 'cbor-diagnostic-app/ip'
 require 'cbor-diagnostic-app/h'
 require 'cbor-diagnostic-app/b64'

data/lib/parser/edngrammar.rb

@@ -289,13 +289,13 @@ module EDNGRAMMAR
     r0
   end
 
-  module String0
+  module String10
     def spec
       elements[1]
     end
   end
 
-  module String1
+  module String11
     def ast
       if ei = spec.text_value[1..-1]
          warn "*** ignoring unimplemented encoding indicator #{ei.inspect} for #{elements[0].text_value}"
@@ -304,12 +304,12 @@ module EDNGRAMMAR
     end
   end
 
-  def _nt_string
+  def _nt_string1
     start_index = index
-    if node_cache[:string].has_key?(index)
-      cached = node_cache[:string][index]
+    if node_cache[:string1].has_key?(index)
+      cached = node_cache[:string1][index]
       if cached
-        node_cache[:string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        node_cache[:string1][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
         @index = cached.interval.end
       end
       return cached
@@ -338,8 +338,180 @@ module EDNGRAMMAR
     end
     if s0.last
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(String0)
+      r0.extend(String10)
+      r0.extend(String11)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:string1][start_index] = r0
+
+    r0
+  end
+
+  def _nt_string1e
+    start_index = index
+    if node_cache[:string1e].has_key?(index)
+      cached = node_cache[:string1e][index]
+      if cached
+        node_cache[:string1e][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_string1
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      r2 = _nt_ellipsis
+      if r2
+        r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:string1e][start_index] = r0
+
+    r0
+  end
+
+  module Ellipsis0
+    def ast; CBOR::Tagged.new(888, nil) end
+  end
+
+  def _nt_ellipsis
+    start_index = index
+    if node_cache[:ellipsis].has_key?(index)
+      cached = node_cache[:ellipsis][index]
+      if cached
+        node_cache[:ellipsis][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if (match_len = has_terminal?(".", false, index))
+        r1 = true
+        @index += match_len
+      else
+        terminal_parse_failure('"."')
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.size < 3
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+      r0.extend(Ellipsis0)
+      r0.extend(Ellipsis0)
+    end
+
+    node_cache[:ellipsis][start_index] = r0
+
+    r0
+  end
+
+  module String0
+    def S
+      elements[0]
+    end
+
+    def string1e
+      elements[1]
+    end
+  end
+
+  module String1
+    def string1e
+      elements[0]
+    end
+
+  end
+
+  module String2
+    def join1(s)
+      s.join # XXX -- look at encoding and ei
+    end
+    def unpack_chunk(c, s)
+      if c == String
+        join1(s)
+      else
+        unless c == CBOR::Tagged && s.first.tag == 888 && s.first.value == nil # XXX check all values?
+          raise "*** unjoinable chunks #{c.inspect} #{s.inspect}" if s.size != 1
+        end
+        s.first
+      end
+    end
+    def ast
+      arr = [elements[0].ast] + elements[1].elements.map {|x| x.elements[1].ast}
+      charr = arr.chunk(&:class).to_a
+      if charr.size == 1
+        unpack_chunk(*charr.first)
+      else
+        CBOR::Tagged.new(888, charr.map {|x| unpack_chunk(*x)})
+      end
+    end
+  end
+
+  def _nt_string
+    start_index = index
+    if node_cache[:string].has_key?(index)
+      cached = node_cache[:string][index]
+      if cached
+        node_cache[:string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_string1e
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        i3, s3 = index, []
+        r4 = _nt_S
+        s3 << r4
+        if r4
+          r5 = _nt_string1e
+          s3 << r5
+        end
+        if s3.last
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          r3.extend(String0)
+        else
+          @index = i3
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      s0 << r2
+    end
+    if s0.last
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
       r0.extend(String1)
+      r0.extend(String2)
     else
       @index = i0
       r0 = nil
@@ -1228,6 +1400,13 @@ module EDNGRAMMAR
 
   end
 
+  module AppPrefix1
+    def ucalpha
+      elements[0]
+    end
+
+  end
+
   def _nt_app_prefix
     start_index = index
     if node_cache[:app_prefix].has_key?(index)
@@ -1239,28 +1418,64 @@ module EDNGRAMMAR
       return cached
     end
 
-    i0, s0 = index, []
-    r1 = _nt_lcalpha
-    s0 << r1
-    if r1
-      s2, i2 = [], index
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_lcalpha
+    s1 << r2
+    if r2
+      s3, i3 = [], index
       loop do
-        r3 = _nt_lcalnum
-        if r3
-          s2 << r3
+        r4 = _nt_lcalnum
+        if r4
+          s3 << r4
         else
           break
         end
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
+      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+      s1 << r3
     end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(AppPrefix0)
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(AppPrefix0)
     else
-      @index = i0
-      r0 = nil
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+      r0 = r1
+    else
+      i5, s5 = index, []
+      r6 = _nt_ucalpha
+      s5 << r6
+      if r6
+        s7, i7 = [], index
+        loop do
+          r8 = _nt_ucalnum
+          if r8
+            s7 << r8
+          else
+            break
+          end
+        end
+        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+        s5 << r7
+      end
+      if s5.last
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        r5.extend(AppPrefix1)
+      else
+        @index = i5
+        r5 = nil
+      end
+      if r5
+        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+        r0 = r5
+      else
+        @index = i0
+        r0 = nil
+      end
     end
 
     node_cache[:app_prefix][start_index] = r0
@@ -1284,7 +1499,8 @@ module EDNGRAMMAR
       app = app_prefix.text_value
       # Find a better place to put a default initialization
       EDNGRAMMAR.const_set(:APPS, Hash.new { |h, k|
-                             h[k] = begin ::CBOR_DIAG.const_get("App_#{app}")
+                             h[k] = begin ::CBOR_DIAG.const_get("App_#{app.downcase}")
+  
                                     rescue NameError
                                       raise ArgumentError, "cbor-diagnostic: Unknown application-oriented extension '#{k}'", caller
                                     end
@@ -3924,6 +4140,62 @@ module EDNGRAMMAR
     r0
   end
 
+  def _nt_ucalpha
+    start_index = index
+    if node_cache[:ucalpha].has_key?(index)
+      cached = node_cache[:ucalpha][index]
+      if cached
+        node_cache[:ucalpha][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
+      r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('[A-Z]')
+      r0 = nil
+    end
+
+    node_cache[:ucalpha][start_index] = r0
+
+    r0
+  end
+
+  def _nt_ucalnum
+    start_index = index
+    if node_cache[:ucalnum].has_key?(index)
+      cached = node_cache[:ucalnum][index]
+      if cached
+        node_cache[:ucalnum][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_ucalpha
+    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
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:ucalnum][start_index] = r0
+
+    r0
+  end
+
   def _nt_wordchar
     start_index = index
     if node_cache[:wordchar].has_key?(index)
@@ -3952,13 +4224,7 @@ module EDNGRAMMAR
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
       else
-        if has_terminal?(@regexps[gr = '\A[A-Z]'] ||= Regexp.new(gr), :regexp, index)
-          r3 = true
-          @index += 1
-        else
-          terminal_parse_failure('[A-Z]')
-          r3 = nil
-        end
+        r3 = _nt_ucalpha
         if r3
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: edn-abnf
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.12
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-12 00:00:00.000000000 Z
+date: 2023-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,8 +94,12 @@ files:
 - edn-abnf.gemspec
 - lib/cbor-diagnostic-app/b64.rb
 - lib/cbor-diagnostic-app/b64grammar.rb
+- lib/cbor-diagnostic-app/dt.rb
+- lib/cbor-diagnostic-app/dtgrammar.rb
 - lib/cbor-diagnostic-app/h.rb
 - lib/cbor-diagnostic-app/hgrammar.rb
+- lib/cbor-diagnostic-app/ip.rb
+- lib/cbor-diagnostic-app/ipgrammar.rb
 - lib/edn-abnf.rb
 - lib/parser/edn-util.rb
 - lib/parser/edngrammar.rb