cddl 0.8.0 → 0.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1f2111d3dcde0aece7da0e1cf03c4272247aee32
-  data.tar.gz: b67e1acb473b033a2297c8a14fe94a3729316f06
+SHA256:
+  metadata.gz: 6c877883cb125426e061f527ba4375c0f021d70dfef060336fe0bb0f5e2ca3d4
+  data.tar.gz: 7a3dc4065f3616bf57c229b410782b35140018ecada4418c0ef45056c62aef0b
 SHA512:
-  metadata.gz: 8ee61cf0a7772ee11af3623afc996b991715f594c638b35946ffc56fef1b3e85930c8ea04b8e390e28fe611741674c9a5eeac6a9393c3a492e047428c41c20ef
-  data.tar.gz: 1008940ffc91f0b2fec830cac7bf34aa32eb3c9fde85f9d2bc6157c3429405bd4f786d29f8793649fd89778fa1bc1f75d0e797568de8536a21346508d781d060
+  metadata.gz: b3987fbe82e80dddba2f650b1a12941ed6092708297302cf1a78dfe45b20b79d08e85901cb8739b5fc79eab8cde70ca8efb88698f4340da72c722a7a461565c6
+  data.tar.gz: 68c35688bac9b30411ee419e171860c463df28c3452bce1741399274e51295b609e0acc8df54e9876037f9d96ba02e369fd9465c2fe7c38bb9682d5ec19018cd

data/bin/cddl

@@ -7,13 +7,16 @@ require 'json'
 
 Encoding.default_external = "UTF-8" # wake up, smell the coffee
 
+EX_USAGE = 64
+EX_DATAERR = 65
+
 def usage
   warn "Usage:"
   warn "#$0 spec.cddl generate [n]"
   warn "#$0 spec.cddl json-generate [n]"
   warn "#$0 spec.cddl validate instance.cbor"
   warn "#$0 spec.cddl validate instance.json"
-  exit 1
+  exit EX_USAGE
 end
 
 def read_arg(arg)
@@ -21,7 +24,7 @@ def read_arg(arg)
     STDIN.read
   else
     usage unless arg
-    File.read(arg)
+    File.read(arg, mode: "rb")
   end
 end
 
@@ -86,10 +89,11 @@ begin
     # my_pp ann
     instance.cbor_add_annotations_from(ann) rescue nil
     my_diag(instance) if $annotate
+    exit 1 unless ann
   else
     usage
   end
 rescue CDDL::ParseError => e
   warn e.message
-  exit 1
+  exit EX_DATAERR
 end

data/cddl.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'cddl'
-  s.version = '0.8.0'
+  s.version = '0.8.8'
   s.summary = "CDDL generator and validator."
   s.description = %{A parser, generator, and validator for CDDL}
   s.add_dependency('cbor-diag')

data/data/cddl.abnf

@@ -49,11 +49,14 @@ occur = [uint] "*" [uint]
       / "+"
       / "?"
 
-uint = ["0x" / "0b"] "0"
-     / ["0x" / "0b"] DIGIT1 *DIGIT
+uint = DIGIT1 *DIGIT
+     / "0x" 1*HEXDIG
+     / "0b" 1*BINDIG
+     / "0"
 
 value = number
-      / string
+      / text
+      / bytes
 
 int = ["-"] uint
 
@@ -62,15 +65,23 @@ number = int ["." fraction] ["e" exponent ]
 fraction = 1*DIGIT
 exponent = int
 
-string = %x22 *SCHAR %x22
+text = %x22 *SCHAR %x22
 SCHAR = %x20-21 / %x23-7E / SESC
 SESC = "\" %x20-7E
 
+bytes = [bsqual] %x27 *BCHAR %x27
+BCHAR = %x20-26 / %x28-7E / SESC / CRLF
+bsqual = %x68 ; "h"
+       / %x62.36.34 ; "b64"
+
 id = EALPHA *(*("-" / ".") (EALPHA / DIGIT))
 ALPHA = %x41-5A / %x61-7A
 EALPHA = %x41-5A / %x61-7A / "@" / "_" / "$"
 DIGIT = %x30-39
 DIGIT1 = %x31-39
+HEXDIG = DIGIT / "A" / "B" / "C" / "D" / "E" / "F"
+BINDIG = %x30-31
+
 S = *WS
 WS = SP / NL
 SP = %x20
@@ -78,3 +89,4 @@ NL = COMMENT / CRLF
 COMMENT = ";" *(SP / VCHAR) CRLF
 VCHAR = %x21-7E
 CRLF = %x0A / %x0D.0A
+

data/data/prelude.cddl

@@ -22,8 +22,8 @@ unsigned = uint / biguint
 decfrac = #6.4([e10: int, m: integer])
 bigfloat = #6.5([e2: int, m: integer])
 eb64url = #6.21(any)
-eb64legacy = #6.21(any)
-eb16 = #6.21(any)
+eb64legacy = #6.22(any)
+eb16 = #6.23(any)
 encoded-cbor = #6.24(bstr)
 uri = #6.32(tstr)
 b64url = #6.33(tstr)

data/lib/cddl.rb

@@ -4,6 +4,7 @@ require 'pathname'
 require 'cbor-pure' unless defined?(CBOR::Tagged)
 require 'regexp-examples'
 require 'colorize'
+require 'base64'
 
 module CDDL
 
@@ -14,7 +15,7 @@ module CDDL
 
   MANY = Float::INFINITY
 
-  MAX_RECURSE = 32              # XXX
+  MAX_RECURSE = 128              # XXX
 
   class ParseError < ArgumentError; end
 
@@ -139,7 +140,7 @@ module CDDL
             arrayname = cname(arrayname ? arrayname.first : anno)
             subtree[1..-1].each_with_index do |x, i|
               if x[0] == :member
-                if Array === x[3] && x[3][0] == :string
+                if Array === x[3] && x[3][0] == :text
                   memname = x[3][1] # preferably use key string
                 elsif memname = x[4].cbor_annotations
                   memname = memname.first # use value annotation otherwise
@@ -319,7 +320,8 @@ module CDDL
         end
       when :member
         st = where[1]
-        en = [where[2], [st, 4].max].min # truncate to 4 unless must be more
+        fudge = 4 * (1 - (@recursion / MAX_RECURSE.to_f))**3 # get less generate-happy with more recursion
+        en = [where[2], [st, fudge].max].min # truncate to fudge unless must be more
         st += rand(en + 1 - st) if en != st
         kr = where[3]
         vr = where[4]
@@ -348,7 +350,7 @@ module CDDL
           fail BackTrack.new("Need #{where[1]}..#{where[2]} of these: #{[kr, vr].inspect}") unless where[1] == 0
           []
         end
-      when :string, :int, :float
+      when :text, :int, :float, :bytes
         where[1]
       when :range
         rand(where[1])
@@ -390,15 +392,19 @@ module CDDL
         case where[1]
         when :size
           should_be_int = generate1(control)
-          unless (target == [:prim, 2] || target == [:prim, 0]) && Integer === should_be_int && should_be_int >= 0
+          unless (Array === target && target[0] == :prim && [0, 2, 3].include?(target[1])) && Integer === should_be_int && should_be_int >= 0
             fail "Don't know yet how to generate #{where}"
           end
           s = Random.new.bytes(should_be_int)
-          if target == [:prim, 0]
+          case target[1]
+          when 0
             # silently restrict to what we can put into a uint
             s[0...8].bytes.inject(0) {|a, b| a << 8 | b }
-          else
+          when 2
             s
+          when 3
+            Base64.urlsafe_encode64(s)[0...should_be_int]
+            # XXX generate word a la w = gen_word
           end
         when :bits
           set_of_bits = Array.new(10) { generate1(control) } # XXX: ten?
@@ -517,7 +523,7 @@ module CDDL
       end
     end
 
-    VALUE_TYPE = {string: String, int: Integer, float: Float}
+    VALUE_TYPE = {text: String, int: Integer, float: Float}
     SIMPLE_VALUE = {
       [:prim, 7, 20] => [true, false, :bool],
       [:prim, 7, 21] => [true, true, :bool],
@@ -525,7 +531,7 @@ module CDDL
       [:prim, 7, 23] => [true, :undefined, :undefined],
     }
 
-    def extract_value(t)
+    def extract_value(t)        # []
       if vt = VALUE_TYPE[t[0]]
         [true, t[1], vt]
       elsif v = SIMPLE_VALUE[t]
@@ -642,7 +648,7 @@ module CDDL
             d_check1 = d_check.dup
             occ = 0
             ann2 = []
-            while occ < e && (ann3 = map_check(d, d_check1, entries))
+            while occ < e && (ann3 = map_check(d, d_check1, entries)) && ann3 != []
               occ += 1
               ann2.concat(ann3)
             end
@@ -660,7 +666,7 @@ module CDDL
           # this is mostly quadratic; let's do the linear thing if possible
           simple, simpleval = extract_value(k)
           if simple
-            #              puts "SIMPLE: #{d_check.inspect} #{simpleval}"
+                          puts "SIMPLE: #{d_check.inspect} #{simpleval}"         if ENV["CDDL_TRACE"]
             # add occurrence check; check that val is present in the first place
             actual = d.fetch(simpleval, :not_found)
             if actual == :not_found
@@ -672,7 +678,7 @@ module CDDL
               end
             end
           else
-            #              puts "COMPLEX: #{k.inspect} #{simple.inspect} #{simpleval.inspect}"
+                          puts "COMPLEX: #{k.inspect} #{simple.inspect} #{simpleval.inspect}"         if ENV["CDDL_TRACE"]
             keys = d_check.keys
             ta, keys = keys.partition{ |key| validate1(key, k)}
             # XXX check ta.size against s/e
@@ -724,7 +730,7 @@ module CDDL
             ann
           else
             if ENV["CDDL_TRACE"]
-              puts "MAP RESIDUAL: #{d_check.inspect}"
+              puts "MAP RESIDUAL: #{d_check.inspect} for #{where[1..-1]} and #{d.inspect}"
             end
           end
         end
@@ -735,7 +741,7 @@ module CDDL
           idx, ann = validate_forward(d, 0, where)
           ann if validate_result(idx == d.size) { "#{validate_diag.inspect} -- cannot complete (#{idx}, #{d.size}) array #{d} for #{where}" }
         end
-      when :string, :int, :float
+      when :text, :int, :float, :bytes
         _, v = extract_value(where)
         [] if d == v
       when :range
@@ -942,14 +948,34 @@ module CDDL
     def value(n)
       # cheat:
       # warn n
-      val = eval(n.to_s)
-      # warn val
-      [case val
-       when Integer; :int
-       when Numeric; :float
-       when String; :string
-       else fail "huh? value #{val.inspect}"
-       end, val]
+      s = n.to_s
+      if s[-1] == "'"
+        parts = s.split("'", 3)
+        if parts[2] != "" || parts[1] =~ /\\/
+          warn "*** Can't handle backslashes in #{s.inspect} yet"
+        end
+        [:bytes,
+         case parts[0]
+         when ""
+           parts[1].b
+         when "h"
+           parts[1].gsub(/\s/, "").chars.each_slice(2).map{ |x| Integer(x.join, 16).chr("BINARY") }.join
+         when "b64"
+            Base64.urlsafe_decode64(parts[1])
+         else
+           warn "*** Can't handle byte string type #{parts[0].inspect} yet"
+         end
+        ]
+      else
+        val = eval(n.to_s)
+        # warn val
+        case val
+         when Integer; [:int, val]
+         when Numeric; [:float, val]
+         when String; [:text, val.force_encoding(Encoding::UTF_8)]
+         else fail "huh? value #{val.inspect}"
+        end
+      end
     end
 
     def workaround1(n)
@@ -988,7 +1014,7 @@ module CDDL
             fail [n, n.children, mk, mk.children].inspect
           end
           name = bw.to_s
-          [[:member, *occ, [:string, name], type(nt)]]
+          [[:member, *occ, [:text, name.force_encoding(Encoding::UTF_8)], type(nt)]]
         end
       else
         t = if nbw = nt.bareword
@@ -1000,8 +1026,8 @@ module CDDL
             else
               type(nt, true)              # type can actually be a group here!
             end
-        # pp ["t is", t]
-        if t[0] == :grpent && (@insides.last != :array || occ == [1, 1])
+        pp ["t is", t]               if ENV["CDDL_TRACE"]
+        if t[0] == :grpent && (occ == [1, 1])
           # go through the members here and multiply the occs
           t1 = t[1..-1].flatten(1)
           if t1[0] == :recurse_grpent

data/test/test-cddl.rb

@@ -21,26 +21,26 @@ class TestABNF < Test::Unit::TestCase
 
   EXPECTED_RULES = [:type1,
  [:map,
-  [:member, 1, 1, [:string, "application"], [:prim, 3]],
+  [:member, 1, 1, [:text, "application"], [:prim, 3]],
   [:member,
    1,
    1,
-   [:string, "reputons"],
+   [:text, "reputons"],
    [:array,
     [:member,
      0,
      CDDL::MANY,
      nil,
      [:map,
-      [:member, 1, 1, [:string, "rater"], [:prim, 3]],
-      [:member, 1, 1, [:string, "assertion"], [:prim, 3]],
-      [:member, 1, 1, [:string, "rated"], [:prim, 3]],
-      [:member, 1, 1, [:string, "rating"], [:prim, 7, 25]],
-      [:member, 0, 1, [:string, "confidence"], [:prim, 7, 25]],
-      [:member, 0, 1, [:string, "normal-rating"], [:prim, 7, 25]],
-      [:member, 0, 1, [:string, "sample-size"], [:prim, 0]],
-      [:member, 0, 1, [:string, "generated"], [:prim, 0]],
-      [:member, 0, 1, [:string, "expires"], [:prim, 0]],
+      [:member, 1, 1, [:text, "rater"], [:prim, 3]],
+      [:member, 1, 1, [:text, "assertion"], [:prim, 3]],
+      [:member, 1, 1, [:text, "rated"], [:prim, 3]],
+      [:member, 1, 1, [:text, "rating"], [:prim, 7, 25]],
+      [:member, 0, 1, [:text, "confidence"], [:prim, 7, 25]],
+      [:member, 0, 1, [:text, "normal-rating"], [:prim, 7, 25]],
+      [:member, 0, 1, [:text, "sample-size"], [:prim, 0]],
+      [:member, 0, 1, [:text, "generated"], [:prim, 0]],
+      [:member, 0, 1, [:text, "expires"], [:prim, 0]],
       [:member, 0, CDDL::MANY, [:prim, 3], [:prim]]]]]]]]
 
   def test_aa_rfc7071_concise
@@ -59,9 +59,9 @@ class TestABNF < Test::Unit::TestCase
 
   def test_generate_hex_bin
     parser = CDDL::Parser.new <<HERE
-test = [0x4711, 0b1011001110001111000]
+test = [0x4711, 0xabcDEF, 0b1011001110001111000]
 HERE
-    assert_equal [0x4711, 0b1011001110001111000], parser.generate
+    assert_equal [0x4711, 0xabcDEF, 0b1011001110001111000], parser.generate
   end
 
   def test_generate_le
@@ -182,6 +182,74 @@ HERE
     refute parser.validate_for_test([2, 1], false)
   end
 
+  def test_validate_a_map
+    parser = CDDL::Parser.new <<HERE
+test = {* one: 1}
+HERE
+    assert parser.validate_for_test({})
+    assert parser.validate_for_test({"one" => 1})
+    refute parser.validate_for_test({"one" => 2}, false)
+    refute parser.validate_for_test({"two" => 1}, false)
+  end
+
+  def test_validate_a_group_map
+    parser = CDDL::Parser.new <<HERE
+test = {* (text => 1)}
+HERE
+    assert parser.validate_for_test({})
+    assert parser.validate_for_test({"one" => 1})
+    refute parser.validate_for_test({"one" => 2}, false)
+    assert parser.validate_for_test({"one" => 1, "two" => 1}, false)
+  end
+
+  def test_validate_a_nontrivial_group_map
+    parser = CDDL::Parser.new <<HERE
+test = {* (text => 1, text => 2)}
+HERE
+    assert parser.validate_for_test({})
+    assert parser.validate_for_test({"one" => 2, "two" => 1})
+    assert parser.validate_for_test({"one" => 1, "two" => 2})
+    refute parser.validate_for_test({"one" => 1}, false)
+    assert parser.validate_for_test({"one" => 1, "two" => 2, "uno" => 1, "due" => 2})
+  end
+
+
+  def test_murray
+    parser = CDDL::Parser.new <<HERE
+a = {
+  b
+}
+
+b = (
+  (x: int // y: int), z: int
+)
+HERE
+    assert parser.validate_for_test({})
+    assert parser.validate_for_test({"x" => 2, "z" => 1})
+    assert parser.validate_for_test({"y" => 1, "z" => 2})
+    refute parser.validate_for_test({"z" => 1}, false)
+    assert parser.validate_for_test({"one" => 1, "two" => 2, "uno" => 1, "due" => 2})
+  end
+
+
+  def test_murray_workaround
+    parser = CDDL::Parser.new <<HERE
+a = {
+  b
+}
+
+b = ( z: int
+  (x: int // y: int)
+)
+HERE
+    assert parser.validate_for_test({})
+    assert parser.validate_for_test({"x" => 2, "z" => 1})
+    assert parser.validate_for_test({"y" => 1, "z" => 2})
+    refute parser.validate_for_test({"z" => 1}, false)
+    assert parser.validate_for_test({"one" => 1, "two" => 2, "uno" => 1, "due" => 2})
+  end
+
+
   def test_validate_a_string
     parser = CDDL::Parser.new <<HERE
 test = [* one: "one"]
@@ -739,7 +807,7 @@ HERE
 foo = {* bar}
 bar = (* b: 1)
 HERE
-    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
+    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:text, "b"], [:int, 1]]]], parser.rules
   end
 
   def test_nested_group_many2
@@ -747,7 +815,7 @@ HERE
 foo = {* bar}
 bar = (b: 1)
 HERE
-    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
+    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:text, "b"], [:int, 1]]]], parser.rules
   end
 
   def test_nested_group_many3
@@ -755,7 +823,7 @@ HERE
 foo = {* bar}
 bar = (4*6 b: 1)
 HERE
-    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:string, "b"], [:int, 1]]]], parser.rules
+    assert_equal [:type1, [:map, [:member, 0, CDDL::MANY, [:text, "b"], [:int, 1]]]], parser.rules
   end
 
   def test_range_integer
@@ -1595,9 +1663,9 @@ identifier //= ( "ifmap" // "ifmap")
 ;identifier = ( "ifmap" // "ifmap" )
 HERE
     p parser.rules
-    # - [:type1, [:array, [:member, 2, 2, nil, [:grpchoice, [[:member, 1, 1, nil, [:string, "ifmap"]]]]]]]
-    # - [:type1, [:array, [:member, 2, 2, nil, [:grpchoice, [[:grpchoice, [[:member, 1, 1, nil, [:string, "ifmap"]]], [[:member, 1, 1, nil, [:string, "ifmap"]]]]]]]]]
-    # + [:type1, [:array, [:member, 2, 2, nil, [:grpent, [:grpchoice, [[:member, 1, 1, nil, [:string, "ifmap"]]], [[:member, 1, 1, nil, [:string, "ifmap"]]]]]]]]
+    # - [:type1, [:array, [:member, 2, 2, nil, [:grpchoice, [[:member, 1, 1, nil, [:text, "ifmap"]]]]]]]
+    # - [:type1, [:array, [:member, 2, 2, nil, [:grpchoice, [[:grpchoice, [[:member, 1, 1, nil, [:text, "ifmap"]]], [[:member, 1, 1, nil, [:text, "ifmap"]]]]]]]]]
+    # + [:type1, [:array, [:member, 2, 2, nil, [:grpent, [:grpchoice, [[:member, 1, 1, nil, [:text, "ifmap"]]], [[:member, 1, 1, nil, [:text, "ifmap"]]]]]]]]
     g = parser.generate
     assert_equal g, ["ifmap", "ifmap"]
   end

data/test-data/7071-concise-cut.cddl

@@ -0,0 +1,48 @@
+reputation-object = {
+  application: tstr
+  reputons: [* reputon]
+}
+
+reputon = {
+  rater: tstr
+  assertion: tstr
+  rated: tstr
+  rating: float16
+  ? confidence: float16
+  ? normal-rating: float16
+  ? sample-size: uint
+  ? generated: uint
+  ? expires: uint
+  * tstr => any
+}
+
+#
+# a = b / c / d
+# a = b / (c / d)
+# b = "foo" ^ bar
+# c = "bar" ^ baz
+
+# foo: bar
+# "foo" ^ => bar
+
+
+# (rater: tstr // rater: uint)
+# (rater: tstr / uint)
+
+# (
+#  * tstr => uint
+#  rater: float16
+# )
+
+# a = b / c
+# c = e / f
+# a = b / (e / f)
+
+# a = ( a // b )
+# a = ( b // a )
+
+# a = (uint .size 3) .le 100000
+
+# name = uint .size 3
+# reserved_name = name .le 100000
+

data/test-data/ambig.cddl

@@ -0,0 +1,2 @@
+b = [ a ]
+a = uint

data/test-data/badaddr.cddl

@@ -0,0 +1 @@
+badaddr = text .regexp "[0-9A-Fa-f][0-9A-Fa-f]:[0-9A-Fa-f][0-9A-Fa-f]:[0-9A-Fa-f][0-9A-Fa-f]:[0-9A-Fa-f][0-9A-Fa-f]:[0-9A-Fa-f][0-9A-Fa-f]:[0-9A-Fa-f][0-9A-Fa-f]"

data/test-data/dotsize.cddl

@@ -0,0 +1,7 @@
+foo = [a, b, c]
+
+a = uint .size 4
+
+b = bytes .size 4
+
+c = text .size (0..30)

data/test-data/grasp-09.cddl

@@ -0,0 +1,108 @@
+  grasp-message = (message .within message-structure) / noop-message
+
+  message-structure = [MESSAGE_TYPE, session-id, ?initiator,
+                       *grasp-option]
+
+  MESSAGE_TYPE = 0..255
+  session-id = 0..4294967295 ;up to 32 bits
+  grasp-option = any
+
+  message /= discovery-message
+  discovery-message = [M_DISCOVERY, session-id, initiator, objective]
+
+  message /= response-message ;response to Discovery
+  response-message = [M_RESPONSE, session-id, initiator, ttl,
+                     (+locator-option // divert-option), ?objective]
+
+  message /= synch-message ;response to Synchronization request
+  synch-message = [M_SYNCH, session-id, objective]
+
+  message /= flood-message
+  flood-message = [M_FLOOD, session-id, initiator, ttl,
+                  +[objective, (locator-option / [])]]
+
+  message /= request-negotiation-message
+  request-negotiation-message = [M_REQ_NEG, session-id, objective]
+
+  message /= request-synchronization-message
+  request-synchronization-message = [M_REQ_SYN, session-id, objective]
+
+  message /= negotiation-message
+  negotiation-message = [M_NEGOTIATE, session-id, objective]
+
+  message /= end-message
+  end-message = [M_END, session-id, accept-option / decline-option ]
+
+  message /= wait-message
+  wait-message = [M_WAIT, session-id, waiting-time]
+
+  message /= invalid-message
+  invalid-message = [M_INVALID, session-id, ?any]
+
+  noop-message = [M_NOOP]
+
+  divert-option = [O_DIVERT, +locator-option]
+
+  accept-option = [O_ACCEPT]
+
+  decline-option = [O_DECLINE, ?reason]
+  reason = text  ;optional error message
+
+  waiting-time = 0..4294967295 ; in milliseconds
+  ttl = 0..4294967295 ; in milliseconds
+
+  locator-option /= [O_IPv4_LOCATOR, ipv4-address,
+                     transport-proto, port-number]
+  ipv4-address = bytes .size 4
+
+  locator-option /= [O_IPv6_LOCATOR, ipv6-address,
+                     transport-proto, port-number]
+  ipv6-address = bytes .size 16
+
+  locator-option /= [O_FQDN_LOCATOR, text, transport-proto, port-number]
+
+  transport-proto = IPPROTO_TCP / IPPROTO_UDP
+  IPPROTO_TCP = 6
+  IPPROTO_UDP = 17
+  port-number = 0..65535
+
+  locator-option /= [O_URI_LOCATOR, text]
+
+  initiator = ipv4-address / ipv6-address
+
+  objective-flags = uint .bits objective-flag
+
+  objective-flag = &(
+    F_DISC: 0    ; valid for discovery
+    F_NEG: 1     ; valid for negotiation
+    F_SYNCH: 2   ; valid for synchronization
+    F_NEG_DRY: 3 ; negotiation is dry-run
+  )
+
+  objective = [objective-name, objective-flags, loop-count, ?any]
+
+  objective-name = text ;see specification for uniqueness rules
+
+  loop-count = 0..255
+
+  ; Constants for message types and option types
+
+  M_NOOP = 0
+  M_DISCOVERY = 1
+  M_RESPONSE = 2
+  M_REQ_NEG = 3
+  M_REQ_SYN = 4
+  M_NEGOTIATE = 5
+  M_END = 6
+  M_WAIT = 7
+  M_SYNCH = 8
+  M_FLOOD = 9
+  M_INVALID = 99
+
+  O_DIVERT = 100
+  O_ACCEPT = 101
+  O_DECLINE = 102
+  O_IPv6_LOCATOR = 103
+  O_IPv4_LOCATOR = 104
+  O_FQDN_LOCATOR = 105
+  O_URI_LOCATOR = 106

data/test-data/kevin5.cddl

@@ -0,0 +1,5 @@
+   top = { topgroup }
+
+   topgroup = ( first: tstr, second: tstr,
+            (option1: uint //
+            option2: uint) )

data/test-data/map-group.cddl

@@ -0,0 +1,13 @@
+map = {
+ first_group,
+ ? second_group,
+}
+
+first_group = ( e1, e2,)
+second_group = (e3, e4, e5)
+
+e1 = (1: uint)
+e2 = (2: tstr)
+e3 = (3: tdate)
+e4 = (4: tstr)
+e5 = (5: uint)

data/test-data/mapkey.cddl

@@ -0,0 +1,2 @@
+foo = { foo: bool, "foob" => bar, * tstr => uint }
+bar = "blba"

data/test-data/toerless0.cddl

@@ -0,0 +1,14 @@
+
+foo = { 1*relement }
+
+context-element = 4711
+
+relement = $$relement .within relement-generic
+
+relement-generic = ( relement-codepoint => relement-value ) ; [1]
+relement-codepoint = uint                            ; [1]
+relement-value     = any                             ; [1]
+
+$$relement //= ( &(sender-loop-count:1) => 1..255 )    ; [2]
+$$relement //= ( &(srv-element:2) => context-element ) ; [2]
+

data/test-data/toerless1.cddl

@@ -0,0 +1,11 @@
+foo = foo-specific .within foo-generic
+foo-specific = { 1*$$relement }
+foo-generic = { 1*relement-generic }
+
+relement-generic = ( relement-codepoint => relement-value ) ; [1]
+relement-codepoint = uint                            ; [1]
+relement-value     = any                             ; [1]
+
+$$relement //= ( &(sender-loop-count:1) => 1..255 )    ; [2]
+$$relement //= ( &(srv-element:2) => context-element ) ; [2]
+context-element = "and so on"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cddl
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.8
 platform: ruby
 authors:
 - Carsten Bormann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-17 00:00:00.000000000 Z
+date: 2018-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cbor-diag
@@ -94,19 +94,24 @@ files:
 - lib/cbor-pp-play.rb
 - lib/cbor-pp.rb
 - lib/cddl.rb
+- test-data/7071-concise-cut.cddl
 - test-data/7071-concise.cddl
 - test-data/7071-verbose.cddl
 - test-data/a.cddl
+- test-data/ambig.cddl
 - test-data/b.cddl
+- test-data/badaddr.cddl
 - test-data/basic_syntax_example.cddl
 - test-data/cdni-ct.cddl
 - test-data/cose.cddl
 - test-data/dcaf.cddl
 - test-data/dcaf1.cddl
+- test-data/dotsize.cddl
 - test-data/extractor-demo.cddl
 - test-data/grasp-01-extract.cddl
 - test-data/grasp-01-test.cddl
 - test-data/grasp-01.cddl
+- test-data/grasp-09.cddl
 - test-data/grasp-v1.cddl
 - test-data/grasp-v2X.cddl
 - test-data/ifmap-base-2.0v17.cddl
@@ -114,10 +119,15 @@ files:
 - test-data/ifmap-metadata-2.2v9_fh-cabo.cddl
 - test-data/ifmap2.cddl
 - test-data/jcr-ex.cddl
+- test-data/kevin5.cddl
+- test-data/map-group.cddl
+- test-data/mapkey.cddl
 - test-data/minimal.cddl
 - test-data/patch1.cddl
 - test-data/reused_named_group.cddl
 - test-data/structure.cddl
+- test-data/toerless0.cddl
+- test-data/toerless1.cddl
 - test-data/two_anonymous_groups.cddl
 - test-data/wrong1.cddl
 - test-data/wrong1a.cddl
@@ -145,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: CDDL generator and validator.