bindata 0.9.2 → 0.9.3

data/lib/bindata/choice.rb

@@ -4,13 +4,18 @@ require 'bindata/sanitize'
 
 module BinData
   # A Choice is a collection of data objects of which only one is active
-  # at any particular time.
+  # at any particular time.  Method calls will be delegated to the active
+  # choice.
   #
   #   require 'bindata'
   #
   #   type1 = [:string, {:value => "Type1"}]
   #   type2 = [:string, {:value => "Type2"}]
   #
+  #   choices = {5 => type1, 17 => type2}
+  #   a = BinData::Choice.new(:choices => choices, :selection => 5)
+  #   a.value # => "Type1"
+  #
   #   choices = [ type1, type2 ]
   #   a = BinData::Choice.new(:choices => choices, :selection => 1)
   #   a.value # => "Type2"
@@ -19,17 +24,14 @@ module BinData
   #   a = BinData::Choice.new(:choices => choices, :selection => 3)
   #   a.value # => "Type1"
   #
-  #   choices = {5 => type1, 17 => type2}
-  #   a = BinData::Choice.new(:choices => choices, :selection => 5)
-  #   a.value # => "Type1"
-  #
   #   mychoice = 'big'
   #   choices = {'big' => :uint16be, 'little' => :uint16le}
   #   a = BinData::Choice.new(:choices => choices,
   #                           :selection => lambda { mychoice })
   #   a.value  = 256
   #   a.to_s #=> "\001\000"
-  #   mychoice[0..-1] = 'little'
+  #   mychoice.replace 'little'
+  #   a.selection #=> 'little'
   #   a.to_s #=> "\000\001"
   #
   #
@@ -54,62 +56,91 @@ module BinData
     register(self.name, self)
 
     # These are the parameters used by this class.
-    mandatory_parameters :choices, :selection
+    bindata_mandatory_parameters :choices, :selection
 
     class << self
 
-      # Returns a sanitized +params+ that is of the form expected
-      # by #initialize.
-      def sanitize_parameters(sanitizer, params)
-        params = params.dup
-
+      # Ensures that +params+ is of the form expected by #initialize.
+      def sanitize_parameters!(sanitizer, params)
         if params.has_key?(:choices)
           choices = params[:choices]
 
-          case choices
-          when ::Hash
-            new_choices = {}
-            choices.keys.each do |key|
-              # ensure valid hash keys
-              if Symbol === key
-                msg = ":choices hash may not have symbols for keys"
-                raise ArgumentError, msg
-              elsif key.nil?
-                raise ArgumentError, ":choices hash may not have nil key"
-              end
-
-              # collect sanitized choice values
-              type, param = choices[key]
-              new_choices[key] = sanitizer.sanitize(type, param)
+          # convert array to hash keyed by index
+          if ::Array === choices
+            tmp = {}
+            choices.each_with_index do |el, i|
+              tmp[i] = el unless el.nil?
             end
-            params[:choices] = new_choices
-          when ::Array
-            choices.collect! do |type, param|
-              if type.nil?
-                # allow sparse arrays
-                nil
-              else
-                sanitizer.sanitize(type, param)
-              end
-            end
-            params[:choices] = choices
-          else
-            raise ArgumentError, "unknown type for :choices (#{choices.class})"
+            choices = tmp
           end
+
+          # ensure valid hash keys
+          if choices.has_key?(nil)
+            raise ArgumentError, ":choices hash may not have nil key"
+          end
+          if choices.keys.detect { |k| Symbol === k }
+            raise ArgumentError, ":choices hash may not have symbols for keys"
+          end
+
+          # sanitize each choice
+          new_choices = {}
+          choices.each_pair do |key, val|
+            type, param = val
+            klass = sanitizer.lookup_klass(type)
+            sanitized_params = sanitizer.sanitize_params(klass, param)
+            new_choices[key] = [klass, sanitized_params]
+          end
+          params[:choices] = new_choices
         end
 
         super(sanitizer, params)
       end
     end
 
-    def initialize(params = {}, env = nil)
-      super(params, env)
+    def initialize(params = {}, parent = nil)
+      super(params, parent)
 
-      # prepare collection of instantiated choice objects
-      @choices = (param(:choices) === ::Array) ? [] : {}
+      @choices  = {}
       @last_key = nil
     end
 
+    # A convenience method that returns the current selection.
+    def selection
+      eval_param(:selection)
+    end
+
+    # This method does not exist. This stub only exists to document why.
+    # There is no #selection= method to complement the #selection method.
+    # This is deliberate to promote the declarative nature of BinData.
+    #
+    # If you really *must* be able to programmatically adjust the selection
+    # then try something like the following.
+    #
+    #   class ProgrammaticChoice < BinData::MultiValue
+    #     choice :data, :choices => :choices, :selection => :selection
+    #     attrib_accessor :selection
+    #   end
+    #
+    #   type1 = [:string, {:value => "Type1"}]
+    #   type2 = [:string, {:value => "Type2"}]
+    #
+    #   choices = {5 => type1, 17 => type2}
+    #   pc = ProgrammaticChoice.new(:choices => choices)
+    #
+    #   pc.selection = 5
+    #   pc.data #=> "Type1"
+    #
+    #   pc.selection = 17
+    #   pc.data #=> "Type2"
+    def selection=(v)
+      raise NoMethodError
+    end
+
+    # A choice represents a specific object.
+    def obj
+      the_choice
+    end
+
     def_delegators :the_choice, :clear, :clear?, :single_value?
     def_delegators :the_choice, :done_read, :_snapshot
     def_delegators :the_choice, :_do_read, :_do_write, :_do_num_bytes
@@ -141,11 +172,11 @@ module BinData
       obj = @choices[key]
       if obj.nil?
         # instantiate choice object
-        choice_klass, choice_params = param(:choices)[key]
+        choice_klass, choice_params = no_eval_param(:choices)[key]
         if choice_klass.nil?
           raise IndexError, "selection #{key} does not exist in :choices"
         end
-        obj = choice_klass.new(choice_params, create_env)
+        obj = choice_klass.new(choice_params, self)
         @choices[key] = obj
       end
 

data/lib/bindata/int.rb

@@ -34,15 +34,21 @@ module BinData
     def self.create_read_code(nbits, endian)
       c16 = (endian == :little) ? 'v' : 'n'
       c32 = (endian == :little) ? 'V' : 'N'
-      b1  = (endian == :little) ? 0 : 1
-      b2  = (endian == :little) ? 1 : 0
+      idx = (0 ... (nbits / 32)).to_a
+      idx.reverse! if (endian == :little)
 
       case nbits
-      when  8; "io.readbytes(1).unpack('C').at(0)"
-      when 16; "io.readbytes(2).unpack('#{c16}').at(0)"
-      when 32; "io.readbytes(4).unpack('#{c32}').at(0)"
-      when 64; "(a = io.readbytes(8).unpack('#{c32 * 2}'); " +
-                     "(a.at(#{b2}) << 32) + a.at(#{b1}))"
+      when   8; "io.readbytes(1).unpack('C').at(0)"
+      when  16; "io.readbytes(2).unpack('#{c16}').at(0)"
+      when  32; "io.readbytes(4).unpack('#{c32}').at(0)"
+      when  64; "(a = io.readbytes(8).unpack('#{c32 * 2}'); " +
+                     "(a.at(#{idx[0]}) << 32) + " +
+                      "a.at(#{idx[1]}))"
+      when 128; "(a = io.readbytes(16).unpack('#{c32 * 4}'); " +
+                     "((a.at(#{idx[0]}) << 96) + " +
+                      "(a.at(#{idx[1]}) << 64) + " +
+                      "(a.at(#{idx[2]}) << 32) + " +
+                       "a.at(#{idx[3]})))"
       else
         raise "unknown nbits '#{nbits}'"
       end
@@ -51,14 +57,19 @@ module BinData
     def self.create_to_s_code(nbits, endian)
       c16 = (endian == :little) ? 'v' : 'n'
       c32 = (endian == :little) ? 'V' : 'N'
-      v1  = (endian == :little) ? 'val' : '(val >> 32)'
-      v2  = (endian == :little) ? '(val >> 32)' : 'val'
+      vals = (0 ... (nbits / 32)).collect { |i| "(val >> #{32 * i})" }
+      vals.reverse! if (endian == :little)
 
       case nbits
-      when  8; "val.chr"
-      when 16; "[val].pack('#{c16}')"
-      when 32; "[val].pack('#{c32}')"
-      when 64; "[#{v1} & 0xffffffff, #{v2} & 0xffffffff].pack('#{c32 * 2}')"
+      when   8; "val.chr"
+      when  16; "[val].pack('#{c16}')"
+      when  32; "[val].pack('#{c32}')"
+      when  64; "[#{vals[1]} & 0xffffffff, " +
+                 "#{vals[0]} & 0xffffffff].pack('#{c32 * 2}')"
+      when 128; "[#{vals[3]} & 0xffffffff, " +
+                 "#{vals[2]} & 0xffffffff, " +
+                 "#{vals[1]} & 0xffffffff, " +
+                 "#{vals[0]} & 0xffffffff].pack('#{c32 * 4}')"
       else
         raise "unknown nbits '#{nbits}'"
       end
@@ -141,6 +152,18 @@ module BinData
     Integer.create_uint_methods(self, 64, :big)
   end
 
+  # Unsigned 16 byte little endian integer.
+  class Uint128le < BinData::Single
+    register(self.name, self)
+    Integer.create_uint_methods(self, 128, :little)
+  end
+
+  # Unsigned 16 byte big endian integer.
+  class Uint128be < BinData::Single
+    register(self.name, self)
+    Integer.create_uint_methods(self, 128, :big)
+  end
+
   # Signed 1 byte integer.
   class Int8 < BinData::Single
     register(self.name, self)
@@ -182,4 +205,16 @@ module BinData
     register(self.name, self)
     Integer.create_int_methods(self, 64, :big)
   end
+
+  # Signed 16 byte little endian integer.
+  class Int128le < BinData::Single
+    register(self.name, self)
+    Integer.create_int_methods(self, 128, :little)
+  end
+
+  # Signed 16 byte big endian integer.
+  class Int128be < BinData::Single
+    register(self.name, self)
+    Integer.create_int_methods(self, 128, :big)
+  end
 end

data/lib/bindata/io.rb

@@ -31,7 +31,7 @@ module BinData
       @raw_io = io
 
       # initial stream position if stream supports positioning
-      @initial_pos = io.respond_to?(:pos) ? io.pos : 0
+      @initial_pos = positioning_supported? ? io.pos : 0
 
       # bits when reading
       @rnbits  = 0
@@ -50,7 +50,7 @@ module BinData
     # Returns the current offset of the io stream.  The exact value of
     # the offset when reading bitfields is not defined.
     def offset
-      if @raw_io.respond_to?(:pos)
+      if positioning_supported?
         @raw_io.pos - @initial_pos
       else
         # stream does not support positioning
@@ -79,8 +79,8 @@ module BinData
       str
     end
 
-    # Reads exactly +nbits+ bits from +io+. +endian+ specifies whether
-    # the bits are stored in :big or :little endian format.
+    # Reads exactly +nbits+ bits from the stream. +endian+ specifies whether
+    # the bits are stored in +:big+ or +:little+ endian format.
     def readbits(nbits, endian = :big)
       if @rendian != endian
         # don't mix bits of differing endian
@@ -89,31 +89,11 @@ module BinData
         @rendian = endian
       end
 
-      while nbits > @rnbits
-        byte = @raw_io.read(1)
-        raise EOFError, "End of file reached" if byte.nil?
-        byte = byte.unpack('C').at(0) & 0xff
-
-        if endian == :big
-          @rval = (@rval << 8) | byte
-        else
-          @rval = @rval | (byte << @rnbits)
-        end
-
-        @rnbits += 8
-      end
-
       if endian == :big
-        val     = (@rval >> (@rnbits - nbits)) & ((1 << nbits) - 1)
-        @rnbits -= nbits
-        @rval   &= ((1 << @rnbits) - 1)
+        read_be_bits(nbits)
       else
-        val     = @rval & ((1 << nbits) - 1)
-        @rnbits -= nbits
-        @rval   >>= nbits
+        read_le_bits(nbits)
       end
-
-      val
     end
 
     # Writes the given string of bytes to the io stream.
@@ -122,8 +102,8 @@ module BinData
       @raw_io.write(str)
     end
 
-    # Reads +nbits+ bits from +val+ to the stream. +endian+ specifies whether
-    # the bits are to be stored in :big or :little endian format.
+    # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether
+    # the bits are to be stored in +:big+ or +:little+ endian format.
     def writebits(val, nbits, endian = :big)
       # clamp val to range
       val = val & ((1 << nbits) - 1)
@@ -136,43 +116,9 @@ module BinData
       end
 
       if endian == :big
-        while nbits > 0
-          bits_req = 8 - @wnbits
-          if nbits >= bits_req
-            msb_bits = (val >> (nbits - bits_req)) & ((1 << bits_req) - 1)
-            nbits -= bits_req
-            val &= (1 << nbits) - 1
-
-            @wval   = (@wval << bits_req) | msb_bits
-            @raw_io.write(@wval.chr)
-
-            @wval   = 0
-            @wnbits = 0
-          else
-            @wval = (@wval << nbits) | val
-            @wnbits += nbits
-            nbits = 0
-          end
-        end
+        write_be_bits(val, nbits)
       else
-        while nbits > 0
-          bits_req = 8 - @wnbits
-          if nbits >= bits_req
-            lsb_bits = val & ((1 << bits_req) - 1)
-            nbits -= bits_req
-            val >>= bits_req
-
-            @wval   |= (lsb_bits << @wnbits)
-            @raw_io.write(@wval.chr)
-
-            @wval   = 0
-            @wnbits = 0
-          else
-            @wval   |= (val << @wnbits)
-            @wnbits += nbits
-            nbits = 0
-          end
-        end
+        write_le_bits(val, nbits)
       end
     end
 
@@ -188,5 +134,102 @@ module BinData
     end
     alias_method :flush, :flushbits
 
+    #---------------
+    private
+
+    # Checks if positioning is supported by the underlying io stream.
+    def positioning_supported?
+      unless defined? @positioning_supported
+        @positioning_supported = begin
+          @raw_io.pos
+          true
+        rescue NoMethodError, Errno::ESPIPE
+          false
+        end
+      end
+      @positioning_supported
+    end
+
+    # Reads exactly +nbits+ big endian bits from the stream.
+    def read_be_bits(nbits)
+      # ensure enough bits have accumulated
+      while nbits > @rnbits
+        byte = @raw_io.read(1)
+        raise EOFError, "End of file reached" if byte.nil?
+        byte = byte.unpack('C').at(0) & 0xff
+
+        @rval = (@rval << 8) | byte
+        @rnbits += 8
+      end
+
+      val     = (@rval >> (@rnbits - nbits)) & ((1 << nbits) - 1)
+      @rnbits -= nbits
+      @rval   &= ((1 << @rnbits) - 1)
+
+      val
+    end
+
+    # Reads exactly +nbits+ little endian bits from the stream.
+    def read_le_bits(nbits)
+      # ensure enough bits have accumulated
+      while nbits > @rnbits
+        byte = @raw_io.read(1)
+        raise EOFError, "End of file reached" if byte.nil?
+        byte = byte.unpack('C').at(0) & 0xff
+
+        @rval = @rval | (byte << @rnbits)
+        @rnbits += 8
+      end
+
+      val     = @rval & ((1 << nbits) - 1)
+      @rnbits -= nbits
+      @rval   >>= nbits
+
+      val
+    end
+
+    # Writes +nbits+ bits from +val+ to the stream in big endian format.
+    def write_be_bits(val, nbits)
+      while nbits > 0
+        bits_req = 8 - @wnbits
+        if nbits >= bits_req
+          msb_bits = (val >> (nbits - bits_req)) & ((1 << bits_req) - 1)
+          nbits -= bits_req
+          val &= (1 << nbits) - 1
+
+          @wval   = (@wval << bits_req) | msb_bits
+          @raw_io.write(@wval.chr)
+
+          @wval   = 0
+          @wnbits = 0
+        else
+          @wval = (@wval << nbits) | val
+          @wnbits += nbits
+          nbits = 0
+        end
+      end
+    end
+
+    # Writes +nbits+ bits from +val+ to the stream in little endian format.
+    def write_le_bits(val, nbits)
+      while nbits > 0
+        bits_req = 8 - @wnbits
+        if nbits >= bits_req
+          lsb_bits = val & ((1 << bits_req) - 1)
+          nbits -= bits_req
+          val >>= bits_req
+
+          @wval   |= (lsb_bits << @wnbits)
+          @raw_io.write(@wval.chr)
+
+          @wval   = 0
+          @wnbits = 0
+        else
+          @wval   |= (val << @wnbits)
+          @wnbits += nbits
+          nbits = 0
+        end
+      end
+    end
   end
 end