cauterize 0.0.1.pre1

data/c/test/test.c

@@ -0,0 +1,166 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "cauterize.h"
+#include "greatest.h"
+
+GREATEST_MAIN_DEFS();
+
+TEST t_CauterizeInitAppend_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
+
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(m.size, 64);
+  ASSERT_EQ(m.used, 0);
+  ASSERT_EQ(m.pos, 0);
+
+  PASS();
+}
+
+TEST t_CauterizeInitRead_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+
+  s = CauterizeInitRead(&m, buffer, 13);
+
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(m.size, 13);
+  ASSERT_EQ(m.used, 13);
+  ASSERT_EQ(m.pos, 0);
+
+  PASS();
+}
+
+TEST t_CauterizeAppend_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
+  ASSERT_EQ(CA_OK, s);
+
+  s = CauterizeAppend(&m, (uint8_t*)data, sizeof(data));
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(m.used, sizeof(data));
+  ASSERT_STR_EQ(data, (char*)m.buffer);
+
+  PASS();
+}
+
+TEST t_CauterizeAppend_works_again() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+
+  char data_1[3] = "ABC";
+  char data_2[] = "DEF";
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(buffer));
+  ASSERT_EQ(CA_OK, s);
+
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data_1, sizeof(data_1)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data_2, sizeof(data_2)));
+
+  ASSERT_EQ(sizeof(data_1) + sizeof(data_2), m.used);
+  ASSERT_STR_EQ("ABCDEF", (char*)m.buffer);
+
+  PASS();
+}
+
+TEST t_CauterizeAppend_checks_space_needs() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  s = CauterizeInitAppend(&m, buffer, sizeof(data) - 5);
+  ASSERT_EQ(CA_OK, s);
+
+  s = CauterizeAppend(&m, (uint8_t*)data, sizeof(data));
+  ASSERT_EQ(CA_ERR_NOT_ENOUGH_SPACE, s);
+  ASSERT_EQ(m.used, 0);
+
+  PASS();
+}
+
+TEST t_CauterizeRead_works() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  struct Cauterize n;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
+
+  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
+
+  char dest[64] = {0};
+
+  s = CauterizeRead(&n, (uint8_t*)dest, 5);
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(5, n.pos);
+  ASSERT_STR_EQ("Hello", dest);
+
+  PASS();
+}
+
+TEST t_CauterizeRead_works_again() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  struct Cauterize n;
+  uint8_t buffer[64] = { 0 };
+  char data[] = "Hello World";
+
+  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
+
+  char dest[64] = {0};
+
+  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
+  ASSERT_EQ(CA_OK, CauterizeRead(&n, (uint8_t*)dest, 5));
+
+  s = CauterizeRead(&n, (uint8_t*)dest, 6);
+  ASSERT_EQ(CA_OK, s);
+  ASSERT_EQ(11, n.pos);
+  ASSERT_STR_EQ(" World", dest);
+
+  PASS();
+}
+
+TEST t_CauterizeRead_checks_data_needs() {
+  CAUTERIZE_STATUS_T s = CA_ERR_GENERAL;
+  struct Cauterize m;
+  struct Cauterize n;
+  uint8_t buffer[32] = { 0 };
+  char data[] = "Hello World";
+
+  ASSERT_EQ(CA_OK, CauterizeInitAppend(&m, buffer, sizeof(buffer)));
+  ASSERT_EQ(CA_OK, CauterizeAppend(&m, (uint8_t*)data, sizeof(data)));
+
+  char dest[64] = {0};
+
+  ASSERT_EQ(CA_OK, CauterizeInitRead(&n, buffer, m.used));
+  s = CauterizeRead(&n, (uint8_t*)dest, sizeof(dest));
+  ASSERT_EQ(CA_ERR_NOT_ENOUGH_DATA, s);
+  ASSERT_EQ(0, n.pos);
+
+  PASS();
+}
+
+GREATEST_SUITE(marshal) {
+/* test_suite.c is generated programatically by the Rakefile */
+#include "test_suite.c"
+}
+
+int main(int argc, char * argv[]) {
+  GREATEST_MAIN_BEGIN();
+  RUN_SUITE(marshal);
+  GREATEST_MAIN_END();
+}

data/cauterize.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cauterize/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cauterize"
+  gem.version       = Cauterize::VERSION
+  gem.authors       = ["John Van Enk"]
+  gem.email         = ["vanenkj@gmail.com"]
+  gem.summary       = %q{Tools to generate structures and mashalers suitable for static-memory environments.}
+  gem.description   = %q{Tools to generate C structures and marshalers with a Ruby DSL.}
+  gem.homepage      = "https://github.com/sw17ch/cauterize"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'rake',        '>= 0.9.2.0'
+  gem.add_dependency 'thor',        '>= 0.16.0'
+  gem.add_dependency 'require_all', '>= 1.2.1'
+
+  gem.add_development_dependency 'rspec', '>= 2.12.0'
+  gem.add_development_dependency 'mocha', '>= 0.13.0'
+end

data/example/Cauterize

@@ -0,0 +1,44 @@
+set_name("example_project")
+
+scalar(:int8_t)
+scalar(:int16_t)
+scalar(:int32_t)
+scalar(:int64_t)
+scalar(:uint8_t)
+scalar(:uint16_t)
+scalar(:uint32_t)
+scalar(:uint64_t)
+
+enumeration(:color) do |e|
+  e.value :red
+  e.value :blue
+  e.value :green
+end
+
+fixed_array(:color_list) do |a|
+  a.array_type :color
+  a.array_size 4
+end
+
+variable_array(:numbers) do |a|
+  a.size_type  :uint8_t
+  a.array_type :int32_t
+  a.array_size 128
+end
+
+composite(:nonsensical) do |c|
+  c.field :color, :color
+  c.field :color_list, :color_list
+  c.field :numbers, :numbers
+end
+
+composite(:crazy) do |c|
+  c.field :first_numbers, :numbers
+  c.field :second_numbers, :numbers
+  c.field :third_numbers, :numbers
+end
+
+group(:insanity) do |g|
+  g.field :nonsensical, :nonsensical
+  g.field :crazy, :crazy
+end

data/example/build.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+rm -rf cauterize_output
+../bin/cauterize generate c cauterize_output

data/lib/cauterize/base_type.rb

@@ -0,0 +1,96 @@
+require 'set'
+
+module Cauterize
+  class BaseType
+    attr_reader :name, :id
+    @@next_id = {}
+    @@instances = {}
+    @@used_names = Set.new
+
+    def initialize(name)
+      if @@used_names.include?(name)
+        raise Exception.new("A type with the name #{name} already exists.")
+      else
+        @@used_names << name
+      end
+
+      @name = name
+      @id = next_id
+      register_instance(self)
+    end
+
+    def type
+      tag_part = ((tag << BaseType.id_bit_width) & BaseType.tag_bit_mask)
+      id_part  = (id & BaseType.id_bit_mask)
+      (tag_part | id_part) & BaseType.type_bit_mask
+    end
+
+    def type_str
+      "0x%04X" % type
+    end
+
+    def tag
+      cname = self.class.name
+      case cname
+      when "Cauterize::Scalar";        0
+      when "Cauterize::Enumeration";   1
+      when "Cauterize::Composite";     2
+      when "Cauterize::FixedArray";    3
+      when "Cauterize::VariableArray"; 4
+      when "Cauterize::Group";         5
+      else
+        raise Exception.new("Tag not defined for #{cname}.")
+      end
+    end
+
+    def self.tag_bit_mask;  0xE000 end
+    def self.tag_bit_width;      3 end
+    def self.id_bit_mask;   0x1FFF end
+    def self.id_bit_width;      13 end
+    def self.type_bit_mask; 0xFFFF end
+    def self.type_bit_width; tag_bit_width + id_bit_width end
+    def self.all_instances; @@instances.values end
+
+    def self.find_type(name)
+      @@instances[name]
+    end
+
+    def self.find_type!(name)
+      unless t = find_type(name)
+        raise Exception.new("The name #{name} does not correspond to a type.")
+      else
+        return t
+      end
+    end
+
+    alias :orig_method_missing :method_missing
+
+    def method_missing(sym, *args)
+      m = sym.to_s.match /is_([^\?]+)\?/
+      if m
+        return ("Cauterize::#{m[1].camel}" == self.class.name)
+      else
+        orig_method_missing(sym, *args)
+      end
+    end
+
+    protected
+
+    def register_instance(inst)
+      if @@instances[inst.name]
+        raise Exception.new("Type with name #{inst.name} already defined.")
+      end
+
+      @@instances[inst.name] = inst
+    end
+
+    def next_id
+      cname = self.class.name
+      @@next_id[cname] ||= 0
+
+      an_id = @@next_id[cname]
+      @@next_id[cname] += 1
+      return an_id
+    end
+  end
+end

data/lib/cauterize/builders.rb

@@ -0,0 +1,27 @@
+module Cauterize
+  module Builders
+    class UnregisteredException < Exception; end
+    class DuplicateException < Exception; end
+
+    module_function
+
+    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)
+      if @builders and @builders[language]
+        @builders[language][description_instance.class].new(description_instance)
+      else
+        raise UnregisteredException.new("The builder for #{description_instance.class} in #{language} is unregistered.")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+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
+
+        # 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 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/composite.rb

@@ -0,0 +1,55 @@
+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 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;"
+          end
+        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;"
+          end
+        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)