bindata 0.9.3 → 0.10.0

data/lib/bindata/choice.rb

@@ -1,6 +1,7 @@
 require 'forwardable'
 require 'bindata/base'
 require 'bindata/sanitize'
+require 'bindata/trace'
 
 module BinData
   # A Choice is a collection of data objects of which only one is active
@@ -29,10 +30,10 @@ module BinData
   #   a = BinData::Choice.new(:choices => choices,
   #                           :selection => lambda { mychoice })
   #   a.value  = 256
-  #   a.to_s #=> "\001\000"
+  #   a.to_binary_s #=> "\001\000"
   #   mychoice.replace 'little'
   #   a.selection #=> 'little'
-  #   a.to_s #=> "\000\001"
+  #   a.to_binary_s #=> "\000\001"
   #
   #
   # == Parameters
@@ -40,73 +41,89 @@ module BinData
   # Parameters may be provided at initialisation to control the behaviour of
   # an object.  These params are:
   #
-  # <tt>:choices</tt>::   Either an array or a hash specifying the possible
-  #                       data objects.  The format of the array/hash.values is
-  #                       a list of symbols representing the data object type.
-  #                       If a choice is to have params passed to it, then it
-  #                       should be provided as [type_symbol, hash_params].
-  #                       An implementation gotcha is that the hash may not
-  #                       contain symbols as keys.
-  # <tt>:selection</tt>:: An index/key into the :choices array/hash which
-  #                       specifies the currently active choice.
+  # <tt>:choices</tt>::        Either an array or a hash specifying the possible
+  #                            data objects.  The format of the
+  #                            array/hash.values is a list of symbols
+  #                            representing the data object type.  If a choice
+  #                            is to have params passed to it, then it should
+  #                            be provided as [type_symbol, hash_params].  An
+  #                            implementation constraint is that the hash may
+  #                            not contain symbols as keys.
+  # <tt>:selection</tt>::      An index/key into the :choices array/hash which
+  #                            specifies the currently active choice.
+  # <tt>:copy_on_change</tt>:: If set to true, copy the value of the previous
+  #                            selection to the current selection whenever the
+  #                            selection changes.  Default is false.
   class Choice < BinData::Base
     extend Forwardable
 
-    # Register this class
     register(self.name, self)
 
-    # These are the parameters used by this class.
-    bindata_mandatory_parameters :choices, :selection
+    mandatory_parameters :choices, :selection
+    optional_parameter   :copy_on_change
 
     class << self
 
-      # Ensures that +params+ is of the form expected by #initialize.
       def sanitize_parameters!(sanitizer, params)
         if params.has_key?(:choices)
-          choices = params[:choices]
-
-          # 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
-            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
+          choices = choices_as_hash(params[:choices])
+          ensure_valid_keys(choices)
+          params[:choices] = sanitized_choices(sanitizer, choices)
         end
 
         super(sanitizer, params)
       end
+
+      #-------------
+      private
+
+      def choices_as_hash(choices)
+        if choices.respond_to?(:to_ary)
+          key_array_by_index(choices.to_ary)
+        else
+          choices
+        end
+      end
+
+      def key_array_by_index(array)
+        result = {}
+        array.each_with_index do |el, i|
+          result[i] = el unless el.nil?
+        end
+        result
+      end
+
+      def ensure_valid_keys(choices)
+        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
+      end
+
+      def sanitized_choices(sanitizer, choices)
+        result = {}
+        choices.each_pair do |key, val|
+          type, param = val
+          the_class = sanitizer.lookup_class(type)
+          sanitized_params = sanitizer.sanitized_params(the_class, param)
+          result[key] = [the_class, sanitized_params]
+        end
+        result
+      end
     end
 
     def initialize(params = {}, parent = nil)
       super(params, parent)
 
-      @choices  = {}
-      @last_key = nil
+      @choices = {}
+      @last_selection = nil
     end
 
     # A convenience method that returns the current selection.
     def selection
-      eval_param(:selection)
+      eval_parameter(:selection)
     end
 
     # This method does not exist. This stub only exists to document why.
@@ -116,7 +133,7 @@ module BinData
     # If you really *must* be able to programmatically adjust the selection
     # then try something like the following.
     #
-    #   class ProgrammaticChoice < BinData::MultiValue
+    #   class ProgrammaticChoice < BinData::Record
     #     choice :data, :choices => :choices, :selection => :selection
     #     attrib_accessor :selection
     #   end
@@ -136,62 +153,120 @@ module BinData
       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
+    def_delegators :current_choice, :clear, :clear?
 
-    # Override to include selected data object.
     def respond_to?(symbol, include_private = false)
-      super || the_choice.respond_to?(symbol, include_private)
+      super || current_choice.respond_to?(symbol, include_private)
     end
 
     def method_missing(symbol, *args, &block)
-      if the_choice.respond_to?(symbol)
-        the_choice.__send__(symbol, *args, &block)
+      if current_choice.respond_to?(symbol)
+        current_choice.__send__(symbol, *args, &block)
       else
         super
       end
     end
 
+    def debug_name_of(child)
+      debug_name
+    end
+
+    def offset_of(child)
+      offset
+    end
+
     #---------------
     private
 
-    # Returns the selected data object.
-    def the_choice
-      key = eval_param(:selection)
+    def _do_read(io)
+      trace_selection
+      current_choice.do_read(io)
+    end
+
+    def trace_selection
+      BinData::trace_message do |tracer|
+        selection_string = eval_parameter(:selection).inspect
+        if selection_string.length > 30
+          selection_string = selection_string.slice(0 .. 30) + "..."
+        end
+
+        tracer.trace("#{debug_name}-selection- => #{selection_string}")
+      end
+    end
+
+    def _done_read
+      current_choice.done_read
+    end
+
+    def _do_write(io)
+      current_choice.do_write(io)
+    end
+
+    def _do_num_bytes(what)
+      current_choice.do_num_bytes(what)
+    end
+
+    def _assign(val)
+      current_choice.assign(val)
+    end
+
+    def _snapshot
+      current_choice.snapshot
+    end
 
-      if key.nil?
-        raise IndexError, ":selection returned nil value"
+    def current_choice
+      selection = eval_parameter(:selection)
+      if selection.nil?
+        raise IndexError, ":selection returned nil for #{debug_name}"
       end
 
-      obj = @choices[key]
+      obj = get_or_instantiate_choice(selection)
+      copy_previous_value_if_required(selection, obj)
+
+      obj
+    end
+
+    def get_or_instantiate_choice(selection)
+      obj = @choices[selection]
       if obj.nil?
-        # instantiate choice object
-        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, self)
-        @choices[key] = obj
+        obj = instantiate_choice(selection)
+        @choices[selection] = obj
+      end
+      obj
+    end
+
+    def instantiate_choice(selection)
+      choice_class, choice_params = get_parameter(:choices)[selection]
+      if choice_class.nil?
+        raise IndexError, "selection '#{selection}' does not exist in :choices for #{debug_name}"
       end
+      choice_class.new(choice_params, self)
+    end
 
-      # for single_values copy the value when the selected object changes
-      if key != @last_key
-        if @last_key != nil
-          prev = @choices[@last_key]
-          if prev != nil and prev.single_value? and obj.single_value?
-            obj.value = prev.value
-          end
-        end
-        @last_key = key
+    def copy_previous_value_if_required(selection, obj)
+      prev = get_previous_choice(selection)
+      if should_copy_value?(prev, obj)
+        obj.assign(prev)
       end
+      remember_current_selection(selection)
+    end
 
-      obj
+    def should_copy_value?(prev, cur)
+      prev != nil and eval_parameter(:copy_on_change) == true
+    end
+
+    def get_previous_choice(selection)
+      if selection != @last_selection and @last_selection != nil
+        @choices[@last_selection]
+      else
+        nil
+      end
+    end
+
+    def remember_current_selection(selection)
+      if selection != @last_selection
+        @last_selection = selection
+      end
     end
   end
 end

data/lib/bindata/float.rb

@@ -1,19 +1,20 @@
-require 'bindata/single'
+require 'bindata/base_primitive'
 
 module BinData
-  # Provides a number of classes that contain a floating point number.
-  # The float is defined by endian, and precision.
+  # Defines a number of classes that contain a floating point number.
+  # The float is defined by precision and endian.
 
-  module Float #:nodoc: all
-    def self.create_float_methods(klass, single_precision, endian)
-      read = create_read_code(single_precision, endian)
-      to_s = create_to_s_code(single_precision, endian)
+  module FloatingPoint #:nodoc: all
+    def self.create_float_methods(float_class, precision, endian)
+      read = create_read_code(precision, endian)
+      to_s = create_to_s_code(precision, endian)
+      nbytes = (precision == :single) ? 4 : 8
 
-      define_methods(klass, single_precision, read, to_s)
+      define_methods(float_class, nbytes, read, to_s)
     end
 
-    def self.create_read_code(single_precision, endian)
-      if single_precision
+    def self.create_read_code(precision, endian)
+      if precision == :single
         unpack = (endian == :little) ? 'e' : 'g'
         nbytes = 4
       else # double_precision
@@ -24,8 +25,8 @@ module BinData
       "io.readbytes(#{nbytes}).unpack('#{unpack}').at(0)"
     end
 
-    def self.create_to_s_code(single_precision, endian)
-      if single_precision
+    def self.create_to_s_code(precision, endian)
+      if precision == :single
         pack = (endian == :little) ? 'e' : 'g'
       else # double_precision
         pack = (endian == :little) ? 'E' : 'G'
@@ -34,11 +35,8 @@ module BinData
       "[val].pack('#{pack}')"
     end
 
-    def self.define_methods(klass, single_precision, read, to_s)
-      nbytes = single_precision ? 4 : 8
-
-      # define methods in the given class
-      klass.module_eval <<-END
+    def self.define_methods(float_class, nbytes, read, to_s)
+      float_class.module_eval <<-END
         def _do_num_bytes(ignored)
           #{nbytes}
         end
@@ -50,11 +48,11 @@ module BinData
           0.0
         end
 
-        def val_to_str(val)
+        def value_to_binary_string(val)
           #{to_s}
         end
 
-        def read_val(io)
+        def read_and_return_value(io)
           #{read}
         end
       END
@@ -63,26 +61,26 @@ module BinData
 
 
   # Single precision floating point number in little endian format
-  class FloatLe < BinData::Single
+  class FloatLe < BinData::BasePrimitive
     register(self.name, self)
-    Float.create_float_methods(self, true, :little)
+    FloatingPoint.create_float_methods(self, :single, :little)
   end
 
   # Single precision floating point number in big endian format
-  class FloatBe < BinData::Single
+  class FloatBe < BinData::BasePrimitive
     register(self.name, self)
-    Float.create_float_methods(self, true, :big)
+    FloatingPoint.create_float_methods(self, :single, :big)
   end
 
   # Double precision floating point number in little endian format
-  class DoubleLe < BinData::Single
+  class DoubleLe < BinData::BasePrimitive
     register(self.name, self)
-    Float.create_float_methods(self, false, :little)
+    FloatingPoint.create_float_methods(self, :double, :little)
   end
 
   # Double precision floating point number in big endian format
-  class DoubleBe < BinData::Single
+  class DoubleBe < BinData::BasePrimitive
     register(self.name, self)
-    Float.create_float_methods(self, false, :big)
+    FloatingPoint.create_float_methods(self, :double, :big)
   end
 end

data/lib/bindata/int.rb

@@ -1,220 +1,187 @@
-require 'bindata/single'
+require 'bindata/base_primitive'
 
 module BinData
-  # Provides a number of classes that contain an integer.  The integer
+  # Defines a number of classes that contain an integer.  The integer
   # is defined by endian, signedness and number of bytes.
 
   module Integer #:nodoc: all
-    def self.create_int_methods(klass, nbits, endian)
-      max = (1 << (nbits - 1)) - 1
-      min = -(max + 1)
-      clamp = "val = (val < #{min}) ? #{min} : (val > #{max}) ? #{max} : val"
+    class << self
+      def define_class(nbits, endian, signed)
+        endian_str = (endian == :big) ? "be" : "le"
+        if signed == :signed
+          name = "Int#{nbits}#{endian_str}"
+          creation_method = "create_int_methods"
+        else
+          name = "Uint#{nbits}#{endian_str}"
+          creation_method = "create_uint_methods"
+        end
+
+        BinData.module_eval <<-END
+          class #{name} < BinData::BasePrimitive
+            register(self.name, self)
+            Integer.#{creation_method}(self, #{nbits}, :#{endian.to_s})
+          end
+        END
+      end
 
-      int2uint = "val = val & #{(1 << nbits) - 1}"
-      uint2int = "val = ((val & #{1 << (nbits - 1)}).zero?) ? " +
-                 "val & #{max} : -(((~val) & #{max}) + 1)"
+      def create_uint_methods(int_class, nbits, endian)
+        min = 0
+        max = (1 << nbits) - 1
 
-      read = create_read_code(nbits, endian)
-      to_s = create_to_s_code(nbits, endian)
+        clamp = create_clamp_code(min, max)
+        read = create_read_code(nbits, endian)
+        to_s = create_to_s_code(nbits, endian)
 
-      define_methods(klass, nbits / 8, clamp, read, to_s, int2uint, uint2int)
-    end
+        define_methods(int_class, nbits / 8, clamp, read, to_s)
+      end
 
-    def self.create_uint_methods(klass, nbits, endian)
-      min = 0
-      max = (1 << nbits) - 1
-      clamp = "val = (val < #{min}) ? #{min} : (val > #{max}) ? #{max} : val"
+      def create_int_methods(int_class, nbits, endian)
+        max = (1 << (nbits - 1)) - 1
+        min = -(max + 1)
 
-      read = create_read_code(nbits, endian)
-      to_s = create_to_s_code(nbits, endian)
+        clamp = create_clamp_code(min, max)
+        read = create_read_code(nbits, endian)
+        to_s = create_to_s_code(nbits, endian)
 
-      define_methods(klass, nbits / 8, clamp, read, to_s)
-    end
+        int2uint = create_int2uint_code(nbits)
+        uint2int = create_uint2int_code(nbits)
 
-    def self.create_read_code(nbits, endian)
-      c16 = (endian == :little) ? 'v' : 'n'
-      c32 = (endian == :little) ? 'V' : 'N'
-      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(#{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}'"
+        define_methods(int_class, nbits / 8, clamp, read, to_s, int2uint, uint2int)
       end
-    end
 
-    def self.create_to_s_code(nbits, endian)
-      c16 = (endian == :little) ? 'v' : 'n'
-      c32 = (endian == :little) ? 'V' : 'N'
-      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; "[#{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}'"
+      def create_clamp_code(min, max)
+        "val = (val < #{min}) ? #{min} : (val > #{max}) ? #{max} : val"
       end
-    end
 
-    def self.define_methods(klass, nbytes, clamp, read, to_s,
-                            int2uint = nil, uint2int = nil)
-      # define methods in the given class
-      klass.module_eval <<-END
-        def value=(val)
-          #{clamp}
-          super(val)
-        end
+      def create_int2uint_code(nbits)
+        "val = val & #{(1 << nbits) - 1}"
+      end
 
-        def _do_num_bytes(ignored)
-          #{nbytes}
-        end
+      def create_uint2int_code(nbits)
+        mask = (1 << (nbits - 1)) - 1
 
-        #---------------
-        private
+        "val = ((val & #{1 << (nbits - 1)}).zero?) ? " +
+                 "val & #{mask} : -(((~val) & #{mask}) + 1)"
+      end
 
-        def sensible_default
-          0
+      def create_read_code(nbits, endian)
+        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+
+        # determine "word" size and unpack directive
+        if (nbits % 32).zero?
+          bytes_per_word = 4
+          d = (endian == :big) ? 'N' : 'V'
+        elsif (nbits % 16).zero?
+          bytes_per_word = 2
+          d = (endian == :big) ? 'n' : 'v'
+        else
+          bytes_per_word = 1
+          d = 'C'
         end
 
-        def val_to_str(val)
-          #{clamp}
-          #{int2uint unless int2uint.nil?}
-          #{to_s}
-        end
+        bits_per_word = bytes_per_word * 8
+        nwords        = nbits / bits_per_word
+        nbytes        = nbits / 8
 
-        def read_val(io)
-          val = #{read}
-          #{uint2int unless uint2int.nil?}
-        end
-      END
-    end
-  end
+        idx = (0 ... nwords).to_a
+        idx.reverse! if (endian == :big)
 
+        unpack_str = "a = io.readbytes(#{nbytes}).unpack('#{d * nwords}')"
 
-  # Unsigned 1 byte integer.
-  class Uint8 < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 8, :little)
-  end
+        parts = (0 ... nwords).collect do |i|
+                  i.zero? ? "a.at(#{idx[i]})" :
+                            "(a.at(#{idx[i]}) << #{bits_per_word * i})"
+                end
+        assemble_str = parts.join(" + ")
 
-  # Unsigned 2 byte little endian integer.
-  class Uint16le < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 16, :little)
-  end
+        "(#{unpack_str}; #{assemble_str})"
+      end
 
-  # Unsigned 2 byte big endian integer.
-  class Uint16be < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 16, :big)
-  end
+      def create_to_s_code(nbits, endian)
+        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+
+        # special case 8bit integers for speed
+        return "val.chr" if nbits == 8
+
+        # determine "word" size and pack directive
+        if (nbits % 32).zero?
+          bytes_per_word = 4
+          d = (endian == :big) ? 'N' : 'V'
+        elsif (nbits % 16).zero?
+          bytes_per_word = 2
+          d = (endian == :big) ? 'n' : 'v'
+        else
+          bytes_per_word = 1
+          d = 'C'
+        end
 
-  # Unsigned 4 byte little endian integer.
-  class Uint32le < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 32, :little)
-  end
+        bits_per_word = bytes_per_word * 8
+        nwords        = nbits / bits_per_word
+        mask          = (1 << bits_per_word) - 1
 
-  # Unsigned 4 byte big endian integer.
-  class Uint32be < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 32, :big)
-  end
+        vals = (0 ... nwords).collect do |i|
+                 i.zero? ? "val" : "(val >> #{bits_per_word * i})"
+               end
+        vals.reverse! if (endian == :big)
 
-  # Unsigned 8 byte little endian integer.
-  class Uint64le < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 64, :little)
-  end
+        parts = (0 ... nwords).collect { |i| "#{vals[i]} & #{mask}" }
+        array_str = "[" + parts.join(", ") + "]"
 
-  # Unsigned 8 byte big endian integer.
-  class Uint64be < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 64, :big)
-  end
+        "#{array_str}.pack('#{d * nwords}')"
+      end
 
-  # Unsigned 16 byte little endian integer.
-  class Uint128le < BinData::Single
-    register(self.name, self)
-    Integer.create_uint_methods(self, 128, :little)
+      def define_methods(int_class, nbytes, clamp, read, to_s,
+                              int2uint = nil, uint2int = nil)
+        int_class.module_eval <<-END
+          #---------------
+          private
+
+          def _assign(val)
+            #{clamp}
+            super(val)
+          end
+
+          def _do_num_bytes(ignored)
+            #{nbytes}
+          end
+
+          def sensible_default
+            0
+          end
+
+          def value_to_binary_string(val)
+            #{clamp}
+            #{int2uint unless int2uint.nil?}
+            #{to_s}
+          end
+
+          def read_and_return_value(io)
+            val = #{read}
+            #{uint2int unless uint2int.nil?}
+          end
+        END
+      end
+    end
   end
 
-  # Unsigned 16 byte big endian integer.
-  class Uint128be < BinData::Single
+
+  # Unsigned 1 byte integer.
+  class Uint8 < BinData::BasePrimitive
     register(self.name, self)
-    Integer.create_uint_methods(self, 128, :big)
+    Integer.create_uint_methods(self, 8, :little)
   end
 
   # Signed 1 byte integer.
-  class Int8 < BinData::Single
+  class Int8 < BinData::BasePrimitive
     register(self.name, self)
     Integer.create_int_methods(self, 8, :little)
   end
 
-  # Signed 2 byte little endian integer.
-  class Int16le < BinData::Single
-    register(self.name, self)
-    Integer.create_int_methods(self, 16, :little)
-  end
-
-  # Signed 2 byte big endian integer.
-  class Int16be < BinData::Single
-    register(self.name, self)
-    Integer.create_int_methods(self, 16, :big)
-  end
-
-  # Signed 4 byte little endian integer.
-  class Int32le < BinData::Single
-    register(self.name, self)
-    Integer.create_int_methods(self, 32, :little)
-  end
-
-  # Signed 4 byte big endian integer.
-  class Int32be < BinData::Single
-    register(self.name, self)
-    Integer.create_int_methods(self, 32, :big)
-  end
-
-  # Signed 8 byte little endian integer.
-  class Int64le < BinData::Single
-    register(self.name, self)
-    Integer.create_int_methods(self, 64, :little)
-  end
-
-  # Signed 8 byte big endian integer.
-  class Int64be < BinData::Single
-    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)
+  # Create commonly used integers
+  [8, 16, 32, 64, 128].each do |nbits|
+    Integer.define_class(nbits, :little, :unsigned)
+    Integer.define_class(nbits, :little, :signed)
+    Integer.define_class(nbits, :big, :unsigned)
+    Integer.define_class(nbits, :big, :signed)
   end
 end