cauterize 0.0.1.pre1 → 0.0.1.pre5

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

@@ -6,6 +6,11 @@ module Cauterize
           @blueprint.name.to_s
         end
 
+        def typedef_decl(formatter)
+          tn_bldr = Builders.get(:c, @blueprint.type_name)
+          formatter << "typedef #{tn_bldr.render} #{render};"
+        end
+
         def declare(formatter, sym)
           formatter << "#{render} #{sym};"
         end

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

@@ -7,7 +7,7 @@ module Cauterize
         end
 
         def declare(formatter, sym)
-          formatter << "struct #{@blueprint.name} #{sym};"
+          formatter << "#{render} #{sym};"
         end
 
         def packer_defn(formatter)

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

@@ -0,0 +1,59 @@
+module Cauterize
+  module Builders
+    module CS
+      # sym - symbol - the lexical symbol associated with the generated entity
+      # sig - signature - the C signature associated with the entity
+      # proto - prototype - the C prototype associated with the entity
+      # defn - definition - the C definition associated with the entity
+      REQUIRED_METHODS = [
+      ]
+
+      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
+
+        # Things below here are tested in shared_examples_for_c_buildables #
+        ####################################################################
+
+        # Methods that are pretty much the same for everyone.
+        # WFIXME what do I do with these???
+        # def packer_sym; "Pack_#{@blueprint.name}" end
+        # def packer_sig; "CAUTERIZE_STATUS_T #{packer_sym}(struct Cauterize * dst, #{render} * src)" end
+        # def packer_proto(formatter)
+        #   formatter << packer_sig + ";"
+        # end
+
+        # def unpacker_sym; "Unpack_#{@blueprint.name}" end
+        # def unpacker_sig; "CAUTERIZE_STATUS_T #{unpacker_sym}(struct Cauterize * src, #{render} * dst)" end
+        # def unpacker_proto(formatter)
+        #   formatter << unpacker_sig + ";"
+        # end
+
+        # These are only different in a few type varieties.
+        def render
+          @blueprint.name.to_s.camel
+        end
+        def declare(formatter, sym)
+          formatter << "public #{render} #{sym.to_s.camel} { get; set; }" 
+        end
+        def class_defn(formatter); nil end
+        def enum_defn(formatter); nil end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Cauterize::Builders::CS
+  class BuiltIn < Buildable
+    @@CS_TYPE_MAPPING = {
+      1 => {signed: "SByte", unsigned: "Byte"},
+      2 => {signed: "Int16", unsigned: "UInt16"},
+      4 => {signed: "Int32", unsigned: "UInt32"},
+      8 => {signed: "Int64", unsigned: "UInt64"},
+    }
+
+    def render
+      render_cstype
+    end
+
+    private
+
+    def render_cstype
+      s_key = @blueprint.is_signed ? :signed : :unsigned
+      @@CS_TYPE_MAPPING[@blueprint.byte_length][s_key]
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::BuiltIn, Cauterize::Builders::CS::BuiltIn)

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

@@ -0,0 +1,21 @@
+module Cauterize::Builders::CS
+  class Composite < Buildable
+
+    def render_parent
+      "CauterizeComposite"
+    end
+
+    def class_defn(formatter)
+      formatter << "public class #{render} : #{render_parent}"
+      formatter.braces do
+        @blueprint.fields.values.each_with_index do |field, i|
+          formatter << "[Order(#{i})]"
+          Cauterize::Builders.get(:cs, field.type).declare(formatter, field.name)
+        end
+      end
+      formatter.blank_line
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::Composite, Cauterize::Builders::CS::Composite)

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

@@ -0,0 +1,32 @@
+module Cauterize::Builders::CS
+  class CSArray < Buildable
+    def class_defn(formatter)
+      formatter << "public class #{render} : #{render_parent}"
+      formatter.braces do
+        extra_array_declarations(formatter)
+        formatter.blank_line
+        formatter << simple_constructor_line
+        formatter.braces do
+          formatter << "Allocate(#{size});"
+        end
+        formatter.blank_line
+        formatter << "public #{render}(#{ty_bldr.render}[] data)"
+        formatter.braces do
+          formatter << "Allocate(data);"
+        end
+        formatter.blank_line
+        size_defn(formatter)
+      end
+      formatter.blank_line
+    end
+
+    protected
+
+    def extra_array_declarations(formatter)
+    end
+
+    def ty_bldr
+      @ty_bldr ||= Cauterize::Builders.get(:cs, @blueprint.array_type)
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Cauterize
+  module Builders
+    module CS
+      class Enumeration < Buildable
+        def enum_defn(formatter)
+          rep_builder = Builders.get(:cs, @blueprint.representation)
+          formatter << "[SerializedRepresentation(typeof(#{rep_builder.render}))]"
+          formatter << "public enum #{render}"
+          formatter.braces do
+            @blueprint.values.values.each do |v|
+              formatter << "#{v.name.to_s.camel} = #{v.value},"
+            end
+          end
+          formatter.append(";")
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::Enumeration, Cauterize::Builders::CS::Enumeration)

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

@@ -0,0 +1,25 @@
+module Cauterize::Builders::CS
+  class FixedArray < CSArray
+
+    def render_parent
+      "CauterizeFixedArrayTyped<#{ty_bldr.render}>"
+    end
+
+    def simple_constructor_line
+      "public #{render}()"
+    end
+
+    def size_defn(formatter)
+      formatter << "protected override int Size"
+      formatter.braces do
+        formatter << "get { return #{size}; }"
+      end
+    end
+
+    def size
+      @blueprint.array_size
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::FixedArray, Cauterize::Builders::CS::FixedArray)

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

@@ -0,0 +1,33 @@
+module Cauterize::Builders::CS
+  class Group < Buildable
+    def initialize(blueprint)
+      super(blueprint)
+      @tag_enum = blueprint.tag_enum
+    end
+
+    def render_parent
+      "CauterizeGroup"
+    end
+
+    def class_defn(formatter)
+      formatter << "public class #{render} : #{render_parent}"
+      formatter.braces do
+        formatter << "[Order(0)]"
+        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
+            formatter << "[Order(#{i+1})]"
+            b.declare(formatter, field.name)
+          else
+            formatter << "/* No data associated with '#{field.name}'. */"
+          end
+        end
+      end
+      formatter.blank_line
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::Group, Cauterize::Builders::CS::Group)

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

@@ -0,0 +1,10 @@
+module Cauterize::Builders::CS
+  class Scalar < Buildable
+    def render
+      bldr = Cauterize::Builders.get(:cs, @blueprint.type_name)
+      bldr.render
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::Scalar, Cauterize::Builders::CS::Scalar)

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

@@ -0,0 +1,34 @@
+module Cauterize::Builders::CS
+  class VariableArray < CSArray
+
+    def render_parent
+      "CauterizeVariableArrayTyped<#{ty_bldr.render}>"
+    end
+
+    def simple_constructor_line
+      "public #{render}(int size)"
+    end
+
+    def size_defn(formatter)
+      formatter << "protected override int MaxSize"
+      formatter.braces do
+        formatter << "get { return #{size_type}.MaxValue; }"
+      end
+    end
+
+    def size
+      return "size"
+    end
+
+    protected
+    def extra_array_declarations(formatter)
+      formatter << "public static Type SizeType = typeof(#{size_type});"
+    end
+
+    def size_type
+      Cauterize::Builders.get(:cs, @blueprint.size_type).render
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::VariableArray, Cauterize::Builders::CS::VariableArray)

data/lib/cauterize/builtin.rb

@@ -0,0 +1,52 @@
+module Cauterize
+  module_function
+
+  BUILT_IN_TYPES = [
+    { :name => :int8,   :size => 1, :signed => true },
+    { :name => :int16,  :size => 2, :signed => true },
+    { :name => :int32,  :size => 4, :signed => true },
+    { :name => :int64,  :size => 8, :signed => true },
+    { :name => :uint8,  :size => 1, :signed => false },
+    { :name => :uint16, :size => 2, :signed => false },
+    { :name => :uint32, :size => 4, :signed => false },
+    { :name => :uint64, :size => 8, :signed => false },
+  ]
+
+  def builtins
+    @builtins ||= {}
+  end
+
+  def create_builtins
+    BUILT_IN_TYPES.each do |b|
+      _b = BuiltIn.new(b[:name])
+      _b.byte_length(b[:size])
+      _b.is_signed(b[:signed])
+      builtins[b[:name]] = _b
+    end
+  end
+
+  class BuiltIn < BaseType
+    def initialize(name)
+      super
+    end
+
+    def is_signed(signed = nil)
+      unless signed.nil?
+        @is_signed = signed
+      else
+        @is_signed
+      end
+    end
+
+    def byte_length(len = nil)
+      unless len.nil?
+        @byte_length = len
+      else
+        @byte_length
+      end
+    end
+  end
+
+  # Create all the builtin types.
+  create_builtins
+end

data/lib/cauterize/c_builder.rb

@@ -1,3 +1,5 @@
+require 'time'
+
 module Cauterize
   class CBuilder
     attr_reader :h, :c
@@ -23,18 +25,30 @@ module Cauterize
       f << "#define #{excluder}"
       f.blank_line
       f << %Q{#include <cauterize.h>}
-      f << %Q{#include <stdint.h>}
+      f.blank_line
+      f << "#define GEN_VERSION (\"#{Cauterize.get_version}\")"
+      f << "#define GEN_DATE (\"#{DateTime.now.to_s}\")"
       f.blank_line
 
       instances = BaseType.all_instances
       builders = instances.map {|i| Builders.get(:c, i)}
 
+      builders.each { |b| b.typedef_decl(f) }
       builders.each { |b| b.enum_defn(f) }
       builders.each { |b| b.struct_proto(f) }
       builders.each { |b| b.struct_defn(f) }
+
+      f << "#ifdef __cplusplus"
+      f << "extern \"C\" {"
+      f << "#endif"
+
       builders.each { |b| b.packer_proto(f) }
       builders.each { |b| b.unpacker_proto(f) }
 
+      f << "#ifdef __cplusplus"
+      f << "}"
+      f << "#endif"
+
       f.blank_line
       f << "#endif /* #{excluder} */"
 

data/lib/cauterize/cauterize.rb

@@ -4,30 +4,61 @@ lib_path = File.dirname(__FILE__) + "/.."
 require_all Dir[lib_path + "/**/*.rb"]
 
 module Cauterize
-  # Genearte the C code corresponding to the generated configuration
-  def self.generate_c(target_dir, desc_file)
-    Object.new.extend(Cauterize).instance_exec do
-      # this magic allows us to emit useful exception messages when evaling the
-      # file. if your description file has errors, you'll be able to find them
-      # because of this magic.
-      p = Proc.new {}
-      eval(File.read(desc_file), p.binding, desc_file)
-    end
-    output_prefix = get_name || "generated_interface"
 
+  module_function
+  def generate(language, target_dir, desc_file)
+    parse_dsl(desc_file)
     FileUtils.mkdir_p(target_dir)
+    output_prefix = get_name || "generated_interface"
+    builder = send "make_builder_#{language}".to_sym, target_dir, output_prefix
+    builder.build
+  end
+
+  # Generate the C code corresponding to the generated configuration
+  def make_builder_c(target_dir, output_prefix)
     h_file = File.join(target_dir, "#{output_prefix}.h")
     c_file = File.join(target_dir, "#{output_prefix}.c")
 
-    builder = Cauterize::CBuilder.new(h_file, c_file, output_prefix)
-    builder.build
+    Cauterize::CBuilder.new(h_file, c_file, output_prefix)
+  end
+
+  # Generate the CS code corresponding to the generated configuration
+  def make_builder_cs(target_dir, output_prefix)
+    cs_file = File.join(target_dir, "#{output_prefix}.cs")
+
+    Cauterize::CSBuilder.new(cs_file, output_prefix)
   end
 
-  def self.get_name
+  def get_name
     @@description_name
   end
 
+  def get_version
+    if defined? @@version
+      @@version
+    else
+      "UNDEFINED"
+    end
+  end
+
   def set_name(desc_name)
     @@description_name = desc_name
   end
+
+  def set_version(version)
+    @@version = version
+  end
+
+  private 
+  def self.parse_dsl(desc_file)
+    Object.new.extend(Cauterize).instance_exec do
+      # this magic allows us to emit useful exception messages when evaling the
+      # file. if your description file has errors, you'll be able to find them
+      # because of this magic.
+      p = Proc.new {}
+      eval(File.read(desc_file), p.binding, desc_file)
+    end
+
+  end
+
 end