cauterize 0.0.1.pre13 → 0.0.1.pre14

data/spec/support/shared_examples_for_sane_c_buildables.rb

@@ -1,22 +1,22 @@
-include Cauterize::Builders::C
-
-shared_examples "a sane buildable" do
-  let(:desc_instance) { type_constructor.call(:some_type_name) }
-  let(:formatter) { default_formatter }
-  subject { described_class.new(desc_instance) }
-
-  describe :render do
-    it "contains the name" do
-      subject.render.should match /some_type_name/
-    end
-  end
-
-  describe :declare do
-    before { subject.declare(formatter, :some_sym) }
-
-    it "contains the name and a ;" do
-      formatter.to_s.should match /some_type_name/
-      formatter.to_s.should match /;/
-    end
-  end
-end
+include Cauterize::Builders::C
+
+shared_examples "a sane buildable" do
+  let(:desc_instance) { type_constructor.call(:some_type_name) }
+  let(:formatter) { default_formatter }
+  subject { described_class.new(desc_instance) }
+
+  describe :render do
+    it "contains the name" do
+      subject.render.should match /some_type_name/
+    end
+  end
+
+  describe :declare do
+    before { subject.declare(formatter, :some_sym) }
+
+    it "contains the name and a ;" do
+      formatter.to_s.should match /some_type_name/
+      formatter.to_s.should match /;/
+    end
+  end
+end

data/spec/support/shared_examples_for_stubbed_functions.rb

@@ -1,18 +1,18 @@
-# shared examples for stubbed functions
-
-include Cauterize::Builders::C
-
-shared_examples "no struct" do
-  let(:desc_instance) { type_constructor.call(:some_type_name) }
-  let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
-
-  it {  builder.struct_proto(:f).should be_nil }
-  it {  builder.struct_defn(:f).should be_nil }
-end
-
-shared_examples "no enum" do
-  let(:desc_instance) { type_constructor.call(:some_type_name) }
-  let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
-
-  it {  builder.enum_defn(:f).should be_nil }
-end
+# shared examples for stubbed functions
+
+include Cauterize::Builders::C
+
+shared_examples "no struct" do
+  let(:desc_instance) { type_constructor.call(:some_type_name) }
+  let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
+
+  it {  builder.struct_proto(:f).should be_nil }
+  it {  builder.struct_defn(:f).should be_nil }
+end
+
+shared_examples "no enum" do
+  let(:desc_instance) { type_constructor.call(:some_type_name) }
+  let(:builder) { Cauterize::Builders.get(:c, desc_instance) }
+
+  it {  builder.enum_defn(:f).should be_nil }
+end

data/spec/support/spec_sample_model.rb

@@ -1,74 +1,74 @@
-module Cauterize
-  module CauterizeHelpers
-    def gen_a_model
-      Cauterize.scalar(:foo) do |t|
-        t.type_name :uint8
-      end
-
-      Cauterize.enumeration(:color) do |e|
-        e.value :red
-        e.value :blue
-        e.value :green
-      end
-
-      Cauterize.fixed_array(:color_list) do |a|
-        a.array_type :color
-        a.array_size 41
-      end
-
-      Cauterize.variable_array(:int8_list) do |a|
-        a.array_type :int8
-        a.array_size 200
-      end
-
-      Cauterize.composite(:two_things) do |t|
-        t.field :thing_1, :uint8
-        t.field :thing_2, :uint16
-      end
-
-      Cauterize.group(:one_of_everything) do |t|
-        t.field :a_foo, :foo
-        t.field :a_color, :color
-        t.field :a_color_list, :color_list
-        t.field :an_int8_list, :int8_list
-        t.field :a_two_things, :two_things
-      end
-    end
-
-    def gen_b_model
-      Cauterize.scalar(:foo) do |t|
-        t.type_name :uint8
-      end
-
-      Cauterize.enumeration(:color) do |e|
-        e.value :red
-        e.value :blue
-        e.value :green
-      end
-
-      Cauterize.fixed_array(:color_list) do |a|
-        a.array_type :color
-        a.array_size 41
-      end
-
-      Cauterize.variable_array(:int8_list) do |a|
-        a.array_type :int8
-        a.array_size 2000
-      end
-
-      Cauterize.composite(:two_things) do |t|
-        t.field :thing_1, :uint8
-        t.field :thing_2, :uint16
-      end
-
-      Cauterize.group(:one_of_everything) do |t|
-        t.field :a_foo, :foo
-        t.field :a_color, :color
-        t.field :a_color_list, :color_list
-        t.field :an_int8_list, :int8_list
-        t.field :a_two_things, :two_things
-        t.dataless :emptyness
-      end
-    end
-  end
-end
+module Cauterize
+  module CauterizeHelpers
+    def gen_a_model
+      Cauterize.scalar(:foo) do |t|
+        t.type_name :uint8
+      end
+
+      Cauterize.enumeration(:color) do |e|
+        e.value :red
+        e.value :blue
+        e.value :green
+      end
+
+      Cauterize.fixed_array(:color_list) do |a|
+        a.array_type :color
+        a.array_size 41
+      end
+
+      Cauterize.variable_array(:int8_list) do |a|
+        a.array_type :int8
+        a.array_size 200
+      end
+
+      Cauterize.composite(:two_things) do |t|
+        t.field :thing_1, :uint8
+        t.field :thing_2, :uint16
+      end
+
+      Cauterize.group(:one_of_everything) do |t|
+        t.field :a_foo, :foo
+        t.field :a_color, :color
+        t.field :a_color_list, :color_list
+        t.field :an_int8_list, :int8_list
+        t.field :a_two_things, :two_things
+      end
+    end
+
+    def gen_b_model
+      Cauterize.scalar(:foo) do |t|
+        t.type_name :uint8
+      end
+
+      Cauterize.enumeration(:color) do |e|
+        e.value :red
+        e.value :blue
+        e.value :green
+      end
+
+      Cauterize.fixed_array(:color_list) do |a|
+        a.array_type :color
+        a.array_size 41
+      end
+
+      Cauterize.variable_array(:int8_list) do |a|
+        a.array_type :int8
+        a.array_size 2000
+      end
+
+      Cauterize.composite(:two_things) do |t|
+        t.field :thing_1, :uint8
+        t.field :thing_2, :uint16
+      end
+
+      Cauterize.group(:one_of_everything) do |t|
+        t.field :a_foo, :foo
+        t.field :a_color, :color
+        t.field :a_color_list, :color_list
+        t.field :an_int8_list, :int8_list
+        t.field :a_two_things, :two_things
+        t.dataless :emptyness
+      end
+    end
+  end
+end

data/spec/test_main.c

@@ -1,13 +1,13 @@
-#include "testing.h"
-
-int main(int argc, char * argv[])
-{
-  (void)argc;
-  (void)argv;
-
-  void * ptr;
-
-  ptr = (void *)Pack_enum_group_animal_type;
-
-  return 0;
-}
+#include "testing.h"
+
+int main(int argc, char * argv[])
+{
+  (void)argc;
+  (void)argv;
+
+  void * ptr;
+
+  ptr = (void *)Pack_enum_group_animal_type;
+
+  return 0;
+}

data/spec/variable_array_spec.rb

@@ -1,73 +1,73 @@
-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, 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!, Cauterize.variable_arrays) }
-  end
-
-  describe :variable_arrays do
-    it { is_hash_of_created_objs(:variable_array, Cauterize.variable_arrays) }
-  end
-
-  describe VariableArray do
-    before { @a = VariableArray.new(:foo) }
-
-    describe :initialize do
-      it "creates a VariableArray" do
-        @a.name.should == :foo
-      end
-    end
-
-    describe :array_type do
-      it "defines the type of the VariableArray" do
-        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 {
-          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 = Cauterize.scalar(:uint32_t)
-        @a.array_type :uint32_t
-        @a.array_type.should be s
-      end
-    end
-
-    describe :array_size do
-      it "Defines the size of the FixedArray." do
-        @a.array_size 46
-        @a.instance_variable_get(:@array_size).should == 46
-      end
-
-      it "is the defined size if no argument is passed" do
-        @a.array_size 46
-        @a.array_size.should == 46
-      end
-    end
-
-    describe :size_type do
-      it "determines the type used to encode the array size" do
-        @a.array_size 30000
-        @a.size_type.name.should == :uint16
-
-        @a.array_size 10
-        @a.size_type.name.should == :uint8
-      end
-    end
-  end
-end
+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, 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!, Cauterize.variable_arrays) }
+  end
+
+  describe :variable_arrays do
+    it { is_hash_of_created_objs(:variable_array, Cauterize.variable_arrays) }
+  end
+
+  describe VariableArray do
+    before { @a = VariableArray.new(:foo) }
+
+    describe :initialize do
+      it "creates a VariableArray" do
+        @a.name.should == :foo
+      end
+    end
+
+    describe :array_type do
+      it "defines the type of the VariableArray" do
+        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 {
+          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 = Cauterize.scalar(:uint32_t)
+        @a.array_type :uint32_t
+        @a.array_type.should be s
+      end
+    end
+
+    describe :array_size do
+      it "Defines the size of the FixedArray." do
+        @a.array_size 46
+        @a.instance_variable_get(:@array_size).should == 46
+      end
+
+      it "is the defined size if no argument is passed" do
+        @a.array_size 46
+        @a.array_size.should == 46
+      end
+    end
+
+    describe :size_type do
+      it "determines the type used to encode the array size" do
+        @a.array_size 30000
+        @a.size_type.name.should == :uint16
+
+        @a.array_size 10
+        @a.size_type.name.should == :uint8
+      end
+    end
+  end
+end

data/support/c/src/cauterize.c

@@ -1,75 +1,75 @@
-#define CAUTERIZE_C
-
-#include "cauterize.h"
-#include "cauterize_util.h"
-#include "cauterize_debug.h"
-
-#include <string.h>
-
-#define S CAUTERIZE_STATUS_T
-#define T struct Cauterize
-
-S CauterizeInitAppend(T * m, uint8_t * buffer, uint32_t length)
-{
-  CA_ASSERT(NULL != m);
-  CA_ASSERT(NULL != buffer);
-
-  m->size = length;
-  m->used = 0;
-  m->pos = 0;
-  m->buffer = buffer;
-
-  return CA_OK;
-}
-
-S CauterizeInitRead(T * m, uint8_t * buffer, uint32_t used)
-{
-  CA_ASSERT(NULL != m);
-  CA_ASSERT(NULL != buffer);
-
-  m->size = used;
-  m->used = used;
-  m->pos = 0;
-  m->buffer = buffer;
-
-  return CA_OK;
-}
-
-S CauterizeAppend(T * m, uint8_t * src, uint32_t length)
-{
-  CA_ASSERT(NULL != m);
-  CA_ASSERT(NULL != src);
-
-  uint32_t needed = m->used + length;
-
-  if (needed > m->size)
-    return CA_ERR_NOT_ENOUGH_SPACE;
-
-  uint8_t * dest = &m->buffer[m->used];
-  memcpy(dest, src, length);
-  m->used += length;
-
-  return CA_OK;
-}
-
-S CauterizeRead(T * m, uint8_t * dst, uint32_t length)
-{
-  CA_ASSERT(NULL != m);
-  CA_ASSERT(NULL != dst);
-  CA_ASSERT(m->used >= m->pos);
-
-  uint32_t available = m->used - m->pos;
-
-  if (length > available)
-    return CA_ERR_NOT_ENOUGH_DATA;
-
-  uint8_t * src = &m->buffer[m->pos];
-  memcpy(dst, src, length);
-  m->pos += length;
-
-  return CA_OK;
-}
-
-#undef S
-#undef T
-#undef CAUTERIZE_C
+#define CAUTERIZE_C
+
+#include "cauterize.h"
+#include "cauterize_util.h"
+#include "cauterize_debug.h"
+
+#include <string.h>
+
+#define S CAUTERIZE_STATUS_T
+#define T struct Cauterize
+
+S CauterizeInitAppend(T * m, uint8_t * buffer, uint32_t length)
+{
+  CA_ASSERT(NULL != m);
+  CA_ASSERT(NULL != buffer);
+
+  m->size = length;
+  m->used = 0;
+  m->pos = 0;
+  m->buffer = buffer;
+
+  return CA_OK;
+}
+
+S CauterizeInitRead(T * m, uint8_t * buffer, uint32_t used)
+{
+  CA_ASSERT(NULL != m);
+  CA_ASSERT(NULL != buffer);
+
+  m->size = used;
+  m->used = used;
+  m->pos = 0;
+  m->buffer = buffer;
+
+  return CA_OK;
+}
+
+S CauterizeAppend(T * m, uint8_t * src, uint32_t length)
+{
+  CA_ASSERT(NULL != m);
+  CA_ASSERT(NULL != src);
+
+  uint32_t needed = m->used + length;
+
+  if (needed > m->size)
+    return CA_ERR_NOT_ENOUGH_SPACE;
+
+  uint8_t * dest = &m->buffer[m->used];
+  memcpy(dest, src, length);
+  m->used += length;
+
+  return CA_OK;
+}
+
+S CauterizeRead(T * m, uint8_t * dst, uint32_t length)
+{
+  CA_ASSERT(NULL != m);
+  CA_ASSERT(NULL != dst);
+  CA_ASSERT(m->used >= m->pos);
+
+  uint32_t available = m->used - m->pos;
+
+  if (length > available)
+    return CA_ERR_NOT_ENOUGH_DATA;
+
+  uint8_t * src = &m->buffer[m->pos];
+  memcpy(dst, src, length);
+  m->pos += length;
+
+  return CA_OK;
+}
+
+#undef S
+#undef T
+#undef CAUTERIZE_C