cddlc 0.0.5 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f5d1377201859a791bdc1be22f2dc20b77048a9bcfc832ad2959a716107295a
-  data.tar.gz: e5f78bad21f03856dc472ef8e1047fce2a0500c5af38cd95bcc0428e640919e4
+  metadata.gz: 446e27ac8733454e0a3a9a9e2f24a43f600f60a414400419287fe147649a7a1f
+  data.tar.gz: 1a4e7b41949419befd15479d0373bf3c316e22c62a6796c6453db6c3467f2b5d
 SHA512:
-  metadata.gz: ded873394d88ba7aa55e1e1220b6dd56112ae19740c54835f5d1e0398eb453f145f08ae861f65dd9dff3c510241784ff9e2763f094192ccbd287b7a8e631aa45
-  data.tar.gz: 1c3ddbeec752dcac4de46d8e68ee36c8b315b6486f4723b72fb4d7b50bdc67425facf041e6098b8278f36c83e6e864d6e0e4e86efbad27e14f04b75cbfa777f0
+  metadata.gz: 5fce60c859d8b361973c52a9e4d0a4e18908a7978d938a91c0e50125d64db3a5d704a9cc7f6ad8d17fb7f242bed3f31bb5df2107459d9fdacc57afae9f8df53e
+  data.tar.gz: 2c8a8e5f3653125cb719d6aeb7f46642643b561702824a4fcdd404dd40bcdf3ae362ca5cda5323b97f6da521dc555677d8f5139774a12ef9b2f599539b08850e

data/bin/cddlc

@@ -52,7 +52,16 @@ begin
     opts.on("-r", "--[no-]rules", "Process rules") do |v|
       $options.rules = v
     end
-    opts.on("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :enum], "Target format") do |v|
+    opts.on("-x", "--[no-]expand", "Expand generics") do |v|
+      $options.expand_generics = v
+    end
+    opts.on("-u", "--[no-]undefined", "Note undefined names") do |v|
+      $options.note_undefined = v
+    end
+    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, :enum, :cddl], "Target format") do |v|
       $options.target = v
     end
   end
@@ -70,11 +79,58 @@ cddl_file = ARGF.read
 
 cddl = CDDL.from_cddl(cddl_file)
 result = if $options.rules
+           if $options.expand_generics
+             require_relative "../lib/processor/cddl-expander.rb"
+             cddl.expand_generics
+           end
            cddl.rules
          else
+           warn "** can't expand in tree; use -r flag as well" if $options.expand_generics
            cddl.tree
          end
 
+warn "** can't note undefined for target != cddl" if $options.note_undefined && $options.target != :cddl
+
+if $options.cddl2
+  require_relative '../lib/processor/cddl-undefined.rb'
+  directives = cddl_file.lines.grep(/^;# /).map(&:chomp).map{|l| l.sub(/^;#\s+/, '')}
+  # puts "** Directives: <<"
+  # puts directives
+  directives.each do |di|
+    case di
+    when /\Ainclude\s+([-._a-zA-Z0-9]+)(?:\s+as\s+([-._a-zA-Z0-9]+))?\s*\z/
+      docref = $1
+      explicit_preferred_tag = $2
+      preferred_tag = explicit_preferred_tag || docref
+      puts "PREFERRED_TAG #{preferred_tag}" if $options.verbose
+      puts "DOCREF #{docref}" if $options.verbose
+      fn = docref.downcase << ".cddl"
+      io = File.open(fn) rescue File.open(CDDL::DATA_DIR + fn) # XXX CDDL_PATH
+      include_file = io.read
+      # XXX: processing directives recursively!
+      included_cddl = CDDL.from_cddl(include_file)
+      # XXX: Should namespace that thing now! all names -> preferred_tag.name
+      p included_cddl.rules.keys
+      # XXX: do once, first, to rename COSE_Key to RFC9052.COSE_Key
+      loop do
+        undef_rule, _undef_gen = cddl.cddl_undefined # ignore undef_gen for now
+        # p undef_rule
+        got_more = false
+        undef_rule.each do |name|
+          if rule = included_cddl.rules[name]
+            cddl.rules[name] = rule                     # XXX must be namespaced!
+            puts "IMPORTED #{name} from #{fn}" # ...: #{rule}... if $options.verbose
+            got_more = true
+          end
+        end
+        break unless got_more
+      end
+    else
+      warn "** unknown directive '#{di}' ignored"
+    end
+  end
+end
+
 case $options.target
 when :basic, nil
   pp result
@@ -100,6 +156,19 @@ when :enum
       end
     end
   end
+when :cddl
+  require_relative '../lib/writer/cddl-writer.rb'
+  if $options.note_undefined
+    require_relative '../lib/processor/cddl-undefined.rb'
+    undef_rule, undef_gen = cddl.cddl_undefined
+    undef_rule.each do |k|
+      puts ";;; *** undefined: #{k}"
+    end
+    undef_gen.each do |k|
+      puts ";;; *** undefined: #{k}<>"
+    end
+  end
+  puts cddl.to_s
 else
   warn ["Unknown target format: ", $options.target].inspect
 end

data/cddlc.gemspec

@@ -1,13 +1,13 @@
 Gem::Specification.new do |s|
   s.name = "cddlc"
-  s.version = "0.0.5"
+  s.version = "0.1.1"
   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"
   s.email = "cabo@tzi.org"
   s.license = "MIT"
   s.homepage = "http://github.com/cabo/cddlc"
-  s.files = Dir['lib/**/*.rb'] + %w(cddlc.gemspec) + Dir['bin/**/*.rb']
+  s.files = Dir['lib/**/*.rb'] + %w(cddlc.gemspec) + Dir['data/*.cddl'] + Dir['bin/**/*.rb']
   s.executables = Dir['bin/*'].map {|x| File.basename(x)}
   s.required_ruby_version = '>= 1.9.2'
 

data/data/prelude.cddl

@@ -0,0 +1,45 @@
+any = #
+
+uint = #0
+nint = #1
+int = uint / nint
+
+bstr = #2
+bytes = bstr
+tstr = #3
+text = tstr
+
+tdate = #6.0(tstr)
+time = #6.1(number)
+number = int / float
+biguint = #6.2(bstr)
+bignint = #6.3(bstr)
+bigint = biguint / bignint
+integer = int / bigint
+unsigned = uint / biguint
+decfrac = #6.4([e10: int, m: integer])
+bigfloat = #6.5([e2: int, m: integer])
+eb64url = #6.21(any)
+eb64legacy = #6.22(any)
+eb16 = #6.23(any)
+encoded-cbor = #6.24(bstr)
+uri = #6.32(tstr)
+b64url = #6.33(tstr)
+b64legacy = #6.34(tstr)
+regexp = #6.35(tstr)
+mime-message = #6.36(tstr)
+cbor-any = #6.55799(any)
+
+float16 = #7.25
+float32 = #7.26
+float64 = #7.27
+float16-32 = float16 / float32
+float32-64 = float32 / float64
+float = float16-32 / float64
+
+false = #7.20
+true = #7.21
+bool = false / true
+nil = #7.22
+null = nil
+undefined = #7.23

data/data/rfc9052.cddl

@@ -0,0 +1,154 @@
+
+start = COSE_Messages / COSE_Key / COSE_KeySet / Internal_Types
+
+; This is defined to make the tool quieter:
+Internal_Types = Sig_structure / Enc_structure / MAC_structure
+
+
+label = int / tstr
+values = any
+
+
+COSE_Messages = COSE_Untagged_Message / COSE_Tagged_Message
+
+COSE_Untagged_Message = COSE_Sign / COSE_Sign1 /
+    COSE_Encrypt / COSE_Encrypt0 /
+    COSE_Mac / COSE_Mac0
+
+COSE_Tagged_Message = COSE_Sign_Tagged / COSE_Sign1_Tagged /
+    COSE_Encrypt_Tagged / COSE_Encrypt0_Tagged /
+    COSE_Mac_Tagged / COSE_Mac0_Tagged
+
+
+Headers = (
+    protected : empty_or_serialized_map,
+    unprotected : header_map
+)
+
+header_map = {
+    Generic_Headers,
+    * label => values
+}
+
+empty_or_serialized_map = bstr .cbor header_map / bstr .size 0
+
+
+
+Generic_Headers = (
+    ? 1 => int / tstr,  ; algorithm identifier
+    ? 2 => [+label],    ; criticality
+    ? 3 => tstr / int,  ; content type
+    ? 4 => bstr,        ; key identifier
+    ? ( 5 => bstr //    ; IV
+        6 => bstr )     ; Partial IV
+)
+
+
+COSE_Sign_Tagged = #6.98(COSE_Sign)
+
+
+COSE_Sign = [
+    Headers,
+    payload : bstr / nil,
+    signatures : [+ COSE_Signature]
+]
+
+
+COSE_Signature =  [
+    Headers,
+    signature : bstr
+]
+
+
+COSE_Sign1_Tagged = #6.18(COSE_Sign1)
+
+
+COSE_Sign1 = [
+    Headers,
+    payload : bstr / nil,
+    signature : bstr
+]
+
+
+Sig_structure = [
+    context : "Signature" / "Signature1",
+    body_protected : empty_or_serialized_map,
+    ? sign_protected : empty_or_serialized_map,
+    external_aad : bstr,
+    payload : bstr
+]
+
+
+COSE_Encrypt_Tagged = #6.96(COSE_Encrypt)
+
+
+COSE_Encrypt = [
+    Headers,
+    ciphertext : bstr / nil,
+    recipients : [+COSE_recipient]
+]
+
+
+COSE_recipient = [
+    Headers,
+    ciphertext : bstr / nil,
+    ? recipients : [+COSE_recipient]
+]
+
+
+COSE_Encrypt0_Tagged = #6.16(COSE_Encrypt0)
+
+
+COSE_Encrypt0 = [
+    Headers,
+    ciphertext : bstr / nil,
+]
+
+
+Enc_structure = [
+    context : "Encrypt" / "Encrypt0" / "Enc_Recipient" /
+        "Mac_Recipient" / "Rec_Recipient",
+    protected : empty_or_serialized_map,
+    external_aad : bstr
+]
+
+
+COSE_Mac_Tagged = #6.97(COSE_Mac)
+
+
+COSE_Mac = [
+   Headers,
+   payload : bstr / nil,
+   tag : bstr,
+   recipients : [+COSE_recipient]
+]
+
+
+COSE_Mac0_Tagged = #6.17(COSE_Mac0)
+
+
+COSE_Mac0 = [
+   Headers,
+   payload : bstr / nil,
+   tag : bstr,
+]
+
+
+MAC_structure = [
+     context : "MAC" / "MAC0",
+     protected : empty_or_serialized_map,
+     external_aad : bstr,
+     payload : bstr
+]
+
+
+COSE_Key = {
+    1 => tstr / int,          ; kty
+    ? 2 => bstr,              ; kid
+    ? 3 => tstr / int,        ; alg
+    ? 4 => [+ (tstr / int) ], ; key_ops
+    ? 5 => bstr,              ; Base IV
+    * label => values
+}
+
+COSE_KeySet = [+COSE_Key]

data/lib/cddlc.rb

@@ -50,8 +50,8 @@ class CDDL
           fail name
         end
         @rules[name] =
-          if old = @rules[name]
-            fail "duplicate rule for name #{name}" unless cho
+          if (old = @rules[name]) && old != val
+            fail "duplicate rule for name #{name} #{old.inspect} #{val.inspect}" unless cho
             if Array === old && old[0] == cho
               old.dup << val
             else
@@ -66,4 +66,13 @@ class CDDL
     @rules
   end
 
+  DATA_DIR = Pathname.new(__FILE__) + "../../data/"
+
+  def prelude
+    if @prelude.nil?
+      @prelude = CDDL.from_cddl(File.read(DATA_DIR + "prelude.cddl"))
+
+    end
+    @prelude
+  end
 end

data/lib/processor/cddl-expander.rb

@@ -0,0 +1,56 @@
+require_relative "../cddlc.rb"
+require_relative "./cddl-visitor.rb"
+
+class CDDL
+  def substitute(prod, parms, args, &block)
+    subs = Hash[parms.zip(args)]
+    visit(prod) do |p, &block1|
+      case p
+      in ["gen", name, *gen_args]
+        [true, gen_apply(name, gen_args, &block1)]
+      in ["name", name]
+        if replacement = subs[name]
+          [true, visit(expand_prod(replacement), &block)]
+        end
+      else
+        false
+      end
+    end
+  end
+  def gen_apply(gen_name, gen_args, &block)
+    gen_parms, gen_prod = @gen[gen_name]
+    fail "** no generic for #{gen_name}<#{gen_args}>" unless gen_parms
+    substitute(gen_prod, gen_parms, gen_args, &block)
+  end
+  def expand_prod(prod)
+    visit(prod) do |p, &block|
+      case p
+      in ["gen", name, *gen_args]
+        [true, gen_apply(name, gen_args, &block)]
+      else
+        [false]
+      end
+    end
+  end
+  def expand_generics
+    @gen = {}
+    rules.each do |name, prod|
+      if Array === name
+        @gen[name[0]] = [name[1..-1], prod]
+      end
+    end
+    p @gen if $options.verbose
+    @gen.each do |k, v|
+      namep = v[0]
+      fail unless rules[[k, *namep]] == v[1]
+      rules.delete([k, *namep])
+    end
+    @new_rules = {}
+    rules.each do |name, prod|
+      fail if Array === name
+      @new_rules[name] = expand_prod(prod)
+    end
+    p @new_rules if $options.verbose
+    @rules = @new_rules
+  end
+end

data/lib/processor/cddl-undefined.rb

@@ -0,0 +1,29 @@
+require_relative "../cddlc.rb"
+require_relative "./cddl-visitor.rb"
+require_relative "./cddl-expander.rb"
+
+class CDDL
+  def cddl_undefined
+    # currently only works on expanded...
+    cddl2 = self
+    cddl2.expand_generics
+    used = {}
+    gen_used = {}
+    def_gen = {}
+    cddl2.rules.each do |k, v|
+      def_gen[k[0]] = true if Array === k
+      cddl2.visit(v) do |p, &block|
+        case p
+        in ["gen", name, *_gen_args]
+          gen_used[name] = true
+        in ["name", name]
+          used[name] = true
+        else
+          false
+        end
+      end
+    end
+    [used.keys.reject {|name| cddl2.rules[name] || prelude.rules[name]},
+     gen_used.keys.reject {|name| def_gen[name] }]
+  end
+end

data/lib/processor/cddl-visitor.rb

@@ -0,0 +1,42 @@
+require_relative "../cddlc.rb"
+
+class CDDL
+  def visit_all(prod_array, &block)
+    prod_array.map {|prod| visit(prod, &block)}
+  end
+  def visit(prod, &block)
+    done, ret = block.call(prod, &block)
+    if done
+      return ret
+    end
+
+    case prod
+    in ["gen", name, *types]
+      ["gen", name, *visit_all(types, &block)]
+    in ["op", op, *prods]
+      ["op", op, *visit_all(prods, &block)]
+    in ["map", prod]
+      ["map", visit(prod, &block)]
+    in ["ary", prod]
+      ["ary", visit(prod, &block)]
+    in ["gcho", *prods]
+      ["gcho", *visit_all(prods, &block)]
+    in ["tcho", *prods]
+      ["tcho", *visit_all(prods, &block)]
+    in ["seq", *prods]
+      ["seq", *visit_all(prods, &block)]
+    in ["enum", prod]
+      ["enum", visit(prod, &block)]
+    in ["unwrap", prod]
+      ["unwrap", visit(prod, &block)] # XXX, this may need to be bottled in a rule
+    in ["prim", Array => prod, *prods]
+      ["prim", visit(prod, &block), *visit_all(prods, &block)]
+    in ["mem", *prods]
+      ["mem", *visit_all(prods, &block)]
+    in ["rep", s, e, prod]
+      ["rep", s, e, visit(prod, &block)]
+    else
+      prod
+    end
+  end
+end

data/lib/writer/cddl-writer.rb

@@ -0,0 +1,104 @@
+require_relative "../cddlc.rb"
+
+class CDDL
+
+  def write_lhs(k)
+    case k
+    in [id, *parms]
+      "#{id}<#{parms.join(", ")}>"
+    in String
+      k
+    end
+  end
+
+  # precedence:
+  # 0: // gcho
+  # 1: , seq
+  # 2: / tcho -> (type1)
+  # 3: (type1) .xxx op -> type2
+  # 4: type2
+
+  def prec_check(inner, targetprec, prec, indent_s)
+    if targetprec > prec
+      "(#{inner.gsub("\n", "\n" << indent_s)})" # XXX embedded byte strings
+    else
+      inner
+    end
+  end
+
+  def write_rhs(v, targetprec = 0, indent = 0)
+#    warn "** #{v.inspect}"
+    indent_p = "  " * indent
+    indent += 1
+    indent_s = "  " * indent
+    prec, ret =
+    case v
+    in ["name", id]
+      [4, id]
+    in ["gen", id, *parms]  # oops -- namep vs. namea; ouch
+      [4, "#{id}<#{parms.map{write_rhs(_1, 2, indent)}.join(", ")}>"]
+    in ["tcho", *types]
+      [2, types.map{write_rhs(_1, 3, indent)}.join(" / ")]
+    in ["gcho", *groups]
+      [0, groups.map{write_rhs(_1, 2, indent)}.join(" // ")]
+    in ["op", op, l, r]
+      [3, "#{write_rhs(l, 3, indent)} #{op} #{write_rhs(r, 3, indent)}"]
+    in ["map", group]
+      [4, "{#{write_rhs(group, 0, indent)}}"]
+    in ["ary", group]
+      [4, "[#{write_rhs(group, 0, indent)}]"]
+    in ["unwrap", namep]
+      [4, "~#{write_rhs(namep, 4, indent)}"]
+    in ["enum", ["name", _name] => namep]
+      [4, "&#{write_rhs(namep, 4, indent)}"]
+    in ["enum", ["gen", _name, *types] => namep]
+      [4, "&#{write_rhs(namep, 4, indent)})"]
+    in ["enum", group]
+      [4, "&(#{write_rhs(group, 0, indent)})"]
+    in ["prim"]
+      [4, "#"]
+    in ["prim", maj]
+      [4, "##{maj}"]
+    in ["prim", maj, min]
+      [4, "##{maj}.#{min}"]
+    in ["prim", 6, Integer => tag, type]
+      [4, "#6.#{tag}(#{write_rhs(type, 0, indent)})"]
+    in ["prim", 6, nil, type]
+      [4, "#6(#{write_rhs(type, 0, indent)})"]
+# prim: extension for #6.<i>(t)
+    in ["seq", *groups]
+      case groups.size
+      when 0; [4, ""]
+      # when 1; "#{write_rhs(g[0], targetprec, indent)}"
+      else
+        [1, "\n#{indent_p}#{groups.map{write_rhs(_1, 1, indent)}.join(",\n#{indent_p}")},\n"]
+      end
+    in ["rep", s, e, group]
+      occur = case [s, e]
+              in [1, 1];     ""
+              in [0, 1];     "? "
+              in [0, false]; "* "
+              in [1, false]; "+ "
+              else
+                "#{s}*#{e || ""}"
+              end
+      [1, "#{occur}#{write_rhs(group, 2, indent)}"]
+    in ["mem", nil, t2]
+      [2, write_rhs(t2, 2, indent)]
+    in ["mem", t1, t2]
+      [2, "#{write_rhs(t1, 2, indent)} => #{write_rhs(t2, 2, indent)}"]
+    in ["text", t]
+      [4, "\"#{t}\""]              # XXX escape
+    in ["number", t]
+      [4, t.to_s]
+    end
+    prec_check(ret, targetprec, prec, indent_s)
+  end
+
+  def to_s
+    rules.map {|k, v|
+      "#{write_lhs(k)} = #{write_rhs(v, 2)}" # 2: parenthesize groups
+    }.join("\n")
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddlc
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.1
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-21 00:00:00.000000000 Z
+date: 2023-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,9 +75,15 @@ extra_rdoc_files: []
 files:
 - bin/cddlc
 - cddlc.gemspec
+- data/prelude.cddl
+- data/rfc9052.cddl
 - lib/cddlc.rb
 - lib/parser/cddl-util.rb
 - lib/parser/cddlgrammar.rb
+- lib/processor/cddl-expander.rb
+- lib/processor/cddl-undefined.rb
+- lib/processor/cddl-visitor.rb
+- lib/writer/cddl-writer.rb
 homepage: http://github.com/cabo/cddlc
 licenses:
 - MIT
@@ -97,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.2
 signing_key:
 specification_version: 4
 summary: CDDL (Concise Data Definition Language) converters and miscellaneous tools