cauterize 0.0.1.pre11 → 0.0.1.pre12

data/example/Cauterize

@@ -4,6 +4,12 @@ set_version("1.2.3")
 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
+
 enumeration(:color) do |e|
   e.value :red
   e.value :blue

data/example/build.sh

@@ -7,11 +7,14 @@ rm -rf c_cauterize_output
 ../bin/cauterize generate c c_cauterize_output
 
 CFLAGS="-Wall -Werror -Wextra"
-INCLUDES="-Ic_cauterize_output"
-
-
-gcc $CFLAGS $INCLUDES c_cauterize_output/cauterize.c -c -o c_cauterize_output/cauterize.o
-gcc $CFLAGS $INCLUDES c_cauterize_output/example_project.c -c -o c_cauterize_output/example_project.o
+INCLUDES="-Ic_cauterize_output -Ic_example_support"
+DEFINES="-DUSE_CAUTERIZE_CONFIG_HEADER"
+
+gcc $CFLAGS $INCLUDES $DEFINES c_example_support/example_project_config.c \
+                               c_example_support/empty_main.c \
+                               c_cauterize_output/cauterize.c \
+                               c_cauterize_output/example_project.c \
+                               -o c_cauterize_output/example_project
 
 rm -rf cs_cauterize_output
 ../bin/cauterize generate cs cs_cauterize_output

data/example/c_example_support/empty_main.c

@@ -0,0 +1 @@
+int main(int argc, char * argv[]) { (void)argc; (void)argv; return 0; }

data/example/c_example_support/example_project_config.c

@@ -0,0 +1,11 @@
+#include "example_project_config.h"
+
+CAUTERIZE_STATUS_T spec_Pack_uint8_buffer(struct Cauterize * dst, struct uint8_buffer * src)
+{
+  CAUTERIZE_STATUS_T err;
+
+  if (src->length > ARRAY_SIZE(src->data)) { return CA_ERR_INVALID_LENGTH; }
+  if (CA_OK != (err = Pack_uint8(dst, &src->length))) { return err; }
+
+  return CauterizeAppend(dst, src->data, src->length * sizeof(src->data[0]));
+}

data/example/c_example_support/example_project_config.h

@@ -0,0 +1,15 @@
+#ifndef EXAMPLE_PROJECT_CONFIG_H
+#define EXAMPLE_PROJECT_CONFIG_H
+
+#include "example_project.h"
+
+/* We're going to define a specialized version of Pack_uint8_buffer which packs
+ * the entire buffer at once. We know this is okay since we're guaranteed not
+ * to have any padding between the bytes in the array. */
+#define SPECIALIZED_Pack_uint8_buffer spec_Pack_uint8_buffer
+
+CAUTERIZE_STATUS_T spec_Pack_uint8_buffer(
+    struct Cauterize * dst,
+    struct uint8_buffer * src);
+
+#endif /* EXAMPLE_PROJECT_CONFIG_H */

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

@@ -33,18 +33,42 @@ module Cauterize
           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
+
         # 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; "CALLCONV CAUTERIZE_STATUS_T DLLDECL #{packer_sym}(struct Cauterize * dst, #{render} * src)" 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; "CALLCONV CAUTERIZE_STATUS_T DLLDECL #{unpacker_sym}(struct Cauterize * src, #{render} * dst)" end
+        def unpacker_sig; "CAUTERIZE_STATUS_T #{unpacker_sym}(struct Cauterize * src, #{render} * dst)" end
         def unpacker_proto(formatter)
           formatter << unpacker_sig + ";"
         end

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

@@ -19,17 +19,11 @@ module Cauterize
 
         # These are identical to the Scalar definitions. For now.
         def packer_defn(formatter)
-          formatter << packer_sig
-          formatter.braces do
-            formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
-          end
+          formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
         end
 
         def unpacker_defn(formatter)
-          formatter << unpacker_sig
-          formatter.braces do
-            formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
-          end
+          formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
         end
 
         private

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

@@ -11,27 +11,21 @@ module Cauterize
         end
 
         def packer_defn(formatter)
-          formatter << packer_sig
-          formatter.braces do
-            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;"
+          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 << unpacker_sig
-          formatter.braces do
-            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;"
+          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)

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

@@ -13,35 +13,29 @@ module Cauterize
         def packer_defn(formatter)
           rep_builder = Builders.get(:c, @blueprint.representation)
 
-          formatter << packer_sig
-          formatter.braces do
-            rep = "enum_representation"
-            rep_builder.declare(formatter, rep)
+          rep = "enum_representation"
+          rep_builder.declare(formatter, rep)
 
-            formatter << "#{rep} = (#{rep_builder.render})(*src);"
-            formatter << "return #{rep_builder.packer_sym}(dst, &#{rep});"
-          end
+          formatter << "#{rep} = (#{rep_builder.render})(*src);"
+          formatter << "return #{rep_builder.packer_sym}(dst, &#{rep});"
         end
 
         def unpacker_defn(formatter)
           rep_builder = Builders.get(:c, @blueprint.representation)
 
-          formatter << unpacker_sig
-          formatter.braces do
-            rep = "enum_representation"
-            rep_builder.declare(formatter, rep)
+          rep = "enum_representation"
+          rep_builder.declare(formatter, rep)
 
-            formatter << "CAUTERIZE_STATUS_T s = #{rep_builder.unpacker_sym}(src, &#{rep});"
-            formatter << "if (CA_OK != s)"
-            formatter.braces do
-              formatter << "return s;"
-            end
+          formatter << "CAUTERIZE_STATUS_T s = #{rep_builder.unpacker_sym}(src, &#{rep});"
+          formatter << "if (CA_OK != s)"
+          formatter.braces do
+            formatter << "return s;"
+          end
 
-            formatter << "else"
-            formatter.braces do
-              formatter << "*dst = (#{render})#{rep};"
-              formatter << "return CA_OK;"
-            end
+          formatter << "else"
+          formatter.braces do
+            formatter << "*dst = (#{render})#{rep};"
+            formatter << "return CA_OK;"
           end
         end
 

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

@@ -11,39 +11,33 @@ module Cauterize
         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->data[i]))) { return err; }"
-            end
-            formatter.blank_line
+          formatter << "CAUTERIZE_STATUS_T err;"
+          formatter << "size_t i;"
+          formatter.blank_line
 
-            formatter << "return CA_OK;"
+          # 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->data[i]))) { return err; }"
           end
+          formatter.blank_line
+
+          formatter << "return CA_OK;"
         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->data[i]))) { return err; }"
-            end
-            formatter.blank_line
+          formatter << "CAUTERIZE_STATUS_T err;"
+          formatter << "size_t i;"
+          formatter.blank_line
 
-            formatter << "return CA_OK;"
+          # 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->data[i]))) { return err; }"
           end
+          formatter.blank_line
+
+          formatter << "return CA_OK;"
         end
 
         def struct_proto(formatter)

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

@@ -17,60 +17,55 @@ module Cauterize
 
         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
-              having_data.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 << "CAUTERIZE_STATUS_T err;"
 
-              format_no_data_stubs(formatter)
+          # pack the tag
+          formatter << "if (CA_OK != (err = #{enum_builder.packer_sym}(dst, &src->tag))) { return err; }"
 
-              formatter.backdent "default:"
-              formatter << "return CA_ERR_INVALID_TYPE_TAG;"
+          # pack the fields
+          formatter << "switch (src->tag)"
+          formatter.braces do
+            having_data.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 << "return CA_OK;"
+
+            format_no_data_stubs(formatter)
+
+            formatter.backdent "default:"
+            formatter << "return CA_ERR_INVALID_TYPE_TAG;"
+            formatter << "break;"
           end
+          formatter << "return CA_OK;"
         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; }"
+          formatter << "CAUTERIZE_STATUS_T err;"
 
-            # pack the fields
-            formatter << "switch (dst->tag)"
-            formatter.braces do
-              having_data.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
+          # unpack the tag
+          formatter << "if (CA_OK != (err = #{enum_builder.unpacker_sym}(src, &dst->tag))) { return err; }"
 
-              format_no_data_stubs(formatter)
-
-              formatter.backdent "default:"
-              formatter << "return CA_ERR_INVALID_TYPE_TAG;"
+          # pack the fields
+          formatter << "switch (dst->tag)"
+          formatter.braces do
+            having_data.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 << "return CA_OK;"
+
+            format_no_data_stubs(formatter)
+
+            formatter.backdent "default:"
+            formatter << "return CA_ERR_INVALID_TYPE_TAG;"
+            formatter << "break;"
           end
+          formatter << "return CA_OK;"
         end
 
         def struct_proto(formatter)

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

@@ -16,17 +16,11 @@ module Cauterize
         end
 
         def packer_defn(formatter)
-          formatter << packer_sig
-          formatter.braces do
-            formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
-          end
+          formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
         end
 
         def unpacker_defn(formatter)
-          formatter << unpacker_sig
-          formatter.braces do
-            formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
-          end
+          formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
         end
       end
     end

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

@@ -14,57 +14,51 @@ module Cauterize
           size_type_builder = Builders.get(:c, @blueprint.size_type)
           array_type_builder = Builders.get(:c, @blueprint.array_type)
 
-          formatter << packer_sig
+          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 << "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;"
+            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 << 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
+          formatter << "CAUTERIZE_STATUS_T err;"
+          formatter << "size_t i;"
+          formatter.blank_line
 
-            # check the length
-            formatter << "if (dst->length > ARRAY_SIZE(dst->data)) { return CA_ERR_INVALID_LENGTH; }"
-            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;"
+          # 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)

data/lib/cauterize/c_builder.rb

@@ -72,12 +72,22 @@ module Cauterize
       f << ""
       f << %Q{#include <cauterize_util.h>}
       f << %Q{#include "#{@name}.h"}
+      f.blank_line
+
+      f << %Q{/* Some extra configuration information may be provided. This is}
+      f << %Q{ * a good place for the user to put prototypes or defines used}
+      f << %Q{ * elsewhere. This is a user defined file and should be in the}
+      f << %Q{ * include search path. */}
+      f << %Q{#ifdef USE_CAUTERIZE_CONFIG_HEADER}
+      f << %Q{#include "#{@name}_config.h"}
+      f << %Q{#endif}
+      f.blank_line
 
       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) }
+      builders.each { |b| b.wrapped_packer_defn(f); f.blank_line }
+      builders.each { |b| b.wrapped_unpacker_defn(f); f.blank_line }
 
       File.open(@c, "wb") do |fh|
         fh.write(f.to_s)

data/lib/cauterize/formatter.rb

@@ -23,9 +23,13 @@ class Formatter
 
   # indent back one level
   def backdent(line)
-    @indent_level -= 1
-    @lines << indent(line)
-    @indent_level += 1
+    if 0 == @indent_level
+      @lines << line
+    else
+      @indent_level -= 1
+      @lines << indent(line)
+      @indent_level += 1
+    end
   end
 
   def append(text)

data/lib/cauterize/version.rb

@@ -1,3 +1,3 @@
 module Cauterize
-  VERSION = "0.0.1.pre11"
+  VERSION = "0.0.1.pre12"
 end

data/spec/support/shared_examples_for_c_buildables.rb

@@ -30,7 +30,7 @@ module Cauterize
 
     describe :packer_sig do
       it "looks like this" do
-        r = /CALLCONV CAUTERIZE_STATUS_T DLLDECL (?<sym>[^\(]+)\(struct Cauterize \* dst, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* src\)/
+        r = /CAUTERIZE_STATUS_T (?<sym>[^\(]+)\(struct Cauterize \* dst, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* src\)/
         subject.packer_sig.should match r
         m = subject.packer_sig.match(r)
         m[:sym].should == subject.packer_sym
@@ -45,12 +45,16 @@ module Cauterize
       end
     end
 
-    describe :packer_defn do
-      before { subject.packer_defn(formatter) }
+    describe :wrapped_packer_defn do
+      before { subject.wrapped_packer_defn(formatter) }
 
       it "contains the signature" do
         formatter.to_s.should match Regexp.escape(subject.packer_sig)
       end
+    end
+
+    describe :packer_defn do
+      before { subject.packer_defn(formatter) }
 
       it "contains a return statement" do
         formatter.to_s.should match /return.*;/
@@ -65,7 +69,7 @@ module Cauterize
 
     describe :unpacker_sig do
       it "looks like this" do
-        r = /CALLCONV CAUTERIZE_STATUS_T DLLDECL (?<sym>[^\(]+)\(struct Cauterize \* src, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* dst\)/
+        r = /CAUTERIZE_STATUS_T (?<sym>[^\(]+)\(struct Cauterize \* src, (?<rend>(?:(?:struct|enum) )?[^ ]+) \* dst\)/
         subject.unpacker_sig.should match r
         m = subject.unpacker_sig.match(r)
         m[:sym].should == subject.unpacker_sym
@@ -80,12 +84,16 @@ module Cauterize
       end
     end
 
-    describe :unpacker_defn do
-      before { subject.unpacker_defn(formatter) }
+    describe :wrapped_unpacker_defn do
+      before { subject.wrapped_unpacker_defn(formatter) }
 
       it "contains the signature" do
         formatter.to_s.should match Regexp.escape(subject.unpacker_sig)
       end
+    end
+
+    describe :unpacker_defn do
+      before { subject.unpacker_defn(formatter) }
 
       it "contains a return statement" do
         formatter.to_s.should match /return.*;/

data/support/c/src/cauterize.c

@@ -6,7 +6,7 @@
 
 #include <string.h>
 
-#define S CALLCONV CAUTERIZE_STATUS_T DLLDECL
+#define S CAUTERIZE_STATUS_T
 #define T struct Cauterize
 
 S CauterizeInitAppend(T * m, uint8_t * buffer, uint32_t length)

data/support/c/src/cauterize.h

@@ -33,22 +33,22 @@ struct Cauterize {
 extern "C" {
 #endif
 
-CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeInitAppend(
+CAUTERIZE_STATUS_T CauterizeInitAppend(
     struct Cauterize * m,
     uint8_t * buffer,
     uint32_t length);
 
-CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeInitRead(
+CAUTERIZE_STATUS_T CauterizeInitRead(
     struct Cauterize * m,
     uint8_t * buffer,
     uint32_t used);
 
-CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeAppend(
+CAUTERIZE_STATUS_T CauterizeAppend(
     struct Cauterize * m,
     uint8_t * src,
     uint32_t length);
 
-CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeRead(
+CAUTERIZE_STATUS_T CauterizeRead(
     struct Cauterize * m,
     uint8_t * dst,
     uint32_t length);

data/support/c/src/cauterize_util.h

@@ -5,45 +5,4 @@
 #define CA_MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define CA_MAX(a,b) ((a) > (b) ? (a) : (b))
 
-/* Buidling Cauterize files as a DLL. */
-
-#if defined(BUILDING_DLL) || defined(USING_DLL)
-  #if !defined(_WIN32)
-    #error "Can only build DLL in Windows."
-  #endif
-
-  #define CALLCONV __stdcall
-#endif
-
-#if defined(BUILDING_DLL)
-  #define DLLDECL __declspec(dllexport)
-#elif defined(USING_DLL)
-  #define DLLDECL __declspec(dllimport)
-#endif
-
-#ifndef DLLDECL
-#define DLLDECL
-#endif
-
-#ifndef CALLCONV
-#define CALLCONV
-#endif
-
-/* Buidling Cauterize files as a DLL. */
-
-#if defined(BUILDING_DLL)
-#define DLLDECL __declspec(dllexport)
-#elif defined(USING_DLL)
-#define DLLDECL __declspec(dllimport)
-#else
-#define DLLDECL
-#endif
-
-#if defined(_WIN32)
-#warn "building on win32"
-#define CALLCONV __stdcal
-#else
-#define CALLCONV
-#endif
-
 #endif /* CAUTERIZE_UTIL_H */

data/support/ruby/src/cauterize_ruby_baseclasses.rb

@@ -16,11 +16,13 @@ class CauterizeData
 end
 
 class CauterizeBuiltin < CauterizeData
-  attr_reader :val
   def initialize(val)
     raise "Out of range value" if not in_range(val)
     @val = val
   end
+  def to_ruby
+    @val
+  end
 end
 
 class CauterizeBuiltinInteger < CauterizeBuiltin
@@ -29,7 +31,7 @@ class CauterizeBuiltinInteger < CauterizeBuiltin
   end
 
   def to_i
-    val
+    @val
   end
 end
 
@@ -39,7 +41,7 @@ class CauterizeBuiltinFloat < CauterizeBuiltin
   end
 
   def to_f
-    val
+    @val
   end
 end
 
@@ -55,8 +57,8 @@ class CauterizeScalar < CauterizeData
     @val = self.class.builtin.construct val
   end
 
-  def val
-    @val.val
+  def to_ruby
+    @val.to_ruby
   end
 
   def pack
@@ -69,12 +71,12 @@ class CauterizeScalar < CauterizeData
 end
 
 class CauterizeArray < CauterizeData
-  def val
-    @elems.map{|e| e.val}
+  def to_ruby
+    @elems.map{|e| e.to_ruby}
   end
 
-  def to_s
-    val.to_a.pack("C*")
+  def to_string
+    to_ruby.to_a.pack("C*")
   end
 end
 
@@ -106,17 +108,13 @@ class CauterizeVariableArray < CauterizeArray
     raise "Invalid length" if @elems.length > self.class.max_length
   end
 
-  def val
-    @elems.map{|e| e.val}
-  end
-
   def pack
     @length.pack + @elems.inject("") { |sum, n| sum + n.pack }
   end
 
   def self.unpackio(str)
     length = self.size_type.unpackio(str)
-    self.new (1..length.val).map { self.elem_type.unpackio(str) }
+    self.new (1..length.to_i).map { self.elem_type.unpackio(str) }
   end
 end
 
@@ -134,8 +132,8 @@ class CauterizeComposite < CauterizeData
     end]
   end
 
-  def val
-    Hash[@fields.map{|name, value| [name, value.val]}]
+  def to_ruby
+    Hash[@fields.map{|name, value| [name, value.to_ruby]}]
   end
 
   def pack
@@ -168,11 +166,11 @@ class CauterizeEnumeration < CauterizeData
     @field_name = field_name
   end
 
-  def val
+  def to_ruby
     @field_name
   end
 
-  def val() self.class.fields[@field_name] end
+  def to_i() self.class.fields[@field_name] end
 
   def pack
     self.class.repr_type.construct(self.class.fields[@field_name]).pack
@@ -193,12 +191,12 @@ class CauterizeGroup < CauterizeData
   attr_reader :tag
   attr_reader :data
 
-  def val
+  def to_ruby
     if data.nil?
       { tag: tag_field_name }
     else
       { tag: tag_field_name,
-        data: data.val }
+        data: data.to_ruby }
     end
   end
 

data/support/ruby/src/cauterize_ruby_builtins.rb

@@ -3,7 +3,7 @@ require_relative './cauterize_ruby_baseclasses'
 class UInt8 < CauterizeBuiltinInteger
   def in_range(v) v >= 0 && v < 2**8 end
   def pack
-    [val.to_i].pack("C")
+    [to_i].pack("C")
   end
   def self.unpackio(str)
     UInt8.new str.read(1).unpack("C")[0]
@@ -13,7 +13,7 @@ end
 class UInt16 < CauterizeBuiltinInteger
   def in_range(v) v >= 0 && v < 2**16 end
   def pack
-    [val.to_i].pack("S")
+    [to_i].pack("S")
   end
   def self.unpackio(str)
     UInt16.new str.read(2).unpack("S")[0]
@@ -23,7 +23,7 @@ end
 class UInt32 < CauterizeBuiltinInteger
   def in_range(v) v >= 0 && v < 2**32 end
   def pack
-    [val.to_i].pack("L")
+    [to_i].pack("L")
   end
   def self.unpackio(str)
     UInt32.new str.read(4).unpack("L")[0]
@@ -33,7 +33,7 @@ end
 class UInt64 < CauterizeBuiltinInteger
   def in_range(v) v >= 0 && v < 2**64 end
   def pack
-    [val.to_i].pack("Q")
+    [to_i].pack("Q")
   end
   def self.unpackio(str)
     UInt64.new str.read(8).unpack("Q")[0]
@@ -43,7 +43,7 @@ end
 class Int8 < CauterizeBuiltinInteger
   def in_range(v) (v >= -2**7) && (v < 2**7) end
   def pack
-    [val.to_i].pack("c")
+    [to_i].pack("c")
   end
   def self.unpackio(str)
     Int8.new str.read(1).unpack("c")[0]
@@ -53,7 +53,7 @@ end
 class Int16 < CauterizeBuiltinInteger
   def in_range(v) (v >= -2**15) && (v < 2**15) end
   def pack
-    [val.to_i].pack("s")
+    [to_i].pack("s")
   end
   def self.unpackio(str)
     Int16.new str.read(2).unpack("s")[0]
@@ -63,7 +63,7 @@ end
 class Int32 < CauterizeBuiltinInteger
   def in_range(v) (v >= -2**31) && (v < 2**31) end
   def pack
-    [val.to_i].pack("l")
+    [to_i].pack("l")
   end
   def self.unpackio(str)
     Int32.new str.read(4).unpack("l")[0]
@@ -73,7 +73,7 @@ end
 class Int64 < CauterizeBuiltinInteger
   def in_range(v) (v >= -2**63) && (v < 2**63) end
   def pack
-    [val.to_i].pack("q")
+    [to_i].pack("q")
   end
   def self.unpackio(str)
     Int64.new str.read(8).unpack("q")[0]
@@ -101,7 +101,7 @@ end
 class Float32 < CauterizeBuiltinFloat
   def in_range(v) v > (-3.402823466e38) && v < (3.402823466e38) end
   def pack
-    [val.to_f].pack("f")
+    [to_f].pack("f")
   end
   def self.unpackio(str)
     Float32.new str.read(4).unpack("f")[0]
@@ -111,7 +111,7 @@ end
 class Float64 < CauterizeBuiltinFloat
   def in_range(v) true end
   def pack
-    [val.to_f].pack("d")
+    [to_f].pack("d")
   end
   def self.unpackio(str)
     Float64.new str.read(8).unpack("d")[0]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cauterize
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre11
+  version: 0.0.1.pre12
   prerelease: 6
 platform: ruby
 authors:
@@ -126,6 +126,9 @@ files:
 - cauterize.gemspec
 - example/Cauterize
 - example/build.sh
+- example/c_example_support/empty_main.c
+- example/c_example_support/example_project_config.c
+- example/c_example_support/example_project_config.h
 - example/ruby_ex.rb
 - lib/cauterize.rb
 - lib/cauterize/base_type.rb
@@ -263,7 +266,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3567501395549835058
+      hash: 2978929199543110981
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: