cauterize 0.0.1.pre13 → 0.0.1.pre14

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

@@ -1,34 +1,34 @@
-module Cauterize
-  module Builders
-    module C
-      class Scalar < Buildable
-        def render
-          @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
-
-        def preprocessor_defines(formatter)
-          formatter << "#define #{max_enc_len_cpp_sym} sizeof(#{render})"
-        end
-
-        def packer_defn(formatter)
-          formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
-        end
-
-        def unpacker_defn(formatter)
-          formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
-        end
-      end
-    end
-  end
-end
-
-Cauterize::Builders.register(:c, Cauterize::Scalar, Cauterize::Builders::C::Scalar)
+module Cauterize
+  module Builders
+    module C
+      class Scalar < Buildable
+        def render
+          @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
+
+        def preprocessor_defines(formatter)
+          formatter << "#define #{max_enc_len_cpp_sym} sizeof(#{render})"
+        end
+
+        def packer_defn(formatter)
+          formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
+        end
+
+        def unpacker_defn(formatter)
+          formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::Scalar, Cauterize::Builders::C::Scalar)

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

@@ -1,98 +1,98 @@
-module Cauterize
-  module Builders
-    module C
-      class VariableArray < Buildable
-        def render
-          "struct #{@blueprint.name}"
-        end
-
-        def declare(formatter, sym)
-          formatter << "#{render} #{sym};"
-        end
-
-        def preprocessor_defines(formatter)
-          formatter << "#define #{length_sym} (#{@blueprint.array_size})"
-          formatter << [
-            "#define #{max_enc_len_cpp_sym} (",
-            "#{size_type_builder.max_enc_len_cpp_sym} + ",
-            "(#{length_sym} * #{array_type_builder.max_enc_len_cpp_sym}))"].join
-        end
-
-        def packer_defn(formatter)
-          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
-
-        def unpacker_defn(formatter)
-          size_type_builder = Builders.get(:c, @blueprint.size_type)
-          array_type_builder = Builders.get(:c, @blueprint.array_type)
-
-          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
-
-        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
-
-        private
-
-        def length_sym
-          "VARIABLE_ARRAY_MAX_LENGTH_#{@blueprint.name}"
-        end
-
-        def size_type_builder; Builders.get(:c, @blueprint.size_type) end
-        def array_type_builder; Builders.get(:c, @blueprint.array_type) end
-      end
-    end
-  end
-end
-
-Cauterize::Builders.register(:c, Cauterize::VariableArray, Cauterize::Builders::C::VariableArray)
+module Cauterize
+  module Builders
+    module C
+      class VariableArray < Buildable
+        def render
+          "struct #{@blueprint.name}"
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        def preprocessor_defines(formatter)
+          formatter << "#define #{length_sym} (#{@blueprint.array_size})"
+          formatter << [
+            "#define #{max_enc_len_cpp_sym} (",
+            "#{size_type_builder.max_enc_len_cpp_sym} + ",
+            "(#{length_sym} * #{array_type_builder.max_enc_len_cpp_sym}))"].join
+        end
+
+        def packer_defn(formatter)
+          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
+
+        def unpacker_defn(formatter)
+          size_type_builder = Builders.get(:c, @blueprint.size_type)
+          array_type_builder = Builders.get(:c, @blueprint.array_type)
+
+          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
+
+        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
+
+        private
+
+        def length_sym
+          "VARIABLE_ARRAY_MAX_LENGTH_#{@blueprint.name}"
+        end
+
+        def size_type_builder; Builders.get(:c, @blueprint.size_type) end
+        def array_type_builder; Builders.get(:c, @blueprint.array_type) end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::VariableArray, Cauterize::Builders::C::VariableArray)

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

@@ -1,59 +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
+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

@@ -1,22 +1,22 @@
-module Cauterize::Builders::CS
-  class BuiltIn < Buildable
-    @@CS_TYPE_MAPPING = {
-      1 => {signed: "SByte", unsigned: "Byte",   :float => nil,      :bool => "bool"},
-      2 => {signed: "Int16", unsigned: "UInt16", :float => nil,      :bool => nil},
-      4 => {signed: "Int32", unsigned: "UInt32", :float => "Single",  :bool => nil},
-      8 => {signed: "Int64", unsigned: "UInt64", :float => "Double", :bool => nil},
-    }
-
-    def render
-      render_cstype
-    end
-
-    private
-
-    def render_cstype
-      @@CS_TYPE_MAPPING[@blueprint.byte_length][@blueprint.flavor]
-    end
-  end
-end
-
-Cauterize::Builders.register(:cs, Cauterize::BuiltIn, Cauterize::Builders::CS::BuiltIn)
+module Cauterize::Builders::CS
+  class BuiltIn < Buildable
+    @@CS_TYPE_MAPPING = {
+      1 => {signed: "SByte", unsigned: "Byte",   :float => nil,      :bool => "bool"},
+      2 => {signed: "Int16", unsigned: "UInt16", :float => nil,      :bool => nil},
+      4 => {signed: "Int32", unsigned: "UInt32", :float => "Single",  :bool => nil},
+      8 => {signed: "Int64", unsigned: "UInt64", :float => "Double", :bool => nil},
+    }
+
+    def render
+      render_cstype
+    end
+
+    private
+
+    def render_cstype
+      @@CS_TYPE_MAPPING[@blueprint.byte_length][@blueprint.flavor]
+    end
+  end
+end
+
+Cauterize::Builders.register(:cs, Cauterize::BuiltIn, Cauterize::Builders::CS::BuiltIn)

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

@@ -1,21 +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)
+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)