cddlc 0.3.5 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d01061fd86124e6e68aae0a7ef043d23c9a2211992f9421e9333c50d8a870ee
-  data.tar.gz: 7efe567eeca90c756dac4354791583cae6da812b05eaf4074dfb953f71d09adb
+  metadata.gz: f2a8aaeed392227b1d7650ddc62d010a577360f06c3bd07f879dd22d6a2e3ce9
+  data.tar.gz: e0db7efbdb77e5cc3f770e6a586ce710414e82419127f7b08302248943f1e045
 SHA512:
-  metadata.gz: c051e4c6c4e319e223dc8126512ffe8c7368b985735c8b15b34ac3ae5dad183f7f80f74e3a4b90f1679877472c8c5a0968f38d73994fc4e3dbb8669a39938c09
-  data.tar.gz: 29fce82dbdfd0bf5e14184b8445d3281a648fdd3f1fb982e37020317c23b94100449d21fed9a609a2f041fdc4a035c7842e23f861b5730480f9a828963122fef
+  metadata.gz: 2b95180d14a2cab74e89e76a753a8519f3aa2b17abc7809ed5b9fd1bbbaf20e2dee87a6635c279b35d89cb754b2e9ac4b9051c4eb15a628ac6accb2ad5f3ccb1
+  data.tar.gz: 1ad97e5fc8ac2b5242dacedb9a8521b4ea376c79f54669370d7a1d1156d10ce6ca2b3d9ce2075844d5991dee8d1fa36e17fd9d5a175317f14516e92314396e89

data/bin/cddlc

@@ -44,7 +44,7 @@ require 'ostruct'
 $options = OpenStruct.new
 begin
   op = OptionParser.new do |opts|
-    opts.banner = "Usage: cddlc.rb [options] [-e cddl | file.cddl... | -]"
+    opts.banner = "Usage: cddlc [options] [-e cddl | file.cddl... | -]"
 
     opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
       $options.verbose = v
@@ -64,7 +64,23 @@ begin
     opts.on("-2", "--[no-]cddl2", "Perform some CDDL 2.0 processing") do |v|
       $options.cddl2 = v
     end
-    opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :const, :enum, :cddl], "Target format") do |v|
+    opts.on("-c", "--cbor-validate=FILE", "Validate CBOR file against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :cbor
+    end
+    opts.on("-j", "--json-validate=FILE", "Validate JSON file against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :json
+    end
+    opts.on("-d", "--diag-validate=FILE", "Validate EDN file against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :diag
+    end
+    opts.on("--test", "Validate embedded EDN against CDDL grammar") do |v|
+      $options.validate = v
+      $options.source_format = :embedded
+    end
+    opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :const, :enum, :cddl, :diag, :edn, :cbor], "Target format") do |v|
       $options.target = v
     end
     opts.on("-sRULE", "--start=RULE", String, "Start rule name") do |v|
@@ -73,6 +89,9 @@ begin
     opts.on("-eCDDL", "CDDL model on command line") do |v|
       $options.model = v
     end
+    opts.on("--[no-]prelude", "Add (default)/do not add prelude") do |v|
+      $options.prelude = v
+    end
     opts.on("-iIMPORT", "--import=IMPORT", String, "Import [namespace=]reference") do |v|
       $options.import ||= []
       $options.import << v
@@ -83,11 +102,13 @@ begin
     end
   end
   op.parse!
-rescue Exception => e
+rescue StandardError => e
   warn e
   exit 1
 end
 
+$options.prelude = true if $options.validate # XXX
+
 if ($options.expand_generics || $options.flattening) && !$options.rules
   warn "** can't expand or flatten in tree; adding -r flag"
   $options.rules = true
@@ -131,8 +152,16 @@ else
   cddl_file << ARGF.read
 end
 
+if $options.validate
+  $options.expand_generics = true # for now
+  $options.rules = true
+  # manually select -f/--flattening if desired
+end
 
 cddl = CDDL.from_cddl(cddl_file)
+if $options.prelude
+  cddl.rules.merge! cddl.prelude.rules
+end
 result = if $options.rules
            if $options.expand_generics
              require_relative "../lib/processor/cddl-expander.rb"
@@ -150,6 +179,77 @@ result = if $options.rules
 
 warn "** can't note undefined for target != cddl" if $options.note_undefined && $options.target != :cddl
 
+embedded = $options.source_format == :embedded
+
+def parse_diag(data)
+  require 'cbor-diag-parser'
+  parser = CBOR_DIAGParser.new
+  if result = parser.parse(data)
+    result.to_rb
+  else
+    warn "*** can't parse #{data}"
+    warn "*** #{parser.failure_reason}"
+    exit 1
+  end
+end
+
+if fn = $options.validate
+  require "cbor-pure"
+  require "validator/validate"
+  data = fn == "-" ? STDIN.read : File.binread(fn) unless embedded
+  items = case $options.source_format
+         in :cbor
+           [[CBOR.decode(data), true]]
+         in :json
+           [[JSON.load(data), true]]
+         in :diag                      # XXX move to EDN, take diag2x options
+           [[parse_diag(data), true]]
+         in :embedded
+           input = cddl_file.lines(chomp: true)
+           tests = []
+           input.each do |l|
+             case l
+             when /\A;;([-+:]p?)\s*(.*)\z/
+               disc = $1
+               payload = $2
+               if disc == ':'
+                 if t = tests[-1]
+                   t[1] << payload
+                 else
+                   warn "*** : to what? #{l}"
+                 end
+               else
+                 tests << [disc, [payload]]
+               end
+             end
+           end
+           tests.map {|disc, lines|
+             [parse_diag(lines.join("\n")), disc == "+"]
+           }
+         else
+           fail $options.source_format
+          end
+  items.each do |item, expected|
+    warn [:ITEM, item, expected].inspect if CDDL::CDDLC_DEBUG
+    r = cddl.validate(item)
+    if r[0]
+      # TODO: build annotated output here!
+      warn r.inspect
+      if !expected
+        warn "*** should NOT have validated"
+        exit 1
+      end
+    else
+      puts r.to_yaml
+      if expected
+        warn "*** should have validated" if embedded
+        exit 1
+      end
+    end
+  end
+  exit
+end
+
 case $options.target
 when :basic, nil
   pp result
@@ -189,5 +289,5 @@ when :cddl
   end
   puts cddl.to_s
 else
-  warn ["Unknown target format: ", $options.target].inspect
+  warn ["Unknown target format for CDDL output: ", $options.target].inspect
 end

data/cddlc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "cddlc"
-  s.version = "0.3.5"
+  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/data/rfc9360.cddl

@@ -0,0 +1,2 @@
+COSE_X509 = bstr / [ 2*certs: bstr ]
+COSE_CertHash = [ hashAlg: (int / tstr), hashValue: bstr ]

data/data/rfc9431.cddl

@@ -0,0 +1,5 @@
+ AIF-MQTT = AIF-Generic<mqtt-topic-filter, mqtt-permissions>
+ AIF-Generic<Toid, Tperm> = [* [Toid, Tperm]]
+ mqtt-topic-filter = tstr ; as per Section 4.7 of MQTT v5.0
+ mqtt-permissions = [+permission]
+ permission = "pub"/"sub"

data/data/rfc9526.cddl

@@ -0,0 +1,12 @@
+hna-configuration = {
+  "registered_domain" : tstr,
+  "dm"                : tstr,
+  ? "dm_transport" : "DoT"
+  ? "dm_port"        : uint,
+  ? "dm_acl"         : hna-acl / [ +hna-acl ]
+  ? "hna_auth_method": hna-auth-method
+  ? "hna_certificate": tstr
+}
+
+hna-acl          = tstr
+hna-auth-method  /= "certificate"

data/data/rfc9528.cddl

@@ -0,0 +1,59 @@
+suites = [ 2* int ] / int
+
+ead = (
+  ead_label : int,
+  ? ead_value : bstr,
+)
+
+EAD_1 = (1* ead)
+EAD_2 = (1* ead)
+EAD_3 = (1* ead)
+EAD_4 = (1* ead)
+
+message_1 = (
+  METHOD : int,
+  SUITES_I : suites,
+  G_X : bstr,
+  C_I : bstr / -24..23,
+  ? EAD_1,
+)
+
+message_2 = (
+  G_Y_CIPHERTEXT_2 : bstr,
+)
+
+PLAINTEXT_2 = (
+  C_R : bstr / -24..23,
+  ID_CRED_R : header_map / bstr / -24..23,
+  Signature_or_MAC_2 : bstr,
+  ? EAD_2,
+)
+
+message_3 = (
+  CIPHERTEXT_3 : bstr,
+)
+
+PLAINTEXT_3 = (
+  ID_CRED_I : header_map / bstr / -24..23,
+  Signature_or_MAC_3 : bstr,
+  ? EAD_3,
+)
+
+message_4 = (
+  CIPHERTEXT_4 : bstr,
+)
+
+PLAINTEXT_4 = (
+  ? EAD_4,
+)
+
+error = (
+  ERR_CODE : int,
+  ERR_INFO : any,
+)
+
+info = (
+  info_label : int,
+  context : bstr,
+  length : uint,
+)

data/data/rfc9594-error-handling.cddl

@@ -0,0 +1,3 @@
+   ace-groupcomm-error = {
+     &(error-id: 0) => int
+   }

data/data/rfc9594-example-extended-scope-aif.cddl

@@ -0,0 +1,20 @@
+;# include rfc9237
+
+gname = tstr
+
+permissions = uint .bits roles
+
+roles = &(
+   Requester: 1,
+   Responder: 2,
+   Monitor: 3,
+   Verifier: 4
+)
+
+scope_entries = AIF-Generic<gname, permissions>
+
+scope = bstr .cbor scope_entries
+
+extended_scope = #6.<TAG_FOR_THIS_SEMANTICS>(scope)
+
+TAG_FOR_THIS_SEMANTICS = uint

data/data/rfc9594-example-extended-scope-text.cddl

@@ -0,0 +1,13 @@
+gname = tstr
+
+role = tstr
+
+scope_entry = [ gname , ? ( role / [ 2*role ] ) ]
+
+scope_entries = [ * scope_entry ]
+
+scope = bstr .cbor scope_entries
+
+extended_scope = #6.<TAG_FOR_THIS_SEMANTICS>(scope)
+
+TAG_FOR_THIS_SEMANTICS = uint

data/data/rfc9594-example-scope-aif.cddl

@@ -0,0 +1,16 @@
+;# include rfc9237
+
+gname = tstr
+
+permissions = uint .bits roles
+
+roles = &(
+   Requester: 1,
+   Responder: 2,
+   Monitor: 3,
+   Verifier: 4
+)
+
+scope_entries = AIF-Generic<gname, permissions>
+
+scope = bstr .cbor scope_entries

data/data/rfc9594-example-scope-text.cddl

@@ -0,0 +1,9 @@
+gname = tstr
+
+role = tstr
+
+scope_entry = [gname, ? ( role / [2* role] )]
+
+scope_entries = [* scope_entry]
+
+scope = bstr .cbor scope_entries

data/data/rfc9594-get_creds.cddl

@@ -0,0 +1,10 @@
+inclusion_flag = bool
+
+role = tstr
+comb_role = [2* role]
+role_filter = [* ( role / comb_role )]
+
+id = bstr
+id_filter = [* id]
+
+get_creds = null / [inclusion_flag, role_filter, id_filter]

data/data/rfc9594-sign_info-parameter.cddl

@@ -0,0 +1,18 @@
+sign_info = sign_info_req / sign_info_resp
+
+sign_info_req  = null                  ; in the Token Transfer
+                                       ; Request to the KDC
+
+sign_info_resp = [+ sign_info_entry]   ; in the Token Transfer
+                                       ; Response from the KDC
+
+sign_info_entry =
+[
+ id: gname / [+ gname],
+ sign_alg: int / tstr,
+ sign_parameters: [any],
+ sign_key_parameters: [+ parameter: any],
+ cred_fmt: int / null
+]
+
+gname = tstr

data/data/rfc9594-sign_info_entry-with-a-gene.cddl

@@ -0,0 +1,10 @@
+sign_info_entry =
+[
+    id : gname / [+ gname],
+    sign_alg : int / tstr,
+    sign_parameters : [* alg_capab : any],
+  * sign_capab : [* capab : any],
+    cred_fmt : int / null
+]
+
+gname = tstr

data/data/rfc9597.cddl

@@ -0,0 +1,5 @@
+CWT-Claims = {
+ * Claim-Label => any
+}
+
+Claim-Label = int / text

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

@@ -0,0 +1,489 @@
+# requires for CBOR
+
+require 'cbor-pure' unless defined?(CBOR::Tagged)
+require 'half'
+
+# requires for control operators
+require 'cbor-deterministic'
+require 'regexp-examples'
+require 'abnftt'
+require 'base64'
+require 'base32'
+require 'base45_lite'
+require 'scanf'
+
+# Hmm:
+#!/usr/bin/env RUBY_THREAD_VM_STACK_SIZE=5000000 ruby
+
+
+class CDDL
+
+#  DATA_DIR = Pathname.new(__FILE__).split[0] + '../../data'
+#  PRELUDE = File.read("#{DATA_DIR}/prelude.cddl") -> #prelude -- parsed
+
+  MANY = Float::INFINITY
+
+  MAX_RECURSE = 128              # XXX
+
+  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)
+    l = s.lines
+    indent = l.grep(/\S/).map {|l| l[/^\s*/].size}.min
+    l.map {|l| l.sub(/^ {0,#{indent}}/, "")}.join
+  end
+
+  # [success, item, info, sublist (a/m/t)]
+  # [true, item, annos, sub-results [kv]]
+  # [false, item, error, sub-results [kv]]
+  # separate bad specs (always fails) from non-matching specs
+
+  def validate(item)
+    @rootrule ||= @rules.keys.first
+    # boxify item
+    validate1(item, ["name", @rootrule])
+  end
+
+  def numval(s)
+    Integer(s) rescue Float(s)
+  end
+
+  def validate1(item, where)
+    pp [:VALIDATE1, item, where].inspect if CDDLC_DEBUG
+    anno = nil
+    case where
+    in ["name", name]
+      # invent or error out if !rules[name]
+      rhs = rules[name]
+      unless rhs
+        if s = CDDLC_INVENT
+          s = "_" if s == ""
+          rules[name] = rhs = ["text", "#{s}-#{name}"]
+        else
+          return [false, item, {undefined: [name]}, []]
+        end
+      end
+      r = validate1(item, rhs)
+      case r
+      in [true, item, _annos, _sub]
+        [true, item, {name: name}, [r]]
+      in [false, item, error, _sub]
+        [false, item, {nomatch: [name, error]}, [r]]
+      else
+        fail [:MALFORMED_R, r, item, rhs].inspect
+      end
+    in ["number", num]
+      val = numval(num)
+      if !(item.eql? val)            # TODO: 0.0 vs. -0.0
+        [false, item, {wrongnumber: [item, val, num]}, []]
+      else
+        [true, item, {}, []]
+      end
+    in ["text", val]
+      if !(item.eql? val)            # check text vs. bytes
+        [false, item, {wrongtext: [item, val]}, []]
+      else
+        [true, item, {}, []]
+      end
+    in ["bytes", val]
+      # XXX Need to fix abnftt to yield correct value
+      if !(item.eql? val)            # check text vs. bytes
+        [false, item, {wrongtext: [item, val]}, []]
+      else
+        [true, item, {}, []]
+      end
+    in ["tcho", *choices]
+      nomatches = []
+      choices.each do |where|
+        r = validate1(item, where)
+        if r[0]
+          pp [:TCHO, item, where, r] if CDDLC_DEBUG
+          return r
+        end
+        nomatches << r
+      end
+      [false, item, nomatches, [r]]
+    in ["prim"]
+      [true, item, {}, []]
+    in ["prim", 0]
+      simple_result(Integer === item && item >= 0 && item <= 0xffffffffffffffff,
+                    item, where, :wrongnumber)
+    in ["prim", 1]
+      simple_result(Integer === item && item < 0 && item >= -0x10000000000000000,
+                    item, where, :wrongnumber)
+    in ["prim", 2]
+      simple_result(String === item && item.encoding == Encoding::BINARY,
+                    item, where, :wrongbytes)
+    in ["prim", 3]
+      simple_result(String === item && item.encoding != Encoding::BINARY, # cheat
+                    item, where, :wrongtext)
+    in ["prim", 6, *wh2]
+      warn [:WH2, wh2].inspect
+      d = if Integer === item
+            biggify(item)
+          else
+            item
+          end
+      # XXX validate tag against headnum if present
+      if CBOR::Tagged === d
+        r0 = if Integer === wh2[0]
+               simple_result(d.tag == wh2[0], d.tag, wh2[0], :wrongtag)
+             else validate1(d.tag, wh2[0])
+             end
+        r1 = validate1(d.data, wh2[1])
+        if r0[0] && r1[0]
+          [true, item, {}, []]  # XXX add diagnosics
+        else
+          [false, item, {wrongtag: [item, where]}, [r0, r1]]
+        end
+      else
+        [false, item, {not_a_tag: [item, where]}, []]
+      end
+    in ["prim", 7, *ai]
+    # t, v = extract_value(where)  --           if t --             v.eql? d -- 
+      headnum = case item
+                when Float
+                  FLOAT_AI_FROM_SIZE[item.to_cbor.size]
+                when CBOR::Simple
+                  item.value
+                when false
+                  20
+                when true
+                  21
+                when nil
+                  22
+                end
+      if Array === ai[0]        # CDDL for head number
+        validate1(headnum, ai[0])
+      else
+        simple_result(
+          ai[0].nil? ||
+          ai[0] == headnum,
+          item, where, :wrong7)
+      end
+    in ["op", op, lhs, rhs]
+      case op
+      in ".." | "..."
+        rex = RANGE_EXCLUDE_END[op]
+        lhss, lhsv, lhst = extract_value(lhs)
+        rhss, rhsv, rhst = extract_value(rhs)
+        if !lhss || !rhss
+          [false, item, {UNSPECIFIC_RANGE: [op, lhs, rhs]}, []]
+        elsif lhst != rhst
+          [false, item, {INCOHERENT_RANGE: [op, lhs, rhs]}, []]
+        else
+          st = scalar_type(item)
+          if lhst != st
+            [false, item, {rangetype: [op, lhs, rhs]}, []]
+          else
+            rg = Range.new(lhsv, rhsv, rex)
+            simple_result(
+              rg.include?(item),
+              item, where, :out_of_range)
+          end
+        end
+      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
+          [false, item, v, []]
+        end
+      in ".size"
+        anno = :lhs
+        r = validate1(item, lhs)
+        if r[0]
+          case item
+            when Integer
+              ok, v, vt = extract_value(rhs)
+              if ok && vt == :int
+                simple_result((item >> (8*v)) == 0,
+                              item, where, :toolarge)
+              end
+            when String
+              validate1(item.bytesize, rhs)
+            else
+              false
+          end
+        end
+      in ".bits"
+        anno = :lhs
+        r = validate1(item, lhs)
+        if r[0]
+            if String === item
+              simple_result(
+                item.each_byte.with_index.all? { |b, i|
+                  bit = i << 3
+                  8.times.all? { |nb|
+                    b[nb] == 0 || validate1(bit+nb, rhs)[0] # collect
+                  }
+                },
+                item, where, :unwanted_bit_set)
+            elsif Integer === item
+              if item >= 0
+                ok = true
+                i = 0
+                d = item
+                while ok && d > 0
+                  if d.odd?
+                    ok &&= validate1(i, rhs)[0] # collect
+                  end
+                  d >>= 1; i += 1
+                end
+                simple_result(ok,
+                              item, where, :unwanted_bit_set)
+              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
+    else
+      warn [:UNIMPLEMENTED, item, where].inspect
+      exit 1
+    end || [false, item, {anno => [item, where]}, []]
+  end
+
+def scalar_type(item)
+  case item
+  in NilClass
+    :null
+  in FalseClass | TrueClass
+    :bool
+  in Integer
+    :int
+  in Float
+    :float
+  in String if item.encoding == Encoding::BINARY
+    :bytes
+  in String
+    :text
+  else
+    nil
+  end
+end
+
+FLOAT_AI_FROM_SIZE = {3 => 25, 5 => 26, 9 => 27}
+SIMPLE_VALUE = {
+  [:prim, 7, 20] => [true, false, :bool],
+  [:prim, 7, 21] => [true, true, :bool],
+  [:prim, 7, 22] => [true, nil, :nil],
+}
+SIMPLE_VALUE_SIMPLE = Set[23] + (0..19) + (32..255)
+RANGE_EXCLUDE_END = {".." => false, "..." => true}
+
+def simple_result(check, item, where, anno)
+  if check
+    [true, item, {}, []]
+  else
+    [false, item, {anno => [item, where]}, []]
+  end
+end
+
+def biggify(d)                  # stand-in for real stand-ins
+  t = 2               # assuming only 2/3 match an Integer
+  if d < 0
+    d = ~d
+    t = 3
+  end
+  CBOR::Tagged.new(t, d == 0 ? "".b : d.digits(256).reverse!.pack("C*"))
+end
+
+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]
+  in ["number", num]
+    [true, Integer(num), :int] rescue [true, Float(num), :float]
+  in ["text", val]
+    [true, val, :text]
+  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,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cddlc
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.2
 platform: ruby
 authors:
 - Carsten Bormann
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-09 00:00:00.000000000 Z
+date: 2025-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,12 +82,25 @@ files:
 - data/rfc9290.cddl
 - data/rfc9321.cddl
 - data/rfc9338.cddl
+- data/rfc9360.cddl
 - data/rfc9393-concise-swid-tag.cddl
 - data/rfc9393-sign.cddl
 - data/rfc9393-sign1.cddl
 - data/rfc9393-tags.cddl
 - data/rfc9393.cddl
+- data/rfc9431.cddl
+- data/rfc9526.cddl
+- data/rfc9528.cddl
 - data/rfc9581.cddl
+- data/rfc9594-error-handling.cddl
+- data/rfc9594-example-extended-scope-aif.cddl
+- data/rfc9594-example-extended-scope-text.cddl
+- data/rfc9594-example-scope-aif.cddl
+- data/rfc9594-example-scope-text.cddl
+- data/rfc9594-get_creds.cddl
+- data/rfc9594-sign_info-parameter.cddl
+- data/rfc9594-sign_info_entry-with-a-gene.cddl
+- data/rfc9597.cddl
 - lib/cddlc.rb
 - lib/parser/cddl-util.rb
 - lib/parser/cddlgrammar.rb
@@ -97,12 +109,12 @@ files:
 - lib/processor/cddl-flattening.rb
 - lib/processor/cddl-undefined.rb
 - lib/processor/cddl-visitor.rb
+- lib/validator/validate.rb
 - lib/writer/cddl-writer.rb
 homepage: http://github.com/cabo/cddlc
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -117,8 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: CDDL (Concise Data Definition Language) converters and miscellaneous tools
 test_files: []