cauterize 0.0.1.pre13 → 0.0.1.pre14

data/lib/cauterize/enumeration.rb

@@ -1,98 +1,98 @@
-# enumeration.rb
-#
-# Enumerations correspond exactly to C enumerations.
-
-require 'set'
-
-module Cauterize
-  module_function
-  def enumeration(name, desc=nil)
-    e = Cauterize.enumerations[name] || Cauterize.enumerations[name] = Enumeration.new(name, desc)
-    yield e if block_given?
-    return e
-  end
-
-  def enumeration!(name, desc=nil, &blk)
-    if Cauterize.enumerations[name]
-      raise Exception.new("Enumeration with name #{name} already exists.")
-    else
-      Cauterize.enumeration(name, desc, &blk)
-    end
-  end
-
-  def enumerations
-    @enumerations ||= {}
-  end
-
-  class EnumerationValue
-    attr_reader :name, :value
-
-    def initialize(name, value)
-      @name = name
-      @value = value
-    end
-
-    def value_hash(digest)
-      digest.update(@name.to_s)
-      digest.update(@value.to_s)
-    end
-  end
-
-  class Enumeration < BaseType
-    attr_reader :values
-
-    def initialize(name, desc=nil)
-      super
-      @values = {}
-      @value_id = 0
-      @used_ids = Set.new
-    end
-
-    def value(name, id=nil)
-      if @values[name]
-        raise Exception.new("Cannot duplicate name #{name}.")
-      end
-
-      next_id = value_id(id)
-      @used_ids << next_id
-      @values[name] = EnumerationValue.new(name, next_id)
-    end
-
-    def representation
-      Representation.enumRepresentation(
-        min: @values.values.map(&:value).min,
-        max: @values.values.map(&:value).max
-      )
-    end
-    
-    protected
-
-    def local_hash(digest)
-      representation.type_hash(digest)
-      values.keys.sort.inject(digest) {|d, k|
-        values[k].value_hash(digest)
-      }
-    end
-
-    private
-
-    def value_id(next_id=nil)
-      if next_id
-        @value_id = next_id.to_i
-      end
-
-      v = @value_id
-
-      if @used_ids.include? v
-        raise Exception.new("Cannot duplicate constant #{v}.")
-      end
-
-      loop do
-        @value_id += 1
-        break unless @used_ids.include? @value_id
-      end
-
-      return v
-    end
-  end
-end
+# enumeration.rb
+#
+# Enumerations correspond exactly to C enumerations.
+
+require 'set'
+
+module Cauterize
+  module_function
+  def enumeration(name, desc=nil)
+    e = Cauterize.enumerations[name] || Cauterize.enumerations[name] = Enumeration.new(name, desc)
+    yield e if block_given?
+    return e
+  end
+
+  def enumeration!(name, desc=nil, &blk)
+    if Cauterize.enumerations[name]
+      raise Exception.new("Enumeration with name #{name} already exists.")
+    else
+      Cauterize.enumeration(name, desc, &blk)
+    end
+  end
+
+  def enumerations
+    @enumerations ||= {}
+  end
+
+  class EnumerationValue
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def value_hash(digest)
+      digest.update(@name.to_s)
+      digest.update(@value.to_s)
+    end
+  end
+
+  class Enumeration < BaseType
+    attr_reader :values
+
+    def initialize(name, desc=nil)
+      super
+      @values = {}
+      @value_id = 0
+      @used_ids = Set.new
+    end
+
+    def value(name, id=nil)
+      if @values[name]
+        raise Exception.new("Cannot duplicate name #{name}.")
+      end
+
+      next_id = value_id(id)
+      @used_ids << next_id
+      @values[name] = EnumerationValue.new(name, next_id)
+    end
+
+    def representation
+      Representation.enumRepresentation(
+        min: @values.values.map(&:value).min,
+        max: @values.values.map(&:value).max
+      )
+    end
+    
+    protected
+
+    def local_hash(digest)
+      representation.type_hash(digest)
+      values.keys.sort.inject(digest) {|d, k|
+        values[k].value_hash(digest)
+      }
+    end
+
+    private
+
+    def value_id(next_id=nil)
+      if next_id
+        @value_id = next_id.to_i
+      end
+
+      v = @value_id
+
+      if @used_ids.include? v
+        raise Exception.new("Cannot duplicate constant #{v}.")
+      end
+
+      loop do
+        @value_id += 1
+        break unless @used_ids.include? @value_id
+      end
+
+      return v
+    end
+  end
+end

data/lib/cauterize/fixed_array.rb

@@ -1,50 +1,50 @@
-module Cauterize
-  module_function
-
-  def fixed_array(name, desc=nil)
-    a = Cauterize.fixed_arrays[name] || Cauterize.fixed_arrays[name] = FixedArray.new(name, desc)
-    yield a if block_given?
-    return a
-  end
-
-  def fixed_array!(name, &blk)
-    if Cauterize.fixed_arrays[name]
-      raise Exception.new("FixedArray with name #{name} already exists.")
-    else
-      Cauterize.fixed_array(name, &blk)
-    end
-  end
-
-  def fixed_arrays
-    @fixed_ararys ||= {}
-  end
-
-  class FixedArray < BaseType
-    def initialize(name, desc=nil)
-      super
-    end
-
-    def array_type(t = nil)
-      if t
-        @array_type = BaseType.find_type!(t)
-      else
-        @array_type
-      end
-    end
-
-    def array_size(s = nil)
-      if s
-        @array_size = s
-      else
-        @array_size
-      end
-    end
-
-    protected
-
-    def local_hash(digest)
-      digest.update(@array_size.to_s)
-      @array_type.type_hash(digest)
-    end
-  end
-end
+module Cauterize
+  module_function
+
+  def fixed_array(name, desc=nil)
+    a = Cauterize.fixed_arrays[name] || Cauterize.fixed_arrays[name] = FixedArray.new(name, desc)
+    yield a if block_given?
+    return a
+  end
+
+  def fixed_array!(name, &blk)
+    if Cauterize.fixed_arrays[name]
+      raise Exception.new("FixedArray with name #{name} already exists.")
+    else
+      Cauterize.fixed_array(name, &blk)
+    end
+  end
+
+  def fixed_arrays
+    @fixed_ararys ||= {}
+  end
+
+  class FixedArray < BaseType
+    def initialize(name, desc=nil)
+      super
+    end
+
+    def array_type(t = nil)
+      if t
+        @array_type = BaseType.find_type!(t)
+      else
+        @array_type
+      end
+    end
+
+    def array_size(s = nil)
+      if s
+        @array_size = s
+      else
+        @array_size
+      end
+    end
+
+    protected
+
+    def local_hash(digest)
+      digest.update(@array_size.to_s)
+      @array_type.type_hash(digest)
+    end
+  end
+end

data/lib/cauterize/formatter.rb

@@ -1,67 +1,67 @@
-def default_formatter
-  Formatter.new("  ")
-end
-
-def four_space_formatter
-  Formatter.new("    ")
-end
-
-class Formatter
-  def initialize(indent_str)
-    @indent_level = 0
-    @indent_str = indent_str
-    @lines = []
-  end
-
-  def indent(line)
-    (@indent_str * @indent_level) + line
-  end
-
-  def <<(line)
-    @lines << indent(line)
-  end
-
-  # indent back one level
-  def backdent(line)
-    if 0 == @indent_level
-      @lines << line
-    else
-      @indent_level -= 1
-      @lines << indent(line)
-      @indent_level += 1
-    end
-  end
-
-  def append(text)
-    if @lines.length == 0
-      @lines << ""
-    end
-
-    @lines[-1] += text
-  end
-
-  def braces
-    self << "{"
-    indented { yield self } if block_given?
-    self << "}"
-  end
-
-  def blank_line
-    @lines << ""
-  end
-
-  def to_s(extra_indent = 0)
-    @indent_level += extra_indent
-    s = @lines.map {|l| indent(l) }.join("\n")
-    @indent_level -= extra_indent
-    return s
-  end
-
-  private
-
-  def indented
-    @indent_level += 1
-    yield self
-    @indent_level -= 1
-  end
-end
+def default_formatter
+  Formatter.new("  ")
+end
+
+def four_space_formatter
+  Formatter.new("    ")
+end
+
+class Formatter
+  def initialize(indent_str)
+    @indent_level = 0
+    @indent_str = indent_str
+    @lines = []
+  end
+
+  def indent(line)
+    (@indent_str * @indent_level) + line
+  end
+
+  def <<(line)
+    @lines << indent(line)
+  end
+
+  # indent back one level
+  def backdent(line)
+    if 0 == @indent_level
+      @lines << line
+    else
+      @indent_level -= 1
+      @lines << indent(line)
+      @indent_level += 1
+    end
+  end
+
+  def append(text)
+    if @lines.length == 0
+      @lines << ""
+    end
+
+    @lines[-1] += text
+  end
+
+  def braces
+    self << "{"
+    indented { yield self } if block_given?
+    self << "}"
+  end
+
+  def blank_line
+    @lines << ""
+  end
+
+  def to_s(extra_indent = 0)
+    @indent_level += extra_indent
+    s = @lines.map {|l| indent(l) }.join("\n")
+    @indent_level -= extra_indent
+    return s
+  end
+
+  private
+
+  def indented
+    @indent_level += 1
+    yield self
+    @indent_level -= 1
+  end
+end

data/lib/cauterize/group.rb

@@ -1,81 +1,81 @@
-module Cauterize
-  module_function
-
-  def group(name, desc=nil)
-    a = Cauterize.groups[name] || Cauterize.groups[name] = Group.new(name, desc)
-    yield a if block_given?
-    return a
-  end
-
-  def group!(name, &blk)
-    if Cauterize.groups[name]
-      raise Exception.new("Group with name #{name} already exists.")
-    else
-      Cauterize.group(name, &blk)
-    end
-  end
-
-  def groups
-    @groups ||= {}
-  end
-
-  class GroupField
-    attr_reader :name, :type, :description
-
-    def initialize(name, type, desc=nil)
-      @name = name
-      @type = BaseType.find_type!(type) if type
-      @description = desc
-    end
-
-    def field_hash(digest)
-      digest.update(@name.to_s)
-      if @type
-        @type.type_hash(digest)
-      else 
-        digest
-      end
-    end
-  end
-
-  class Group < BaseType
-    attr_reader :fields, :tag_enum
-
-    def initialize(name, desc=nil)
-      # This technically should be defined before the group itself is defined
-      # because the group depends on the enumeration. Technically, this snippet
-      # of code doesn't care, but others may depend on the ordering.
-      @tag_enum = Cauterize.enumeration!("group_#{name}_type".to_sym)
-
-      # Make sure that this is called *AFTER* the enumeration is created.
-      super
-      @fields = {}
-    end
-
-    def field(name, type, desc=nil)
-      if @fields[name]
-        raise Exception.new("Field name #{name} already used.")
-      else
-        @fields[name] = GroupField.new(name, type, desc)
-        @tag_enum.value(enum_sym(name))
-      end
-    end
-
-    def dataless(name, desc=nil)
-      field(name, nil, desc)
-    end
-
-    def enum_sym(fname)
-      "group_#{@name}_type_#{fname}".up_snake.to_sym
-    end
-
-    protected
-
-    def local_hash(digest)
-      @tag_enum.type_hash(digest)
-      @fields.keys.inject(digest) {|d, k|
-        @fields[k].field_hash(digest)
-      }
-    end
-  end
-end
+module Cauterize
+  module_function
+
+  def group(name, desc=nil)
+    a = Cauterize.groups[name] || Cauterize.groups[name] = Group.new(name, desc)
+    yield a if block_given?
+    return a
+  end
+
+  def group!(name, &blk)
+    if Cauterize.groups[name]
+      raise Exception.new("Group with name #{name} already exists.")
+    else
+      Cauterize.group(name, &blk)
+    end
+  end
+
+  def groups
+    @groups ||= {}
+  end
+
+  class GroupField
+    attr_reader :name, :type, :description
+
+    def initialize(name, type, desc=nil)
+      @name = name
+      @type = BaseType.find_type!(type) if type
+      @description = desc
+    end
+
+    def field_hash(digest)
+      digest.update(@name.to_s)
+      if @type
+        @type.type_hash(digest)
+      else 
+        digest
+      end
+    end
+  end
+
+  class Group < BaseType
+    attr_reader :fields, :tag_enum
+
+    def initialize(name, desc=nil)
+      # This technically should be defined before the group itself is defined
+      # because the group depends on the enumeration. Technically, this snippet
+      # of code doesn't care, but others may depend on the ordering.
+      @tag_enum = Cauterize.enumeration!("group_#{name}_type".to_sym)
+
+      # Make sure that this is called *AFTER* the enumeration is created.
+      super
+      @fields = {}
+    end
+
+    def field(name, type, desc=nil)
+      if @fields[name]
+        raise Exception.new("Field name #{name} already used.")
+      else
+        @fields[name] = GroupField.new(name, type, desc)
+        @tag_enum.value(enum_sym(name))
+      end
+    end
+
+    def dataless(name, desc=nil)
+      field(name, nil, desc)
+    end
+
+    def enum_sym(fname)
+      "group_#{@name}_type_#{fname}".up_snake.to_sym
+    end
+
+    protected
+
+    def local_hash(digest)
+      @tag_enum.type_hash(digest)
+      @fields.keys.inject(digest) {|d, k|
+        @fields[k].field_hash(digest)
+      }
+    end
+  end
+end