cauterize 0.0.1.pre12 → 0.0.1.pre13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8dc3160a85139642df941d4afd5e3e7bbac2b32b
+  data.tar.gz: 827cf33e36a85a7acf94e0c92418e4a5ece5b419
+SHA512:
+  metadata.gz: 6f4311c1ca2b228a9cad06b595756f57e40327fdba18664b8419770c91e7f2b1fd95aa1cb0a7b94e66b7f8007d1cbd2aeea19a41209197ece8bf7da8c082b9dd
+  data.tar.gz: c32033d4dfd4575cc11ff4dda714211df2cbf46b552903a69659278b90f8ee049bf3f2ef4191da363f4664f2e115a8aa4dd143a401c2017b34233c19cd8edfd7

data/.gitignore

@@ -25,3 +25,9 @@ example/*_cauterize_output
 
 # Nunit test results
 TestResult.xml
+
+# rbenv
+.ruby-version
+
+# Tags
+tags

data/example/Cauterize

@@ -5,7 +5,6 @@ scalar(:bigint)  { |t| t.type_name(:int32) }
 scalar(:usmallint) { |t| t.type_name(:uint8) }
 
 variable_array(:uint8_buffer) do |a|
-  a.size_type  :uint8
   a.array_type :uint8
   a.array_size 128
 end
@@ -37,7 +36,6 @@ fixed_array(:color_list_list) do |a|
 end
  
 variable_array(:numbers) do |a|
-  a.size_type  :usmallint
   a.array_type :bigint
   a.array_size 128
 end

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

@@ -57,6 +57,12 @@ module Cauterize
           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 #
         ####################################################################
 
@@ -74,6 +80,7 @@ module Cauterize
         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

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

@@ -17,6 +17,10 @@ module Cauterize
           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));"

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

@@ -10,6 +10,14 @@ module Cauterize
           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|

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

@@ -10,9 +10,11 @@ module Cauterize
           formatter << "#{render} #{sym};"
         end
 
-        def packer_defn(formatter)
-          rep_builder = Builders.get(:c, @blueprint.representation)
+        def preprocessor_defines(formatter)
+          formatter << "#define #{max_enc_len_cpp_sym} (#{rep_builder.max_enc_len_cpp_sym})"
+        end
 
+        def packer_defn(formatter)
           rep = "enum_representation"
           rep_builder.declare(formatter, rep)
 
@@ -21,8 +23,6 @@ module Cauterize
         end
 
         def unpacker_defn(formatter)
-          rep_builder = Builders.get(:c, @blueprint.representation)
-
           rep = "enum_representation"
           rep_builder.declare(formatter, rep)
 
@@ -48,6 +48,10 @@ module Cauterize
           end
           formatter.append(";")
         end
+
+        private
+
+        def rep_builder; Builders.get(:c, @blueprint.representation) end
       end
     end
   end

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

@@ -10,13 +10,18 @@ module Cauterize
           formatter << "#{render} #{sym};"
         end
 
+        def preprocessor_defines(formatter)
+          formatter << "#define #{length_sym} (#{@blueprint.array_size})"
+          formatter << "#define #{max_enc_len_cpp_sym} (#{length_sym} * #{ty_bldr.max_enc_len_cpp_sym})"
+        end
+
         def packer_defn(formatter)
           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 << "for (i = 0; i < #{length_sym}; i++)"
           formatter.braces do
             formatter << "if (CA_OK != (err = #{ty_bldr.packer_sym}(dst, &src->data[i]))) { return err; }"
           end
@@ -31,7 +36,7 @@ module Cauterize
           formatter.blank_line
 
           # store each used item in the array
-          formatter << "for (i = 0; i < #{@blueprint.array_size}; i++)"
+          formatter << "for (i = 0; i < #{length_sym}; i++)"
           formatter.braces do
             formatter << "if (CA_OK != (err = #{ty_bldr.unpacker_sym}(src, &dst->data[i]))) { return err; }"
           end
@@ -54,6 +59,10 @@ module Cauterize
 
         private
 
+        def length_sym
+          "FIXED_ARRAY_LENGTH_#{@blueprint.name}"
+        end
+
         def ty_bldr
           @ty_bldr ||= Builders.get(:c, @blueprint.array_type)
         end

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

@@ -1,6 +1,16 @@
 module Cauterize
   module Builders
     module C
+      class Maxer
+        # Produce a preprocessor string that results in the maximum size of the passed
+        # in symbols. Uses the CA_MAX macro from the Cauterize support C files.
+        def self.max_str(*syms)
+          a = syms.to_a
+          pre = syms.to_a.inject("") {|s, v| s + "CA_MAX(" + v.to_s + ", "}
+          return pre + "0" + (")" * a.length)
+        end
+      end
+
       class Group < Buildable
         def initialize(blueprint)
           super(blueprint)
@@ -15,8 +25,21 @@ module Cauterize
           formatter << "#{render} #{sym};"
         end
 
+        def preprocessor_defines(formatter)
+          field_lens = @blueprint.fields.values.map do |field|
+            if field.type.nil?
+              nil
+            else
+              Builders.get(:c, field.type).max_enc_len_cpp_sym
+            end
+          end.compact
+
+          formatter << ["#define #{max_enc_len_cpp_sym}",
+                        "(#{enum_builder.max_enc_len_cpp_sym} +",
+                        Maxer.max_str(*field_lens)].join(" ") + ")"
+        end
+
         def packer_defn(formatter)
-          enum_builder = Builders.get(:c, @tag_enum)
           formatter << "CAUTERIZE_STATUS_T err;"
 
           # pack the tag
@@ -110,6 +133,8 @@ module Cauterize
             formatter << "break;"
           end
         end
+
+        def enum_builder; Builders.get(:c, @tag_enum) end
       end
     end
   end

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

@@ -15,6 +15,10 @@ module Cauterize
           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

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

@@ -10,10 +10,15 @@ module Cauterize
           formatter << "#{render} #{sym};"
         end
 
-        def packer_defn(formatter)
-          size_type_builder = Builders.get(:c, @blueprint.size_type)
-          array_type_builder = Builders.get(:c, @blueprint.array_type)
+        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
@@ -76,6 +81,15 @@ module Cauterize
           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

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

@@ -3,7 +3,7 @@ module Cauterize::Builders::CS
     @@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 => "Float",  :bool => nil},
+      4 => {signed: "Int32", unsigned: "UInt32", :float => "Single",  :bool => nil},
       8 => {signed: "Int64", unsigned: "UInt64", :float => "Double", :bool => nil},
     }
 

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

@@ -10,9 +10,11 @@ module Cauterize::Builders::CS
     end
 
     def size_defn(formatter)
+      formatter << "public static int MySize = #{size};"
+      formatter.blank_line
       formatter << "protected override int Size"
       formatter.braces do
-        formatter << "get { return #{size}; }"
+        formatter << "get { return MySize; }"
       end
     end
 

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

@@ -8,7 +8,7 @@ module Cauterize::Builders::Ruby
     }
 
     def render
-      render_rbtype
+      "CauterizeRuby::#{render_rbtype}"
     end
 
     def class_defn(f)

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

@@ -5,16 +5,19 @@ module Cauterize::Builders::Ruby
     end
 
     def class_defn(f)
-      f << "class #{render} < CauterizeComposite"
-      f << "  def self.fields"
-      f << "    {"
-      @blueprint.fields.values.each_with_index do |field, i|
+      f << "  class #{render} < CauterizeRuby::Composite"
+      @blueprint.fields.values.each do |field|
+        f << "    def #{field.name}() fields[:#{field.name}] end"
+      end
+      f << "    def self.fields"
+      f << "      {"
+      @blueprint.fields.values.each do |field|
         t = Cauterize::Builders.get(:ruby, field.type).render
-        f << "      #{field.name}: #{t},"
+        f << "        #{field.name}: #{t},"
       end
-      f << "    }"
+      f << "      }"
+      f << "    end"
       f << "  end"
-      f << "end"
       f << ""
     end
   end

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

@@ -6,19 +6,19 @@ module Cauterize::Builders::Ruby
 
     def class_defn(f)
       rep_builder = Cauterize::Builders.get(:ruby, @blueprint.representation)
-      f << "class #{render} < CauterizeEnumeration"
-      f << "  def self.repr_type() #{rep_builder.render} end"
-      f << "  def self.fields"
-      f << "    {"
+      f << "  class #{render} < CauterizeRuby::Enumeration"
+      f << "    def self.repr_type() #{rep_builder.render} end"
+      f << "    def self.fields"
+      f << "      {"
       @blueprint.values.values.each do |v|
-        f << "      #{v.name.to_s.upcase}: #{v.value},"
+        f << "        #{v.name.to_s.upcase}: #{v.value},"
       end
-      f << "    }"
-      f << "  end"
+      f << "      }"
+      f << "    end"
       @blueprint.values.values.each do |v|
-        f << "  #{v.name.to_s.upcase} = #{render}.new(:#{v.name.to_s.upcase})"
+        f << "    #{v.name.to_s.upcase} = #{render}.new(:#{v.name.to_s.upcase})"
       end
-      f << "end"
+      f << "  end"
       f << ""
     end
   end

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

@@ -7,10 +7,10 @@ module Cauterize::Builders::Ruby
     def class_defn(f)
       array_type_bldr = Cauterize::Builders.get(:ruby, @blueprint.array_type)
       x = <<EOF
-class #{render} < CauterizeFixedArray
-  def self.length () #{@blueprint.array_size} end
-  def self.elem_type() #{array_type_bldr.render} end
-end
+  class #{render} < CauterizeRuby::FixedArray
+    def self.length () #{@blueprint.array_size} end
+    def self.elem_type() #{array_type_bldr.render} end
+  end
 EOF
       f << x
     end

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

@@ -11,22 +11,22 @@ module Cauterize::Builders::Ruby
     def class_defn(f)
       tag = Cauterize::Builders.get(:ruby, @tag_enum).render
 
-      f << "class #{render} < CauterizeGroup"
-      f << "  def self.tag_type() #{tag} end"
-      f << "  def self.tag_prefix() '#{@blueprint.tag_enum.name.upcase}_' end"
-      f << "  def self.fields"
-      f << "    {"
+      f << "  class #{render} < CauterizeRuby::Group"
+      f << "    def self.tag_type() #{tag} end"
+      f << "    def self.tag_prefix() '#{@blueprint.tag_enum.name.upcase}_' end"
+      f << "    def self.fields"
+      f << "      {"
       @blueprint.fields.values.each_with_index do |field, i|
         if field.type
           t = Cauterize::Builders.get(:ruby, field.type).render
-          f << "      #{field.name.to_s.upcase}: #{t},"
+          f << "        #{field.name.to_s.upcase}: #{t},"
         else
-          f << "      #{field.name.to_s.upcase}: nil,"
+          f << "        #{field.name.to_s.upcase}: nil,"
         end
       end
-      f << "    }"
+      f << "      }"
+      f << "    end"
       f << "  end"
-      f << "end"
       f << ""
     end
   end

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

@@ -7,9 +7,9 @@ module Cauterize::Builders::Ruby
     def class_defn(f)
       tn_bldr = Cauterize::Builders.get(:ruby, @blueprint.type_name)
       x = <<EOF
-class #{render} < CauterizeScalar
-  def self.builtin() #{tn_bldr.render} end
-end
+  class #{render} < CauterizeRuby::Scalar
+    def self.builtin() #{tn_bldr.render} end
+  end
 EOF
       f << x
     end

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

@@ -8,11 +8,11 @@ module Cauterize::Builders::Ruby
       array_type_bldr = Cauterize::Builders.get(:ruby, @blueprint.array_type)
       size_type_bldr = Cauterize::Builders.get(:ruby, @blueprint.size_type)
       x = <<EOF
-class #{render} < CauterizeVariableArray
-  def self.size_type () #{size_type_bldr.render} end
-  def self.max_length () #{@blueprint.array_size} end
-  def self.elem_type() #{array_type_bldr.render} end
-end
+  class #{render} < CauterizeRuby::VariableArray
+    def self.size_type () #{size_type_bldr.render} end
+    def self.max_length () #{@blueprint.array_size} end
+    def self.elem_type() #{array_type_bldr.render} end
+  end
 EOF
       f << x
     end

data/lib/cauterize/c_builder.rb

@@ -40,10 +40,16 @@ module Cauterize
       instances = BaseType.all_instances
       builders = instances.map {|i| Builders.get(:c, i)}
 
+      builders.each { |b| b.preprocessor_defines(f) }
+      f.blank_line
       builders.each { |b| b.typedef_decl(f) }
+      f.blank_line
       builders.each { |b| b.enum_defn(f) }
+      f.blank_line
       builders.each { |b| b.struct_proto(f) }
+      f.blank_line
       builders.each { |b| b.struct_defn(f) }
+      f.blank_line
 
       f << "#ifdef __cplusplus"
       f << "extern \"C\" {"