cauterize 0.0.1.pre13 → 0.0.1.pre14

data/example/c_example_support/empty_main.c

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

data/example/c_example_support/example_project_config.c

@@ -1,11 +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]));
-}
+#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

@@ -1,15 +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 */
+#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/example/ruby_ex.rb

@@ -1,14 +1,14 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
-require 'cauterize'
-require 'bindata'
-
-
-Cauterize.populate(ARGV[0])
-
-i = Cauterize::ExampleProject::Wat.new
-i.tag.representation = 0
-p i.num_bytes
-i.tag.representation = 1
-p i.num_bytes
-i.tag.representation = 2
-p i.num_bytes
+$LOAD_PATH << File.join(File.dirname(__FILE__), "../lib")
+require 'cauterize'
+require 'bindata'
+
+
+Cauterize.populate(ARGV[0])
+
+i = Cauterize::ExampleProject::Wat.new
+i.tag.representation = 0
+p i.num_bytes
+i.tag.representation = 1
+p i.num_bytes
+i.tag.representation = 2
+p i.num_bytes

data/lib/cauterize.rb

@@ -1,117 +1,117 @@
-require 'bindata'
-require 'cauterize/snake_case'
-require 'cauterize/base_type'
-require 'cauterize/cauterize'
-
-def fix(s)
-  s.gsub(/([[:alpha:]])_([[:digit:]])/) do |m|
-    $1 + $2
-  end
-end
-
-
-def populate_scalar(klass, inst)
-  klass.class_eval do
-    endian :little
-    send(fix(inst.type_name.name.to_s), :data)
-  end
-end
-
-def populate_enum(klass, inst)
-  klass.class_eval do
-    endian :little
-
-    send(fix(inst.representation.name.to_s), :representation)
-
-    enum_vals = inst.values.values.map {|v| [v.value, v.name.to_sym]}
-    enum_hash = Hash[enum_vals]
-    const_set(:ENUM_MAP, enum_hash)
-    inst.values.values.each do |v| 
-      klass.const_set(v.name.upcase.to_sym, v.value)
-    end
-
-    def enum
-      self.class.const_get(:ENUM_MAP)[representation]
-    end
-  end
-end
-
-def populate_fixed_array(klass, inst)
-  klass.class_eval do
-    endian :little
-    array :data, { :type => fix(inst.array_type.name.to_s),
-                   :initial_length => inst.array_size }
-  end
-end
-
-def populate_variable_array(klass, inst)
-  # TODO: Figure out what we should do with inst.array_size
-  klass.class_eval do
-    endian :little
-    send(fix(inst.size_type.name.to_s), :va_len, :value => lambda { data.length })
-    array :data, { :type => fix(inst.array_type.name.to_s),
-                   :read_until => lambda { index == va_len - 1}}
-  end
-end
-
-def populate_composite(klass, inst)
-  klass.class_eval do
-    endian :little
-    inst.fields.values.each do |v|
-      send(fix(v.type.name.to_s), v.name.to_s)
-    end
-  end
-end
-
-def populate_group(klass, inst)
-  choices = inst.fields.values.each_with_index.map do |v, i|
-    [i, v.type.nil? ? :empty_data : fix(v.type.name.to_s).to_sym]
-  end
-
-  klass.class_eval do
-    endian :little
-    send(fix(inst.tag_enum.name.to_s), :tag)
-
-    choice :data, :selection => lambda { tag.representation },
-                  :choices => Hash[choices]
-  end
-end
- 
-module Cauterize
-  class EmptyData < BinData::Record; end
-
-  def self.populate(desc_file)
-    parse_dsl(desc_file)
-
-    dsl_mod = Module.new do |mod|
-
-      BaseType.all_instances.each do |inst|
-        next if Cauterize::BuiltIn == inst.class
-
-        n = inst.name.to_s.camel
-        module_eval("class #{n} < BinData::Record; end")
-        klass = const_get(n)
-
-        case inst
-        when Cauterize::Scalar
-          populate_scalar(klass, inst)
-        when Cauterize::Enumeration
-          populate_enum(klass, inst)
-        when Cauterize::FixedArray
-          populate_fixed_array(klass, inst)
-        when Cauterize::VariableArray
-          populate_variable_array(klass, inst)
-        when Cauterize::Composite
-          populate_composite(klass, inst)
-        when Cauterize::Group
-          populate_group(klass, inst)
-        else
-          puts "Unhandled instance: #{inst.class.name}"
-        end
-      end
-    end
-
-    const_set(Cauterize.get_name.camel, dsl_mod)
-  end
-end
-
+require 'bindata'
+require 'cauterize/snake_case'
+require 'cauterize/base_type'
+require 'cauterize/cauterize'
+
+def fix(s)
+  s.gsub(/([[:alpha:]])_([[:digit:]])/) do |m|
+    $1 + $2
+  end
+end
+
+
+def populate_scalar(klass, inst)
+  klass.class_eval do
+    endian :little
+    send(fix(inst.type_name.name.to_s), :data)
+  end
+end
+
+def populate_enum(klass, inst)
+  klass.class_eval do
+    endian :little
+
+    send(fix(inst.representation.name.to_s), :representation)
+
+    enum_vals = inst.values.values.map {|v| [v.value, v.name.to_sym]}
+    enum_hash = Hash[enum_vals]
+    const_set(:ENUM_MAP, enum_hash)
+    inst.values.values.each do |v| 
+      klass.const_set(v.name.upcase.to_sym, v.value)
+    end
+
+    def enum
+      self.class.const_get(:ENUM_MAP)[representation]
+    end
+  end
+end
+
+def populate_fixed_array(klass, inst)
+  klass.class_eval do
+    endian :little
+    array :data, { :type => fix(inst.array_type.name.to_s),
+                   :initial_length => inst.array_size }
+  end
+end
+
+def populate_variable_array(klass, inst)
+  # TODO: Figure out what we should do with inst.array_size
+  klass.class_eval do
+    endian :little
+    send(fix(inst.size_type.name.to_s), :va_len, :value => lambda { data.length })
+    array :data, { :type => fix(inst.array_type.name.to_s),
+                   :read_until => lambda { index == va_len - 1}}
+  end
+end
+
+def populate_composite(klass, inst)
+  klass.class_eval do
+    endian :little
+    inst.fields.values.each do |v|
+      send(fix(v.type.name.to_s), v.name.to_s)
+    end
+  end
+end
+
+def populate_group(klass, inst)
+  choices = inst.fields.values.each_with_index.map do |v, i|
+    [i, v.type.nil? ? :empty_data : fix(v.type.name.to_s).to_sym]
+  end
+
+  klass.class_eval do
+    endian :little
+    send(fix(inst.tag_enum.name.to_s), :tag)
+
+    choice :data, :selection => lambda { tag.representation },
+                  :choices => Hash[choices]
+  end
+end
+ 
+module Cauterize
+  class EmptyData < BinData::Record; end
+
+  def self.populate(desc_file)
+    parse_dsl(desc_file)
+
+    dsl_mod = Module.new do |mod|
+
+      BaseType.all_instances.each do |inst|
+        next if Cauterize::BuiltIn == inst.class
+
+        n = inst.name.to_s.camel
+        module_eval("class #{n} < BinData::Record; end")
+        klass = const_get(n)
+
+        case inst
+        when Cauterize::Scalar
+          populate_scalar(klass, inst)
+        when Cauterize::Enumeration
+          populate_enum(klass, inst)
+        when Cauterize::FixedArray
+          populate_fixed_array(klass, inst)
+        when Cauterize::VariableArray
+          populate_variable_array(klass, inst)
+        when Cauterize::Composite
+          populate_composite(klass, inst)
+        when Cauterize::Group
+          populate_group(klass, inst)
+        else
+          puts "Unhandled instance: #{inst.class.name}"
+        end
+      end
+    end
+
+    const_set(Cauterize.get_name.camel, dsl_mod)
+  end
+end
+

data/lib/cauterize/base_type.rb

@@ -1,78 +1,78 @@
-require 'set'
-require 'digest'
-
-module Cauterize
-  class BaseType
-    attr_reader :name, :description
-    @@instances = {}
-
-    def initialize(name, description=nil)
-      if @@instances.keys.include?(name)
-        raise Exception.new("A type with the name #{name} already exists. [#{@@instances[name].inspect}]")
-      end
-
-      @name = name
-      @description = description
-      register_instance(self)
-    end
-
-    def type_hash(digest = nil)
-      digest ||= BaseType.digest_class.new
-      digest.update(@name.to_s)
-      local_hash(digest)
-    end
-
-    def self.all_instances; @@instances.values end
-
-    def self.model_hash
-      @@instances.keys.sort.map do |k|
-        @@instances[k]
-      end.inject(BaseType.digest_class.new) do |d, i|
-        i.type_hash(d)
-      end.digest
-    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
-
-    def self.digest_class
-      Digest::SHA1
-    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
-
-    # local_hash is responsible for hashing the things in the type that
-    # are not known about in the BaseType parent class.
-    def local_hash(digest)
-      raise Exception.new("All instances of BaseType (including #{self.class}) must implement local_hash.")
-    end
-
-    def register_instance(inst)
-      if @@instances[inst.name]
-        raise Exception.new("Type with name #{inst.name} already defined.")
-      end
-
-      @@instances[inst.name] = inst
-    end
-  end
-end
+require 'set'
+require 'digest'
+
+module Cauterize
+  class BaseType
+    attr_reader :name, :description
+    @@instances = {}
+
+    def initialize(name, description=nil)
+      if @@instances.keys.include?(name)
+        raise Exception.new("A type with the name #{name} already exists. [#{@@instances[name].inspect}]")
+      end
+
+      @name = name
+      @description = description
+      register_instance(self)
+    end
+
+    def type_hash(digest = nil)
+      digest ||= BaseType.digest_class.new
+      digest.update(@name.to_s)
+      local_hash(digest)
+    end
+
+    def self.all_instances; @@instances.values end
+
+    def self.model_hash
+      @@instances.keys.sort.map do |k|
+        @@instances[k]
+      end.inject(BaseType.digest_class.new) do |d, i|
+        i.type_hash(d)
+      end.digest
+    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
+
+    def self.digest_class
+      Digest::SHA1
+    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
+
+    # local_hash is responsible for hashing the things in the type that
+    # are not known about in the BaseType parent class.
+    def local_hash(digest)
+      raise Exception.new("All instances of BaseType (including #{self.class}) must implement local_hash.")
+    end
+
+    def register_instance(inst)
+      if @@instances[inst.name]
+        raise Exception.new("Type with name #{inst.name} already defined.")
+      end
+
+      @@instances[inst.name] = inst
+    end
+  end
+end