BitStructEx 0.0.54

data/Rakefile

@@ -0,0 +1,53 @@
+
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/version'
+
+
+PROJECT_NAME='BitStructEx'
+PROJECT_FORGE_ID='bit-struct-ex'
+
+SRC_DIR='src/ruby'
+TEST_DIR='test/ruby'
+
+PKG_VERSION = Rake::Version.new
+PKG_FILES = FileList[
+    'lib/**/*.rb', 
+    'src/**/*.rb', 
+    'test/**/*.rb',
+    'Rakefile',
+    'Version'
+]
+
+CLOBBER.include 'pkg'
+
+
+desc "Run all tests, update build number and build gem"
+task :default => [ :run_tests, :increment_build_number, :build_gem ]
+
+desc "Execute the unit tests using the specialized test runner"
+task :run_tests do
+    sh "ruby -I#{TEST_DIR} #{TEST_DIR}/runner.rb --verbose=v"
+end
+
+desc "Increment the build number and upate the Version file"
+task :increment_build_number => [ :run_tests ] do
+    src = Dir.glob "#{SRC_DIR}/**/*"
+    target = 'Version'
+    unless uptodate?( target, src )
+        new_version = PKG_VERSION.increment( :build )
+        puts "Version: #{new_version}"
+    end
+end
+
+desc "Build the gem package"
+task :build_gem => [ :run_tests, :define_gem, :gem ]
+
+desc "Define the Gem specification and associated task(s)"
+task :define_gem do
+    PKG_SPEC = eval IO.read( 'GemSpec' ), binding
+    Rake::GemPackageTask.new( PKG_SPEC ) do |pkg|
+        pkg.need_zip = true
+        pkg.need_tar = true
+    end
+end

data/Version

@@ -0,0 +1 @@
+0.0.54

data/lib/ruby/rake/version.rb

@@ -0,0 +1,71 @@
+module Rake
+
+  #
+  # Simple helper class for maintaining a Version number within a Rakefile.
+  # Provides an easy way increase the version tags. Supports purely numeric
+  # version tags only.
+  #
+  class Version
+
+      def self.increment( symbol )
+          Version.new.increment symbol
+      end
+
+      def initialize( config = {} )
+          @config = config
+          @config[ :version_file ] ||= 'Version'
+          @config[ :version_regex ] ||= /\A(\d+)\.(\d+).(\d+)\Z/
+          @config[ :version_tags ] ||= [ :release, :version, :build ]
+          @tag_values = {}
+          read
+      end
+
+      def increment( symbol )
+          raise "Unknown tag: #{symbol}" unless version_tags.include? symbol
+          read
+          @tag_values[ symbol ] += 1
+          write
+          current_version
+      end
+
+      def current_version
+          version_tags.map { |tag| @tag_values[ tag ] }.join( '.' )
+      end
+
+      alias version current_version
+
+      alias to_s version
+
+      private
+
+      def read
+          version = IO.read version_file
+          raise "Error reading #{version_file}" unless version_regex =~ version
+          version_tags.each_index do |idx|
+              @tag_values[ version_tags[ idx ] ] = Regexp.last_match[ 1 + idx ].to_i
+          end
+          self
+      end
+
+      def write
+          File.open( version_file, 'w' ) do |file|
+              file.write current_version
+          end
+          self
+      end
+
+      def version_file
+          @config[ :version_file ]
+      end
+
+      def version_regex
+          @config[ :version_regex ]
+      end
+
+      def version_tags
+          @config[ :version_tags ]
+      end
+
+  end
+
+end

data/src/ruby/bit_struct/bit_slicer.rb

@@ -0,0 +1,202 @@
+
+module BitStruct
+
+  # Implements access to a 'segment' of a byte string, specified by
+  # offset (from bit 0) and length (in bits). Supports little and big
+  # endian data input and output.
+  #
+  # NOTE: This is highly inefficient. If a segment is byte-aligned,
+  # please use the optimized ByteSlicer class.
+  class BitSlicer
+
+    module Endianess
+      LITTLE_ENDIAN = LITTLE = INTEL = 0
+      BIG_ENDIAN = BIG = MOTOROLA = 1
+      NETWORK_BYTE_ORDER = BIG_ENDIAN
+    end
+
+    include Endianess
+
+    def initialize( bit_offset, bit_length, endianess = MOTOROLA )
+      raise ArgumentError if bit_offset < 0 || bit_length < 0
+
+      @bit_offset = bit_offset
+      @bit_length = bit_length
+      @endianess = endianess
+    end
+
+    def data=( new_data )
+      raise ArgumentError if ( @bit_offset + @bit_length ) > new_data.length * 8
+      @data = new_data
+    end
+
+    def data
+      @data
+    end
+
+    def get_bytes
+      align_shift = required_shift
+      bytes = get_raw_bytes
+
+      # Step 1: Shift all bytes to the right to align bit 0
+      # (in case bit_offset is not on byte border).
+      BitSlicer.shift_bytes_right( bytes, align_shift )
+
+      # Step 2: Strip highest (unused/empty) byte if necessary
+      # (in case bit_length is on byte border, but bit_offset not).
+      data_length = length_in_bytes
+      while bytes.length > data_length
+        bytes = bytes[ 1, bytes.length - 1 ]
+      end
+
+      # Step 3: Apply mask to 'highest' byte
+      # (in case bit_length is not on byte border).
+      bytes[ 0 ] &= highest_byte_mask
+      bytes
+    end
+
+    def set_bytes( bytes )
+      align_shift = required_shift
+
+      # Step 1: Insert empty bytes to allow overflow from shifting.
+      data_length = insert_length_in_bytes
+      while bytes.length < data_length
+        bytes.insert 0, 0x00
+      end
+      while bytes.length > data_length
+        bytes = bytes[ 1, bytes.length - 1 ]
+      end
+
+      # Step 2: Shift all bytes to the left to align bit 0 with the 'destination postion'
+      # (in case bit_offset is not on byte border).
+      BitSlicer.shift_bytes_left( bytes, align_shift )
+
+      # Step 3: Mask out unused parts of first and last byte.
+      bytes[ 0 ] &= insert_first_byte_mask
+      bytes[ bytes.length - 1 ] &= insert_last_byte_mask
+
+      # Step 4: Merge existing data into first and last byte.
+      bytes[ 0 ] |= masked_first_byte
+      bytes[ bytes.length - 1 ] |= masked_last_byte
+
+      # Step 5: Write back the byte data.
+      set_raw_bytes bytes
+
+      data
+    end
+
+    #private
+
+    def get_data( idx )
+      return @data[ idx ] if @endianess == MOTOROLA
+      return @data[ -idx ] if @endianess == INTEL
+    end
+
+    def set_data( idx, val )
+      @data[ idx ] = val if @endianess == MOTOROLA
+      @data[ -idx ] = val if @endianess == INTEL
+    end
+
+    def first_byte
+      data.length - ( ( @bit_offset + @bit_length ) / 8.0 ).ceil
+    end
+
+    def last_byte
+      data.length - 1 - @bit_offset / 8
+    end
+
+    def length_in_bytes
+      ( @bit_length / 8.0 ).ceil
+    end
+
+    def insert_length_in_bytes
+      ( ( ( @bit_offset & 7 ) + @bit_length ) / 8.0 ).ceil
+    end
+
+    def masked_first_byte
+      get_data( first_byte ) & merge_first_byte_mask
+    end
+
+    def masked_last_byte
+      get_data( last_byte ) & merge_last_byte_mask
+    end
+
+    def required_shift
+      @bit_offset & 7
+    end
+
+    def get_raw_bytes
+      raw_bytes = []
+      first_byte.upto( last_byte ) do |idx|
+        raw_bytes << get_data( idx )
+      end
+      raw_bytes
+    end
+
+    def set_raw_bytes( raw_bytes )
+      first_byte.upto( last_byte ) do |idx|
+        set_data idx, raw_bytes[ idx - first_byte ]
+      end
+    end
+
+    def highest_byte_mask
+      mask_bits = ( ( @bit_length ) & 7 )
+      mask_bits = 8 if mask_bits == 0
+      ( 2 ** mask_bits ) - 1
+    end
+
+    def insert_first_byte_mask
+      mask_bits = ( ( @bit_offset + @bit_length ) & 7 )
+      mask_bits = 8 if mask_bits == 0
+      ( 2 ** mask_bits ) - 1
+    end
+
+    def insert_last_byte_mask
+      mask_bits = 0xFF
+      ( mask_bits << ( @bit_offset & 7 ) ) & 0xFF
+    end
+
+    def merge_first_byte_mask
+      255 - insert_first_byte_mask
+    end
+
+    def merge_last_byte_mask
+      255 - insert_last_byte_mask
+    end
+
+    def self.right_shifted( before, subject, bits )
+      ( ( before << 8 | subject ) >> bits ) & 0xFF
+    end
+
+    def self.left_shifted( subject, after, bits )
+      ( ( ( subject << 8 | after ) << bits ) >> 8 ) & 0xFF
+    end
+
+    def self.shift_bytes_right( bytes, bit_shift_count )
+      return if bit_shift_count == 0
+      raise ArgumentError if bit_shift_count < 0 || bit_shift_count > 8
+
+      from = bytes.length - 1
+      from.downto( 0 ) do |idx|
+        before = idx > 0 ? bytes[ idx - 1 ] : 0
+        bytes[ idx ] = BitSlicer.right_shifted( before, bytes[ idx ], bit_shift_count )
+      end
+
+      bytes
+    end
+
+    def self.shift_bytes_left( bytes, bit_shift_count )
+      return if bit_shift_count == 0
+      raise ArgumentError if bit_shift_count < 0 || bit_shift_count > 8
+
+      0.upto( bytes.length - 1 ) do |idx|
+        after = bytes[ idx + 1 ] || 0
+        bytes[ idx ] = BitSlicer.left_shifted( bytes[ idx ], after, bit_shift_count )
+      end
+
+      bytes
+    end
+
+  end
+
+end

data/src/ruby/bit_struct/field.rb

@@ -0,0 +1,18 @@
+
+module BitStruct
+
+  class Field
+
+    attr_reader :name
+    attr_reader :length
+    attr_reader :description
+
+    def initialize( name, length, description )
+      @name = name
+      @length = length
+      @description = description
+    end
+
+  end
+
+end

data/src/ruby/bit_struct/nested.rb

@@ -0,0 +1,32 @@
+
+require 'bit_struct/field'
+
+module BitStruct
+
+  class NestedField < Field
+
+    def initialize( name, nested_class, description = nil )
+      super name, nil, description
+      @nested_class = nested_class
+    end
+
+    def length
+      @nested_class.length
+    end
+
+    def read( slicer )
+      bytes = slicer.get_bytes
+      @nested_class.new bytes
+    end
+
+    def write( slicer, new_value )
+      # TODO: What should be allowed here?
+      # TODO: new_value.is_a? String
+      # TODO: new_value.is_a? Array
+      # TODO: new_value.is_a? StructBase
+      raise "NYI"
+    end
+
+  end
+
+end

data/src/ruby/bit_struct/struct_base.rb

@@ -0,0 +1,124 @@
+
+require 'bit_struct/bit_slicer'
+require 'bit_struct/field'
+
+# The BitStruct module primarily provides the StructBase class, which in turn
+# allows the definition of bit-based structures that can be used to access
+# byte data on a bit offset / length manner.
+#
+# Example:
+#
+# class Flags < StructBase
+#   unsigned :direction, 4
+#   unsigned :multiplier, 2
+#   unsigned :offset, 2
+# end
+#
+# class Entry < StructBase
+#   unsigned :offset, 4
+#   nested   :flags, Flags
+#   unsigned :address, 24
+#   unsigned :cache_id, 16
+# end
+#
+# In contrast to the already available
+# http://raa.ruby-lang.org/project/bit-struct/ implementation, BitStructEx
+# allows nested structures which are not aligned on byte boundaries.
+#
+# Author::    Daniel Lukic (mailto:bitstructex@berlinfactor.com)
+# Copyright:: Copyright (c) 2005 The.Berlin.Factor
+# License::   Distributes under the GPL
+#
+module BitStruct
+
+  # Define a subclass of StructBase and use the available field types (at
+  # least "nested" and "unsigned" are available) to define the bit-based
+  # structure like this:
+  #
+  #  * unsigned :name_of_field, length_of_field_in_bits
+  #  * nested   :name_of_nested_field, class_of_nested_field
+  #
+  # Please see the provided examples in the samples folder for.. well..
+  # examples.
+  #
+  class StructBase < String
+
+    def initialize( data = nil )
+      @data = data
+    end
+
+    def data
+      @data
+    end
+
+    class << self
+
+      def fields
+        @fields ||= []
+      end
+
+      def length
+        @fields.inject( 0 ) { |l,f| l + f.length }
+      end
+
+      private
+
+      def add_field( field )
+        context = self
+
+        define_method "#{field.name}" do
+          slicer = context.send :get_slicer_for, field
+          slicer.data = @data
+          field.send :read, slicer
+        end
+        define_method "#{field.name}=" do |val|
+          slicer = context.send :get_slicer_for, field
+          slicer.data = @data
+          field.send :write, slicer, val
+        end
+
+        fields << field
+      end
+
+      def get_slicer_for( field )
+        unless slicers[ field ]
+          bit_offset, bit_length = get_field_spec field
+          slicers[ field ] = BitSlicer.new bit_offset, bit_length
+        end
+        slicers[ field ]
+      end
+
+      def get_field_spec( field )
+        index = fields.index field
+        offset = 0
+        0.upto( index - 1 ) { |idx| offset += fields[ idx ].length }
+        return offset, field.length
+      end
+
+      def method_missing( symbol, *args )
+        require "bit_struct/#{symbol.id2name}"
+
+        class_name = make_class_name symbol
+        clazz = const_get class_name.to_sym
+        self.class.send :define_method, symbol do |*args|
+          add_field clazz.new( *args )
+        end
+
+        send symbol, *args
+      end
+
+      def make_class_name( symbol )
+        words = symbol.id2name.split '_'
+        words.map! { |w| w.capitalize }
+        words.join + 'Field'
+      end
+
+      def slicers
+        @slicers ||= {}
+      end
+
+    end
+
+  end
+
+end

data/src/ruby/bit_struct/unsigned.rb

@@ -0,0 +1,27 @@
+
+require 'bit_struct/field'
+
+module BitStruct
+
+  class UnsignedField < Field
+
+    def initialize( name, length, description = nil )
+      super name, length, description
+    end
+
+    def read( slicer )
+      slicer.get_bytes.inject( 0 ) { |r,b| ( r << 8 ) + b }
+    end
+
+    def write( slicer, new_value )
+      bytes = []
+      while new_value > 0
+        bytes.insert 0, ( new_value & 0xFF )
+        new_value >>= 8
+      end
+      slicer.set_bytes bytes
+    end
+
+  end
+
+end

data/test/ruby/bit_struct/test_bit_slicer.rb

@@ -0,0 +1,299 @@
+
+require 'test/unit'
+
+require 'bit_struct/bit_slicer'
+
+
+
+class TestBitSlicer < Test::Unit::TestCase
+
+  def test_endianess
+    slicer = BitStruct::BitSlicer.new 0, 16, BitStruct::BitSlicer::MOTOROLA
+    slicer.data = test_data
+    assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.data.hexify
+  end
+
+  def test_right_shifted
+    assert_equal '34', BitStruct::BitSlicer.right_shifted( 0x12, 0x34, 0 ).hexify
+    assert_equal '23', BitStruct::BitSlicer.right_shifted( 0x12, 0x34, 4 ).hexify
+    assert_equal '12', BitStruct::BitSlicer.right_shifted( 0x12, 0x34, 8 ).hexify
+  end
+
+  def test_left_shifted
+    assert_equal '12', BitStruct::BitSlicer.left_shifted( 0x12, 0x34, 0 ).hexify
+    assert_equal '23', BitStruct::BitSlicer.left_shifted( 0x12, 0x34, 4 ).hexify
+    assert_equal '34', BitStruct::BitSlicer.left_shifted( 0x12, 0x34, 8 ).hexify
+
+    assert_equal '11000011', BitStruct::BitSlicer.left_shifted( 0xF0, 0xF0, 2 ).binarize
+  end
+
+  def test_first_byte
+    assert_equal 4, slicer( 0, 1 ).first_byte
+    assert_equal 4, slicer( 0, 7 ).first_byte
+    assert_equal 4, slicer( 0, 8 ).first_byte
+    assert_equal 3, slicer( 0, 12 ).first_byte
+    assert_equal 3, slicer( 0, 16 ).first_byte
+    assert_equal 3, slicer( 2, 8 ).first_byte
+    assert_equal 4, slicer( 2, 2 ).first_byte
+    assert_equal 2, slicer( 2, 16 ).first_byte
+    assert_equal 2, slicer( 4, 16 ).first_byte
+    assert_equal 2, slicer( 6, 16 ).first_byte
+    assert_equal 2, slicer( 7, 16 ).first_byte
+    assert_equal 2, slicer( 8, 16 ).first_byte
+    assert_equal 1, slicer( 9, 16 ).first_byte
+    assert_equal 1, slicer( 15, 16 ).first_byte
+    assert_equal 1, slicer( 16, 16 ).first_byte
+    assert_equal 0, slicer( 17, 16 ).first_byte
+  end
+
+  def test_last_byte
+    assert_equal 4, slicer( 0, 16 ).last_byte
+    assert_equal 4, slicer( 2, 16 ).last_byte
+    assert_equal 4, slicer( 4, 16 ).last_byte
+    assert_equal 4, slicer( 6, 16 ).last_byte
+    assert_equal 4, slicer( 7, 16 ).last_byte
+    assert_equal 3, slicer( 8, 16 ).last_byte
+    assert_equal 3, slicer( 9, 16 ).last_byte
+    assert_equal 3, slicer( 15, 16 ).last_byte
+    assert_equal 2, slicer( 16, 16 ).last_byte
+    assert_equal 2, slicer( 17, 16 ).last_byte
+  end
+
+  def test_length_in_bytes
+    assert_equal 1, slicer( 0, 1 ).length_in_bytes
+    assert_equal 1, slicer( 0, 4 ).length_in_bytes
+    assert_equal 1, slicer( 0, 8 ).length_in_bytes
+    assert_equal 2, slicer( 0, 9 ).length_in_bytes
+    assert_equal 2, slicer( 0, 14 ).length_in_bytes
+    assert_equal 2, slicer( 0, 16 ).length_in_bytes
+    assert_equal 3, slicer( 0, 20 ).length_in_bytes
+
+    assert_equal 1, slicer( 4, 1 ).length_in_bytes
+    assert_equal 1, slicer( 4, 4 ).length_in_bytes
+    assert_equal 1, slicer( 5, 8 ).length_in_bytes
+    assert_equal 2, slicer( 6, 9 ).length_in_bytes
+    assert_equal 2, slicer( 7, 14 ).length_in_bytes
+    assert_equal 2, slicer( 7, 16 ).length_in_bytes
+    assert_equal 3, slicer( 8, 20 ).length_in_bytes
+  end
+
+  def test_insert_length_in_bytes
+    assert_equal 1, slicer( 0, 1 ).insert_length_in_bytes
+    assert_equal 1, slicer( 0, 4 ).insert_length_in_bytes
+    assert_equal 1, slicer( 0, 8 ).insert_length_in_bytes
+    assert_equal 2, slicer( 0, 9 ).insert_length_in_bytes
+    assert_equal 2, slicer( 0, 14 ).insert_length_in_bytes
+    assert_equal 2, slicer( 0, 16 ).insert_length_in_bytes
+    assert_equal 3, slicer( 0, 20 ).insert_length_in_bytes
+
+    assert_equal 1, slicer( 8, 8 ).insert_length_in_bytes
+
+    assert_equal 1, slicer( 4, 1 ).insert_length_in_bytes
+    assert_equal 1, slicer( 4, 4 ).insert_length_in_bytes
+    assert_equal 2, slicer( 5, 8 ).insert_length_in_bytes
+    assert_equal 2, slicer( 6, 9 ).insert_length_in_bytes
+    assert_equal 3, slicer( 7, 14 ).insert_length_in_bytes
+    assert_equal 3, slicer( 7, 16 ).insert_length_in_bytes
+    assert_equal 3, slicer( 8, 20 ).insert_length_in_bytes
+    assert_equal 3, slicer( 8, 24 ).insert_length_in_bytes
+    assert_equal 4, slicer( 8, 25 ).insert_length_in_bytes
+    assert_equal 3, slicer( 9, 16 ).insert_length_in_bytes
+  end
+
+  def test_highest_byte_mask
+    assert_equal '00111111', slicer( 2, 22 ).highest_byte_mask.binarize
+    assert_equal '00111111', slicer( 0, 22 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 0, 16 ).highest_byte_mask.binarize
+    assert_equal '00111111', slicer( 2, 14 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 2, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 4, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 6, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 7, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 8, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 9, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 15, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 16, 16 ).highest_byte_mask.binarize
+    assert_equal '11111111', slicer( 17, 16 ).highest_byte_mask.binarize
+  end
+
+  def test_insert_first_byte_mask
+    assert_equal '11111111', slicer( 0, 8 ).insert_first_byte_mask.binarize
+    assert_equal '00000011', slicer( 2, 8 ).insert_first_byte_mask.binarize
+    assert_equal '00001111', slicer( 4, 8 ).insert_first_byte_mask.binarize
+    assert_equal '00111111', slicer( 6, 8 ).insert_first_byte_mask.binarize
+    assert_equal '11111111', slicer( 8, 8 ).insert_first_byte_mask.binarize
+    assert_equal '00000011', slicer( 10, 8 ).insert_first_byte_mask.binarize
+  end
+
+  def test_insert_last_byte_mask
+    assert_equal '11111111', slicer( 0, 8 ).insert_last_byte_mask.binarize
+    assert_equal '11111100', slicer( 2, 8 ).insert_last_byte_mask.binarize
+    assert_equal '11110000', slicer( 4, 8 ).insert_last_byte_mask.binarize
+    assert_equal '11000000', slicer( 6, 8 ).insert_last_byte_mask.binarize
+    assert_equal '11111111', slicer( 8, 8 ).insert_last_byte_mask.binarize
+  end
+
+  def test_masked_last_byte
+    slicer = slicer( 12, 24 )
+    assert_equal '00000001', slicer.data[ slicer.first_byte ].binarize
+    assert_equal '11110000', slicer.merge_first_byte_mask.binarize
+    assert_equal '00000000', slicer.masked_first_byte.binarize
+
+    assert_equal '01100111', slicer.data[ slicer.last_byte ].binarize
+    assert_equal '00001111', slicer.merge_last_byte_mask.binarize
+    assert_equal '00000111', slicer.masked_last_byte.binarize
+  end
+
+  def test_required_shift
+    assert_equal 0, slicer( 0, 16 ).required_shift
+    assert_equal 2, slicer( 2, 16 ).required_shift
+    assert_equal 4, slicer( 4, 16 ).required_shift
+    assert_equal 6, slicer( 6, 16 ).required_shift
+    assert_equal 0, slicer( 8, 4 ).required_shift
+    assert_equal 0, slicer( 8, 16 ).required_shift
+    assert_equal 2, slicer( 10, 16 ).required_shift
+  end
+
+  def test_get_raw_bytes
+    # test_data = [ 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
+
+    assert_equal '0x89', slicer( 0, 8 ).get_raw_bytes.hexify
+    assert_equal '0x67 0x89', slicer( 0, 16 ).get_raw_bytes.hexify
+    assert_equal '0x45 0x67 0x89', slicer( 0, 24 ).get_raw_bytes.hexify
+
+    assert_equal '0x45 0x67 0x89', slicer( 4, 16 ).get_raw_bytes.hexify
+    assert_equal '0x45 0x67 0x89', slicer( 4, 20 ).get_raw_bytes.hexify
+    assert_equal '0x23 0x45 0x67 0x89', slicer( 6, 20 ).get_raw_bytes.hexify
+
+    assert_equal '0x45 0x67', slicer( 12, 8 ).get_raw_bytes.hexify
+
+    assert_equal '0x67', slicer( 8, 4 ).get_raw_bytes.hexify
+
+    assert_equal '0x45 0x67', slicer( 8, 16 ).get_raw_bytes.hexify
+    assert_equal '0x23 0x45', slicer( 16, 16 ).get_raw_bytes.hexify
+  end
+
+  def test_shift_bytes_right
+    assert_equal '0x01 0x23 0x45', BitStruct::BitSlicer.shift_bytes_right( [ 0x12, 0x34, 0x56 ], 4 ).hexify
+    assert_equal '0x00 0x12 0x34', BitStruct::BitSlicer.shift_bytes_right( [ 0x12, 0x34, 0x56 ], 8 ).hexify
+  end
+
+  def test_shift_bytes_left
+    assert_equal '0x23 0x45 0x60', BitStruct::BitSlicer.shift_bytes_left( [ 0x12, 0x34, 0x56 ], 4 ).hexify
+    assert_equal '0x34 0x56 0x00', BitStruct::BitSlicer.shift_bytes_left( [ 0x12, 0x34, 0x56 ], 8 ).hexify
+  end
+
+  def test_get_bytes
+    assert_equal '0x89', slicer( 0, 8 ).get_bytes.hexify
+    assert_equal '0x09', slicer( 0, 4 ).get_bytes.hexify
+    assert_equal '0x08', slicer( 4, 4 ).get_bytes.hexify
+
+    assert_equal '0x07', slicer( 8, 4 ).get_bytes.hexify
+    assert_equal '0x06', slicer( 12, 4 ).get_bytes.hexify
+
+    assert_equal '0x67 0x89', slicer( 4, 8 ).get_raw_bytes.hexify
+    assert_equal '0x06 0x78', BitStruct::BitSlicer.shift_bytes_right( [ 0x67, 0x89 ], 4 ).hexify
+    assert_equal '0x78', slicer( 4, 8 ).get_bytes.hexify
+
+    assert_equal '0x45 0x67', slicer( 12, 8 ).get_raw_bytes.hexify
+    assert_equal '0x04 0x56', BitStruct::BitSlicer.shift_bytes_right( [ 0x45, 0x67 ], 4 ).hexify
+    assert_equal '0x56', slicer( 12, 8 ).get_bytes.hexify
+
+    assert_equal '0x67 0x89', slicer( 0, 16 ).get_bytes.hexify
+    assert_equal '0x45 0x67 0x89', slicer( 0, 24 ).get_bytes.hexify
+    assert_equal '0x05 0x67 0x89', slicer( 0, 22 ).get_bytes.hexify
+
+    assert_equal '0x45 0x67', slicer( 8, 16 ).get_bytes.hexify
+    assert_equal '0x23 0x45', slicer( 16, 16 ).get_bytes.hexify
+
+    assert_equal '0x23 0x45 0x67', slicer( 12, 16 ).get_raw_bytes.hexify
+    assert_equal '0x34 0x56', slicer( 12, 16 ).get_bytes.hexify
+    assert_equal '0x04 0x56', slicer( 12, 12 ).get_bytes.hexify
+    assert_equal '0x56', slicer( 12, 8 ).get_bytes.hexify
+    assert_equal '0x16', slicer( 12, 6 ).get_bytes.hexify
+    assert_equal '0x06', slicer( 12, 4 ).get_bytes.hexify
+    assert_equal '0x02', slicer( 12, 2 ).get_bytes.hexify
+  end
+
+  def test_set_bytes
+    slicer = slicer( 0, 8 )
+    assert_equal 4, slicer.first_byte
+    assert_equal 4, slicer.last_byte
+    assert_equal 1, slicer.length_in_bytes
+    assert_equal 1, slicer.insert_length_in_bytes
+    assert_equal 4, slicer.first_byte
+    assert_equal 4, slicer.last_byte
+#    assert_equal '0x01 0x23 0x45 0x67 0xcd', slicer.set_bytes( [ 0xCD ] ).hexify
+
+    slicer = slicer( 8, 8 )
+    assert_equal 3, slicer.first_byte
+    assert_equal 3, slicer.last_byte
+    assert_equal 1, slicer.length_in_bytes
+    assert_equal 1, slicer.insert_length_in_bytes
+#    assert_equal '0x01 0x23 0x45 0xcd 0x89', slicer.set_bytes( [ 0xCD ] ).hexify
+
+    slicer = slicer( 4, 8 )
+    assert_equal 3, slicer.first_byte
+    assert_equal 4, slicer.last_byte
+    assert_equal 1, slicer.length_in_bytes
+    assert_equal 2, slicer.insert_length_in_bytes
+#    assert_equal '0x01 0x23 0x45 0x6c 0xd9', slicer.set_bytes( [ 0xCD ] ).hexify
+
+    slicer = slicer( 4, 2 )
+    assert_equal 4, slicer.first_byte
+    assert_equal 4, slicer.last_byte
+    assert_equal 1, slicer.length_in_bytes
+    assert_equal 1, slicer.insert_length_in_bytes
+
+    assert_equal '00111111', slicer.insert_first_byte_mask.binarize
+    assert_equal '11110000', slicer.insert_last_byte_mask.binarize
+
+    assert_equal '11000000', slicer.merge_first_byte_mask.binarize
+    assert_equal '00001111', slicer.merge_last_byte_mask.binarize
+
+    assert_equal '10000000', slicer.masked_first_byte.binarize
+    assert_equal '00001001', slicer.masked_last_byte.binarize
+
+    assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.data.hexify
+    assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.set_bytes( [ 0x00 ] ).hexify
+    assert_equal '0x01 0x23 0x45 0x67 0xb9', slicer.set_bytes( [ 0xFF ] ).hexify
+
+    slicer = slicer( 12, 24 )
+    assert_equal 0, slicer.first_byte
+    assert_equal 3, slicer.last_byte
+    assert_equal 3, slicer.length_in_bytes
+    assert_equal 4, slicer.insert_length_in_bytes
+
+    assert_equal '00001111', slicer.insert_first_byte_mask.binarize
+    assert_equal '11110000', slicer.insert_last_byte_mask.binarize
+
+    assert_equal '11110000', slicer.merge_first_byte_mask.binarize
+    assert_equal '00001111', slicer.merge_last_byte_mask.binarize
+
+    assert_equal '00000001', slicer.data[ slicer.first_byte ].binarize
+    assert_equal '00000000', slicer.masked_first_byte.binarize
+
+    assert_equal '01100111', slicer.data[ slicer.last_byte ].binarize
+    assert_equal '00000111', slicer.masked_last_byte.binarize
+
+    assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.data.hexify
+    assert_equal '0x12 0x34 0x56', slicer.get_bytes.hexify
+    assert_equal '0x07 0x75 0x53 0x37 0x89', slicer.set_bytes( [ 0x99, 0x77, 0x55, 0x33 ] ).hexify
+    assert_equal '0x07 0x75 0x53 0x37 0x89', slicer.set_bytes( [ 0xAA, 0xFF, 0x99, 0x77, 0x55, 0x33 ] ).hexify
+  end
+
+  def slicer( bit_offset, bit_length )
+    slicer = BitStruct::BitSlicer.new bit_offset, bit_length
+    slicer.data = test_data.dup
+    slicer
+  end
+
+  def test_data
+    [ 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
+  end
+
+  def test_data_intel
+    [ 0x89, 0x67, 0x45, 0x23, 0x01].pack( 'C*' )
+  end
+
+end

data/test/ruby/bit_struct/test_struct_base.rb

@@ -0,0 +1,125 @@
+
+require 'test/unit'
+
+require 'bit_struct/struct_base'
+
+include BitStruct
+
+
+
+class Flags < StructBase
+  unsigned :direction, 4
+  unsigned :multiplier, 2
+  unsigned :offset, 2
+end
+
+class Entry < StructBase
+  unsigned :offset, 4
+  nested   :flags, Flags
+  unsigned :address, 24
+  unsigned :cache_id, 16
+end
+
+class TestBitStruct < Test::Unit::TestCase
+
+  def test_flags_class
+    fields = Flags.fields
+    assert_equal 3, fields.size
+
+    assert_equal :direction, fields[ 0 ].name
+    assert_equal 4, fields[ 0 ].length
+    assert_equal :multiplier, fields[ 1 ].name
+    assert_equal 2, fields[ 1 ].length
+    assert_equal :offset, fields[ 2 ].name
+    assert_equal 2, fields[ 2 ].length
+  end
+
+  def test_attributes_class
+    fields = Entry.fields
+    assert_equal 4, fields.size
+
+    assert_equal :offset, fields[ 0 ].name
+    assert_equal 4, fields[ 0 ].length
+    assert_equal :flags, fields[ 1 ].name
+    assert_equal 8, fields[ 1 ].length
+    assert_equal :address, fields[ 2 ].name
+    assert_equal 24, fields[ 2 ].length
+    assert_equal :cache_id, fields[ 3 ].name
+    assert_equal 16, fields[ 3 ].length
+  end
+
+  def test_flags_read
+    flags = Flags.new [ 0xFF ].pack( 'C*' )
+    assert_equal 0x0F, flags.direction
+    assert_equal 0x03, flags.multiplier
+    assert_equal 0x03, flags.offset
+
+    flags = Flags.new [ 0x0F ].pack( 'C*' )
+    assert_equal 0x0F, flags.direction
+    assert_equal 0x00, flags.multiplier
+    assert_equal 0x00, flags.offset
+
+    flags = Flags.new [ 0x3F ].pack( 'C*' )
+    assert_equal 0x0F, flags.direction
+    assert_equal 0x03, flags.multiplier
+    assert_equal 0x00, flags.offset
+
+    flags = Flags.new [ 0xCF ].pack( 'C*' )
+    assert_equal 0x0F, flags.direction
+    assert_equal 0x00, flags.multiplier
+    assert_equal 0x03, flags.offset
+  end
+
+  def test_flags_write
+    data = [ 0xFF ].pack( 'C*' )
+
+    flags = Flags.new data
+    assert_equal '0xff', flags.data.hexify
+    assert_equal 0x0F, flags.direction
+    assert_equal 0x03, flags.multiplier
+    assert_equal 0x03, flags.offset
+
+    flags.multiplier = 0
+    assert_equal '0xcf', flags.data.hexify
+    assert_equal 0x0F, flags.direction
+    assert_equal 0x00, flags.multiplier
+    assert_equal 0x03, flags.offset
+  end
+
+  def test_entry_read
+    data = [ 0xAA, 0xFF, 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
+    entry = Entry.new data
+
+    assert_equal 9, entry.offset
+    assert_equal '0x12 0x34 0x56', entry.address.bytes.hexify
+    assert_equal '0xaf 0xf0', entry.cache_id.bytes.hexify
+
+    flags = entry.flags
+    assert_equal 8, flags.direction
+    assert_equal 3, flags.multiplier
+    assert_equal 1, flags.offset
+  end
+
+  def test_attributes_write
+    data = [ 0xAA, 0xFF, 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
+    entry = Entry.new data
+
+    entry.offset = 15
+    assert_equal '0x0f', entry.offset.bytes.hexify
+    assert_equal '0xaa 0xff 0x01 0x23 0x45 0x67 0x8f', entry.data.hexify
+
+    entry.address = 0x44332211
+    assert_equal '0x33 0x22 0x11', entry.address.bytes.hexify
+    assert_equal '0xaa 0xff 0x03 0x32 0x21 0x17 0x8f', entry.data.hexify
+
+    entry.cache_id = 0xAABBCCDD
+    assert_equal '0xcc 0xdd', entry.cache_id.bytes.hexify
+    assert_equal '0xac 0xcd 0xd3 0x32 0x21 0x17 0x8f', entry.data.hexify
+
+    flags = entry.flags
+    assert_equal 8, flags.direction
+    assert_equal 3, flags.multiplier
+    assert_equal 1, flags.offset
+  end
+
+end

data/test/ruby/runner.rb

@@ -0,0 +1,115 @@
+
+require 'logger'
+
+require 'test/unit/autorunner'
+
+class String
+
+  def hexify
+    result = ''
+    each_byte do |b|
+      result << "0x#{b.hexify} "
+    end
+    result.chop
+  end
+
+end
+
+class Array
+
+  def hexify
+    map { |b| "0x#{b && b.hexify}" }.join( ' ' )
+  end
+
+  def binarize
+    map { |b| "%#{b && b.binarize}" }.join( ' ' )
+  end
+
+end
+
+class Fixnum
+
+  def bytes
+    bytes = []
+    val = to_i
+    while val > 0
+      bytes.insert 0, ( val & 0xFF )
+      val >>= 8
+    end
+    bytes
+  end
+
+  def hexify
+    result = ''
+    val = to_i
+    while val > 0
+      b = val & 0xF
+      result = b.to_s( 16 ) + result
+      val >>= 4
+    end
+    padded result, 2
+  end
+
+  def binarize
+    result = ''
+    val = to_i
+    while val > 0
+      b = val & 1
+      result = b.to_s( 2 )  + result
+      val >>= 1
+    end
+    padded result, 8
+  end
+
+  def padded( val, length_multiplier )
+    padded_length = ( val.length / length_multiplier ).ceil * length_multiplier
+    padded_length = length_multiplier if padded_length == 0
+    pad_size = padded_length - val.length
+    '0' * pad_size + val
+  end
+
+end
+
+def hexify( data )
+  result = ''
+  data.each_byte do |b|
+    nibble = ( b >> 4 ) & 15
+    result << ( 0x30 + nibble ) if nibble < 10
+    result << ( 0x41 + nibble - 10 ) if nibble >= 10
+    nibble = ( b >> 0 ) & 15
+    result << ( 0x30 + nibble ) if nibble < 10
+    result << ( 0x41 + nibble - 10 ) if nibble >= 10
+  end
+  result
+end
+
+def get_resource( basedir, relative_filename )
+  basedir = File.dirname basedir unless File.directory? basedir
+  filename = File.join( basedir, relative_filename )
+  raise "Resource not found: #{filename}" unless File.exists? filename
+  return filename
+end
+
+def open_resource( basedir, relative_filename )
+  File.new get_resource( basedir, relative_filename ), 'rb'
+end
+
+def load_resource( basedir, relative_filename )
+  File.open( get_resource( basedir, relative_filename ), 'rb' ) do |file|
+    return file.read
+  end
+end
+
+class NullLogger < Logger
+  def initialize( *args )
+    super STDOUT
+    @level = WARN
+  end
+end
+
+NULL_LOGGER = NullLogger.new
+
+args = [ '--runner=console', '--verbose=v' ]
+args.concat ARGV
+success = Test::Unit::AutoRunner.run( true, File.dirname( $0 ), args )
+exit 10 unless success

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: BitStructEx
+version: !ruby/object:Gem::Version 
+  version: 0.0.54
+date: 2006-04-13 00:00:00 +02:00
+summary: Simple DSL for defining bit-based structures on byte data.
+require_paths: 
+- src/ruby
+email: tfdj {AT} berlinfactor {DOT} com
+homepage: bit-struct-ex.rubyforge.org.
+rubyforge_project: bit-struct-ex
+description: "Allows the specification of bit-based structures and provides an intuitive way of access data.  Example:  class Flags < StructBase unsigned :direction, 4 unsigned :multiplier, 2 unsigned :offset, 2 end  class Entry < StructBase unsigned :offset, 4 nested   :flags, Flags unsigned :address, 24 unsigned :cache_id, 16 end  In contrast to the already available http://raa.ruby-lang.org/project/bit-struct/ implementation, BitStructEx allows nested structures which are not aligned on byte boundaries."
+autorequire: bit_struct/struct_base
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- The.French.DJ
+files: 
+- lib/ruby/rake/version.rb
+- src/ruby/bit_struct/bit_slicer.rb
+- src/ruby/bit_struct/field.rb
+- src/ruby/bit_struct/nested.rb
+- src/ruby/bit_struct/struct_base.rb
+- src/ruby/bit_struct/unsigned.rb
+- test/ruby/runner.rb
+- test/ruby/bit_struct/test_bit_slicer.rb
+- test/ruby/bit_struct/test_struct_base.rb
+- Rakefile
+- Version
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+