cauterize 0.0.1.pre1

data/lib/cauterize/enumeration.rb

@@ -0,0 +1,77 @@
+# enumeration.rb
+#
+# Enumerations correspond exactly to C enumerations.
+
+require 'set'
+
+module Cauterize
+  module_function
+  def enumeration(name)
+    e = enumerations[name] || enumerations[name] = Enumeration.new(name)
+    yield e if block_given?
+    return e
+  end
+
+  def enumeration!(name, &blk)
+    if enumerations[name]
+      raise Exception.new("Enumeration with name #{name} already exists.")
+    else
+      enumeration(name, &blk)
+    end
+  end
+
+  def enumerations
+    @enumerations ||= {}
+  end
+
+  class EnumerationValue
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+  end
+
+  class Enumeration < BaseType
+    attr_reader :values
+
+    def initialize(name)
+      super
+      @values = {}
+      @value_id = 0
+      @used_ids = Set.new
+    end
+
+    def value(name, id=nil)
+      if @values[name]
+        raise Exception.new("Cannot duplicate name #{name}.")
+      end
+
+      next_id = value_id(id)
+      @used_ids << next_id
+      @values[name] = EnumerationValue.new(name, next_id)
+    end
+
+    private
+
+    def value_id(next_id=nil)
+      if next_id
+        @value_id = next_id
+      end
+
+      v = @value_id
+
+      if @used_ids.include? v
+        raise Exception.new("Cannot duplicate constant #{v}.")
+      end
+
+      loop do
+        @value_id += 1
+        break unless @used_ids.include? @value_id
+      end
+
+      return v
+    end
+  end
+end

data/lib/cauterize/fixed_array.rb

@@ -0,0 +1,43 @@
+module Cauterize
+  module_function
+
+  def fixed_array(name)
+    a = fixed_arrays[name] || fixed_arrays[name] = FixedArray.new(name)
+    yield a if block_given?
+    return a
+  end
+
+  def fixed_array!(name, &blk)
+    if fixed_arrays[name]
+      raise Exception.new("FixedArray with name #{name} already exists.")
+    else
+      fixed_array(name, &blk)
+    end
+  end
+
+  def fixed_arrays
+    @fixed_ararys ||= {}
+  end
+
+  class FixedArray < BaseType
+    def initialize(name)
+      super
+    end
+
+    def array_type(t = nil)
+      if t
+        @array_type = BaseType.find_type!(t)
+      else
+        @array_type
+      end
+    end
+
+    def array_size(s = nil)
+      if s
+        @array_size = s
+      else
+        @array_size
+      end
+    end
+  end
+end

data/lib/cauterize/formatter.rb

@@ -0,0 +1,59 @@
+def default_formatter
+  Formatter.new
+end
+
+class Formatter
+  def initialize
+    @indent_level = 0
+    @indent_str = "  "
+    @lines = []
+  end
+
+  def indent(line)
+    (@indent_str * @indent_level) + line
+  end
+
+  def <<(line)
+    @lines << indent(line)
+  end
+
+  # indent back one level
+  def backdent(line)
+    @indent_level -= 1
+    @lines << indent(line)
+    @indent_level += 1
+  end
+
+  def append(text)
+    if @lines.length == 0
+      @lines << ""
+    end
+
+    @lines[-1] += text
+  end
+
+  def braces
+    self << "{"
+    indented { yield self } if block_given?
+    self << "}"
+  end
+
+  def blank_line
+    @lines << ""
+  end
+
+  def to_s(extra_indent = 0)
+    @indent_level += extra_indent
+    s = @lines.map {|l| indent(l) }.join("\n")
+    @indent_level -= extra_indent
+    return s
+  end
+
+  private
+
+  def indented
+    @indent_level += 1
+    yield self
+    @indent_level -= 1
+  end
+end

data/lib/cauterize/group.rb

@@ -0,0 +1,56 @@
+module Cauterize
+  module_function
+
+  def group(name)
+    a = groups[name] || groups[name] = Group.new(name)
+    yield a if block_given?
+    return a
+  end
+
+  def group!(name, &blk)
+    if groups[name]
+      raise Exception.new("Group with name #{name} already exists.")
+    else
+      group(name, &blk)
+    end
+  end
+
+  def groups
+    @groups ||= {}
+  end
+
+  class GroupField
+    attr_reader :name, :type
+
+    def initialize(name, type)
+      @name = name
+      @type = BaseType.find_type!(type)
+    end
+
+    def enum_sym
+    end
+  end
+
+  class Group < BaseType
+    attr_reader :fields, :tag_enum
+
+    def initialize(name)
+      super
+      @fields = {}
+      @tag_enum = Cauterize.enumeration!("group_#{name}_type".to_sym)
+    end
+
+    def field(name, type)
+      if @fields[name]
+        raise Exception.new("Field name #{name} already used.")
+      else
+        @fields[name] = GroupField.new(name, type)
+        @tag_enum.value(enum_sym(name))
+      end
+    end
+
+    def enum_sym(fname)
+      "group_#{@name}_type_#{fname}".up_snake.to_sym
+    end
+  end
+end

data/lib/cauterize/scalar.rb

@@ -0,0 +1,38 @@
+# scalar.rb
+#
+# scalars are types that, in C, can be updated with assignment. This includes
+# native types in C and typedefs around these native types.
+#
+# scalars are not structs, enumerations, unions, or arrays.
+
+module Cauterize
+  module_function
+
+  def scalar(name)
+    a = scalars[name] || scalars[name] = Scalar.new(name)
+    yield a if block_given?
+    return a
+  end
+
+  def scalar!(name, &blk)
+    if scalars[name]
+      raise Exception.new("Scalar with name #{name} already exists.")
+    else
+      scalar(name, &blk)
+    end
+  end
+
+  def scalars
+    @scalars ||= {}
+  end
+
+  def flush_scalars
+    @scalars = {}
+  end
+
+  class Scalar < BaseType
+    def initialize(name)
+      super
+    end
+  end
+end

data/lib/cauterize/snake_case.rb

@@ -0,0 +1,21 @@
+class String
+  def snake
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_")
+  end
+
+  def up_snake
+    snake.upcase
+  end
+
+  def down_snake
+    snake.downcase
+  end
+
+  def camel
+    return self.capitalize if self !~ /_/ && self =~ /[A-z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+end

data/lib/cauterize/variable_array.rb

@@ -0,0 +1,56 @@
+module Cauterize
+  module_function
+
+  def variable_array(name)
+    a = variable_arrays[name] || variable_arrays[name] = VariableArray.new(name)
+    yield a if block_given?
+    return a
+  end
+
+  def variable_array!(name, &blk)
+    if variable_arrays[name]
+      raise Exception.new("VariableArray with name #{name} already exists.")
+    else
+      variable_array(name, &blk)
+    end
+  end
+
+  def variable_arrays
+    @variable_ararys ||= {}
+  end
+
+  class VariableArray < BaseType
+    def intialize(name)
+      super
+    end
+
+    def array_type(t = nil)
+      if t
+        @array_type = BaseType.find_type!(t)
+      else
+        @array_type
+      end
+    end
+
+    def array_size(s = nil)
+      if s
+        @array_size = s
+      else
+        @array_size
+      end
+    end
+
+    def size_type(t = nil)
+      if t
+        _t = BaseType.find_type!(t)
+        if _t.is_scalar?
+          @size_type = _t
+        else
+          raise Exception.new("The type #{t} is not an scalar")
+        end
+      else
+        @size_type
+      end
+    end
+  end
+end

data/lib/cauterize/version.rb

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

data/spec/base_type_spec.rb

@@ -0,0 +1,167 @@
+include Cauterize
+
+describe Cauterize do
+  before {
+    BaseType.class_variable_set(:@@next_id, {})
+    BaseType.class_variable_set(:@@instances, {})
+  }
+
+  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 = enumeration(:foo) do |e|
+          e.value :a, 1
+        end
+        b = enumeration(:bar) do |e|
+          e.value :a, 1
+        end
+
+        b.type_str.should == "0x2001"
+      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
+        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)
+
+        a1.id.should == 0
+        a2.id.should == 1
+        e1.id.should == 0
+        e2.id.should == 1
+      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
+        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)
+
+        x.instance_exec do
+          register_instance(x)
+        end
+
+        BaseType.all_instances[0].should be x
+        BaseType.all_instances.length.should == 1
+      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 == []
+
+        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 = [a, e, c, f, v, g]
+
+        instances = BaseType.all_instances
+        instances.length.should == lst.length + 1 # +1 because groups make an enum as well
+
+        # 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
+
+    describe :find_type do
+      it "returns the instance with the provided name" do
+        f = scalar(:foo)
+        b = scalar(:bar)
+
+        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
+      end
+    end
+
+    describe :find_type! do
+      it "returns the instance with the provided name" do
+        f = scalar(:foo)
+        b = scalar(:bar)
+
+        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/
+      end
+    end
+
+    describe "is_[type]?" do
+      it "supports scalar" do
+        scalar(:foo).is_scalar?.should be_true
+      end
+
+      it "supports enumeration" do
+        enumeration(:foo).is_enumeration?.should be_true
+      end
+
+      it "supports composite" do
+        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 variable_array" do
+        variable_array(:foo).is_variable_array?.should be_true
+      end
+
+      it "supports group" do
+        group(:foo).is_group?.should be_true
+      end
+    end
+  end
+end