cddlc 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f5d1377201859a791bdc1be22f2dc20b77048a9bcfc832ad2959a716107295a
-  data.tar.gz: e5f78bad21f03856dc472ef8e1047fce2a0500c5af38cd95bcc0428e640919e4
+  metadata.gz: 119d5084051bfbc6889d6a9b36e22308cbb580c9d71b738e4c99ea2f908496cb
+  data.tar.gz: 33fafda14412916c5883260cb64bea2793785e359d833e6d9cee37cf76260186
 SHA512:
-  metadata.gz: ded873394d88ba7aa55e1e1220b6dd56112ae19740c54835f5d1e0398eb453f145f08ae861f65dd9dff3c510241784ff9e2763f094192ccbd287b7a8e631aa45
-  data.tar.gz: 1c3ddbeec752dcac4de46d8e68ee36c8b315b6486f4723b72fb4d7b50bdc67425facf041e6098b8278f36c83e6e864d6e0e4e86efbad27e14f04b75cbfa777f0
+  metadata.gz: c5936c13d4bca770fbcd628851f14a604e27a95e5c1c76329eb81932e7d9c7e72edf898d4989176baffa1d99a88f827e981fad338bb731560eb5547dba69342b
+  data.tar.gz: d3fe1f230d47841385cc12dd7cf3092c0feae0326ca6889eefb889ceb55903cac6919075cfaf2879961c185adf695df218cb2e1df418a781e6098bf4269d4d49

data/bin/cddlc

@@ -52,7 +52,13 @@ 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("-tFMT", "--to=FMT", [:basic, :neat, :json, :yaml, :enum, :cddl], "Target format") do |v|
       $options.target = v
     end
   end
@@ -70,11 +76,18 @@ 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
+
 case $options.target
 when :basic, nil
   pp result
@@ -100,6 +113,38 @@ when :enum
       end
     end
   end
+when :cddl
+  require_relative '../lib/writer/cddl-writer.rb'
+  if $options.note_undefined
+    require_relative "../lib/processor/cddl-visitor.rb"
+    used = {}
+    gen_used = {}
+    def_gen = {}
+    cddl.rules.each do |k, v|
+      def_gen[k[0]] = true if Array === k
+      cddl.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.each do |k, v|
+      unless cddl.rules[k] || cddl.prelude.rules[k]
+        puts ";;; *** undefined: #{k}"
+      end
+    end
+    gen_used.each do |k, v|
+      unless def_gen[k]
+        puts ";;; *** undefined: #{k}<>"
+      end
+    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.0"
   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 data/prelude.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/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,10 @@ class CDDL
     @rules
   end
 
+  def prelude
+    if @prelude.nil?
+      @prelude = CDDL.from_cddl(File.read(Pathname.new(__FILE__) + "../../data/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-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.0
 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,13 @@ extra_rdoc_files: []
 files:
 - bin/cddlc
 - cddlc.gemspec
+- data/prelude.cddl
 - lib/cddlc.rb
 - lib/parser/cddl-util.rb
 - lib/parser/cddlgrammar.rb
+- lib/processor/cddl-expander.rb
+- lib/processor/cddl-visitor.rb
+- lib/writer/cddl-writer.rb
 homepage: http://github.com/cabo/cddlc
 licenses:
 - MIT
@@ -97,7 +101,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