Class: CDDL
- Inherits:
-
Object
- Object
- CDDL
- Defined in:
- lib/cddlc.rb,
lib/writer/cddl-writer.rb,
lib/processor/cddl-visitor.rb,
lib/processor/cddl-expander.rb,
lib/processor/cddl-undefined.rb,
lib/processor/cddl-flattening.rb
Constant Summary collapse
- DATA_DIR =
Pathname.new(__FILE__) + "../../data/"
- CDDL_INCLUDE_PATH =
empty string is for CDDL::DATA_DIR
ENV["CDDL_INCLUDE_PATH"] || ".:"
- SAFE_FN =
/\A[-._a-zA-Z0-9]+\z/
- IMPINC =
/\A(?:import|include)\z/
- IDENTIFIER_RE =
/\A[A-Za-z@_$]([-.]*[A-Za-z@_$0-9])*\z/
- RULE_OP_TO_CHOICE =
{"/=" => "tcho", "//=" => "gcho"}
- ID_RE =
/\A[A-Za-z@_$]([-.]*[A-Za-z@_$0-9])*\z/
- MOGRIFIED_ID_RE =
/\A\$\.[A-Za-z@_$]([-.]*[A-Za-z@_$0-9])*\z/
- @@parser =
CDDLGRAMMARParser.new
Instance Attribute Summary collapse
-
#ast ⇒ Object
Returns the value of attribute ast.
-
#directives ⇒ Object
Returns the value of attribute directives.
-
#tree ⇒ Object
Returns the value of attribute tree.
Class Method Summary collapse
- .cddl_include_path ⇒ Object
- .from_cddl(s) ⇒ Object
- .read_from_include_path(fn) ⇒ Object
- .reason(parser, s) ⇒ Object
Instance Method Summary collapse
- #cddl_add_used_by(prod, used) ⇒ Object
- #cddl_extract_names(prod, &name_used) ⇒ Object
- #cddl_undefined ⇒ Object
- #deep_clone ⇒ Object
- #expand_generics ⇒ Object
- #expand_prod(prod) ⇒ Object
- #flattening ⇒ Object
- #flattening_key_name(key, value, env = nil) ⇒ Object
- #flattening_mogrify(name, prod, symtab, alias_rules) ⇒ Object
- #flattening_occurrences ⇒ Object
- #flattening_replace(symtab) ⇒ Object
- #gen_apply(gen_name, gen_args, &block) ⇒ Object
-
#initialize(ast_, directives_ = []) ⇒ CDDL
constructor
A new instance of CDDL.
- #perform_directives ⇒ Object
-
#prec_check(inner, targetprec, prec, indent_s) ⇒ Object
precedence: 0: // gcho 1: , seq 2: / tcho -> (type1) 3: (type1) .xxx op -> type2 4: type2.
- #prelude ⇒ Object
-
#rename(rename_map) ⇒ Object
(keeps only renamed rules).
- #rules ⇒ Object
- #store_rule(k, v) ⇒ Object
- #substitute(prod, parms, subs, &block) ⇒ Object
- #to_s ⇒ Object
- #visit(prod, &block) ⇒ Object
- #visit_all(prod_array, &block) ⇒ Object
- #warn_error(s) ⇒ Object
- #write_lhs(k, parmnames) ⇒ Object
- #write_rhs(v, targetprec = 0, indent = 0, pn = []) ⇒ Object
Constructor Details
#initialize(ast_, directives_ = []) ⇒ CDDL
Returns a new instance of CDDL.
212 213 214 215 216 217 |
# File 'lib/cddlc.rb', line 212 def initialize(ast_, directives_ = []) @ast = ast_ @tree = ast.ast @rules = nil # only fill in if needed @directives = directives_ end |
Instance Attribute Details
#ast ⇒ Object
Returns the value of attribute ast.
211 212 213 |
# File 'lib/cddlc.rb', line 211 def ast @ast end |
#directives ⇒ Object
Returns the value of attribute directives.
211 212 213 |
# File 'lib/cddlc.rb', line 211 def directives @directives end |
#tree ⇒ Object
Returns the value of attribute tree.
211 212 213 |
# File 'lib/cddlc.rb', line 211 def tree @tree end |
Class Method Details
.cddl_include_path ⇒ Object
12 13 14 |
# File 'lib/cddlc.rb', line 12 def self.cddl_include_path CDDL_INCLUDE_PATH.split(":", -1).map {_1 == "" ? CDDL::DATA_DIR : Pathname.new(_1)} end |
.from_cddl(s) ⇒ Object
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
# File 'lib/cddlc.rb', line 59 def self.from_cddl(s) ast = @@parser.parse s if !ast fail self.reason(@@parser, s) end 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.perform_directives end ret end |
.read_from_include_path(fn) ⇒ Object
42 43 44 45 46 47 48 49 50 51 52 53 |
# File 'lib/cddlc.rb', line 42 def self.read_from_include_path(fn) io = nil CDDL::cddl_include_path.each do |path| begin io = (path + fn).open break rescue Errno::ENOENT next end end io end |
.reason(parser, s) ⇒ Object
16 17 18 19 20 21 22 23 24 25 |
# File 'lib/cddlc.rb', line 16 def self.reason(parser, s) reason = [parser.failure_reason] parser.failure_reason =~ /^(Expected .+) after/m reason << "#{$1.gsub("\n", '<<<NEWLINE>>>')}:" if $1 if line = s.lines.to_a[parser.failure_line - 1] reason << line reason << "#{'~' * (parser.failure_column - 1)}^" end reason.join("\n") end |
Instance Method Details
#cddl_add_used_by(prod, used) ⇒ Object
21 22 23 24 25 |
# File 'lib/processor/cddl-undefined.rb', line 21 def cddl_add_used_by(prod, used) cddl_extract_names(prod) do |name| used[name] = true end end |
#cddl_extract_names(prod, &name_used) ⇒ Object
6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# File 'lib/processor/cddl-undefined.rb', line 6 def cddl_extract_names(prod, &name_used) visit(prod) do |p| case p in ["gen", name, *_gen_args] name_used.call(name) false in ["name", name] name_used.call(name) false else false end end end |
#cddl_undefined ⇒ Object
27 28 29 30 31 32 33 34 35 36 37 |
# File 'lib/processor/cddl-undefined.rb', line 27 def cddl_undefined # currently only works on expanded... cddl2 = self.deep_clone # needs deep-clone cddl2. 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 |
#deep_clone ⇒ Object
219 220 221 |
# File 'lib/cddlc.rb', line 219 def deep_clone Marshal.load(Marshal.dump(self)) end |
#expand_generics ⇒ Object
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
# File 'lib/processor/cddl-expander.rb', line 34 def @gen = {} rules.each do |name, prod| case prod in ["parm", parmnames, type] if prod[0] == "parm" @gen[name] = [parmnames, type] end else end end warn "@gen = #{@gen.inspect}" if $options.verbose @gen.each do |k, v| parmnames = v[0] fail unless rules[k] == ["parm", parmnames, v[1]] rules.delete(k) end @new_rules = {} rules.each do |name, prod| fail if Array === name @new_rules[name] = (prod) end warn "@new_rules = #{@new_rules.inspect}" if $options.verbose @rules = @new_rules end |
#expand_prod(prod) ⇒ Object
24 25 26 27 28 29 30 31 32 33 |
# File 'lib/processor/cddl-expander.rb', line 24 def (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 |
#flattening ⇒ Object
94 95 96 97 98 |
# File 'lib/processor/cddl-flattening.rb', line 94 def flattening symtab = flattening_occurrences PP.pp(["*** SYMTAB", symtab], STDERR) if $options.verbose rules.replace(flattening_replace(symtab)) end |
#flattening_key_name(key, value, env = nil) ⇒ Object
7 8 9 10 11 12 13 14 15 16 17 18 |
# File 'lib/processor/cddl-flattening.rb', line 7 def flattening_key_name(key, value, env = nil) case key in ["enum", ["mem", ["text", ID_RE => text], _]] [false, text] in ["text", ID_RE => text] [false, text] in ["number", /\A0|[-]?[1-9][0-9]*\z/ => intval] if env [true, "$.#{env}$#{intval}"] else [false] end end |
#flattening_mogrify(name, prod, symtab, alias_rules) ⇒ Object
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
# File 'lib/processor/cddl-flattening.rb', line 45 def flattening_mogrify(name, prod, symtab, alias_rules) step1 = visit(prod) do |here| case here in ["mem", key, value] ### mogrify labeled, keyname = flattening_key_name(key, value, name) if keyname new_name = unless labeled syment = symtab[keyname] fail keyname unless Array === syment if syment.size == 1 "$.#{keyname}" else "$.#{name}$#{keyname}" end else keyname end new_value2 = flattening_mogrify(new_name, value, symtab, alias_rules) if ar = alias_rules[new_name] fail [:ALIAS_RULES, ar, new_value].inspect if ar != new_value2 else alias_rules[new_name] = new_value2 end [true, ["mem", key, ["name", new_name]]] end else false end end step2 = visit(step1) do |here| case here in ["enum", ["mem", ["text", ID_RE], ["name", MOGRIFIED_ID_RE => new_name]]] [true, ["name", new_name]] else false end end step2 end |
#flattening_occurrences ⇒ Object
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
# File 'lib/processor/cddl-flattening.rb', line 19 def flattening_occurrences symtab = Hash.new { |h, k| h[k] = [] } rules.each do |name, prod| visit(prod) do |here| case here in ["mem", key, value] _labeled, keyname = flattening_key_name(key, value, false) if keyname symtab[keyname] << [name, value] false end else false end end end symtab_replacements = Hash[symtab.map do |k, v| s = Set[*v.map{_2}] # warn "** #{k} #{s.inspect}" if s.size == 1 [k, [[v.map{|k, v| k}.join("|"), s.first]]] end end.compact] # warn "** symtab_replacements: #{symtab_replacements.inspect}" if $options.verbose symtab.merge(symtab_replacements) end |
#flattening_replace(symtab) ⇒ Object
86 87 88 89 90 91 92 93 |
# File 'lib/processor/cddl-flattening.rb', line 86 def flattening_replace(symtab) alias_rules = {} new_rules = Hash[rules.map do |name, prod| [name, flattening_mogrify(name, prod, symtab, alias_rules)] end] new_rules.merge(alias_rules) end |
#gen_apply(gen_name, gen_args, &block) ⇒ Object
19 20 21 22 23 |
# File 'lib/processor/cddl-expander.rb', line 19 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 |
#perform_directives ⇒ Object
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 |
# File 'lib/cddlc.rb', line 77 def perform_directives directives.each do |di| preferred_tag = nil from = nil case di in [IMPINC => dir, SAFE_FN => docref, "as", SAFE_FN => preferred_tag] in [IMPINC => dir, SAFE_FN => docref] in [IMPINC => dir, *from, "from", SAFE_FN => docref, "as", SAFE_FN => preferred_tag] in [IMPINC => dir, *from, "from", SAFE_FN => docref] else warn "** Can't parse directive »#{di.join(" ")}«" next end if from from = from.map do |name| name.chomp!(",") if IDENTIFIER_RE === name name else warn "*** invalid identifier #{name.inspect} ignored in »#{di.join(' ')}«" nil end end.compact end warn "FROM #{from.inspect}" if $options.verbose warn "PREFERRED_TAG #{preferred_tag.inspect}" if $options.verbose warn "DOCREF #{docref.inspect}" if $options.verbose fn = docref.downcase << ".cddl" io = CDDL.read_from_include_path(fn) unless io warn "** #{dir} 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 #{from && from.join(", ") << " from "}#{fn}" if $options.verbose must_be_found = false to_be_imported = if from if preferred_tag from.map{ |k| if k =~ /\A#{preferred_tag}[.]/ k elsif nn = name_rename[k] if old = store_rule(k, v = ["name", nn]) warn "*** autogenerated rule #{k} = #{v} would overwrite #{old}" end nn else warn_error "*** imported rule #{k.inspect} not in #{fn}" end }.compact else must_be_found = true from end else cddl_undefined end loop do # p to_be_imported got_more = false to_be_imported.each do |name| if rule = included_cddl.rules[name] rules[name] = rule warn "IMPORTED #{name} from #{fn}" if $options.verbose got_more = true elsif must_be_found warn_error "*** imported rule #{name.inspect} not in #{fn}" end end break unless got_more to_be_imported = cddl_undefined # XXX square... warn "TO IMPORT #{to_be_imported.inspect}" if $options.verbose must_be_found = false end if preferred_tag to_be_imported.each do |name| warn "** Warning: undefined reference #{name} without namespace prefix is defined in namespaced imported module #{fn}" if name_rename[name] ### instead just add rule... end end in "include" if from from = Set[*from] end warn "** INCLUDING #{from && from.join(", ") << " from "}#{fn}" if $options.verbose included_cddl.rules.each do |k, v| if from next unless from.include?(k) from.delete(k) end if old = store_rule(k, v) warn "*** included rule #{k} = #{v} would overwrite #{old}" end end if from && !from.empty? warn "*** could not find #{from.join(", ")} in #{fn}" end end end end |
#prec_check(inner, targetprec, prec, indent_s) ⇒ Object
precedence: 0: // gcho 1: , seq 2: / tcho -> (type1) 3: (type1) .xxx op -> type2 4: type2
20 21 22 23 24 25 26 |
# File 'lib/writer/cddl-writer.rb', line 20 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 |
#prelude ⇒ Object
273 274 275 276 277 278 279 |
# File 'lib/cddlc.rb', line 273 def prelude if @prelude.nil? @prelude = CDDL.from_cddl(File.read(DATA_DIR + "prelude.cddl")) end @prelude end |
#rename(rename_map) ⇒ Object
(keeps only renamed rules)
28 29 30 31 32 33 34 35 36 37 38 39 40 |
# File 'lib/cddlc.rb', line 28 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 |
#rules ⇒ Object
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 |
# File 'lib/cddlc.rb', line 226 def rules if @rules.nil? # memoize @rules = {} fail unless @tree.first == "cddl" @tree[1..-1].each do |x| op, name, val, rest = x cho = RULE_OP_TO_CHOICE[op] fail rest if rest fail name unless Array === name case name[0] when "name" fail unless name.size == 2 name = name[1] when "gen" 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 @rules[name] = 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 [cho, old, val] end else val end end # warn "** rules #{rules.inspect}" end @rules end |
#store_rule(k, v) ⇒ Object
195 196 197 198 199 200 201 202 203 204 |
# File 'lib/cddlc.rb', line 195 def store_rule(k, v) if old = rules[k] if old != v return old # error end else rules[k] = v end nil # OK end |
#substitute(prod, parms, subs, &block) ⇒ Object
5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
# File 'lib/processor/cddl-expander.rb', line 5 def substitute(prod, parms, subs, &block) visit(prod) do |p, &block1| case p in ["gen", name, *gen_args] # XXX [true, gen_apply(name, gen_args, &block1)] in ["arg", num] if replacement = subs[num] [true, visit((replacement), &block)] end else false end end end |
#to_s ⇒ Object
108 109 110 111 112 113 114 115 116 117 |
# File 'lib/writer/cddl-writer.rb', line 108 def to_s rules.map {|k, v| parmnames = false case v in ["parm", parmnames, _type] else end "#{write_lhs(k, parmnames)} = #{write_rhs(v, 2)}" # 2: parenthesize groups }.join("\n") end |
#visit(prod, &block) ⇒ Object
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
# File 'lib/processor/cddl-visitor.rb', line 7 def visit(prod, &block) done, ret = block.call(prod, &block) if done return ret 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] ["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", 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 |
#visit_all(prod_array, &block) ⇒ Object
4 5 6 |
# File 'lib/processor/cddl-visitor.rb', line 4 def visit_all(prod_array, &block) prod_array.map {|prod| visit(prod, &block)} end |
#warn_error(s) ⇒ Object
206 207 208 209 |
# File 'lib/cddlc.rb', line 206 def warn_error(s) warn s @error = true end |
#write_lhs(k, parmnames) ⇒ Object
5 6 7 8 9 10 11 |
# File 'lib/writer/cddl-writer.rb', line 5 def write_lhs(k, parmnames) if parmnames "#{k}<#{parmnames.join(", ")}>" else k end end |
#write_rhs(v, targetprec = 0, indent = 0, pn = []) ⇒ Object
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 |
# File 'lib/writer/cddl-writer.rb', line 28 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, pn)}.join(", ")}>"] in ["tcho", *types] [2, types.map{write_rhs(_1, 3, indent, pn)}.join(" / ")] in ["gcho", *groups] [0, groups.map{write_rhs(_1, 2, indent, pn)}.join(" // ")] in ["op", op, l, r] [3, "#{write_rhs(l, 4, indent, pn)} #{op} #{write_rhs(r, 4, indent, pn)}"] # 3->4: work around cddl tool limitation in ["map", group] [3, "{#{write_rhs(group, 0, indent, pn)}}"] # 4->3: work around cddl tool limitation in ["ary", group] [3, "[#{write_rhs(group, 0, indent, pn)}]"] # 4->3: work around cddl tool limitation in ["unwrap", namep] [4, "~#{write_rhs(namep, 4, indent, pn)}"] in ["enum", ["name", _name] => namep] [4, "&#{write_rhs(namep, 4, indent, pn)}"] in ["enum", ["gen", _name, *types] => namep] [4, "&#{write_rhs(namep, 4, indent, pn)})"] in ["enum", group] [4, "&(#{write_rhs(group, 0, indent, pn)})"] 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, pn)})"] in ["prim", 6, Array => tag, type] [4, "#6.<#{write_rhs(tag, 0, indent, pn)}>(#{write_rhs(type, 0, indent, pn)})"] in ["prim", 6, nil, type] [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, pn)}" else [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] in [1, 1]; "" in [0, 1]; "? " in [0, false]; "* " in [1, false]; "+ " else "#{s}*#{e || ""}" end [1, "#{occur}#{write_rhs(group, 2, indent, pn)}"] in ["mem", nil, t2] [2, write_rhs(t2, 2, indent, pn)] in ["mem", t1, t2] [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 in ["number", t] [4, t.to_s] end prec_check(ret, targetprec, prec, indent_s) end |