cddlc 0.1.1 → 0.1.3

data/lib/cddlc.rb

@@ -1,8 +1,18 @@
 require_relative "parser/cddl-util.rb"
+require_relative "processor/cddl-visitor.rb"
+require_relative 'processor/cddl-undefined.rb'
 
 class CDDL
   @@parser = CDDLGRAMMARParser.new
 
+  DATA_DIR = Pathname.new(__FILE__) + "../../data/"
+  # empty string is for CDDL::DATA_DIR
+  CDDL_INCLUDE_PATH = ENV["CDDL_INCLUDE_PATH"] || ".:"
+
+  def self.cddl_include_path
+    CDDL_INCLUDE_PATH.split(":", -1).map {_1 == "" ? CDDL::DATA_DIR : Pathname.new(_1)}
+  end
+
   def self.reason(parser, s)
     reason = [parser.failure_reason]
     parser.failure_reason =~ /^(Expected .+) after/m
@@ -14,21 +24,133 @@ class CDDL
     reason.join("\n")
   end
 
+  # (keeps only renamed rules)
+  def rename(rename_map)
+    rules.replace(
+      Hash[rename_map.map do |o, n|
+             [n, visit(rules[o]) do |prod|
+                case prod
+                in ["name", *] | ["gen", *]
+                  prod[1] = rename_map[prod[1]] || prod[1]
+                else
+                end
+                false
+              end]
+           end])
+  end
+
+  SAFE_FN = /\A[-._a-zA-Z0-9]+\z/
+
   def self.from_cddl(s)
     ast = @@parser.parse s
     if !ast
       fail self.reason(@@parser, s)
     end
-    CDDL.new(ast)
+    if $options.cddl2
+      directives = s.lines.grep(/^;# /).map(&:chomp).map{|l| l.sub(/^;#\s+/, '').split(/\s+/)}
+      # puts directives.to_yaml
+    end
+    ret = CDDL.new(ast, directives)
+
+    if $options.cddl2
+      ret.directives.each do |di|
+        preferred_tag = nil
+        case di
+        in ["include" => dir, docref]
+        in ["include" => dir, docref, "as", preferred_tag]
+        in ["import" => dir, docref]
+        in ["import" => dir, docref, "as", preferred_tag]
+        else
+          warn "** Can't parse include directive #{di.inspect}"
+          next
+        end
+        unless docref =~ SAFE_FN
+          warn "** skipping unsafe filename #{docref}"
+          next
+        end
+        puts "PREFERRED_TAG #{preferred_tag}" if $options.verbose
+        puts "DOCREF #{docref}" if $options.verbose
+        fn = docref.downcase << ".cddl"
+
+        io = nil
+        CDDL::cddl_include_path.each do |path|
+          begin
+            io = (path + fn).open
+            break
+          rescue Errno::ENOENT
+            next
+          end
+        end
+        unless io
+          warn "** include file #{fn} not found in #{CDDL::cddl_include_path.map(&:to_s)}"
+          next
+        end
+
+        include_file = io.read
+        included_cddl = CDDL.from_cddl(include_file)
+        if preferred_tag
+          included_cddl = included_cddl.deep_clone # needed?
+          renamed_names = included_cddl.rules.keys
+          name_rename = Hash[
+            renamed_names.map { |o|
+              n = "#{preferred_tag}.#{o}"
+              warn "** Warning: renamed name #{n} already in #{fn}" if included_cddl.rules[n]
+              [o, n]}]
+          included_cddl.rename(name_rename)
+        end
+
+        case dir
+        in "import"
+          warn "** IMPORTING #{fn}" if $options.verbose
+          undef_rule = nil
+          loop do
+            undef_rule = ret.cddl_undefined # XXX square...
+            # p undef_rule
+            got_more = false
+            undef_rule.each do |name|
+              if rule = included_cddl.rules[name]
+                ret.rules[name] = rule
+                warn "IMPORTED #{name} from #{fn}" if $options.verbose
+                got_more = true
+              end
+            end
+            break unless got_more
+          end
+          if preferred_tag
+            undef_rule.each do |name|
+              warn "** Warning: undefined reference #{name} without namespace prefix is defined in namespaced imported module #{fn}" if name_rename[name]
+            end
+          end
+        in "include"
+          warn "** INCLUDING #{fn}" if $options.verbose
+          included_cddl.rules.each do |k, v|
+            if old = ret.rules[k]
+              if old != v
+                warn "** included rule #{k} = #{v} would overwrite #{old}"
+              end
+            else
+              ret.rules[k] = v
+            end
+          end
+        end
+      end
+    end
+    ret
   end
 
-  attr_accessor :ast, :tree
-  def initialize(ast_)
+  attr_accessor :ast, :tree, :directives
+  def initialize(ast_, directives_ = [])
     @ast = ast_
     @tree = ast.ast
     @rules = nil                # only fill in if needed
+    @directives = directives_
+  end
+
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
   end
 
+
   RULE_OP_TO_CHOICE = {"/=" => "tcho", "//=" => "gcho"}
 
   def rules
@@ -45,7 +167,19 @@ class CDDL
           fail unless name.size == 2
           name = name[1]
         when "gen"
-          name = name[1..-1]
+          parmnames = name[2..-1]
+          name = name[1]        # XXX update val with parm/arg
+          val = ["parm", parmnames,
+                 visit(val) do |p|
+                   case p
+                   in ["name", nm]
+                     if ix = parmnames.index(nm)
+                       [true, ["arg", ix]]
+                     end
+                   else
+                     false
+                   end
+                 end]
         else
           fail name
         end
@@ -66,8 +200,6 @@ 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"))

data/lib/parser/cddl-util.rb

@@ -1,4 +1,4 @@
-
+require 'treetop'
 require_relative './cddlgrammar'
 
 class Treetop::Runtime::SyntaxNode

data/lib/processor/cddl-expander.rb

@@ -2,14 +2,13 @@ require_relative "../cddlc.rb"
 require_relative "./cddl-visitor.rb"
 
 class CDDL
-  def substitute(prod, parms, args, &block)
-    subs = Hash[parms.zip(args)]
+  def substitute(prod, parms, subs, &block)
     visit(prod) do |p, &block1|
       case p
-      in ["gen", name, *gen_args]
+      in ["gen", name, *gen_args] # XXX
         [true, gen_apply(name, gen_args, &block1)]
-      in ["name", name]
-        if replacement = subs[name]
+      in ["arg", num]
+        if replacement = subs[num]
           [true, visit(expand_prod(replacement), &block)]
         end
       else
@@ -35,15 +34,19 @@ class CDDL
   def expand_generics
     @gen = {}
     rules.each do |name, prod|
-      if Array === name
-        @gen[name[0]] = [name[1..-1], prod]
+      case prod
+      in ["parm", parmnames, type]
+        if prod[0] == "parm"
+          @gen[name] = [parmnames, type]
+        end
+      else
       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])
+      parmnames = v[0]
+      fail unless rules[k] == ["parm", parmnames, v[1]]
+      rules.delete(k)
     end
     @new_rules = {}
     rules.each do |name, prod|

data/lib/processor/cddl-undefined.rb

@@ -3,27 +3,36 @@ 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
+  def cddl_extract_names(prod, &name_used)
+    visit(prod) do |p|
+      case p
         in ["gen", name, *_gen_args]
-          gen_used[name] = true
+          name_used.call(name)
+          false
         in ["name", name]
-          used[name] = true
+          name_used.call(name)
+          false
         else
           false
-        end
       end
     end
-    [used.keys.reject {|name| cddl2.rules[name] || prelude.rules[name]},
-     gen_used.keys.reject {|name| def_gen[name] }]
+  end
+
+  def cddl_add_used_by(prod, used)
+    cddl_extract_names(prod) do |name|
+      used[name] = true
+    end
+  end
+
+  def cddl_undefined
+    # currently only works on expanded...
+    cddl2 = self.deep_clone                # needs deep-clone
+    cddl2.expand_generics
+    used = {}
+    cddl2.rules.each do |k, v|
+      fail unless String === k
+      cddl2.cddl_add_used_by(v, used)
+    end
+    used.keys.reject {|name| cddl2.rules[name] || prelude.rules[name]}
   end
 end

data/lib/processor/cddl-visitor.rb

@@ -11,6 +11,8 @@ class CDDL
     end
 
     case prod
+    in ["parm", parmnames, prod]
+      ["parm", parmnames, visit(prod, &block)]
     in ["gen", name, *types]
       ["gen", name, *visit_all(types, &block)]
     in ["op", op, *prods]

data/lib/writer/cddl-writer.rb

@@ -2,11 +2,10 @@ require_relative "../cddlc.rb"
 
 class CDDL
 
-  def write_lhs(k)
-    case k
-    in [id, *parms]
-      "#{id}<#{parms.join(", ")}>"
-    in String
+  def write_lhs(k, parmnames)
+    if parmnames
+      "#{k}<#{parmnames.join(", ")}>"
+    else
       k
     end
   end
@@ -26,35 +25,41 @@ class CDDL
     end
   end
 
-  def write_rhs(v, targetprec = 0, indent = 0)
+  def write_rhs(v, targetprec = 0, indent = 0, pn = [])
+    # pn = parmnames
 #    warn "** #{v.inspect}"
     indent_p = "  " * indent
     indent += 1
     indent_s = "  " * indent
     prec, ret =
     case v
+    in ["parm", parmnames, type]
+      [4, write_rhs(type, 2, indent, parmnames)]
+    in ["arg", Integer => num]
+      [4, pn[num] || "id$#{num}"]
     in ["name", id]
       [4, id]
     in ["gen", id, *parms]  # oops -- namep vs. namea; ouch
-      [4, "#{id}<#{parms.map{write_rhs(_1, 2, indent)}.join(", ")}>"]
+      [4, "#{id}<#{parms.map{write_rhs(_1, 2, indent, pn)}.join(", ")}>"]
     in ["tcho", *types]
-      [2, types.map{write_rhs(_1, 3, indent)}.join(" / ")]
+      [2, types.map{write_rhs(_1, 3, indent, pn)}.join(" / ")]
     in ["gcho", *groups]
-      [0, groups.map{write_rhs(_1, 2, indent)}.join(" // ")]
+      [0, groups.map{write_rhs(_1, 2, indent, pn)}.join(" // ")]
     in ["op", op, l, r]
-      [3, "#{write_rhs(l, 3, indent)} #{op} #{write_rhs(r, 3, indent)}"]
+      [3, "#{write_rhs(l, 4, indent, pn)} #{op} #{write_rhs(r, 4, indent, pn)}"]
+      # 3->4: work around cddl tool limitation
     in ["map", group]
-      [4, "{#{write_rhs(group, 0, indent)}}"]
+      [3, "{#{write_rhs(group, 0, indent, pn)}}"] # 4->3: work around cddl tool limitation
     in ["ary", group]
-      [4, "[#{write_rhs(group, 0, indent)}]"]
+      [3, "[#{write_rhs(group, 0, indent, pn)}]"] # 4->3: work around cddl tool limitation
     in ["unwrap", namep]
-      [4, "~#{write_rhs(namep, 4, indent)}"]
+      [4, "~#{write_rhs(namep, 4, indent, pn)}"]
     in ["enum", ["name", _name] => namep]
-      [4, "&#{write_rhs(namep, 4, indent)}"]
+      [4, "&#{write_rhs(namep, 4, indent, pn)}"]
     in ["enum", ["gen", _name, *types] => namep]
-      [4, "&#{write_rhs(namep, 4, indent)})"]
+      [4, "&#{write_rhs(namep, 4, indent, pn)})"]
     in ["enum", group]
-      [4, "&(#{write_rhs(group, 0, indent)})"]
+      [4, "&(#{write_rhs(group, 0, indent, pn)})"]
     in ["prim"]
       [4, "#"]
     in ["prim", maj]
@@ -62,16 +67,16 @@ class CDDL
     in ["prim", maj, min]
       [4, "##{maj}.#{min}"]
     in ["prim", 6, Integer => tag, type]
-      [4, "#6.#{tag}(#{write_rhs(type, 0, indent)})"]
+      [4, "#6.#{tag}(#{write_rhs(type, 0, indent, pn)})"]
     in ["prim", 6, nil, type]
-      [4, "#6(#{write_rhs(type, 0, indent)})"]
+      [4, "#6(#{write_rhs(type, 0, indent, pn)})"]
 # prim: extension for #6.<i>(t)
     in ["seq", *groups]
       case groups.size
       when 0; [4, ""]
-      # when 1; "#{write_rhs(g[0], targetprec, indent)}"
+      # when 1; "#{write_rhs(g[0], targetprec, indent, pn)}"
       else
-        [1, "\n#{indent_p}#{groups.map{write_rhs(_1, 1, indent)}.join(",\n#{indent_p}")},\n"]
+        [1, "\n#{indent_p}#{groups.map{write_rhs(_1, 1, indent, pn)}.join(",\n#{indent_p}")},\n"]
       end
     in ["rep", s, e, group]
       occur = case [s, e]
@@ -82,13 +87,16 @@ class CDDL
               else
                 "#{s}*#{e || ""}"
               end
-      [1, "#{occur}#{write_rhs(group, 2, indent)}"]
+      [1, "#{occur}#{write_rhs(group, 2, indent, pn)}"]
     in ["mem", nil, t2]
-      [2, write_rhs(t2, 2, indent)]
+      [2, write_rhs(t2, 2, indent, pn)]
     in ["mem", t1, t2]
-      [2, "#{write_rhs(t1, 2, indent)} => #{write_rhs(t2, 2, indent)}"]
+      [2, "#{write_rhs(t1, 3, indent, pn)} => #{write_rhs(t2, 2, indent, pn)}"]
+      # 2->3: work around cddl tool limitation
+    in ["bytes", t]
+      [4, t]                    # XXX not very clean
     in ["text", t]
-      [4, "\"#{t}\""]              # XXX escape
+      [4, "\"#{t}\""]           # XXX escape
     in ["number", t]
       [4, t.to_s]
     end
@@ -97,7 +105,12 @@ class CDDL
 
   def to_s
     rules.map {|k, v|
-      "#{write_lhs(k)} = #{write_rhs(v, 2)}" # 2: parenthesize groups
+      parmnames = false
+      case v
+      in ["parm", parmnames, _type]
+      else
+      end
+      "#{write_lhs(k, parmnames)} = #{write_rhs(v, 2)}" # 2: parenthesize groups
     }.join("\n")
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddlc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-25 00:00:00.000000000 Z
+date: 2023-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,7 +76,26 @@ files:
 - bin/cddlc
 - cddlc.gemspec
 - data/prelude.cddl
+- data/rfc8727.cddl
+- data/rfc8927.cddl
+- data/rfc8990.cddl
 - data/rfc9052.cddl
+- data/rfc9053.cddl
+- data/rfc9054.cddl
+- data/rfc9090.cddl
+- data/rfc9115.cddl
+- data/rfc9164.cddl
+- data/rfc9165.cddl
+- data/rfc9171.cddl
+- data/rfc9173.cddl
+- data/rfc9177.cddl
+- data/rfc9202.cddl
+- data/rfc9203.cddl
+- data/rfc9237.cddl
+- data/rfc9277.cddl
+- data/rfc9290.cddl
+- data/rfc9321.cddl
+- data/rfc9338.cddl
 - lib/cddlc.rb
 - lib/parser/cddl-util.rb
 - lib/parser/cddlgrammar.rb