cddlc 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cf26993bc0f0556758da6e5567849461b1b6e2779c02e7a1bf8be89f3466747
-  data.tar.gz: 6d3a7a675a37815fc23fe4cbbe786698fc996cb6b7bb9cbfec5572bb74d50520
+  metadata.gz: f2a8aaeed392227b1d7650ddc62d010a577360f06c3bd07f879dd22d6a2e3ce9
+  data.tar.gz: e0db7efbdb77e5cc3f770e6a586ce710414e82419127f7b08302248943f1e045
 SHA512:
-  metadata.gz: cbbbd25e3cbd37740b856de841a844ce644ef5efc9a97e9966714810db7fb3b070821774a7da17a0d8e20c2047c591de0579d16ba5a12bf8b399578275862a21
-  data.tar.gz: 2fb8b0946855f67c1e6a17f13837cf6484bdc69e01e5f353c8815ceb9ca09f1fc42a5ac02c8449d79973ccac7b205b845716c48314668da9f76bbff986a63b16
+  metadata.gz: 2b95180d14a2cab74e89e76a753a8519f3aa2b17abc7809ed5b9fd1bbbaf20e2dee87a6635c279b35d89cb754b2e9ac4b9051c4eb15a628ac6accb2ad5f3ccb1
+  data.tar.gz: 1ad97e5fc8ac2b5242dacedb9a8521b4ea376c79f54669370d7a1d1156d10ce6ca2b3d9ce2075844d5991dee8d1fa36e17fd9d5a175317f14516e92314396e89

data/cddlc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "cddlc"
-  s.version = "0.4.1"
+  s.version = "0.4.2"
   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/cddlc.rb

@@ -321,4 +321,51 @@ class CDDL
     end
     @prelude
   end
+
+  # In each specific case, use the appropriate subset
+  ESCAPED_STRING_MAPPINGS = Hash[[
+                                   ["\x08", "b"],
+                                   ["\x09", "t"],
+                                   ["\x0A", "n"],
+                                   ["\x0C", "f"],
+                                   ["\x0D", "r"],
+                                   ["\x22", "\""],
+                                   ["\x27", "'"],
+                                   ["\x2F", "/"],
+                                   ["\x5C", "\\"],
+                                 ]]
+
+  # TODO: Enable selecting Unicode-friendly variants
+  def escape_string(s, regexp = /[^\n !#-\[\]-~]/)
+    s.gsub(regexp) {|ch|
+      if m = ESCAPED_STRING_MAPPINGS[ch]
+        "\\#{m}"
+      elsif (o = ch.ord) < 0x10000
+        "\\u#{"%04x" % o}"
+      else
+        "\\u{#{"%x" % o}}"
+      end
+    }
+  end
+
+  def escape_byte_string(s)
+    escape_string(s, /[^\n -&(-\[\]-~]/)
+  end
+
+  def bytes_escaped(tesc, t)
+    if tesc.nil?
+      case t
+      in ["", text]
+        "'" + escape_byte_string(text)
+      in [/\Ah\z/i, text]
+        "h'" + escape_byte_string(text)
+      in [/\Ab64\z/i, text]
+        "b64'" + escape_byte_string(text)
+      # else error
+      end + "'"
+    else
+      tesc
+    end
+  end
+
 end

data/lib/parser/cddlgrammar.rb

@@ -4166,7 +4166,9 @@ module CDDLGRAMMAR
   end
 
   module Bytes1
-    def ast() ["bytes", text_value] end
+    def ast()
+           ["bytes", [elements[0].text_value, elements[2].elements.map(&:ast).join], text_value]
+                                       end
   end
 
   def _nt_bytes
@@ -4235,6 +4237,30 @@ module CDDLGRAMMAR
     r0
   end
 
+  module BCHAR0
+    def ast() text_value end
+  end
+
+  module BCHAR1
+    def ast() text_value end
+  end
+
+  module BCHAR2
+    def ast() text_value end
+  end
+
+  module BCHAR3
+    def ast() text_value end
+  end
+
+  module BCHAR4
+    def ast() "'" end
+  end
+
+  module BCHAR5
+    def ast() "\n" end
+  end
+
   def _nt_BCHAR
     start_index = index
     if node_cache[:BCHAR].has_key?(index)
@@ -4248,7 +4274,9 @@ module CDDLGRAMMAR
 
     i0 = index
     if has_terminal?(@regexps[gr = '\A[\\ -&]'] ||= Regexp.new(gr), :regexp, index)
-      r1 = true
+      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      r1.extend(BCHAR0)
+      r1.extend(BCHAR0)
       @index += 1
     else
       terminal_parse_failure('[\\ -&]')
@@ -4259,7 +4287,9 @@ module CDDLGRAMMAR
       r0 = r1
     else
       if has_terminal?(@regexps[gr = '\A[\\(-\\[]'] ||= Regexp.new(gr), :regexp, index)
-        r2 = true
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r2.extend(BCHAR1)
+        r2.extend(BCHAR1)
         @index += 1
       else
         terminal_parse_failure('[\\(-\\[]')
@@ -4270,7 +4300,9 @@ module CDDLGRAMMAR
         r0 = r2
       else
         if has_terminal?(@regexps[gr = '\A[\\]-~]'] ||= Regexp.new(gr), :regexp, index)
-          r3 = true
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          r3.extend(BCHAR2)
+          r3.extend(BCHAR2)
           @index += 1
         else
           terminal_parse_failure('[\\]-~]')
@@ -4281,6 +4313,8 @@ module CDDLGRAMMAR
           r0 = r3
         else
           r4 = _nt_NONASCII
+          r4.extend(BCHAR3)
+          r4.extend(BCHAR3)
           if r4
             r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
             r0 = r4
@@ -4292,6 +4326,7 @@ module CDDLGRAMMAR
             else
               if (match_len = has_terminal?("\\'", false, index))
                 r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+                r6.extend(BCHAR4)
                 @index += match_len
               else
                 terminal_parse_failure('"\\\\\'"')
@@ -4302,6 +4337,8 @@ module CDDLGRAMMAR
                 r0 = r6
               else
                 r7 = _nt_CRLF
+                r7.extend(BCHAR5)
+                r7.extend(BCHAR5)
                 if r7
                   r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                   r0 = r7
@@ -5148,9 +5185,11 @@ module CDDLGRAMMAR
     r0
   end
 
-end
 
-class CDDLGRAMMARParser < Treetop::Runtime::CompiledParser
-  include CDDLGRAMMAR
+  class Parser < Treetop::Runtime::CompiledParser
+    include CDDLGRAMMAR
+  end
 end
 
+CDDLGRAMMARParser = CDDLGRAMMAR::Parser
+

data/lib/validator/validate.rb

@@ -28,6 +28,34 @@ class CDDL
   CDDLC_INVENT = ENV["CDDLC_INVENT"]
   CDDLC_DEBUG = ENV["CDDLC_DEBUG"]
 
+  FEATURE_REJECT_RE = /\A\^/
+  # CDDLC_FEATURE_OK=cbor,^json
+  CDDLC_FEATURE_OK, CDDLC_FEATURE_REJECT =
+                   if ok = ENV["CDDLC_FEATURE_OK"]
+                     ok.split(/,\s*/)
+                       .partition{|s| s[0] !~ FEATURE_REJECT_RE}
+                       .map {|l| Hash[l.map {|feature|
+                                        [feature.sub(FEATURE_REJECT_RE, ''),
+                                         true]}]}
+                   else
+                     [{}, {}]
+                   end
+
+  REGEXP_FOR_STRING = Hash.new {|h, k|
+    h[k] = Regexp.new("\\A(?:#{k})\\z")
+  }
+
+  ABNF_PARSER_FOR_STRING = Hash.new {|h, k|
+    grammar = "cddl-t0p--1eve1-f0r--abnf = " << k # XXX
+    h[k] = ABNF.from_abnf(grammar)
+  }
+
+  ABNF_ENCODING_FOR_CONOP = {
+    ".abnf" => Encoding::UTF_8,
+    ".abnfb" => Encoding::BINARY
+  }
+
+
   # library:
 
   def remove_indentation(s)
@@ -185,47 +213,14 @@ class CDDL
               item, where, :out_of_range)
           end
         end
-      in ".cat" | ".det"
-        lhss, lhsv, lhst = extract_value(lhs)
-        rhss, rhsv, rhst = extract_value(rhs)
-        if !lhss || !rhss
-          [false, item, {UNSPECIFIC_STRING_CAT: [op, lhs, rhs]}, []]
-        elsif [lhsv, rhsv].any? {!(String === _1)}
-          [false, item, {NON_STRING_CAT: [op, lhs, rhs]}, []]
+      in ".cat" | ".det" | ".plus"
+        s, v, t = extract_value(where)
+        pp [:CAT_DET_PLUS, s, v, t, item, scalar_type(item)] if CDDLC_DEBUG
+        if s
+          simple_result(s && scalar_type(item) == t && item == v,
+                      item, where, :no_match)
         else
-          if op == ".det"
-            lhsv = remove_indentation(lhsv)
-            rhsv = remove_indentation(rhsv)
-          end
-          case [lhst, rhst]
-          in [:text, :text] | [:bytes, :bytes]
-            result = lhsv + rhsv
-          in [:bytes, :text]
-            result = (lhsv + rhsv.b).b
-          in [:text, :bytes]
-              result = lhsv + rhsv.force_encoding(Encoding::UTF_8)
-              unless result.valid_encoding?
-                return [false, item, {text_encoding_error: [lhst, lhsv, rhst, rhsv]}, []]
-              end
-          end
-          simple_result(scalar_type(item) == lhst && item == result,
-                        item, where, :no_match)
-        end
-      in ".plus"
-        lhss, lhsv, lhst = extract_value(lhs)
-        rhss, rhsv, rhst = extract_value(rhs)
-        if !lhss || !rhss
-          [false, item, {UNSPECIFIC_PLUS: [op, lhs, rhs]}, []]
-        elsif [lhsv, rhsv].any? {!(Numeric === _1)}
-          [false, item, {NON_NUMERIC_PLUS: [op, lhs, rhs]}, []]
-        else
-          if lhst == :int
-            result = lhsv + Integer(rhsv)
-          elsif lhst == :float
-            result = rbv + rhsv
-          end
-          simple_result(item.eql?(result),
-                        item, where, :no_match)
+          [false, item, v, []]
         end
       in ".size"
         anno = :lhs
@@ -245,6 +240,7 @@ class CDDL
           end
         end
       in ".bits"
+        anno = :lhs
         r = validate1(item, lhs)
         if r[0]
             if String === item
@@ -272,6 +268,60 @@ class CDDL
               end
             end
         end
+      in ".default"
+        # anno = :lhs
+        r = validate1(item, lhs)
+        # TO DO
+        unless @default_warned
+          warn "*** Ignoring .default for now."
+          @default_warned = true
+        end
+        r
+      in ".feature"
+        r = validate1(item, lhs)
+        if r[0]
+          nm, det = extract_feature(rhs, d)
+          if CDDLC_FEATURE_REJECT[nm]
+            [false, item, {:rejected_feature => [nm, det]}, []]
+          else
+            [true, item, {:accepted_feature => [nm, det]}, []]
+          end
+        end
+
+      in ".regexp"
+        anno = :lhs
+        r = validate1(item, lhs)
+        if r[0]
+          if String === item
+              ok, v, vt = extract_value(rhs)
+              if ok && :text == vt
+                re = REGEXP_FOR_STRING[v]
+                # pp re if CDDLC_DEBUG
+                simple_result(item.match(re),
+                              item, where, :regexp_not_matched)
+              end
+          end
+        end
+      in ".abnf" | ".abnfb"
+        anno = :lhs
+        r = validate1(item, lhs)
+        if r[0]
+            if String === item
+              ok, v, vt = extract_value(rhs)
+              # pp [:abnfex, rhs, ok, v, vt] if CDDLC_DEBUG
+              if ok && (:text == vt || :bytes == vt)
+                begin
+                  ABNF_PARSER_FOR_STRING[v].validate(
+                    item.dup.force_encoding(ABNF_ENCODING_FOR_CONOP[op]).codepoints.pack("U*"))
+                  [true, item, {abnf: [v]}, [r]]
+                rescue => e
+                  # warn "*** #{e}" # XXX
+                  [false, item, {abnf_not_matched: [v, e.to_s.force_encoding(Encoding::UTF_8)] }, [r]]
+                end
+              end
+            end
+        end
+
       else
         fail [:CONTROL_UNIMPLEMENTED, op, item, where].inspect
       end
@@ -280,7 +330,6 @@ class CDDL
       exit 1
     end || [false, item, {anno => [item, where]}, []]
   end
-end
 
 def scalar_type(item)
   case item
@@ -327,7 +376,27 @@ def biggify(d)                  # stand-in for real stand-ins
   CBOR::Tagged.new(t, d == 0 ? "".b : d.digits(256).reverse!.pack("C*"))
 end
 
-def extract_value(wh)           # XXX complete: .cat/plus/det
+def extract_bytes(bsqual, bsval)
+  if bsqual == ""
+    bsval.b
+  else
+    bsclean = bsval.gsub(/\s/, "")
+    case bsqual
+    in /\Ah\z/i
+      bsclean.chars.each_slice(2).map{ |x| Integer(x.join, 16).chr("BINARY") }.join.b
+    in /\Ab64\z/i
+      begin
+        Base64.urlsafe_decode64(bsclean)
+      rescue ArgumentError => e
+        {base64_error: [bsclean, e.to_s]}
+      end
+    else
+      warn "*** Can't handle byte string type #{bsqual.inspect} yet"
+    end
+  end
+end
+
+def extract_value(wh)
   case wh
   in x if a = SIMPLE_VALUE[x]
     SIMPLE_VALUE[x]
@@ -335,9 +404,86 @@ def extract_value(wh)           # XXX complete: .cat/plus/det
     [true, Integer(num), :int] rescue [true, Float(num), :float]
   in ["text", val]
     [true, val, :text]
-  in ["bytes", val]             # TODO
-    [true, val, :bytes]
+  in ["bytes", val, _orig]
+    eb = extract_bytes(*val)
+    if String === eb
+      [true, extract_bytes(*val), :bytes]
+    else
+      [false, eb]
+    end
+  in ["op", ".cat" | ".det" | ".plus", lhs, rhs]
+    op = wh[1]
+    expected_type = op == ".plus" ? Numeric : String;
+    lhss, lhsv, lhst = extract_value(lhs)
+    rhss, rhsv, rhst = extract_value(rhs)
+    if !lhss || !rhss
+      [false, {%i'UNSPECIFIC_#{op}' => [op, lhs, rhs]}]
+    elsif [lhsv, rhsv].any? {!(expected_type === _1)}
+      [false, {%i'BAD_TYPES_#{op}' => [op, lhs, rhs]}]
+    else
+      if op == ".det"
+        lhsv = remove_indentation(lhsv)
+        rhsv = remove_indentation(rhsv)
+      end
+      case [lhst, rhst]
+      in [:text, :text] | [:bytes, :bytes]
+        [true, lhsv + rhsv]
+      in [:bytes, :text]
+        [true, (lhsv + rhsv.b).b]
+      in [:text, :bytes]
+        result = lhsv + rhsv.force_encoding(Encoding::UTF_8)
+        if result.valid_encoding?
+          [true, result]
+        else
+          [false, {text_encoding_not_utf8: [lhst, lhsv, rhst, rhsv]}]
+        end
+      in [:int, _]
+        [true, lhsv + Integer(rhsv)]
+      in [:float, _]
+        [true, lhsv + rhsv]
+      end << lhst
+    end
   else
     [false]
   end
 end
+
+def extract_array(t)
+  case t
+  in ["ary", ["seq", *members]]
+  else
+    return [false]
+  end
+  [true, *members.map { |el|
+     case el
+     in ["mem", _cut, _any, el4]
+       ok, v, vt = extract_value(el4)
+       return [false] unless ok
+       [v, vt]
+     else
+       return [false]
+     end
+   }]
+end
+
+
+def extract_feature(control, d)
+  ok, v, vt = extract_value(control)
+  if ok
+    nm = v
+    det = d
+    warn "*** feature controller should be a string: #{control.inspect}" unless :text == vt || :bytes == vt
+  else
+    ok, *v = extract_array(control)
+    if ok && v.size == 2
+      nm = v[0][0]
+      det = v[1][0]
+      warn "*** first element of feature controller should be a string: #{control.inspect}" unless String === nm
+    else
+      warn "*** feature controller not implemented: #{control.inspect}"
+    end
+  end
+  [nm, det]
+end
+
+end

data/lib/writer/cddl-writer.rb

@@ -2,32 +2,6 @@ require_relative "../cddlc.rb"
 
 class CDDL
 
-  # In each specific case, use the appropriate subset
-  ESCAPED_STRING_MAPPINGS = Hash[[
-                                   ["\x08", "b"],
-                                   ["\x09", "t"],
-                                   ["\x0A", "n"],
-                                   ["\x0C", "f"],
-                                   ["\x0D", "r"],
-                                   ["\x22", "\""],
-                                   ["\x27", "'"],
-                                   ["\x2F", "/"],
-                                   ["\x5C", "\\"],
-                                 ]]
-
-  # TODO: Enable selecting Unicode-friendly variants
-  def escape_string(s)
-    s.gsub(/[^\n !#-\[\]-~]/) {|ch|
-      if m = ESCAPED_STRING_MAPPINGS[ch]
-        "\\#{m}"
-      elsif (o = ch.ord) < 0x10000
-        "\\u#{"%04x" % o}"
-      else
-        "\\u{#{"%x" % o}}"
-      end
-    }
-  end
-
   def write_lhs(k, parmnames)
     if parmnames
       "#{k}<#{parmnames.join(", ")}>"
@@ -127,8 +101,8 @@ class CDDL
     in ["mem", cut, t1, t2]
       [2, "#{write_rhs(t1, 3, indent, pn)} #{cut ? "^" : ""}=> #{write_rhs(t2, 2, indent, pn)}"]
       # 2->3: work around cddl tool limitation
-    in ["bytes", t]
-      [4, t]                    # XXX not very clean
+    in ["bytes", t, tesc]
+      [4, bytes_escaped(tesc, t)]
     in ["text", t]
       [4, "\"#{escape_string(t)}\""]
     in ["number", t]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cddlc
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Carsten Bormann
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler