cauterize 0.0.1.pre13 → 0.0.1.pre14

data/lib/cauterize/builders.rb

@@ -1,41 +1,41 @@
-module Cauterize
-  module Builders
-    class UnregisteredException < Exception; end
-    class DuplicateException < Exception; end
-
-    module_function
-
-    def builders
-      @builders
-    end
-
-    def register(language, description_class, builder_class)
-      @builders ||= {}
-      @builders[language] ||= {}
-
-      if @builders[language][description_class]
-        raise DuplicateException.new("A builder for #{description_class} is already registered for language #{language}.")
-      else
-        @builders[language][description_class] = builder_class
-      end
-    end
-
-    def get(language, description_instance)
-      unless @builders
-        raise UnregisteredException.new("No builders are registered.")
-      end
-
-      unless @builders[language]
-        s = "Language #{language} not registered."
-        raise UnregisteredException.new(s)
-      end
-
-      unless @builders[language][description_instance.class]
-        s = "Class #{description_instance.class} not registered for #{language}."
-        raise UnregisteredException.new(s)
-      end
-
-      @builders[language][description_instance.class].new(description_instance)
-    end
-  end
-end
+module Cauterize
+  module Builders
+    class UnregisteredException < Exception; end
+    class DuplicateException < Exception; end
+
+    module_function
+
+    def builders
+      @builders
+    end
+
+    def register(language, description_class, builder_class)
+      @builders ||= {}
+      @builders[language] ||= {}
+
+      if @builders[language][description_class]
+        raise DuplicateException.new("A builder for #{description_class} is already registered for language #{language}.")
+      else
+        @builders[language][description_class] = builder_class
+      end
+    end
+
+    def get(language, description_instance)
+      unless @builders
+        raise UnregisteredException.new("No builders are registered.")
+      end
+
+      unless @builders[language]
+        s = "Language #{language} not registered."
+        raise UnregisteredException.new(s)
+      end
+
+      unless @builders[language][description_instance.class]
+        s = "Class #{description_instance.class} not registered for #{language}."
+        raise UnregisteredException.new(s)
+      end
+
+      @builders[language][description_instance.class].new(description_instance)
+    end
+  end
+end

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

@@ -1,91 +1,91 @@
-module Cauterize
-  module Builders
-    module C
-      # 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 = [
-        :render,
-        :declare,
-        :packer_sym,   :packer_sig,   :packer_proto,   :packer_defn,
-        :unpacker_sym, :unpacker_sig, :unpacker_proto, :unpacker_defn,
-        :struct_proto, :struct_defn,
-        :enumeration,
-      ]
-
-      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
-
-        # wrapped_(un)packer_defn allow us to wrap every definition in some text #
-        ##########################################################################
-        def wrapped_packer_defn(formatter)
-          formatter << packer_sig
-          formatter.braces do
-            formatter.backdent("#ifdef SPECIALIZED_#{packer_sym}")
-            formatter << "return SPECIALIZED_#{packer_sym}(dst, src);"
-            formatter.backdent("#else")
-            packer_defn(formatter)
-            formatter.backdent("#endif")
-          end
-        end
-
-        def wrapped_unpacker_defn(formatter)
-          formatter << unpacker_sig
-          formatter.braces do
-            formatter.backdent("#ifdef SPECIALIZED_#{unpacker_sym}")
-            formatter << "return SPECIALIZED_#{unpacker_sym}(src, dst);"
-            formatter.backdent("#else")
-            unpacker_defn(formatter)
-            formatter.backdent("#endif")
-          end
-        end
-
-        # This is the symbol used to define the maximum encoded length of any type
-        ##########################################################################
-        def max_enc_len_cpp_sym
-          "MAX_ENCODED_LENGTH_#{@blueprint.name}"
-        end
-
-        # Things below here are tested in shared_examples_for_c_buildables #
-        ####################################################################
-
-        # Methods that are pretty much the same for everyone.
-        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 preprocessor_defines(formatter); nil end
-        def typedef_decl(formatter); nil end
-        def struct_proto(formatter); nil end
-        def struct_defn(formatter); nil end
-        def enum_defn(formatter); nil end
-      end
-    end
-  end
-end
+module Cauterize
+  module Builders
+    module C
+      # 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 = [
+        :render,
+        :declare,
+        :packer_sym,   :packer_sig,   :packer_proto,   :packer_defn,
+        :unpacker_sym, :unpacker_sig, :unpacker_proto, :unpacker_defn,
+        :struct_proto, :struct_defn,
+        :enumeration,
+      ]
+
+      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
+
+        # wrapped_(un)packer_defn allow us to wrap every definition in some text #
+        ##########################################################################
+        def wrapped_packer_defn(formatter)
+          formatter << packer_sig
+          formatter.braces do
+            formatter.backdent("#ifdef SPECIALIZED_#{packer_sym}")
+            formatter << "return SPECIALIZED_#{packer_sym}(dst, src);"
+            formatter.backdent("#else")
+            packer_defn(formatter)
+            formatter.backdent("#endif")
+          end
+        end
+
+        def wrapped_unpacker_defn(formatter)
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter.backdent("#ifdef SPECIALIZED_#{unpacker_sym}")
+            formatter << "return SPECIALIZED_#{unpacker_sym}(src, dst);"
+            formatter.backdent("#else")
+            unpacker_defn(formatter)
+            formatter.backdent("#endif")
+          end
+        end
+
+        # This is the symbol used to define the maximum encoded length of any type
+        ##########################################################################
+        def max_enc_len_cpp_sym
+          "MAX_ENCODED_LENGTH_#{@blueprint.name}"
+        end
+
+        # Things below here are tested in shared_examples_for_c_buildables #
+        ####################################################################
+
+        # Methods that are pretty much the same for everyone.
+        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 preprocessor_defines(formatter); nil end
+        def typedef_decl(formatter); nil end
+        def struct_proto(formatter); nil end
+        def struct_defn(formatter); nil end
+        def enum_defn(formatter); nil end
+      end
+    end
+  end
+end

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

@@ -1,43 +1,43 @@
-module Cauterize
-  module Builders
-    module C
-      class BuiltIn < Buildable
-        @@C_TYPE_MAPPING = {
-          1 => {signed:  :int8_t, unsigned:  :uint8_t, :float => nil,     :bool => :bool},
-          2 => {signed: :int16_t, unsigned: :uint16_t, :float => nil,     :bool =>   nil},
-          4 => {signed: :int32_t, unsigned: :uint32_t, :float => :float,  :bool =>   nil},
-          8 => {signed: :int64_t, unsigned: :uint64_t, :float => :double, :bool =>   nil},
-        }
-
-        def render
-          render_ctype
-        end
-
-        def declare(formatter, sym)
-          formatter << "#{render} #{sym};"
-        end
-
-        def preprocessor_defines(formatter)
-          formatter << "#define #{max_enc_len_cpp_sym} sizeof(#{render_ctype})"
-        end
-
-        # These are identical to the Scalar definitions. For now.
-        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
-
-        private
-
-        def render_ctype
-          @@C_TYPE_MAPPING[@blueprint.byte_length][@blueprint.flavor]
-        end
-      end
-    end
-  end
-end
-
-Cauterize::Builders.register(:c, Cauterize::BuiltIn, Cauterize::Builders::C::BuiltIn)
+module Cauterize
+  module Builders
+    module C
+      class BuiltIn < Buildable
+        @@C_TYPE_MAPPING = {
+          1 => {signed:  :int8_t, unsigned:  :uint8_t, :float => nil,     :bool => :bool},
+          2 => {signed: :int16_t, unsigned: :uint16_t, :float => nil,     :bool =>   nil},
+          4 => {signed: :int32_t, unsigned: :uint32_t, :float => :float,  :bool =>   nil},
+          8 => {signed: :int64_t, unsigned: :uint64_t, :float => :double, :bool =>   nil},
+        }
+
+        def render
+          render_ctype
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        def preprocessor_defines(formatter)
+          formatter << "#define #{max_enc_len_cpp_sym} sizeof(#{render_ctype})"
+        end
+
+        # These are identical to the Scalar definitions. For now.
+        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
+
+        private
+
+        def render_ctype
+          @@C_TYPE_MAPPING[@blueprint.byte_length][@blueprint.flavor]
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::BuiltIn, Cauterize::Builders::C::BuiltIn)

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

@@ -1,57 +1,57 @@
-module Cauterize
-  module Builders
-    module C
-      class Composite < Buildable
-        def render
-          "struct #{@blueprint.name.to_s}"
-        end
-
-        def declare(formatter, sym)
-          formatter << "#{render} #{sym};"
-        end
-
-        def preprocessor_defines(formatter)
-          field_lens = @blueprint.fields.values.map do |field|
-            Builders.get(:c, field.type).max_enc_len_cpp_sym
-          end
-
-          formatter << "#define #{max_enc_len_cpp_sym} (#{field_lens.join(" + ")})"
-        end
-
-        def packer_defn(formatter)
-          formatter << "CAUTERIZE_STATUS_T err;"
-          @blueprint.fields.values.each do |field|
-            p_sym = Builders.get(:c, field.type).packer_sym
-            formatter << "if (CA_OK != (err = #{p_sym}(dst, &src->#{field.name}))) { return err; }"
-          end
-          formatter << "return CA_OK;"
-        end
-
-        def unpacker_defn(formatter)
-          formatter << "CAUTERIZE_STATUS_T err;"
-          @blueprint.fields.values.each do |field|
-            u_sym = Builders.get(:c, field.type).unpacker_sym
-            formatter << "if (CA_OK != (err = #{u_sym}(src, &dst->#{field.name}))) { return err; }"
-          end
-          formatter << "return CA_OK;"
-        end
-
-        def struct_proto(formatter)
-          formatter << (render + ";")
-        end
-
-        def struct_defn(formatter)
-          formatter << render
-          formatter.braces do
-            @blueprint.fields.values.each do |field|
-              Builders.get(:c, field.type).declare(formatter, field.name)
-            end
-          end
-          formatter.append(";")
-        end
-      end
-    end
-  end
-end
-
-Cauterize::Builders.register(:c, Cauterize::Composite, Cauterize::Builders::C::Composite)
+module Cauterize
+  module Builders
+    module C
+      class Composite < Buildable
+        def render
+          "struct #{@blueprint.name.to_s}"
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        def preprocessor_defines(formatter)
+          field_lens = @blueprint.fields.values.map do |field|
+            Builders.get(:c, field.type).max_enc_len_cpp_sym
+          end
+
+          formatter << "#define #{max_enc_len_cpp_sym} (#{field_lens.join(" + ")})"
+        end
+
+        def packer_defn(formatter)
+          formatter << "CAUTERIZE_STATUS_T err;"
+          @blueprint.fields.values.each do |field|
+            p_sym = Builders.get(:c, field.type).packer_sym
+            formatter << "if (CA_OK != (err = #{p_sym}(dst, &src->#{field.name}))) { return err; }"
+          end
+          formatter << "return CA_OK;"
+        end
+
+        def unpacker_defn(formatter)
+          formatter << "CAUTERIZE_STATUS_T err;"
+          @blueprint.fields.values.each do |field|
+            u_sym = Builders.get(:c, field.type).unpacker_sym
+            formatter << "if (CA_OK != (err = #{u_sym}(src, &dst->#{field.name}))) { return err; }"
+          end
+          formatter << "return CA_OK;"
+        end
+
+        def struct_proto(formatter)
+          formatter << (render + ";")
+        end
+
+        def struct_defn(formatter)
+          formatter << render
+          formatter.braces do
+            @blueprint.fields.values.each do |field|
+              Builders.get(:c, field.type).declare(formatter, field.name)
+            end
+          end
+          formatter.append(";")
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::Composite, Cauterize::Builders::C::Composite)