cauterize 0.0.1.pre5 → 0.0.1.pre7

data/README.md

@@ -148,3 +148,12 @@ group(:responses) do |g|
   c.field :delete_user, :delete_user_response
 end
 ```
+
+Groups don't have to specify a data type in all of their fields.
+
+```ruby
+group(:complex) do |g|
+  g.field :a_number, :int32
+  g.dataless :a_state # no associated data with this alternative
+end
+```

data/Rakefile

@@ -14,7 +14,7 @@ task :greatest do
     test_suite_path = File.join(d, "test_suite.c")
     mk_test_suite_file(test_suite_path)
 
-    args = "-Wall -Wextra -Werror -Isupport/c/test -Isupport/c/src -I#{d}"
+    args = "-pedantic -Wall -Wextra -Werror -std=c99 -Isupport/c/test -Isupport/c/src -I#{d}"
     srcs = "support/c/src/cauterize.c support/c/test/test.c"
     bin = File.join(d, "test.bin")
     sh "gcc #{args} #{srcs} -o #{bin}"

data/bin/cauterize

@@ -30,7 +30,7 @@ class CauterizeCmdline < Thor
     end
 
     language = language.downcase
-    if %w(c cs).include? language
+    if %w(c cs doc).include? language
       Cauterize.generate language, target_dir, desc_file
     else
       raise CmdLineException.new("Language '#{language}' is not supported.")

data/cauterize.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'rake',        '>= 0.9.2.0'
   gem.add_dependency 'thor',        '>= 0.16.0'
   gem.add_dependency 'require_all', '>= 1.2.1'
+  gem.add_dependency 'bindata',     '>= 1.5'
 
   gem.add_development_dependency 'rspec', '>= 2.12.0'
   gem.add_development_dependency 'mocha', '>= 0.13.0'

data/example/Cauterize

@@ -15,21 +15,21 @@ enumeration(:large_value) do |e|
   e.value :positive, 500
 end
 
-composite(:weirdness) do |c|
-  c.field :val, :large_value
-  c.field :num, :int8
-end
-
 fixed_array(:color_list) do |a|
   a.array_type :color
-  a.array_size 4
+  a.array_size 41
 end
 
+composite(:weirdness) do |c|
+  c.field :val, :large_value
+  c.field :num, :int8
+end
+ 
 fixed_array(:color_list_list) do |a|
   a.array_type :color_list
   a.array_size 4
 end
-
+ 
 variable_array(:numbers) do |a|
   a.size_type  :usmallint
   a.array_type :bigint
@@ -51,6 +51,12 @@ end
 group(:insanity) do |g|
   g.field :nonsensical, :nonsensical
   g.field :crazy, :crazy
-  g.field :any_empty_entry
-  g.field :another_empty
+  g.dataless :any_empty_entry
+  g.dataless :another_empty
+end
+
+group(:wat) do |g|
+  g.field :arrrr, :color_list_list
+  g.field :coooo, :color
+  g.dataless :ohnoes
 end

data/example/build.sh

@@ -1,5 +1,8 @@
 #!/bin/sh
 
+rm -rf doc_cauterize_output
+../bin/cauterize generate doc doc_cauterize_output
+
 rm -rf c_cauterize_output
 ../bin/cauterize generate c c_cauterize_output
 

data/example/doc_cauterize_output/example_project.txt

@@ -0,0 +1,124 @@
+Type Name: int8
+Cauterize Class: built-in
+Description: <none>
+  data - size: 1 bytes
+
+Type Name: int16
+Cauterize Class: built-in
+Description: <none>
+  data - size: 2 bytes
+
+Type Name: int32
+Cauterize Class: built-in
+Description: <none>
+  data - size: 4 bytes
+
+Type Name: int64
+Cauterize Class: built-in
+Description: <none>
+  data - size: 8 bytes
+
+Type Name: uint8
+Cauterize Class: built-in
+Description: <none>
+  data - size: 1 bytes
+
+Type Name: uint16
+Cauterize Class: built-in
+Description: <none>
+  data - size: 2 bytes
+
+Type Name: uint32
+Cauterize Class: built-in
+Description: <none>
+  data - size: 4 bytes
+
+Type Name: uint64
+Cauterize Class: built-in
+Description: <none>
+  data - size: 8 bytes
+
+Type Name: bigint
+Cauterize Class: scalar
+Description: <none>
+  data - type: int32
+
+Type Name: usmallint
+Cauterize Class: scalar
+Description: <none>
+  data - type: uint8
+
+Type Name: color
+Cauterize Class: enumeration
+Description: <none>
+Encoding: int8
+    red = 0
+    blue = 1
+    green = 2
+
+Type Name: large_value
+Cauterize Class: enumeration
+Description: <none>
+Encoding: int16
+    negative = -500
+    positive = 500
+
+Type Name: weirdness
+Cauterize Class: composite
+Description: <none>
+  val - type: large_value
+  num - type: int8
+
+Type Name: color_list
+Cauterize Class: fixed-array
+Description: <none>
+Stored Type: color
+Value Count: 4
+  data - 4 values of type color
+
+Type Name: color_list_list
+Cauterize Class: fixed-array
+Description: <none>
+Stored Type: color_list
+Value Count: 4
+  data - 4 values of type color_list
+
+Type Name: numbers
+Cauterize Class: variable-array
+Description: <none>
+Maximum Value Count: 128
+  length - type usmallint
+  data - 0 to 128 values of type bigint
+
+Type Name: nonsensical
+Cauterize Class: composite
+Description: <none>
+  color - type: color
+  color_list - type: color_list
+  numbers - type: numbers
+
+Type Name: crazy
+Cauterize Class: composite
+Description: <none>
+  first_numbers - type: numbers
+  second_numbers - type: numbers
+  third_numbers - type: numbers
+
+Type Name: insanity
+Cauterize Class: group
+Description: <none>
+  kind tag: group_insanity_type
+  kinds:
+    nonsensical - payload: nonsensical
+    crazy - payload: crazy
+    any_empty_entry - payload: <no payload>
+    another_empty - payload: <no payload>
+
+Type Name: group_insanity_type
+Cauterize Class: enumeration
+Description: <none>
+Encoding: int8
+    GROUP_INSANITY_TYPE_NONSENSICAL = 0
+    GROUP_INSANITY_TYPE_CRAZY = 1
+    GROUP_INSANITY_TYPE_ANY_EMPTY_ENTRY = 2
+    GROUP_INSANITY_TYPE_ANOTHER_EMPTY = 3

data/example/ruby_ex.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require 'cauterize'
+require 'bindata'
+
+
+Cauterize.populate(ARGV[0])
+
+i = Cauterize::ExampleProject::Wat.new
+i.tag.representation = 0
+p i.num_bytes
+i.tag.representation = 1
+p i.num_bytes
+i.tag.representation = 2
+p i.num_bytes

data/lib/cauterize.rb

@@ -0,0 +1,117 @@
+require 'bindata'
+require 'cauterize/snake_case'
+require 'cauterize/base_type'
+require 'cauterize/cauterize'
+
+def fix(s)
+  s.gsub(/([[:alpha:]])_([[:digit:]])/) do |m|
+    $1 + $2
+  end
+end
+
+
+def populate_scalar(klass, inst)
+  klass.class_eval do
+    endian :little
+    send(fix(inst.type_name.name.to_s), :data)
+  end
+end
+
+def populate_enum(klass, inst)
+  klass.class_eval do
+    endian :little
+
+    send(fix(inst.representation.name.to_s), :representation)
+
+    enum_vals = inst.values.values.map {|v| [v.value, v.name.to_sym]}
+    enum_hash = Hash[enum_vals]
+    const_set(:ENUM_MAP, enum_hash)
+    inst.values.values.each do |v| 
+      klass.const_set(v.name.upcase.to_sym, v.value)
+    end
+
+    def enum
+      self.class.const_get(:ENUM_MAP)[representation]
+    end
+  end
+end
+
+def populate_fixed_array(klass, inst)
+  klass.class_eval do
+    endian :little
+    array :data, { :type => fix(inst.array_type.name.to_s),
+                   :initial_length => inst.array_size }
+  end
+end
+
+def populate_variable_array(klass, inst)
+  # TODO: Figure out what we should do with inst.array_size
+  klass.class_eval do
+    endian :little
+    send(fix(inst.size_type.name.to_s), :va_len, :value => lambda { data.length })
+    array :data, { :type => fix(inst.array_type.name.to_s),
+                   :read_until => lambda { index == va_len - 1}}
+  end
+end
+
+def populate_composite(klass, inst)
+  klass.class_eval do
+    endian :little
+    inst.fields.values.each do |v|
+      send(fix(v.type.name.to_s), v.name.to_s)
+    end
+  end
+end
+
+def populate_group(klass, inst)
+  choices = inst.fields.values.each_with_index.map do |v, i|
+    [i, v.type.nil? ? :empty_data : fix(v.type.name.to_s).to_sym]
+  end
+
+  klass.class_eval do
+    endian :little
+    send(fix(inst.tag_enum.name.to_s), :tag)
+
+    choice :data, :selection => lambda { tag.representation },
+                  :choices => Hash[choices]
+  end
+end
+ 
+module Cauterize
+  class EmptyData < BinData::Record; end
+
+  def self.populate(desc_file)
+    parse_dsl(desc_file)
+
+    dsl_mod = Module.new do |mod|
+
+      BaseType.all_instances.each do |inst|
+        next if Cauterize::BuiltIn == inst.class
+
+        n = inst.name.to_s.camel
+        module_eval("class #{n} < BinData::Record; end")
+        klass = const_get(n)
+
+        case inst
+        when Cauterize::Scalar
+          populate_scalar(klass, inst)
+        when Cauterize::Enumeration
+          populate_enum(klass, inst)
+        when Cauterize::FixedArray
+          populate_fixed_array(klass, inst)
+        when Cauterize::VariableArray
+          populate_variable_array(klass, inst)
+        when Cauterize::Composite
+          populate_composite(klass, inst)
+        when Cauterize::Group
+          populate_group(klass, inst)
+        else
+          puts "Unhandled instance: #{inst.class.name}"
+        end
+      end
+    end
+
+    const_set(Cauterize.get_name.camel, dsl_mod)
+  end
+end
+

data/lib/cauterize/base_type.rb

@@ -2,16 +2,17 @@ require 'set'
 
 module Cauterize
   class BaseType
-    attr_reader :name, :id
+    attr_reader :name, :id, :description
     @@next_id = {}
     @@instances = {}
 
-    def initialize(name)
+    def initialize(name, description=nil)
       if @@instances.keys.include?(name)
         raise Exception.new("A type with the name #{name} already exists. [#{@@instances[name].inspect}]")
       end
 
       @name = name
+      @description = description
       @id = next_id
       register_instance(self)
     end

data/lib/cauterize/builders.rb

@@ -5,6 +5,10 @@ module Cauterize
 
     module_function
 
+    def builders
+      @builders
+    end
+
     def register(language, description_class, builder_class)
       @builders ||= {}
       @builders[language] ||= {}
@@ -17,9 +21,21 @@ module Cauterize
     end
 
     def get(language, description_instance)
-      if @builders and @builders[language] and @builders[language][description_instance.class]
-        @builders[language][description_instance.class].new(description_instance)
+      unless @builders
+        raise UnregisteredException.new("No builders are registered.")
+      end
+
+      unless @builders[language]
+        s = "Language #{language} not registered."
+        raise UnregisteredException.new(s)
       end
+
+      unless @builders[language][description_instance.class]
+        s = "Class #{description_instance.class} not registered for #{language}."
+        raise UnregisteredException.new(s)
+      end
+
+      @builders[language][description_instance.class].new(description_instance)
     end
   end
 end

data/lib/cauterize/builders/c/group.rb

@@ -84,9 +84,8 @@ module Cauterize
             formatter << "union"
             formatter.braces do
               @blueprint.fields.values.each do |field|
-                b = Builders.get(:c, field.type)
-                if b
-                  b.declare(formatter, field.name)
+                if field.type
+                  Builders.get(:c, field.type).declare(formatter, field.name)
                 else
                   formatter << "/* No data associated with '#{field.name}'. */"
                 end

data/lib/cauterize/builders/cs/group.rb

@@ -16,10 +16,9 @@ module Cauterize::Builders::CS
         Cauterize::Builders.get(:cs, @tag_enum).declare(formatter, "Type")
         formatter.blank_line
         @blueprint.fields.values.each_with_index do |field, i|
-          b = Cauterize::Builders.get(:cs, field.type)
-          if b
+          if field.type
             formatter << "[Order(#{i+1})]"
-            b.declare(formatter, field.name)
+            Cauterize::Builders.get(:cs, field.type).declare(formatter, field.name)
           else
             formatter << "/* No data associated with '#{field.name}'. */"
           end

data/lib/cauterize/builders/doc/buildable.rb

@@ -0,0 +1,30 @@
+module Cauterize
+  module Builders
+    module Doc
+      REQUIRED_METHODS = [
+        :heading,
+        :body,
+      ]
+
+      class BuildableException < Exception; end
+
+      class Buildable
+        def initialize(blueprint)
+          @blueprint = blueprint
+        end
+
+        alias_method :orig_method_missing, :method_missing
+
+        def method_missing(sym, *args)
+          sym_required = REQUIRED_METHODS.include?(sym)
+
+          if sym_required
+            raise BuildableException.new("Classes deriving Buildable must implement the method #{sym}.")
+          else
+            orig_method_missing(sym, *args)
+          end
+        end
+      end
+    end
+  end
+end