cauterize 0.0.1.pre1 → 0.0.1.pre5

data/spec/support/shared_examples_for_c_buildables.rb

@@ -1,91 +1,95 @@
 # shared examples for c buildables
 
-include Cauterize::Builders::C
+module Cauterize
+  include Cauterize::Builders::C
 
-shared_examples "a buildable" do
-  let(:desc_instance) { type_constructor.call(:some_type_name) }
-  let(:formatter) { default_formatter }
-  let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
-  subject { described_class.new(desc_instance) }
+  shared_examples "a buildable" do
+    let(:desc_instance) { type_constructor.call(:some_type_name) }
+    let(:formatter) { default_formatter }
+    let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
+    subject { described_class.new(desc_instance) }
 
-  it "should be registered" do
-    builder.class.should be described_class
-  end
+    it "should be registered" do
+      builder.class.should be described_class
+    end
 
-  it "errors on duplicate type names" do
-    BaseType.class_variable_set(:@@used_names, Set.new([:a_common_name]))
-    lambda {
-      type_constructor.call(:a_common_name)
-    }.should raise_error /already exists/
-  end
+    it "errors on duplicate type names" do
+      instances = BaseType.class_variable_get(:@@instances)
+      instances[:a_common_name] = nil
+      BaseType.class_variable_set(:@@instances, instances)
+      lambda {
+        type_constructor.call(:a_common_name)
+      }.should raise_error /already exists/
+    end
 
-  describe :packer_sym do
-    it "contains the word Pack" do
-      subject.packer_sym.should match /Pack_/
+    describe :packer_sym do
+      it "contains the word Pack" do
+        subject.packer_sym.should match /Pack_/
+      end
     end
-  end
 
-  describe :packer_sig do
-    it "looks like this" do
-      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
-      m[:rend].should == subject.render
+    describe :packer_sig do
+      it "looks like this" do
+        r = /CALLCONV CAUTERIZE_STATUS_T DLLDECL (?<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
+        m[:rend].should == subject.render
+      end
     end
-  end
 
-  describe :packer_proto do
-    it "should format the sig + ;" do
-      subject.packer_proto(formatter)
-      formatter.to_s.should == subject.packer_sig + ";"
+    describe :packer_proto do
+      it "should format the sig + ;" do
+        subject.packer_proto(formatter)
+        formatter.to_s.should == subject.packer_sig + ";"
+      end
     end
-  end
 
-  describe :packer_defn do
-    before { subject.packer_defn(formatter) }
+    describe :packer_defn do
+      before { subject.packer_defn(formatter) }
 
-    it "contains the signature" do
-      formatter.to_s.should match Regexp.escape(subject.packer_sig)
-    end
+      it "contains the signature" do
+        formatter.to_s.should match Regexp.escape(subject.packer_sig)
+      end
 
-    it "contains a return statement" do
-      formatter.to_s.should match /return.*;/
+      it "contains a return statement" do
+        formatter.to_s.should match /return.*;/
+      end
     end
-  end
 
-  describe :unpacker_sym do
-    it "contains the word Unpack" do
-      subject.unpacker_sym.should match /Unpack_/
+    describe :unpacker_sym do
+      it "contains the word Unpack" do
+        subject.unpacker_sym.should match /Unpack_/
+      end
     end
-  end
 
-  describe :unpacker_sig do
-    it "looks like this" do
-      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
-      m[:rend].should == subject.render
+    describe :unpacker_sig do
+      it "looks like this" do
+        r = /CALLCONV CAUTERIZE_STATUS_T DLLDECL (?<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
+        m[:rend].should == subject.render
+      end
     end
-  end
 
-  describe :unpacker_proto do
-    it "should format the sig + ;" do
-      subject.unpacker_proto(formatter)
-      formatter.to_s.should == subject.unpacker_sig + ";"
+    describe :unpacker_proto do
+      it "should format the sig + ;" do
+        subject.unpacker_proto(formatter)
+        formatter.to_s.should == subject.unpacker_sig + ";"
+      end
     end
-  end
 
-  describe :unpacker_defn do
-    before { subject.unpacker_defn(formatter) }
+    describe :unpacker_defn do
+      before { subject.unpacker_defn(formatter) }
 
-    it "contains the signature" do
-      formatter.to_s.should match Regexp.escape(subject.unpacker_sig)
-    end
+      it "contains the signature" do
+        formatter.to_s.should match Regexp.escape(subject.unpacker_sig)
+      end
 
-    it "contains a return statement" do
-      formatter.to_s.should match /return.*;/
+      it "contains a return statement" do
+        formatter.to_s.should match /return.*;/
+      end
     end
   end
 end

data/spec/variable_array_spec.rb

@@ -1,26 +1,20 @@
-describe Cauterize do
-  before { reset_for_test }
-
+module Cauterize
   describe :variable_array  do
     it { creates_a_named_object(:variable_array, VariableArray) }
     it { retrieves_obj_with_identical_name(:variable_array) }
     it { yields_the_object(:variable_array) }
-    it { adds_object_to_hash(:variable_array, :variable_arrays) }
+    it { adds_object_to_hash(:variable_array, Cauterize.variable_arrays) }
   end
 
   describe :variable_array! do
     it { creates_a_named_object(:variable_array!, VariableArray) }
     it { raises_exception_with_identical_name(:variable_array!) }
     it { yields_the_object(:variable_array!) }
-    it { adds_object_to_hash(:variable_array!, :variable_arrays) }
+    it { adds_object_to_hash(:variable_array!, Cauterize.variable_arrays) }
   end
 
   describe :variable_arrays do
-    it "is all the variable arrays" do
-      variable_array(:a)
-      variable_array(:b)
-      variable_arrays.values.map(&:name).should == [:a, :b]
-    end
+    it { is_hash_of_created_objs(:variable_array, Cauterize.variable_arrays) }
   end
 
   describe VariableArray do
@@ -34,21 +28,21 @@ describe Cauterize do
 
     describe :array_type do
       it "defines the type of the VariableArray" do
-        scalar(:uint32_t)
+        Cauterize.scalar(:uint32_t)
         @a.array_type :uint32_t
         @a.instance_variable_get(:@array_type).name.should == :uint32_t
       end
 
       it "raises an error if type doesn't exist" do
         lambda {
-          fixed_array(:fa) do |f|
+          Cauterize.fixed_array(:fa) do |f|
             f.array_type :lol
           end
         }.should raise_error /lol does not correspond/
       end
 
       it "is the defined type if no argument is passed" do
-        s = scalar(:uint32_t)
+        s = Cauterize.scalar(:uint32_t)
         @a.array_type :uint32_t
         @a.array_type.should be s
       end
@@ -68,7 +62,7 @@ describe Cauterize do
 
     describe :size_type do
       it "defines the type to use to encode the array size" do
-        scalar(:uint16_t)
+        Cauterize.scalar(:uint16_t)
         @a.size_type :uint16_t
         @a.instance_variable_get(:@size_type).name.should == :uint16_t
       end
@@ -78,12 +72,13 @@ describe Cauterize do
       end
 
       it "raises an error if the type isn't an scalar" do
-        enumeration(:lol)
-        lambda { @a.size_type :lol }.should raise_error /is not an scalar/
+        Cauterize.scalar(:uint32_t) { |t| t.type_name(:uint32) }
+        Cauterize.enumeration(:lol)
+        lambda { @a.size_type :lol }.should raise_error /is not a built-in or scalar/
       end
 
       it "is the defined type if no argument is passed" do
-        s = scalar(:uint32_t)
+        s = Cauterize.scalar(:uint32_t)
         @a.size_type :uint32_t
         @a.size_type.should be s
       end

data/{c → support/c}/src/cauterize.c

@@ -1,14 +1,15 @@
 #define CAUTERIZE_C
 
 #include "cauterize.h"
+#include "cauterize_util.h"
 #include "cauterize_debug.h"
 
 #include <string.h>
 
-#define S CAUTERIZE_STATUS_T
+#define S CALLCONV CAUTERIZE_STATUS_T DLLDECL
 #define T struct Cauterize
 
-S CauterizeInitAppend( struct Cauterize * m, uint8_t * buffer, size_t length)
+S CauterizeInitAppend(T * m, uint8_t * buffer, uint32_t length)
 {
   CA_ASSERT(NULL != m);
   CA_ASSERT(NULL != buffer);
@@ -21,7 +22,7 @@ S CauterizeInitAppend( struct Cauterize * m, uint8_t * buffer, size_t length)
   return CA_OK;
 }
 
-S CauterizeInitRead( struct Cauterize * m, uint8_t * buffer, size_t used)
+S CauterizeInitRead(T * m, uint8_t * buffer, uint32_t used)
 {
   CA_ASSERT(NULL != m);
   CA_ASSERT(NULL != buffer);
@@ -34,12 +35,12 @@ S CauterizeInitRead( struct Cauterize * m, uint8_t * buffer, size_t used)
   return CA_OK;
 }
 
-S CauterizeAppend(T * m, uint8_t * src, size_t length)
+S CauterizeAppend(T * m, uint8_t * src, uint32_t length)
 {
   CA_ASSERT(NULL != m);
   CA_ASSERT(NULL != src);
 
-  size_t needed = m->used + length;
+  uint32_t needed = m->used + length;
 
   if (needed > m->size)
     return CA_ERR_NOT_ENOUGH_SPACE;
@@ -51,13 +52,13 @@ S CauterizeAppend(T * m, uint8_t * src, size_t length)
   return CA_OK;
 }
 
-S CauterizeRead(T * m, uint8_t * dst, size_t length)
+S CauterizeRead(T * m, uint8_t * dst, uint32_t length)
 {
   CA_ASSERT(NULL != m);
   CA_ASSERT(NULL != dst);
   CA_ASSERT(m->used >= m->pos);
 
-  size_t available = m->used - m->pos;
+  uint32_t available = m->used - m->pos;
 
   if (length > available)
     return CA_ERR_NOT_ENOUGH_DATA;

data/support/c/src/cauterize.h

@@ -0,0 +1,59 @@
+#ifndef CAUTERIZE_H
+#define CAUTERIZE_H
+
+#ifndef CUSTOM_TYPES
+  #include <stdint.h>
+  #include <stddef.h>
+#else
+  #include "cauterize_custom_types.h"
+#endif
+
+#include "cauterize_util.h"
+
+typedef enum cauterize_status {
+  CA_OK = 0,
+  CA_ERR_ASSERT = 1,
+  CA_ERR_NOT_ENOUGH_SPACE = 2,
+  CA_ERR_NOT_ENOUGH_DATA = 3,
+  CA_ERR_INVALID_LENGTH = 4,
+  CA_ERR_INVALUD_TYPE_TAG = 5,
+  CA_ERR_INVALID_ENUM_VAL = 6,
+  CA_ERR_GENERAL = UINT32_MAX,
+} CAUTERIZE_STATUS_T;
+
+struct Cauterize {
+  uint32_t size; // Size of the buffer in bytes
+  uint32_t used; // Number of used bytes in the buffer
+  uint32_t pos; // The next byte to be read
+  uint8_t * buffer; // Buffer to hold data
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeInitAppend(
+    struct Cauterize * m,
+    uint8_t * buffer,
+    uint32_t length);
+
+CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeInitRead(
+    struct Cauterize * m,
+    uint8_t * buffer,
+    uint32_t used);
+
+CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeAppend(
+    struct Cauterize * m,
+    uint8_t * src,
+    uint32_t length);
+
+CALLCONV CAUTERIZE_STATUS_T DLLDECL CauterizeRead(
+    struct Cauterize * m,
+    uint8_t * dst,
+    uint32_t length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CAUTERIZE_H */

data/support/c/src/cauterize_util.h

@@ -0,0 +1,49 @@
+#ifndef CAUTERIZE_UTIL_H
+#define CAUTERIZE_UTIL_H
+
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#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/cs/src/CauterizeCompositeFormatter.cs

@@ -0,0 +1,34 @@
+using System;
+using System.IO;
+
+namespace Cauterize
+{
+    public class CauterizeCompositeFormatter : CauterizeContainerFormatter
+    {
+        public CauterizeCompositeFormatter(CauterizeTypeFormatterFactory factory) : base(factory)
+        {
+        }
+        public override object Deserialize(Stream serializationStream, Type t)
+        {
+            var ret = t.GetConstructor(new Type[] {}).Invoke(new object[] {});
+            foreach (var prop in OrderAttribute.GetSortedProperties(t))
+            {
+                var subType = prop.PropertyType;
+                var subFormatter = _typeFormatterFactory.GetFormatter(subType);
+                var subObj = subFormatter.Deserialize(serializationStream, subType);
+                prop.SetValue(ret, subObj, null);
+            }
+            return ret;
+        }
+
+        public override void Serialize(Stream serializationStream, object obj)
+        {
+            foreach (var prop in OrderAttribute.GetSortedProperties(obj.GetType()))
+            {
+                var subType = prop.PropertyType;
+                var subFormatter = _typeFormatterFactory.GetFormatter(subType);
+                subFormatter.Serialize(serializationStream, prop.GetValue(obj, null));
+            }
+        }
+    }
+}