bindata 2.2.0 → 2.3.0

data/lib/bindata/dsl.rb

@@ -135,11 +135,12 @@ module BinData
 
       def parser_abilities
         @abilities ||= {
-          :struct    => [:to_struct_params, [:multiple_fields, :optional_fieldnames, :hidden_fields]],
-          :array     => [:to_array_params,  [:multiple_fields, :optional_fieldnames]],
-          :buffer    => [:to_array_params,  [:multiple_fields, :optional_fieldnames, :hidden_fields]],
-          :choice    => [:to_choice_params, [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]],
-          :primitive => [:to_struct_params, [:multiple_fields, :optional_fieldnames]]
+          :struct     => [:to_struct_params, [:multiple_fields, :optional_fieldnames, :hidden_fields]],
+          :array      => [:to_array_params,  [:multiple_fields, :optional_fieldnames]],
+          :buffer     => [:to_array_params,  [:multiple_fields, :optional_fieldnames, :hidden_fields]],
+          :choice     => [:to_choice_params, [:multiple_fields, :all_or_none_fieldnames, :fieldnames_are_values]],
+          :delayed_io => [:to_array_params,  [:multiple_fields, :optional_fieldnames, :hidden_fields]],
+          :primitive  => [:to_struct_params, [:multiple_fields, :optional_fieldnames]]
         }
       end
 
@@ -153,10 +154,7 @@ module BinData
       end
 
       def hints
-        {
-          :endian => endian,
-          :search_prefix => search_prefix,
-        }
+        { :endian => endian, :search_prefix => search_prefix }
       end
 
       def set_endian(endian)
@@ -185,7 +183,7 @@ module BinData
       end
 
       def has_fields?
-        @fields && @fields.length > 0
+        defined? @fields and @fields.length > 0
       end
 
       def parse_and_append_field(*args, &block)
@@ -289,7 +287,7 @@ module BinData
           }
           bnl_class.define_singleton_method(:new) do |*args|
             if self == bnl_class
-              value, options, parent = arg_processor.separate_args(self, args)
+              _, options, _ = arg_processor.separate_args(self, args)
               delegate = endian_classes[options[:endian]]
               return delegate.new(*args) if delegate
             end
@@ -339,13 +337,8 @@ module BinData
           RegisteredClasses.lookup(class_name, hints)
         end
 
-        def obj_attribute(obj, attr, default = nil)
-          parser = obj.respond_to?(:dsl_parser) ? obj.dsl_parser : nil
-          if parser and parser.respond_to?(attr)
-            parser.send(attr)
-          else
-            default
-          end
+        def obj_attribute(obj, attr)
+          obj.dsl_parser.send(attr)
         end
       end
     end
@@ -362,7 +355,7 @@ module BinData
       attr_reader :type, :name, :params
 
       def name_from_field_declaration(args)
-        name, params = args
+        name, _ = args
         if name == "" or name.is_a?(Hash)
           nil
         else
@@ -389,10 +382,11 @@ module BinData
 
       def params_from_block(&block)
         bindata_classes = {
-          :array  => BinData::Array,
-          :buffer => BinData::Buffer,
-          :choice => BinData::Choice,
-          :struct => BinData::Struct
+          :array      => BinData::Array,
+          :buffer     => BinData::Buffer,
+          :choice     => BinData::Choice,
+          :delayed_io => BinData::DelayedIO,
+          :struct     => BinData::Struct
         }
 
         if bindata_classes.include?(@type)

data/lib/bindata/framework.rb

@@ -47,6 +47,11 @@ module BinData
       0
     end
 
+    # Is this object aligned on non-byte boundaries?
+    def bit_aligned?
+      false
+    end
+
     # Reads the data for this data object from +io+.
     def do_read(io) #:nodoc:
       raise NotImplementedError

data/lib/bindata/int.rb

@@ -104,7 +104,7 @@ module BinData
                 end
         parts[0].sub!(/ << 0\b/, "")  # Remove " << 0" for optimisation
 
-        assemble_str = parts.join(" + ")
+        parts.join(" + ")
       end
 
       def create_to_binary_s_code(nbits, endian, signed)

data/lib/bindata/io.rb

@@ -4,6 +4,147 @@ module BinData
   # A wrapper around an IO object.  The wrapper provides a consistent
   # interface for BinData objects to use when accessing the IO.
   module IO
+
+    # Common operations for both Read and Write.
+    module Common
+      def initialize(io)
+        if self.class === io
+          raise ArgumentError, "io must not be a #{self.class}"
+        end
+
+        # wrap strings in a StringIO
+        if io.respond_to?(:to_str)
+          io = BinData::IO.create_string_io(io.to_str)
+        end
+
+        @raw_io = io
+        @buffer_end_pos = nil
+
+        extend seekable? ? SeekableStream : UnSeekableStream
+        stream_init
+      end
+
+      #-------------
+      private
+
+      def seekable?
+        @raw_io.pos
+      rescue NoMethodError, Errno::ESPIPE, Errno::EPIPE
+        nil
+      end
+
+      def seek(n)
+        seek_raw(buffer_limited_n(n))
+      end
+
+      def buffer_limited_n(n)
+        if @buffer_end_pos
+          if n.nil? or n > 0
+            max = @buffer_end_pos[1] - offset
+            n = max if n.nil? or n > max
+          else
+            min = @buffer_end_pos[0] - offset
+            n = min if n < min
+          end
+        end
+
+        n
+      end
+
+      def with_buffer_common(n, &block)
+        prev = @buffer_end_pos
+        if prev
+          avail = prev[1] - offset
+          n = avail if n > avail
+        end
+        @buffer_end_pos = [offset, offset + n]
+        begin
+          block.call(*@buffer_end_pos)
+        ensure
+          @buffer_end_pos = prev
+        end
+      end
+
+      # Use #seek and #pos on seekable streams
+      module SeekableStream
+        # The number of bytes remaining in the input stream.
+        def num_bytes_remaining
+          mark = @raw_io.pos
+          @raw_io.seek(0, ::IO::SEEK_END)
+          bytes_remaining = @raw_io.pos - mark
+          @raw_io.seek(mark, ::IO::SEEK_SET)
+
+          bytes_remaining
+        end
+
+        #-----------
+        private
+
+        def stream_init
+          @initial_pos = @raw_io.pos
+        end
+
+        def offset_raw
+          @raw_io.pos - @initial_pos
+        end
+
+        def seek_raw(n)
+          @raw_io.seek(n, ::IO::SEEK_CUR)
+        end
+
+        def read_raw(n)
+          @raw_io.read(n)
+        end
+
+        def write_raw(data)
+          @raw_io.write(data)
+        end
+      end
+
+      # Manually keep track of offset for unseekable streams.
+      module UnSeekableStream
+        def offset_raw
+          @offset
+        end
+
+        # The number of bytes remaining in the input stream.
+        def num_bytes_remaining
+          raise IOError, "stream is unseekable"
+        end
+
+        #-----------
+        private
+
+        def stream_init
+          @offset = 0
+        end
+
+        def read_raw(n)
+          data = @raw_io.read(n)
+          @offset += data.size if data
+          data
+        end
+
+        def write_raw(data)
+          @offset += data.size
+          @raw_io.write(data)
+        end
+
+        def seek_raw(n)
+          raise IOError, "stream is unseekable" if n < 0
+
+          # NOTE: how do we seek on a writable stream?
+
+          # skip over data in 8k blocks
+          while n > 0
+            bytes_to_read = [n, 8192].min
+            read_raw(bytes_to_read)
+            n -= bytes_to_read
+          end
+        end
+      end
+    end
+
     # Creates a StringIO around +str+.
     def self.create_string_io(str = "")
       StringIO.new(str.dup.force_encoding(Encoding::BINARY))
@@ -27,43 +168,32 @@ module BinData
     #   readbits(6), readbits(5) #=> [543210, a9876]
     #
     class Read
-      def initialize(io)
-        raise ArgumentError, "io must not be a BinData::IO::Read" if BinData::IO::Read === io
-
-        # wrap strings in a StringIO
-        if io.respond_to?(:to_str)
-          io = BinData::IO.create_string_io(io.to_str)
-        end
+      include Common
 
-        @raw_io = io
+      def initialize(io)
+        super(io)
 
         # bits when reading
         @rnbits  = 0
         @rval    = 0
         @rendian = nil
-
-        @buffer_end_pos = nil
-
-        extend seekable? ? SeekableStream : UnSeekableStream
       end
 
       # Sets a buffer of +n+ bytes on the io stream.  Any reading or seeking
       # calls inside the +block+ will be contained within this buffer.
       def with_buffer(n, &block)
-        prev = @buffer_end_pos
-        if prev
-          avail = prev - offset
-          n = avail if n > avail
-        end
-        @buffer_end_pos = offset + n
-        begin
+        with_buffer_common(n) do
           block.call
           read
-        ensure
-          @buffer_end_pos = prev
         end
       end
 
+      # Returns the current offset of the io stream.  Offset will be rounded
+      # up when reading bitfields.
+      def offset
+        offset_raw
+      end
+
       # Seek +n+ bytes from the current position in the io stream.
       def seekbytes(n)
         reset_read_bits
@@ -116,29 +246,10 @@ module BinData
       #---------------
       private
 
-      def seekable?
-        @raw_io.pos
-      rescue NoMethodError, Errno::ESPIPE, Errno::EPIPE
-        nil
-      end
-
-      def seek(n)
-        seek_raw(buffer_limited_n(n))
-      end
-
       def read(n = nil)
         read_raw(buffer_limited_n(n))
       end
 
-      def buffer_limited_n(n)
-        if @buffer_end_pos
-          max = @buffer_end_pos - offset
-          n = max if n.nil? or n > max
-        end
-
-        n
-      end
-
       def read_big_endian_bits(nbits)
         while @rnbits < nbits
           accumulate_big_endian_bits
@@ -184,77 +295,6 @@ module BinData
       def mask(nbits)
         (1 << nbits) - 1
       end
-
-      # Use #seek and #pos on seekable streams
-      module SeekableStream
-        # Returns the current offset of the io stream.  Offset will be rounded
-        # up when reading bitfields.
-        def offset
-          raw_io.pos - @initial_pos
-        end
-
-        # The number of bytes remaining in the input stream.
-        def num_bytes_remaining
-          mark = raw_io.pos
-          raw_io.seek(0, ::IO::SEEK_END)
-          bytes_remaining = raw_io.pos - mark
-          raw_io.seek(mark, ::IO::SEEK_SET)
-
-          bytes_remaining
-        end
-
-        #-----------
-        private
-
-        def read_raw(n)
-          raw_io.read(n)
-        end
-
-        def seek_raw(n)
-          raw_io.seek(n, ::IO::SEEK_CUR)
-        end
-
-        def raw_io
-          @initial_pos ||= @raw_io.pos
-          @raw_io
-        end
-      end
-
-      # Manually keep track of offset for unseekable streams.
-      module UnSeekableStream
-        # Returns the current offset of the io stream.  Offset will be rounded
-        # up when reading bitfields.
-        def offset
-          @read_count ||= 0
-        end
-
-        # The number of bytes remaining in the input stream.
-        def num_bytes_remaining
-          raise IOError, "stream is unseekable"
-        end
-
-        #-----------
-        private
-
-        def read_raw(n)
-          @read_count ||= 0
-
-          data = @raw_io.read(n)
-          @read_count += data.size if data
-          data
-        end
-
-        def seek_raw(n)
-          raise IOError, "stream is unseekable" if n < 0
-
-          # skip over data in 8k blocks
-          while n > 0
-            bytes_to_read = [n, 8192].min
-            read_raw(bytes_to_read)
-            n -= bytes_to_read
-          end
-        end
-      end
     end
 
     # Create a new IO Write wrapper around +io+.  +io+ must provide #write.
@@ -265,25 +305,13 @@ module BinData
     #
     # See IO::Read for more information.
     class Write
+      include Common
       def initialize(io)
-        if BinData::IO::Write === io
-          raise ArgumentError, "io must not be a BinData::IO::Write"
-        end
-
-        # wrap strings in a StringIO
-        if io.respond_to?(:to_str)
-          io = BinData::IO.create_string_io(io.to_str)
-        end
-
-        @raw_io = io
+        super(io)
 
         @wnbits  = 0
         @wval    = 0
         @wendian = nil
-
-        @write_count = 0
-
-        @bytes_remaining = nil
       end
 
       # Sets a buffer of +n+ bytes on the io stream.  Any writes inside the
@@ -291,31 +319,28 @@ module BinData
       # are written inside the block, the remainder will be padded with '\0'
       # bytes.
       def with_buffer(n, &block)
-        prev = @bytes_remaining
-        if prev
-          n = prev if n > prev
-          prev -= n
-        end
-
-        @bytes_remaining = n
-        begin
+        with_buffer_common(n) do |buf_start, buf_end|
           block.call
-          write_raw("\0" * @bytes_remaining)
-        ensure
-          @bytes_remaining = prev
+          write("\0" * (buf_end - offset))
         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)
+        offset_raw + (@wnbits > 0 ? 1 : 0)
+      end
+
+      # Seek +n+ bytes from the current position in the io stream.
+      def seekbytes(n)
+        flushbits
+        seek(n)
       end
 
       # Writes the given string of bytes to the io stream.
       def writebytes(str)
         flushbits
-        write_raw(str)
+        write(str)
       end
 
       # Writes +nbits+ bits from +val+ to the stream. +endian+ specifies whether
@@ -349,6 +374,15 @@ module BinData
       #---------------
       private
 
+      def write(data)
+        n = buffer_limited_n(data.size)
+        if n < data.size
+          data = data[0, n]
+        end
+
+        write_raw(data)
+      end
+
       def write_big_endian_bits(val, nbits)
         while nbits > 0
           bits_req = 8 - @wnbits
@@ -358,7 +392,7 @@ module BinData
             val &= mask(nbits)
 
             @wval   = (@wval << bits_req) | msb_bits
-            write_raw(@wval.chr)
+            write(@wval.chr)
 
             @wval   = 0
             @wnbits = 0
@@ -379,7 +413,7 @@ module BinData
             val >>= bits_req
 
             @wval   = @wval | (lsb_bits << @wnbits)
-            write_raw(@wval.chr)
+            write(@wval.chr)
 
             @wval   = 0
             @wnbits = 0
@@ -391,18 +425,6 @@ module BinData
         end
       end
 
-      def write_raw(data)
-        if @bytes_remaining
-          if data.size > @bytes_remaining
-            data = data[0, @bytes_remaining]
-          end
-          @bytes_remaining -= data.size
-        end
-
-        @write_count += data.size
-        @raw_io.write(data)
-      end
-
       def mask(nbits)
         (1 << nbits) - 1
       end