cauterize 0.0.1.pre1 → 0.0.1.pre5

data/lib/cauterize/composite.rb

@@ -6,16 +6,16 @@ module Cauterize
   module_function
 
   def composite(name)
-    c = composites[name] || composites[name] = Composite.new(name)
+    c = Cauterize.composites[name] || Cauterize.composites[name] = Composite.new(name)
     yield c if block_given?
     return c
   end
 
   def composite!(name, &blk)
-    if composites[name]
+    if Cauterize.composites[name]
       raise Exception.new("Composite with name #{name} already exists.")
     else
-      composite(name, &blk)
+      Cauterize.composite(name, &blk)
     end
   end
 

data/lib/cauterize/cs_builder.rb

@@ -0,0 +1,53 @@
+require 'time'
+
+module Cauterize
+  class CSBuilder
+    attr_reader :cs
+
+    def initialize(cs_file, name="cauterize")
+      @cs = cs_file
+      @name = name.camel
+    end
+
+    def build
+      build_cs
+    end
+
+    private
+
+    def build_cs
+      f = four_space_formatter
+
+      f << "using System;"
+      f << "using Cauterize;"
+      f.blank_line
+      f << "namespace #{@name}"
+      f.braces do
+        f << "public class #{@name}CauterizeInfo : CauterizeInfo"
+        f.braces do
+          f << "static #{@name}CauterizeInfo()"
+          f.braces do
+            f << "Name = \"#{@name}\";"
+            f << "GeneratedVersion = \"#{Cauterize.get_version}\";"
+            f << "GeneratedDate = \"#{Cauterize.get_version}\";"
+          end
+        end
+        f.blank_line
+
+        instances = BaseType.all_instances
+        builders = instances.map {|i| Builders.get(:cs, i)}
+
+        builders.each { |b| b.enum_defn(f) }
+        builders.each { |b| b.class_defn(f) }
+        # # should we really do these, or is it annotations and a custom
+        # # formatter in support???
+        # builders.each { |b| b.packer_defn(f) }
+        # builders.each { |b| b.unpacker_defn(f) }
+      end
+
+      File.open(@cs, "wb") do |fh|
+        fh.write(f.to_s)
+      end
+    end
+  end
+end

data/lib/cauterize/enumeration.rb

@@ -7,16 +7,16 @@ require 'set'
 module Cauterize
   module_function
   def enumeration(name)
-    e = enumerations[name] || enumerations[name] = Enumeration.new(name)
+    e = Cauterize.enumerations[name] || Cauterize.enumerations[name] = Enumeration.new(name)
     yield e if block_given?
     return e
   end
 
   def enumeration!(name, &blk)
-    if enumerations[name]
+    if Cauterize.enumerations[name]
       raise Exception.new("Enumeration with name #{name} already exists.")
     else
-      enumeration(name, &blk)
+      Cauterize.enumeration(name, &blk)
     end
   end
 
@@ -53,6 +53,23 @@ module Cauterize
       @values[name] = EnumerationValue.new(name, next_id)
     end
 
+    def representation
+      max_val = @values.values.map(&:value).max
+      min_val = @values.values.map(&:value).min
+      
+      if -128 <= min_val and max_val <= 127
+        BaseType.find_type!(:int8)
+      elsif (-32768 <= min_val and max_val <= 32767)
+        BaseType.find_type!(:int16)
+      elsif (-2147483648 <= min_val and max_val <= 2147483647)
+        BaseType.find_type!(:int32)
+      elsif (-9223372036854775808 <= min_val and max_val <= 9223372036854775807)
+        BaseType.find_type!(:int64)
+      else
+        raise Exception.new("Unable to represent enumeration (#{min_val} -> #{max_val})")
+      end
+    end
+
     private
 
     def value_id(next_id=nil)

data/lib/cauterize/fixed_array.rb

@@ -2,16 +2,16 @@ module Cauterize
   module_function
 
   def fixed_array(name)
-    a = fixed_arrays[name] || fixed_arrays[name] = FixedArray.new(name)
+    a = Cauterize.fixed_arrays[name] || Cauterize.fixed_arrays[name] = FixedArray.new(name)
     yield a if block_given?
     return a
   end
 
   def fixed_array!(name, &blk)
-    if fixed_arrays[name]
+    if Cauterize.fixed_arrays[name]
       raise Exception.new("FixedArray with name #{name} already exists.")
     else
-      fixed_array(name, &blk)
+      Cauterize.fixed_array(name, &blk)
     end
   end
 

data/lib/cauterize/formatter.rb

@@ -1,11 +1,15 @@
 def default_formatter
-  Formatter.new
+  Formatter.new("  ")
+end
+
+def four_space_formatter
+  Formatter.new("    ")
 end
 
 class Formatter
-  def initialize
+  def initialize(indent_str)
     @indent_level = 0
-    @indent_str = "  "
+    @indent_str = indent_str
     @lines = []
   end
 

data/lib/cauterize/group.rb

@@ -2,16 +2,16 @@ module Cauterize
   module_function
 
   def group(name)
-    a = groups[name] || groups[name] = Group.new(name)
+    a = Cauterize.groups[name] || Cauterize.groups[name] = Group.new(name)
     yield a if block_given?
     return a
   end
 
   def group!(name, &blk)
-    if groups[name]
+    if Cauterize.groups[name]
       raise Exception.new("Group with name #{name} already exists.")
     else
-      group(name, &blk)
+      Cauterize.group(name, &blk)
     end
   end
 
@@ -24,10 +24,7 @@ module Cauterize
 
     def initialize(name, type)
       @name = name
-      @type = BaseType.find_type!(type)
-    end
-
-    def enum_sym
+      @type = BaseType.find_type!(type) if type
     end
   end
 
@@ -40,7 +37,7 @@ module Cauterize
       @tag_enum = Cauterize.enumeration!("group_#{name}_type".to_sym)
     end
 
-    def field(name, type)
+    def field(name, type=nil)
       if @fields[name]
         raise Exception.new("Field name #{name} already used.")
       else

data/lib/cauterize/scalar.rb

@@ -9,16 +9,16 @@ module Cauterize
   module_function
 
   def scalar(name)
-    a = scalars[name] || scalars[name] = Scalar.new(name)
+    a = Cauterize.scalars[name] || Cauterize.scalars[name] = Scalar.new(name)
     yield a if block_given?
     return a
   end
 
   def scalar!(name, &blk)
-    if scalars[name]
+    if Cauterize.scalars[name]
       raise Exception.new("Scalar with name #{name} already exists.")
     else
-      scalar(name, &blk)
+      Cauterize.scalar(name, &blk)
     end
   end
 
@@ -26,13 +26,22 @@ module Cauterize
     @scalars ||= {}
   end
 
-  def flush_scalars
-    @scalars = {}
-  end
-
   class Scalar < BaseType
     def initialize(name)
       super
     end
+
+    def type_name(type_name = nil)
+      if type_name
+        t = BaseType.find_type!(type_name)
+        if t.class != BuiltIn
+          raise Exception.new("Must specify a BuiltIn type for scalars.")
+        end
+
+        @type_name = t
+      else
+        @type_name
+      end
+    end
   end
 end

data/lib/cauterize/variable_array.rb

@@ -2,21 +2,21 @@ module Cauterize
   module_function
 
   def variable_array(name)
-    a = variable_arrays[name] || variable_arrays[name] = VariableArray.new(name)
+    a = Cauterize.variable_arrays[name] || Cauterize.variable_arrays[name] = VariableArray.new(name)
     yield a if block_given?
     return a
   end
 
   def variable_array!(name, &blk)
-    if variable_arrays[name]
+    if Cauterize.variable_arrays[name]
       raise Exception.new("VariableArray with name #{name} already exists.")
     else
-      variable_array(name, &blk)
+      Cauterize.variable_array(name, &blk)
     end
   end
 
   def variable_arrays
-    @variable_ararys ||= {}
+    @variable_arrays ||= {}
   end
 
   class VariableArray < BaseType
@@ -43,10 +43,10 @@ module Cauterize
     def size_type(t = nil)
       if t
         _t = BaseType.find_type!(t)
-        if _t.is_scalar?
+        if _t.is_built_in? or _t.is_scalar?
           @size_type = _t
         else
-          raise Exception.new("The type #{t} is not an scalar")
+          raise Exception.new("The type #{t} is not a built-in or scalar type")
         end
       else
         @size_type

data/lib/cauterize/version.rb

@@ -1,3 +1,3 @@
 module Cauterize
-  VERSION = "0.0.1.pre1"
+  VERSION = "0.0.1.pre5"
 end

data/spec/base_type_spec.rb

@@ -1,166 +1,174 @@
-include Cauterize
+module Cauterize
 
-describe Cauterize do
-  before {
-    BaseType.class_variable_set(:@@next_id, {})
-    BaseType.class_variable_set(:@@instances, {})
-  }
+  describe Cauterize do
+    describe BaseType do
+      describe :id do
+        it { has_a_unique_id_for_each_instance(BaseType) }
+      end
 
-  describe BaseType do
-    describe :id do
-      it { has_a_unique_id_for_each_instance(BaseType) }
-    end
+      describe :type_str do
+        it "is the hexadecimal representation of type" do
+          f = Cauterize.enumeration(:foo) do |e|
+            e.value :a, 1
+          end
 
-    describe :type_str do
-      it "is the hexadecimal representation of type" do
-        f = enumeration(:foo) do |e|
-          e.value :a, 1
-        end
-        b = enumeration(:bar) do |e|
-          e.value :a, 1
-        end
+          b = Cauterize.enumeration(:bar) do |e|
+            e.value :a, 1
+          end
 
-        b.type_str.should == "0x2001"
+          b.type_str.should == "0x2001"
+        end
       end
-    end
-
-    describe :tag do
-      it { is_tagged_as(Scalar, 0) }
-      it { is_tagged_as(Enumeration, 1) }
-      it { is_tagged_as(Composite, 2) }
-      it { is_tagged_as(FixedArray, 3) }
-      it { is_tagged_as(VariableArray, 4) }
-      it { is_tagged_as(Group, 5) }
-    end
 
-    describe :next_id do
-      it "is an incrementing value starting at 0" do
-        # the .new consumes the 0.
-        BaseType.new(:foo).instance_exec do
-          next_id.should == 1
-          next_id.should == 2
-          next_id.should == 3
-          next_id.should == 4
+      describe :tag do
+        it { is_tagged_as(Scalar, 0) }
+        it { is_tagged_as(Enumeration, 1) }
+        it { is_tagged_as(Composite, 2) }
+        it { is_tagged_as(FixedArray, 3) }
+        it { is_tagged_as(VariableArray, 4) }
+        it { is_tagged_as(Group, 5) }
+      end
+
+      describe :next_id do
+        it "is an incrementing value starting at 0" do
+          # the .new consumes the 0.
+          BaseType.new(:foo).instance_exec do
+            next_id.should == 1
+            next_id.should == 2
+            next_id.should == 3
+            next_id.should == 4
+          end
         end
-      end
 
-      it "should not allow derived class ids to interact" do
-        a1 = Scalar.new(:foo)
-        a2 = Scalar.new(:bar)
-        e1 = Enumeration.new(:zoop)
-        e2 = Enumeration.new(:nih)
+        it "should not allow derived class ids to interact" do
+          a1 = Scalar.new(:uint8_t)
+          a2 = Scalar.new(:uint64_t)
+          e1 = Enumeration.new(:zoop)
+          e2 = Enumeration.new(:nih)
 
-        a1.id.should == 0
-        a2.id.should == 1
-        e1.id.should == 0
-        e2.id.should == 1
+          a1.id.should == 0
+          a2.id.should == 1
+          e1.id.should == 0
+          e2.id.should == 1
+        end
       end
-    end
 
-    describe "bit stuff" do
-      it "is consistent" do
-        BaseType.class_exec do
-          (tag_bit_width + id_bit_width).should == type_bit_width
-          (tag_bit_mask >> id_bit_width).should == 0x7
+      describe "bit stuff" do
+        it "is consistent" do
+          BaseType.class_exec do
+            (tag_bit_width + id_bit_width).should == type_bit_width
+            (tag_bit_mask >> id_bit_width).should == 0x7
+          end
         end
       end
-    end
 
-    describe :register_instance do
-      it "adds an instance to the instance list" do
-        class X < BaseType
-          def initialize(name); end
-        end
-        x = X.new(:foo)
+      describe :register_instance do
+        it "adds an instance to the instance list" do
+          orig_len = BaseType.all_instances.length
 
-        x.instance_exec do
-          register_instance(x)
-        end
+          class X < BaseType
+            def initialize(name); end
+          end
+          x = X.new(:foo)
+
+          x.instance_exec do
+            register_instance(x)
+          end
 
-        BaseType.all_instances[0].should be x
-        BaseType.all_instances.length.should == 1
+          BaseType.all_instances.last.should be x
+          BaseType.all_instances.length.should == orig_len + 1
+        end
       end
-    end
 
-    describe :instances do
-      # Two things are being tested here.
-      # 1. That instances works.
-      # 2. That super() is called in each .new
-      it "is every instance of a BaseType-derived class" do
-        BaseType.all_instances.should == []
+      describe :instances do
+        # Two things are being tested here.
+        # 1. That instances works.
+        # 2. That super() is called in each .new
+        it "is every instance of a BaseType-derived class" do
+          BaseType.class_variable_set(:@@instances, {})
+
+          b = BuiltIn.new(:uint32)
+          s = Scalar.new(:eek)
+          e = Enumeration.new(:emoo)
+          c = Composite.new(:cooo)
+          f = FixedArray.new(:moo)
+          v = VariableArray.new(:quack)
+          g = Group.new(:goo)
 
-        a = Scalar.new(:foo)
-        e = Enumeration.new(:emoo)
-        c = Composite.new(:cooo)
-        f = FixedArray.new(:moo)
-        v = VariableArray.new(:quack)
-        g = Group.new(:goo)
+          lst = [b, s, e, c, f, v, g]
 
-        lst = [a, e, c, f, v, g]
+          instances = BaseType.all_instances
 
-        instances = BaseType.all_instances
-        instances.length.should == lst.length + 1 # +1 because groups make an enum as well
+          # There will be some extras due to automatic creation of enums and
+          # scalars in Enumeration and Group.
+          instances.should include(*lst)
 
-        # Check that each of our instances shows up in the list returned from
-        # all_instances. Do it this way in case there are other types created
-        # (like the enumeration for Group).
-        lst.all? do |l|
-          instances.any? {|i| i.equal? l}
+          # Check that each of our instances shows up in the list returned from
+          # all_instances. Do it this way in case there are other types created
+          # (like the enumeration for Group).
+          lst.all? do |l|
+            instances.any? {|i| i.equal? l}
+          end
         end
       end
-    end
 
-    describe :find_type do
-      it "returns the instance with the provided name" do
-        f = scalar(:foo)
-        b = scalar(:bar)
+      describe :find_type do
+        it "returns the instance with the provided name" do
+          f = Cauterize.scalar(:foo)
+          b = Cauterize.scalar(:bar)
 
-        BaseType.find_type(:bar).should be b
-        BaseType.find_type(:foo).should be f
-      end
+          BaseType.find_type(:bar).should be b
+          BaseType.find_type(:foo).should be f
+        end
 
-      it "is nil on an unknown name" do
-        BaseType.find_type(:xxxxxxxxxxxxxxxxxx).should be_nil
+        it "is nil on an unknown name" do
+          BaseType.find_type(:xxxxxxxxxxxxxxxxxx).should be_nil
+        end
       end
-    end
 
-    describe :find_type! do
-      it "returns the instance with the provided name" do
-        f = scalar(:foo)
-        b = scalar(:bar)
+      describe :find_type! do
+        it "returns the instance with the provided name" do
+          f = Cauterize.scalar(:foo)
+          b = Cauterize.scalar(:bar)
 
-        BaseType.find_type!(:bar).should be b
-        BaseType.find_type!(:foo).should be f
-      end
+          BaseType.find_type!(:bar).should be b
+          BaseType.find_type!(:foo).should be f
+        end
 
-      it "errors on an unknown name" do
-        lambda { BaseType.find_type!(:foo) }.should raise_error /name foo does not/
+        it "errors on an unknown name" do
+          lambda { BaseType.find_type!(:foo) }.should raise_error /name foo does not/
+        end
       end
-    end
 
-    describe "is_[type]?" do
-      it "supports scalar" do
-        scalar(:foo).is_scalar?.should be_true
-      end
+      describe "is_[type]?" do
+        it "supports scalar" do
+          Cauterize.scalar(:foo).is_scalar?.should be_true
+        end
 
-      it "supports enumeration" do
-        enumeration(:foo).is_enumeration?.should be_true
-      end
+        it "supports enumeration" do
+          Cauterize.enumeration(:foo).is_enumeration?.should be_true
+        end
 
-      it "supports composite" do
-        composite(:foo).is_composite?.should be_true
-      end
+        it "supports composite" do
+          Cauterize.composite(:foo).is_composite?.should be_true
+        end
 
-      it "supports fixed_array" do
-        fixed_array(:foo).is_fixed_array?.should be_true
-      end
+        it "supports fixed_array" do
+          Cauterize.fixed_array(:foo).is_fixed_array?.should be_true
+        end
 
-      it "supports variable_array" do
-        variable_array(:foo).is_variable_array?.should be_true
-      end
+        it "supports variable_array" do
+          Cauterize.variable_array(:foo).is_variable_array?.should be_true
+        end
 
-      it "supports group" do
-        group(:foo).is_group?.should be_true
+        it "supports group" do
+          Cauterize.group(:foo).is_group?.should be_true
+        end
+
+        it "supports builtin" do
+          # This one is special because of how buitins are declared
+          Cauterize.builtins[:int32].is_built_in?.should be_true
+        end
       end
     end
   end