cauterize 0.0.1.pre1 → 0.0.1.pre5

data/.gitignore

@@ -22,3 +22,8 @@ pkg
 
 # Examples
 example/cauterize_output
+example/c_cauterize_output
+example/cs_cauterize_output
+
+# Nunit test results
+TestResult.xml

data/.rspec

@@ -1 +1 @@
--r spec_helper --color
+-r spec_helper

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in cauterize.gemspec
 gemspec

data/README.md

@@ -1,5 +1,3 @@
-# *THIS PROJECT IS EXPERIMENTAL. IT MAY BREAK AND RUIN EVERYTHING YOU KNOW AND LOVE.*
-
 # cauterize
 
 A Ruby DSL for generating marshalable structured data easily compatable with

data/Rakefile

@@ -1,4 +1,5 @@
 require 'tmpdir'
+require 'fileutils'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
@@ -13,20 +14,35 @@ task :greatest do
     test_suite_path = File.join(d, "test_suite.c")
     mk_test_suite_file(test_suite_path)
 
-    args = "-Wall -Wextra -Werror -Ic/test -Ic/src -I#{d}"
-    srcs = "c/src/cauterize.c c/test/test.c"
+    args = "-Wall -Wextra -Werror -Isupport/c/test -Isupport/c/src -I#{d}"
+    srcs = "support/c/src/cauterize.c support/c/test/test.c"
     bin = File.join(d, "test.bin")
     sh "gcc #{args} #{srcs} -o #{bin}"
     sh bin
   end
 end
 
+desc "Run C# tests"
+task :nunit do
+  cd "support/cs" do
+    FileUtils.mkdir_p "lib"
+    sh "dmcs -target:library -out:lib/Cauterize.dll src/*.cs"
+    references = "-r:lib/nunit.framework.dll -r:lib/Moq.dll -r:lib/Cauterize.dll"
+    sh "dmcs -target:library #{references} -out:lib/Cauterize.Test.dll test/*.cs"
+    sh "#{nunit} lib/*.dll"
+  end
+end
+
+def nunit
+  "nunit-console4"
+end
+
 # Support Methods
 
 SUITE_ENTRY_TEMPLATE = "  RUN_TEST(%s);"
 
 def mk_test_suite_file(path)
-  test_files = Dir["c/test/*.c"]
+  test_files = Dir["support/c/test/*.c"]
   suite_text = test_files.map do |test_file|
     File.read(test_file).lines.map do |l|
       m = l.match(/^TEST (?<sym>[^\(]+)\(\)/)

data/bin/cauterize

@@ -1,7 +1,6 @@
 #!/usr/bin/env ruby
 
 LIB_PATH = File.dirname(__FILE__) + "/../lib"
-C_PATH = File.dirname(__FILE__) + "/../c/src"
 
 $LOAD_PATH.unshift LIB_PATH
 
@@ -20,8 +19,6 @@ class CauterizeCmdline < Thor
                         :desc => "Bravely overwrite files in non-empty directories",
                         :default => false
   def generate(language, target_dir, desc_file = nil)
-    raise CmdLineException.new("Language '#{language}' is not supported.") unless language == 'c'
-
     if not options[:force] and Dir.exist?(target_dir) and Dir[target_dir + "/*"].size > 0
       raise CmdLineException.new("Directory '#{target_dir}' isn't empty. Cowardly quitting.")
     end
@@ -32,16 +29,27 @@ class CauterizeCmdline < Thor
       raise CmdLineException.new("The description file #{desc_file} does not exist.")
     end
 
-    # Generate the C files.
-    Cauterize.generate_c(target_dir, desc_file)
+    language = language.downcase
+    if %w(c cs).include? language
+      Cauterize.generate language, target_dir, desc_file
+    else
+      raise CmdLineException.new("Language '#{language}' is not supported.")
+    end
 
     # Copy the cauterize support files.
     unless options[:omit_support]
-      Dir[C_PATH + "/*"].each do |path|
+      support_path = File.join(File.dirname(__FILE__),"../support/#{language}/src")
+      Dir["#{support_path}/*"].each do |path|
         FileUtils.cp(path, target_dir)
       end
     end
   end
+
+  desc "version",
+       "Prints the cauterize version to the screen."
+  def version
+    puts "cauterize-" + Cauterize::VERSION
+  end
 end
 
 begin

data/example/Cauterize

@@ -1,13 +1,8 @@
 set_name("example_project")
+set_version("1.2.3")
 
-scalar(:int8_t)
-scalar(:int16_t)
-scalar(:int32_t)
-scalar(:int64_t)
-scalar(:uint8_t)
-scalar(:uint16_t)
-scalar(:uint32_t)
-scalar(:uint64_t)
+scalar(:bigint)  { |t| t.type_name(:int32) }
+scalar(:usmallint) { |t| t.type_name(:uint8) }
 
 enumeration(:color) do |e|
   e.value :red
@@ -15,14 +10,29 @@ enumeration(:color) do |e|
   e.value :green
 end
 
+enumeration(:large_value) do |e|
+  e.value :negative, -500
+  e.value :positive, 500
+end
+
+composite(:weirdness) do |c|
+  c.field :val, :large_value
+  c.field :num, :int8
+end
+
 fixed_array(:color_list) do |a|
   a.array_type :color
   a.array_size 4
 end
 
+fixed_array(:color_list_list) do |a|
+  a.array_type :color_list
+  a.array_size 4
+end
+
 variable_array(:numbers) do |a|
-  a.size_type  :uint8_t
-  a.array_type :int32_t
+  a.size_type  :usmallint
+  a.array_type :bigint
   a.array_size 128
 end
 
@@ -41,4 +51,6 @@ end
 group(:insanity) do |g|
   g.field :nonsensical, :nonsensical
   g.field :crazy, :crazy
+  g.field :any_empty_entry
+  g.field :another_empty
 end

data/example/build.sh

@@ -1,4 +1,17 @@
 #!/bin/sh
 
-rm -rf cauterize_output
-../bin/cauterize generate c cauterize_output
+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
+
+rm -rf cs_cauterize_output
+../bin/cauterize generate cs cs_cauterize_output
+
+dmcs cs_cauterize_output/*.cs -target:library -out:cs_cauterize_output/example_project.dll
+

data/lib/cauterize/base_type.rb

@@ -5,13 +5,10 @@ module Cauterize
     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
+      if @@instances.keys.include?(name)
+        raise Exception.new("A type with the name #{name} already exists. [#{@@instances[name].inspect}]")
       end
 
       @name = name

data/lib/cauterize/builders.rb

@@ -17,10 +17,8 @@ module Cauterize
     end
 
     def get(language, description_instance)
-      if @builders and @builders[language]
+      if @builders and @builders[language] and @builders[language][description_instance.class]
         @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

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

@@ -38,18 +38,19 @@ module Cauterize
 
         # 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_sig; "CALLCONV CAUTERIZE_STATUS_T DLLDECL #{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_sig; "CALLCONV CAUTERIZE_STATUS_T DLLDECL #{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 typedef_decl(formatter); nil end
         def struct_proto(formatter); nil end
         def struct_defn(formatter); nil end
         def enum_defn(formatter); nil end

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

@@ -0,0 +1,46 @@
+module Cauterize
+  module Builders
+    module C
+      class BuiltIn < Buildable
+        @@C_TYPE_MAPPING = {
+          1 => {signed:  :int8_t, unsigned:  :uint8_t},
+          2 => {signed: :int16_t, unsigned: :uint16_t},
+          4 => {signed: :int32_t, unsigned: :uint32_t},
+          8 => {signed: :int64_t, unsigned: :uint64_t},
+        }
+
+        def render
+          render_ctype
+        end
+
+        def declare(formatter, sym)
+          formatter << "#{render} #{sym};"
+        end
+
+        # 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
+        end
+
+        def unpacker_defn(formatter)
+          formatter << unpacker_sig
+          formatter.braces do
+            formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
+          end
+        end
+
+        private
+
+        def render_ctype
+          s_key = @blueprint.is_signed ? :signed : :unsigned
+          @@C_TYPE_MAPPING[@blueprint.byte_length][s_key]
+        end
+      end
+    end
+  end
+end
+
+Cauterize::Builders.register(:c, Cauterize::BuiltIn, Cauterize::Builders::C::BuiltIn)

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

@@ -11,16 +11,37 @@ module Cauterize
         end
 
         def packer_defn(formatter)
+          rep_builder = Builders.get(:c, @blueprint.representation)
+
           formatter << packer_sig
           formatter.braces do
-            formatter << "return CauterizeAppend(dst, (uint8_t*)src, sizeof(*src));"
+            rep = "enum_representation"
+            rep_builder.declare(formatter, rep)
+
+            formatter << "#{rep} = (#{rep_builder.render})(*src);"
+            formatter << "return #{rep_builder.packer_sym}(dst, &#{rep});"
           end
         end
 
         def unpacker_defn(formatter)
+          rep_builder = Builders.get(:c, @blueprint.representation)
+
           formatter << unpacker_sig
           formatter.braces do
-            formatter << "return CauterizeRead(src, (uint8_t*)dst, sizeof(*dst));"
+            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 << "else"
+            formatter.braces do
+              formatter << "*dst = (#{render})#{rep};"
+              formatter << "return CA_OK;"
+            end
           end
         end
 

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

@@ -3,14 +3,11 @@ module Cauterize
     module C
       class FixedArray < Buildable
         def render
-          # HEY! PAY ATTENTION!
-          # Keep in mind that there's no sane way to "render" an array in C
-          # that doesn't involve an identifier.
-          ty_bldr.render
+          "struct #{@blueprint.name}"
         end
 
         def declare(formatter, sym)
-          formatter << "#{ty_bldr.render} #{sym}[#{@blueprint.array_size}]; /* #{@blueprint.name} */"
+          formatter << "#{render} #{sym};"
         end
 
         def packer_defn(formatter)
@@ -23,7 +20,7 @@ module Cauterize
             # 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[i]))) { return err; }"
+              formatter << "if (CA_OK != (err = #{ty_bldr.packer_sym}(dst, &src->data[i]))) { return err; }"
             end
             formatter.blank_line
 
@@ -41,7 +38,7 @@ module Cauterize
             # 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[i]))) { return err; }"
+              formatter << "if (CA_OK != (err = #{ty_bldr.unpacker_sym}(src, &dst->data[i]))) { return err; }"
             end
             formatter.blank_line
 
@@ -49,6 +46,18 @@ module Cauterize
           end
         end
 
+        def struct_proto(formatter)
+          formatter << (render + ";")
+        end
+
+        def struct_defn(formatter)
+          formatter << render
+          formatter.braces do
+            formatter << "#{ty_bldr.render} data[#{@blueprint.array_size}];"
+          end
+          formatter.append(";")
+        end
+
         private
 
         def ty_bldr

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

@@ -27,13 +27,15 @@ module Cauterize
             # pack the fields
             formatter << "switch (src->tag)"
             formatter.braces do
-              @blueprint.fields.values.each do |field|
+              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
 
+              format_no_data_stubs(formatter)
+
               formatter.backdent "default:"
               formatter << "return CA_ERR_INVALUD_TYPE_TAG;"
               formatter << "break;"
@@ -54,13 +56,15 @@ module Cauterize
             # pack the fields
             formatter << "switch (dst->tag)"
             formatter.braces do
-              @blueprint.fields.values.each do |field|
+              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
 
+              format_no_data_stubs(formatter)
+
               formatter.backdent "default:"
               formatter << "return CA_ERR_INVALUD_TYPE_TAG;"
               formatter << "break;"
@@ -80,13 +84,38 @@ module Cauterize
             formatter << "union"
             formatter.braces do
               @blueprint.fields.values.each do |field|
-                Builders.get(:c, field.type).declare(formatter, field.name)
+                b = Builders.get(:c, field.type)
+                if b
+                  b.declare(formatter, field.name)
+                else
+                  formatter << "/* No data associated with '#{field.name}'. */"
+                end
               end
             end
             formatter.append(" data;")
           end
           formatter.append(";")
         end
+
+        private
+
+        def having_data
+          @blueprint.fields.values.reject {|v| v.type.nil?}
+        end
+
+        def no_data
+          @blueprint.fields.values.reject {|v| not v.type.nil?}
+        end
+
+        def format_no_data_stubs(formatter)
+          if 0 < no_data.length
+            formatter.backdent "/* No data associated with the remaining tags. */"
+            no_data.each do |field|
+              formatter.backdent "case #{@blueprint.enum_sym(field.name)}:"
+            end
+            formatter << "break;"
+          end
+        end
       end
     end
   end