cauterize 0.0.1.pre1

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

@@ -0,0 +1,41 @@
+module Cauterize
+  module Builders
+    module C
+      class Enumeration < Buildable
+        def render
+          "enum #{@blueprint.name.to_s}"
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        def packer_defn(formatter)
+          formatter << packer_sig
+          formatter.braces do
+            formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
+          end
+        end
+
+        def unpacker_defn(formatter)
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
+          end
+        end
+
+        def enum_defn(formatter)
+          formatter << render
+          formatter.braces do
+            @blueprint.values.values.each do |v|
+              formatter << "#{v.name.to_s.up_snake} = #{v.value},"
+            end
+          end
+          formatter.append(";")
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::Enumeration, Cauterize::Builders::C::Enumeration)

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

@@ -0,0 +1,62 @@
+module Cauterize
+  module Builders
+    module C
+      class FixedArray < Buildable
+        def render
+          # HEY! PAY ATTENTION!
+          # Keep in mind that there's no sane way to "render" an array in C
+          # that doesn't involve an identifier.
+          ty_bldr.render
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{ty_bldr.render} #{sym}[#{@blueprint.array_size}]; /* #{@blueprint.name} */"
+        end
+
+        def packer_defn(formatter)
+          formatter << packer_sig
+          formatter.braces do
+            formatter << "CAUTERIZE_STATUS_T err;"
+            formatter << "size_t i;"
+            formatter.blank_line
+
+            # store each used item in the array
+            formatter << "for (i = 0; i < #{@blueprint.array_size}; i++)"
+            formatter.braces do
+              formatter << "if (CA_OK != (err = #{ty_bldr.packer_sym}(dst, &src[i]))) { return err; }"
+            end
+            formatter.blank_line
+
+            formatter << "return CA_OK;"
+          end
+        end
+
+        def unpacker_defn(formatter)
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter << "CAUTERIZE_STATUS_T err;"
+            formatter << "size_t i;"
+            formatter.blank_line
+
+            # store each used item in the array
+            formatter << "for (i = 0; i < #{@blueprint.array_size}; i++)"
+            formatter.braces do
+              formatter << "if (CA_OK != (err = #{ty_bldr.unpacker_sym}(src, &dst[i]))) { return err; }"
+            end
+            formatter.blank_line
+
+            formatter << "return CA_OK;"
+          end
+        end
+
+        private
+
+        def ty_bldr
+          @ty_bldr ||= Builders.get(:c, @blueprint.array_type)
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::FixedArray, Cauterize::Builders::C::FixedArray)

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

@@ -0,0 +1,95 @@
+module Cauterize
+  module Builders
+    module C
+      class Group < Buildable
+        def initialize(blueprint)
+          super(blueprint)
+          @tag_enum = blueprint.tag_enum
+        end
+
+        def render
+          "struct #{@blueprint.name.to_s}"
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        def packer_defn(formatter)
+          enum_builder = Builders.get(:c, @tag_enum)
+          formatter << packer_sig
+          formatter.braces do
+            formatter << "CAUTERIZE_STATUS_T err;"
+
+            # pack the tag
+            formatter << "if (CA_OK != (err = #{enum_builder.packer_sym}(dst, &src->tag))) { return err; }"
+
+            # pack the fields
+            formatter << "switch (src->tag)"
+            formatter.braces do
+              @blueprint.fields.values.each do |field|
+                bldr = Builders.get(:c, field.type)
+                formatter.backdent "case #{@blueprint.enum_sym(field.name)}:"
+                formatter << "if (CA_OK != (err = #{bldr.packer_sym}(dst, &src->data.#{field.name}))) { return err; }"
+                formatter << "break;"
+              end
+
+              formatter.backdent "default:"
+              formatter << "return CA_ERR_INVALUD_TYPE_TAG;"
+              formatter << "break;"
+            end
+            formatter << "return CA_OK;"
+          end
+        end
+
+        def unpacker_defn(formatter)
+          enum_builder = Builders.get(:c, @tag_enum)
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter << "CAUTERIZE_STATUS_T err;"
+
+            # unpack the tag
+            formatter << "if (CA_OK != (err = #{enum_builder.unpacker_sym}(src, &dst->tag))) { return err; }"
+
+            # pack the fields
+            formatter << "switch (dst->tag)"
+            formatter.braces do
+              @blueprint.fields.values.each do |field|
+                bldr = Builders.get(:c, field.type)
+                formatter.backdent "case #{@blueprint.enum_sym(field.name)}:"
+                formatter << "if (CA_OK != (err = #{bldr.unpacker_sym}(src, &dst->data.#{field.name}))) { return err; }"
+                formatter << "break;"
+              end
+
+              formatter.backdent "default:"
+              formatter << "return CA_ERR_INVALUD_TYPE_TAG;"
+              formatter << "break;"
+            end
+            formatter << "return CA_OK;"
+          end
+        end
+
+        def struct_proto(formatter)
+          formatter << (render + ";")
+        end
+
+        def struct_defn(formatter)
+          formatter << render
+          formatter.braces do
+            Builders.get(:c, @tag_enum).declare(formatter, "tag")
+            formatter << "union"
+            formatter.braces do
+              @blueprint.fields.values.each do |field|
+                Builders.get(:c, field.type).declare(formatter, field.name)
+              end
+            end
+            formatter.append(" data;")
+          end
+          formatter.append(";")
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::Group, Cauterize::Builders::C::Group)

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

@@ -0,0 +1,31 @@
+module Cauterize
+  module Builders
+    module C
+      class Scalar < Buildable
+        def render
+          @blueprint.name.to_s
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        def packer_defn(formatter)
+          formatter << packer_sig
+          formatter.braces do
+            formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
+          end
+        end
+
+        def unpacker_defn(formatter)
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
+          end
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::Scalar, Cauterize::Builders::C::Scalar)

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

@@ -0,0 +1,90 @@
+module Cauterize
+  module Builders
+    module C
+      class VariableArray < Buildable
+        def render
+          "struct #{@blueprint.name}"
+        end
+
+        def declare(formatter, sym)
+          formatter << "struct #{@blueprint.name} #{sym};"
+        end
+
+        def packer_defn(formatter)
+          size_type_builder = Builders.get(:c, @blueprint.size_type)
+          array_type_builder = Builders.get(:c, @blueprint.array_type)
+
+          formatter << packer_sig
+          formatter.braces do
+            formatter << "CAUTERIZE_STATUS_T err;"
+            formatter << "size_t i;"
+            formatter.blank_line
+            # check the length
+            formatter << "if (src->length > ARRAY_SIZE(src->data)) { return CA_ERR_INVALID_LENGTH; }"
+
+            # store the length
+            formatter << "if (CA_OK != (err = #{size_type_builder.packer_sym}(dst, &src->length))) { return err; }"
+            formatter.blank_line
+
+            # store each used item in the array
+            formatter << "for (i = 0; i < src->length; i++)"
+            formatter.braces do
+              formatter << "if (CA_OK != (err = #{array_type_builder.packer_sym}(dst, &src->data[i]))) { return err; }"
+            end
+            formatter.blank_line
+
+            formatter << "return CA_OK;"
+          end
+        end
+
+        def unpacker_defn(formatter)
+          size_type_builder = Builders.get(:c, @blueprint.size_type)
+          array_type_builder = Builders.get(:c, @blueprint.array_type)
+
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter << "CAUTERIZE_STATUS_T err;"
+            formatter << "size_t i;"
+            formatter.blank_line
+
+            # read the length
+            formatter << "if (CA_OK != (err = #{size_type_builder.unpacker_sym}(src, &dst->length))) { return err; }"
+            formatter.blank_line
+
+            # check the length
+            formatter << "if (dst->length > ARRAY_SIZE(dst->data)) { return CA_ERR_INVALID_LENGTH; }"
+            formatter.blank_line
+
+
+            # store each used item in the array
+            formatter << "for (i = 0; i < dst->length; i++)"
+            formatter.braces do
+              formatter << "if (CA_OK != (err = #{array_type_builder.unpacker_sym}(src, &dst->data[i]))) { return err; }"
+            end
+            formatter.blank_line
+
+            formatter << "return CA_OK;"
+          end
+        end
+
+        def struct_proto(formatter)
+          formatter << (render + ";")
+        end
+
+        def struct_defn(formatter)
+          formatter << render
+          formatter.braces do
+            at_builder = Builders.get(:c, @blueprint.array_type)
+            st_builder = Builders.get(:c, @blueprint.size_type)
+
+            st_builder.declare(formatter, "length")
+            formatter << "#{at_builder.render} data[#{@blueprint.array_size}];"
+          end
+          formatter.append(";")
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::VariableArray, Cauterize::Builders::C::VariableArray)

data/lib/cauterize/c_builder.rb

@@ -0,0 +1,63 @@
+module Cauterize
+  class CBuilder
+    attr_reader :h, :c
+
+    def initialize(h_file, c_file, name="cauterize")
+      @h = h_file
+      @c = c_file
+      @name = name
+    end
+
+    def build
+      build_h
+      build_c
+    end
+
+    private
+
+    def build_h
+      f = default_formatter
+
+      excluder = @name.up_snake + "_H_#{Time.now.to_i}"
+      f << "#ifndef #{excluder}"
+      f << "#define #{excluder}"
+      f.blank_line
+      f << %Q{#include <cauterize.h>}
+      f << %Q{#include <stdint.h>}
+      f.blank_line
+
+      instances = BaseType.all_instances
+      builders = instances.map {|i| Builders.get(:c, i)}
+
+      builders.each { |b| b.enum_defn(f) }
+      builders.each { |b| b.struct_proto(f) }
+      builders.each { |b| b.struct_defn(f) }
+      builders.each { |b| b.packer_proto(f) }
+      builders.each { |b| b.unpacker_proto(f) }
+
+      f.blank_line
+      f << "#endif /* #{excluder} */"
+
+      File.open(@h, "wb") do |fh|
+        fh.write(f.to_s)
+      end
+    end
+
+    def build_c
+      f = default_formatter
+
+      f << %Q{#include <cauterize_util.h>}
+      f << %Q{#include "#{@name}.h"}
+
+      instances = BaseType.all_instances
+      builders = instances.map {|i| Builders.get(:c, i)}
+
+      builders.each { |b| b.packer_defn(f) }
+      builders.each { |b| b.unpacker_defn(f) }
+
+      File.open(@c, "wb") do |fh|
+        fh.write(f.to_s)
+      end
+    end
+  end
+end

data/lib/cauterize/cauterize.rb

@@ -0,0 +1,33 @@
+require "require_all"
+
+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"
+
+    FileUtils.mkdir_p(target_dir)
+    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
+  end
+
+  def self.get_name
+    @@description_name
+  end
+
+  def set_name(desc_name)
+    @@description_name = desc_name
+  end
+end

data/lib/cauterize/composite.rb

@@ -0,0 +1,50 @@
+# composite.rb
+#
+# Composites correspond to C structs.
+
+module Cauterize
+  module_function
+
+  def composite(name)
+    c = composites[name] || composites[name] = Composite.new(name)
+    yield c if block_given?
+    return c
+  end
+
+  def composite!(name, &blk)
+    if composites[name]
+      raise Exception.new("Composite with name #{name} already exists.")
+    else
+      composite(name, &blk)
+    end
+  end
+
+  def composites
+    @composites ||= {}
+  end
+
+  class CompositeField
+    attr_reader :name, :type
+    def initialize(field_name, type_name)
+      @name = field_name
+      @type = BaseType.find_type!(type_name)
+    end
+  end
+
+  class Composite < BaseType
+    attr_reader :fields
+
+    def initialize(name)
+      super
+      @fields = {}
+    end
+
+    def field(name, type)
+      if @fields[name]
+        raise Exception.new("Field name #{name} already used.")
+      else
+        @fields[name] = CompositeField.new(name, type)
+      end
+    end
+  end
+end