bindata 2.0.0 → 2.1.0

data/lib/bindata/framework.rb

@@ -5,17 +5,6 @@ module BinData
   # All methods provided by the framework are to be implemented or overridden 
   # by subclasses of BinData::Base.
   module Framework
-    def self.included(base) #:nodoc:
-      base.extend ClassMethods
-    end
-
-    module ClassMethods #:nodoc:
-      # Performs sanity checks on the given parameters.  This method converts
-      # the parameters to the form expected by this data object.
-      def sanitize_parameters!(parameters)
-      end
-    end
-
     # Initializes the state of the object.  All instance variables that
     # are used by the object must be initialized here.
     def initialize_instance

data/lib/bindata/int.rb

@@ -6,8 +6,7 @@ module BinData
 
   module Int #:nodoc: all
     class << self
-      def define_class(nbits, endian, signed)
-        name = class_name(nbits, endian, signed)
+      def define_class(name, nbits, endian, signed)
         unless BinData.const_defined?(name)
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
@@ -19,13 +18,6 @@ module BinData
         BinData.const_get(name)
       end
 
-      def class_name(nbits, endian, signed)
-        endian_str = (endian == :big) ? "be" : "le"
-        base = (signed == :signed) ? "Int" : "Uint"
-
-        "#{base}#{nbits}#{endian_str}"
-      end
-
       def define_methods(int_class, nbits, endian, signed)
         raise "nbits must be divisible by 8" unless (nbits % 8).zero?
 
@@ -48,14 +40,11 @@ module BinData
 
           def value_to_binary_string(val)
             #{create_clamp_code(nbits, signed)}
-            #{create_int2uint_code(nbits) if signed == :signed}
-            #{create_to_binary_s_code(nbits, endian)}
+            #{create_to_binary_s_code(nbits, endian, signed)}
           end
 
           def read_and_return_value(io)
-            val = #{create_read_code(nbits, endian)}
-            #{create_uint2int_code(nbits) if signed == :signed}
-            val
+            #{create_read_code(nbits, endian, signed)}
           end
         END
       end
@@ -68,79 +57,115 @@ module BinData
           max = (1 << (nbits - 1)) - 1
           min = -(max + 1)
         else
-          min = 0
           max = (1 << nbits) - 1
+          min = 0
         end
 
         "val = (val < #{min}) ? #{min} : (val > #{max}) ? #{max} : val"
       end
 
-      def create_int2uint_code(nbits)
-        "val = val & #{(1 << nbits) - 1}"
+      def create_read_code(nbits, endian, signed)
+        unpack_str   = create_read_unpack_code(nbits, endian, signed)
+        assemble_str = create_read_assemble_code(nbits, endian, signed)
+
+        read_str = "(#{unpack_str} ; #{assemble_str})"
+
+        if need_conversion_code?(nbits, signed)
+          "val = #{read_str} ; #{create_uint2int_code(nbits)}"
+        else
+          read_str
+        end
       end
 
-      def create_uint2int_code(nbits)
-        "val = val - #{1 << nbits} if (val >= #{1 << (nbits - 1)})"
+      def create_read_unpack_code(nbits, endian, signed)
+        nbytes = nbits / 8
+
+        "ints = io.readbytes(#{nbytes}).unpack('#{pack_directive(nbits, endian, signed)}')"
       end
 
-      def create_read_code(nbits, endian)
+      def create_read_assemble_code(nbits, endian, signed)
         bits_per_word = bytes_per_word(nbits) * 8
         nwords        = nbits / bits_per_word
-        nbytes        = nbits / 8
 
         idx = (0 ... nwords).to_a
         idx.reverse! if (endian == :big)
 
         parts = (0 ... nwords).collect do |i|
                   if i.zero?
-                    "a.at(#{idx[i]})"
+                    "ints.at(#{idx[i]})"
                   else
-                    "(a.at(#{idx[i]}) << #{bits_per_word * i})"
+                    "(ints.at(#{idx[i]}) << #{bits_per_word * i})"
                   end
                 end
 
-        unpack_str = "a = io.readbytes(#{nbytes}).unpack('#{pack_directive(nbits, endian)}')"
         assemble_str = parts.join(" + ")
-
-        "(#{unpack_str}; #{assemble_str})"
       end
 
-      def create_to_binary_s_code(nbits, endian)
+      def create_to_binary_s_code(nbits, endian, signed)
         # special case 8bit integers for speed
-        return "val.chr" if nbits == 8
+        return "(val & 0xff).chr" if nbits == 8
 
         bits_per_word = bytes_per_word(nbits) * 8
         nwords        = nbits / bits_per_word
         mask          = (1 << bits_per_word) - 1
 
         vals = (0 ... nwords).collect do |i|
-                 i.zero? ? "val" : "(val >> #{bits_per_word * i})"
+                 i.zero? ? "val" : "val >> #{bits_per_word * i}"
                end
         vals.reverse! if (endian == :big)
 
-        parts = (0 ... nwords).collect { |i| "#{vals[i]} & #{mask}" }
-        array_str = "[" + parts.join(", ") + "]"
+        array_str = "[" + vals.collect { |val| "#{val} & #{mask}" }.join(", ") + "]" # TODO: "& mask" is needed to work around jruby bug
+        pack_str  = "#{array_str}.pack('#{pack_directive(nbits, endian, signed)}')"
 
-        "#{array_str}.pack('#{pack_directive(nbits, endian)}')"
+        if need_conversion_code?(nbits, signed)
+          "#{create_int2uint_code(nbits)} ; #{pack_str}"
+        else
+          pack_str
+        end
+      end
+
+      def create_int2uint_code(nbits)
+        "val &= #{(1 << nbits) - 1}"
+      end
+
+      def create_uint2int_code(nbits)
+        "(val >= #{1 << (nbits - 1)}) ? val - #{1 << nbits} : val"
       end
 
       def bytes_per_word(nbits)
-        (nbits % 32).zero? ? 4 : (nbits % 16).zero? ? 2 : 1
+        (nbits % 64).zero? ? 8 :
+        (nbits % 32).zero? ? 4 :
+        (nbits % 16).zero? ? 2 :
+                             1
       end
 
-      def pack_directive(nbits, endian)
+      def pack_directive(nbits, endian, signed)
         bits_per_word = bytes_per_word(nbits) * 8
         nwords        = nbits / bits_per_word
 
-        if (nbits % 32).zero?
-          d = (endian == :big) ? 'N' : 'V'
+        if (nbits % 64).zero?
+          d = (endian == :big) ? 'Q>' : 'Q<'
+        elsif (nbits % 32).zero?
+          d = (endian == :big) ? 'L>' : 'L<'
         elsif (nbits % 16).zero?
-          d = (endian == :big) ? 'n' : 'v'
+          d = (endian == :big) ? 'S>' : 'S<'
         else
           d = 'C'
         end
 
-        d * nwords
+        if pack_directive_signed?(nbits, signed)
+          (d * nwords).downcase
+        else
+          d * nwords
+        end
+      end
+
+      def need_conversion_code?(nbits, signed)
+        signed == :signed and not pack_directive_signed?(nbits, signed)
+      end
+
+      def pack_directive_signed?(nbits, signed)
+        signed == :signed and [64, 32, 16, 8].include?(nbits)
       end
     end
   end
@@ -160,17 +185,17 @@ module BinData
   module IntFactory
     def const_missing(name)
       mappings = {
-        /^Uint(\d+)be$/ => [:big, :unsigned],
+        /^Uint(\d+)be$/ => [:big,    :unsigned],
         /^Uint(\d+)le$/ => [:little, :unsigned],
-        /^Int(\d+)be$/ => [:big, :signed],
-        /^Int(\d+)le$/ => [:little, :signed],
+        /^Int(\d+)be$/  => [:big,    :signed],
+        /^Int(\d+)le$/  => [:little, :signed],
       }
 
       mappings.each_pair do |regex, args|
         if regex =~ name.to_s
           nbits = $1.to_i
           if (nbits % 8).zero?
-            return Int.define_class(nbits, *args)
+            return Int.define_class(name, nbits, *args)
           end
         end
       end

data/lib/bindata/io.rb

@@ -187,8 +187,8 @@ module BinData
 
       # Use #seek and #pos on seekable streams
       module SeekableStream
-        # Returns the current offset of the io stream.  The exact value of
-        # the offset when reading bitfields is not defined.
+        # Returns the current offset of the io stream.  Offset will be rounded
+        # up when reading bitfields.
         def offset
           raw_io.pos - @initial_pos
         end
@@ -222,8 +222,8 @@ module BinData
 
       # Manually keep track of offset for unseekable streams.
       module UnSeekableStream
-        # Returns the current offset of the io stream.  The exact value of
-        # the offset when reading bitfields is not defined.
+        # Returns the current offset of the io stream.  Offset will be rounded
+        # up when reading bitfields.
         def offset
           @read_count ||= 0
         end
@@ -281,6 +281,8 @@ module BinData
         @wval    = 0
         @wendian = nil
 
+        @write_count = 0
+
         @bytes_remaining = nil
       end
 
@@ -304,6 +306,12 @@ module BinData
         end
       end
 
+      # Returns the current offset of the io stream.  Offset will be rounded
+      # up when writing bitfields.
+      def offset
+        @write_count + (@wnbits > 0 ? 1 : 0)
+      end
+
       # Writes the given string of bytes to the io stream.
       def writebytes(str)
         flushbits
@@ -391,6 +399,7 @@ module BinData
           @bytes_remaining -= data.size
         end
 
+        @write_count += data.size
         @raw_io.write(data)
       end
 

data/lib/bindata/lazy.rb

@@ -85,7 +85,7 @@ module BinData
 
       if obj_parent.has_parameter?(symbol)
         obj_parent.get_parameter(symbol)
-      elsif obj_parent.safe_respond_to?(symbol)
+      elsif obj_parent.safe_respond_to?(symbol, true)
         obj_parent.__send__(symbol, *args)
       else
         symbol

data/lib/bindata/primitive.rb

@@ -60,16 +60,11 @@ module BinData
   # Primitive objects accept all the parameters that BinData::BasePrimitive do.
   #
   class Primitive < BasePrimitive
-    include DSLMixin
+    extend DSLMixin
 
     unregister_self
-    dsl_parser :primitive
-
-    class << self
-      def sanitize_parameters!(params) #:nodoc:
-        params[:struct_params] = params.create_sanitized_params(dsl_params, BinData::Struct)
-      end
-    end
+    dsl_parser    :primitive
+    arg_processor :primitive
 
     mandatory_parameter :struct_params
 
@@ -138,4 +133,10 @@ module BinData
     # To be implemented by subclasses
     ###########################################################################
   end
+
+  class PrimitiveArgProcessor < BaseArgProcessor
+    def sanitize_parameters!(obj_class, params)
+      params[:struct_params] = params.create_sanitized_params(obj_class.dsl_params, BinData::Struct)
+    end
+  end
 end

data/lib/bindata/record.rb

@@ -1,74 +1,23 @@
 require 'bindata/dsl'
-require 'bindata/sanitize'
 require 'bindata/struct'
 
 module BinData
   # A Record is a declarative wrapper around Struct.
   #
-  #    require 'bindata'
-  #
-  #    class SomeDataType < BinData::Record
-  #      hide :a
-  #
-  #      int32le :a
-  #      int16le :b
-  #      struct  :s do
-  #        int8  :x
-  #        int8  :y
-  #        int8  :z
-  #      end
-  #    end
-  #
-  #    obj = SomeDataType.new
-  #    obj.field_names   =># [:b, :s]
-  #    obj.s.field_names =># [:x, :y, :z]
-  #
+  # See +Struct+ for more info.
   class Record < BinData::Struct
-    include DSLMixin
+    extend DSLMixin
 
     unregister_self
-    dsl_parser :struct
-
-    class << self
-
-      def arg_extractor
-        MultiFieldArgExtractor
-      end
-
-      def sanitize_parameters!(params) #:nodoc:
-        params.merge!(dsl_params)
-
-        super(params)
-
-        define_field_accessors(params[:fields].fields)
-      end
-
-      # Defines accessor methods to avoid the overhead of going through
-      # Struct#method_missing.  This is purely a speed optimisation.
-      # Removing this method will not have any effect on correctness.
-      def define_field_accessors(fields) #:nodoc:
-        unless method_defined?(:bindata_defined_accessors_for_fields?)
-          fields.each_with_index do |field, i|
-            name = field.name_as_sym
-            if name
-              define_field_accessors_for(name, i)
-            end
-          end
+    dsl_parser    :struct
+    arg_processor :record
+  end
 
-          define_method(:bindata_defined_accessors_for_fields?) { true }
-        end
-      end
+  class RecordArgProcessor < StructArgProcessor
+    include MultiFieldArgSeparator
 
-      def define_field_accessors_for(name, index)
-        define_method(name) do
-          instantiate_obj_at(index) unless @field_objs[index]
-          @field_objs[index]
-        end
-        define_method(name.to_s + "=") do |*vals|
-          instantiate_obj_at(index) unless @field_objs[index]
-          @field_objs[index].assign(*vals)
-        end
-      end
+    def sanitize_parameters!(obj_class, params)
+      super(obj_class, params.merge!(obj_class.dsl_params))
     end
   end
 end

data/lib/bindata/sanitize.rb

@@ -24,6 +24,14 @@ module BinData
       end
     end
 
+    def has_parameter?(param)
+      if @factory
+        @factory.has_parameter?(param)
+      else
+        @obj_params.has_parameter?(param)
+      end
+    end
+
     def instantiate(value = nil, parent = nil)
       @factory ||= @obj_class.new(@obj_params)
 
@@ -48,6 +56,10 @@ module BinData
       @name
     end
 
+    def has_parameter?(param)
+      @prototype.has_parameter?(param)
+    end
+
     def instantiate(value = nil, parent = nil)
       @prototype.instantiate(value, parent)
     end
@@ -55,6 +67,8 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedFields < SanitizedParameter
+    include Enumerable
+
     def initialize(endian)
       @fields = []
       @endian = endian
@@ -83,10 +97,6 @@ module BinData
       @fields.each(&block)
     end
 
-    def collect(&block)
-      @fields.collect(&block)
-    end
-
     def field_names
       @fields.collect { |field| field.name_as_sym }
     end
@@ -103,6 +113,10 @@ module BinData
       @fields.all? { |f| f.name != nil }
     end
 
+    def any_field_has_parameter?(parameter)
+      @fields.any? { |f| f.has_parameter?(parameter) }
+    end
+
     def copy_fields(other)
       @fields.concat(other.fields)
     end
@@ -207,6 +221,20 @@ module BinData
       end
     end
 
+    def must_be_integer(*keys)
+      keys.each do |key|
+        if has_parameter?(key)
+          parameter = self[key]
+          unless Symbol === parameter or
+                 parameter.respond_to? :arity or
+                 parameter.respond_to? :to_int
+            raise ArgumentError, "parameter '#{key}' in #{@the_class} must " +
+                                 "evaluate to an integer, got #{parameter.class}"
+          end
+        end
+      end
+    end
+
     def endian
       @endian || self[:endian]
     end
@@ -217,6 +245,8 @@ module BinData
         BIG_ENDIAN
       elsif endian == :little
         LITTLE_ENDIAN
+      elsif endian == :big_and_little
+        raise ArgumentError, ":endian => :big or :endian => :little is required"
       else
         raise ArgumentError, "unknown value for endian '#{endian}'"
       end
@@ -245,7 +275,7 @@ module BinData
       ensure_no_nil_values
       merge_default_parameters!
 
-      @the_class.sanitize_parameters!(self)
+      @the_class.arg_processor.sanitize_parameters!(@the_class, self)
 
       ensure_mandatory_parameters_exist
       ensure_mutual_exclusion_of_parameters