bindata 0.9.0 → 0.9.1

data/lib/bindata/choice.rb

@@ -140,9 +140,9 @@ module BinData
       @last_key = nil
     end
 
-    def_delegators :the_choice, :clear, :clear?, :_do_read, :done_read
-    def_delegators :the_choice, :_write, :_num_bytes, :snapshot
-    def_delegators :the_choice, :single_value?, :field_names
+    def_delegators :the_choice, :clear, :clear?, :single_value?, :field_names
+    def_delegators :the_choice, :snapshot, :done_read
+    def_delegators :the_choice, :_do_read, :_do_write, :_do_num_bytes
 
     # Returns the data object that stores values for +name+.
     def find_obj_for_name(name)

data/lib/bindata/float.rb

@@ -21,7 +21,7 @@ module BinData
         nbytes = 8
       end
 
-      "readbytes(io,#{nbytes}).unpack('#{unpack}').at(0)"
+      "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
     end
 
     def self.create_to_s_code(single_precision, endian)
@@ -39,7 +39,7 @@ module BinData
 
       # define methods in the given class
       klass.module_eval <<-END
-        def _num_bytes(ignored)
+        def _do_num_bytes(ignored)
           #{nbytes}
         end
 

data/lib/bindata/int.rb

@@ -38,10 +38,10 @@ module BinData
       b2  = (endian == :little) ? 1 : 0
 
       case nbits
-      when  8; "readbytes(io,1)[0]"
-      when 16; "readbytes(io,2).unpack('#{c16}').at(0)"
-      when 32; "readbytes(io,4).unpack('#{c32}').at(0)"
-      when 64; "(a = readbytes(io,8).unpack('#{c32 * 2}'); " +
+      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}))"
       else
         raise "unknown nbits '#{nbits}'"
@@ -73,7 +73,7 @@ module BinData
           super(val)
         end
 
-        def _num_bytes(ignored)
+        def _do_num_bytes(ignored)
           #{nbytes}
         end
 

data/lib/bindata/io.rb

@@ -0,0 +1,192 @@
+module BinData
+  # A wrapper around an IO object.  The wrapper provides a consistent
+  # interface for BinData objects to use when accessing the IO.
+  class IO
+
+    # Create a new IO wrapper around +io+.  +io+ must support #read if used
+    # for reading, #write if used for writing, #pos if reading the current
+    # stream position and #seek if setting the current stream position.  If
+    # +io+ is a string it will be automatically wrapped in an StringIO object.
+    #
+    # The IO can handle bitstreams in either big or little endian format.
+    # 
+    #      M  byte1   L      M  byte2   L
+    #      S 76543210 S      S fedcba98 S
+    #      B          B      B          B
+    #
+    # In big endian format:
+    #   readbits(6), readbits(5) #=> [765432, 10fed]
+    #
+    # In little endian format:
+    #   readbits(6), readbits(5) #=> [543210, a9876]
+    #
+    def initialize(io)
+      raise ArgumentError, "io must not be a BinData::IO" if BinData::IO === io
+
+      # wrap strings in a StringIO
+      if io.respond_to?(:to_str)
+        io = StringIO.new(io)
+      end
+
+      @raw_io = io
+
+      # initial stream position if stream supports positioning
+      @initial_pos = io.respond_to?(:pos) ? io.pos : 0
+
+      # bits when reading
+      @rnbits  = 0
+      @rval    = 0
+      @rendian = nil
+
+      # bits when writing
+      @wnbits  = 0
+      @wval    = 0
+      @wendian = nil
+    end
+
+    # Access to the underlying raw io.
+    attr_reader :raw_io
+
+    # 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)
+        @raw_io.pos - @initial_pos
+      else
+        # stream does not support positioning
+        0
+      end
+    end
+
+    # Seek +n+ bytes from the current position in the io stream.
+    def seekbytes(n)
+      @raw_io.seek(n, ::IO::SEEK_CUR)
+    end
+
+    # Reads exactly +n+ bytes from +io+.
+    #
+    # If the data read is nil an EOFError is raised.
+    #
+    # If the data read is too short an IOError is raised.
+    def readbytes(n)
+      raise "Internal state error nbits = #{@rnbits}" if @rnbits > 8
+      @rnbits = 0
+      @rval   = 0
+
+      str = @raw_io.read(n)
+      raise EOFError, "End of file reached" if str.nil?
+      raise IOError, "data truncated" if str.size < n
+      str
+    end
+
+    # Reads exactly +nbits+ bits from +io+. +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
+        @rnbits  = 0
+        @rval    = 0
+        @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)
+      else
+        val     = @rval & ((1 << nbits) - 1)
+        @rnbits -= nbits
+        @rval   >>= nbits
+      end
+
+      val
+    end
+
+    # Writes the given string of bytes to the io stream.
+    def writebytes(str)
+      flushbits
+      @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.
+    def writebits(val, nbits, endian = :big)
+      # clamp val to range
+      val = val & ((1 << nbits) - 1)
+
+      if @wendian != endian
+        # don't mix bits of differing endian
+        flushbits if @wnbits > 0
+
+        @wendian = endian
+      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
+      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
+      end
+    end
+
+    # To be called after all +writebits+ have been applied.
+    def flushbits
+      if @wnbits > 8
+        raise "Internal state error nbits = #{@wnbits}" if @wnbits > 8
+      elsif @wnbits > 0
+        writebits(0, 8 - @wnbits, @wendian)
+      else
+        # do nothing
+      end
+    end
+    alias_method :flush, :flushbits
+
+  end
+end

data/lib/bindata/rest.rb

@@ -30,7 +30,7 @@ module BinData
 
     # Read a number of bytes from +io+ and return the value they represent.
     def read_val(io)
-      io.read
+      io.raw_io.read
     end
 
     # Returns an empty string as default.

data/lib/bindata/single.rb

@@ -71,38 +71,14 @@ module BinData
       @value.nil?
     end
 
-    # Reads the value for this data from +io+.
-    def _do_read(io)
-      @in_read = true
-      @value   = read_val(io)
-
-      # does the value meet expectations?
-      if has_param?(:check_value)
-        current_value = self.value
-        expected = eval_param(:check_value, :value => current_value)
-        if not expected
-          raise ValidityError, "value not as expected"
-        elsif current_value != expected and expected != true
-          raise ValidityError, "value is '#{current_value}' but " +
-                               "expected '#{expected}'"
-        end
-      end
-    end
-
-    # To be called after calling #do_read.
-    def done_read
-      @in_read = false
-    end
-
-    # Writes the value for this data to +io+.
-    def _write(io)
-      raise "can't write whilst reading" if @in_read
-      io.write(val_to_str(_value))
+    # Single objects are single_values
+    def single_value?
+      true
     end
 
-    # Returns the number of bytes it will take to write this data.
-    def _num_bytes(ignored)
-      val_to_str(_value).length
+    # Single objects don't contain fields so this returns an empty list.
+    def field_names
+      []
     end
 
     # Returns a snapshot of this data object.
@@ -110,14 +86,9 @@ module BinData
       value
     end
 
-    # Single objects are single_values
-    def single_value?
-      true
-    end
-
-    # Single objects don't contain fields so this returns an empty list.
-    def field_names
-      []
+    # To be called after calling #do_read.
+    def done_read
+      @in_read = false
     end
 
     # Returns the current value of this data.
@@ -131,12 +102,45 @@ module BinData
       unless has_param?(:value)
         raise ArgumentError, "can't set a nil value" if v.nil?
         @value = v
+
+        # Note that this doesn't do anything in ruby 1.8.x so ignore for now
+        # # explicitly return the output of #value as v may be different
+        # self.value
       end
     end
 
     #---------------
     private
 
+    # Reads the value for this data from +io+.
+    def _do_read(io)
+      @in_read = true
+      @value   = read_val(io)
+
+      # does the value meet expectations?
+      if has_param?(:check_value)
+        current_value = self.value
+        expected = eval_param(:check_value, :value => current_value)
+        if not expected
+          raise ValidityError, "value not as expected"
+        elsif current_value != expected and expected != true
+          raise ValidityError, "value is '#{current_value}' but " +
+                               "expected '#{expected}'"
+        end
+      end
+    end
+
+    # Writes the value for this data to +io+.
+    def _do_write(io)
+      raise "can't write whilst reading" if @in_read
+      io.writebytes(val_to_str(_value))
+    end
+
+    # Returns the number of bytes it will take to write this data.
+    def _do_num_bytes(ignored)
+      val_to_str(_value).length
+    end
+
     # The unmodified value of this data object.  Note that #value calls this
     # method.  This is so that #value can be overridden in subclasses to 
     # modify the value.
@@ -159,21 +163,6 @@ module BinData
       end
     end
 
-    # Usuable by subclasses
-
-    # Reads exactly +n+ bytes from +io+.  This should be used by subclasses
-    # in preference to <tt>io.read(n)</tt>.
-    #
-    # If the data read is nil an EOFError is raised.
-    #
-    # If the data read is too short an IOError is raised.
-    def readbytes(io, n)
-      str = io.read(n)
-      raise EOFError, "End of file reached" if str == nil
-      raise IOError, "data truncated" if str.size < n
-      str
-    end
-
     ###########################################################################
     # To be implemented by subclasses
 

data/lib/bindata/string.rb

@@ -107,7 +107,7 @@ module BinData
     # Read a number of bytes from +io+ and return the value they represent.
     def read_val(io)
       len = eval_param(:read_length) || eval_param(:length) || 0
-      readbytes(io, len)
+      io.readbytes(len)
     end
 
     # Returns an empty string as default.

data/lib/bindata/stringz.rb

@@ -58,7 +58,7 @@ module BinData
 
       # read until zero byte or we have read in the max number of bytes
       while ch != "\0" and i != max_length
-        ch = readbytes(io, 1)
+        ch = io.readbytes(1)
         str << ch
         i += 1
       end

data/lib/bindata/struct.rb

@@ -282,41 +282,6 @@ module BinData
       end
     end
 
-    # Reads the values for all fields in this object from +io+.
-    def _do_read(io)
-      bindata_objects.each { |f| f.do_read(io) }
-    end
-
-    # To be called after calling #read.
-    def done_read
-      bindata_objects.each { |f| f.done_read }
-    end
-
-    # Writes the values for all fields in this object to +io+.
-    def _write(io)
-      bindata_objects.each { |f| f.write(io) }
-    end
-
-    # Returns the number of bytes it will take to write the field represented
-    # by +name+.  If +name+ is nil then returns the number of bytes required
-    # to write all fields.
-    def _num_bytes(name)
-      if name.nil?
-        bindata_objects.inject(0) { |sum, f| sum + f.num_bytes }
-      else
-        find_obj_for_name(name.to_s).num_bytes
-      end
-    end
-
-    # Returns a snapshot of this struct as a hash.
-    def snapshot
-      hash = Snapshot.new
-      field_names.each do |name|
-        hash[name] = find_obj_for_name(name).snapshot
-      end
-      hash
-    end
-
     # Returns whether this data object contains a single value.  Single
     # value data objects respond to <tt>#value</tt> and <tt>#value=</tt>.
     def single_value?
@@ -342,6 +307,20 @@ module BinData
       names
     end
 
+    # Returns a snapshot of this struct as a hash.
+    def snapshot
+      hash = Snapshot.new
+      field_names.each do |name|
+        hash[name] = find_obj_for_name(name).snapshot
+      end
+      hash
+    end
+
+    # To be called after calling #read.
+    def done_read
+      bindata_objects.each { |f| f.done_read }
+    end
+
     # Returns the data object that stores values for +name+.
     def find_obj_for_name(name)
       @fields.each do |n, o|
@@ -360,9 +339,17 @@ module BinData
       @fields.each do |name, obj|
         if name != ""
           break if name == field_name
-          offset += obj.num_bytes
+          this_offset = obj.do_num_bytes
+          if ::Float === offset and ::Integer === this_offset
+            offset = offset.ceil
+          end
+          offset += this_offset
         elsif obj.field_names.include?(field_name)
-          offset += obj.offset_of(field)
+          this_offset = obj.offset_of(field)
+          if ::Float === offset and ::Integer === this_offset
+            offset = offset.ceil
+          end
+          offset += this_offset
           break
         end
       end
@@ -400,6 +387,27 @@ module BinData
     #---------------
     private
 
+    # Reads the values for all fields in this object from +io+.
+    def _do_read(io)
+      bindata_objects.each { |f| f.do_read(io) }
+    end
+
+    # Writes the values for all fields in this object to +io+.
+    def _do_write(io)
+      bindata_objects.each { |f| f.do_write(io) }
+    end
+
+    # Returns the number of bytes it will take to write the field represented
+    # by +name+.  If +name+ is nil then returns the number of bytes required
+    # to write all fields.
+    def _do_num_bytes(name)
+      if name.nil?
+        (bindata_objects.inject(0) { |sum, f| sum + f.do_num_bytes }).ceil
+      else
+        find_obj_for_name(name.to_s).do_num_bytes
+      end
+    end
+
     # Returns a list of all the bindata objects for this struct.
     def bindata_objects
       @fields.collect { |f| f[1] }