bindata 2.1.0 → 2.2.0

data/lib/bindata/int.rb

@@ -65,38 +65,44 @@ module BinData
       end
 
       def create_read_code(nbits, endian, signed)
-        unpack_str   = create_read_unpack_code(nbits, endian, signed)
-        assemble_str = create_read_assemble_code(nbits, endian, signed)
+        read_str = create_raw_read_code(nbits, endian, signed)
 
-        read_str = "(#{unpack_str} ; #{assemble_str})"
-
-        if need_conversion_code?(nbits, signed)
+        if need_signed_conversion_code?(nbits, signed)
           "val = #{read_str} ; #{create_uint2int_code(nbits)}"
         else
           read_str
         end
       end
 
+      def create_raw_read_code(nbits, endian, signed)
+        # special case 8bit integers for speed
+        if nbits == 8
+          "io.readbytes(1).ord"
+        else
+          unpack_str   = create_read_unpack_code(nbits, endian, signed)
+          assemble_str = create_read_assemble_code(nbits, endian, signed)
+
+          "(#{unpack_str} ; #{assemble_str})"
+        end
+      end
+
       def create_read_unpack_code(nbits, endian, signed)
-        nbytes = nbits / 8
+        nbytes         = nbits / 8
+        pack_directive = pack_directive(nbits, endian, signed)
 
-        "ints = io.readbytes(#{nbytes}).unpack('#{pack_directive(nbits, endian, signed)}')"
+        "ints = io.readbytes(#{nbytes}).unpack('#{pack_directive}')"
       end
 
       def create_read_assemble_code(nbits, endian, signed)
-        bits_per_word = bytes_per_word(nbits) * 8
-        nwords        = nbits / bits_per_word
+        nwords = nbits / bits_per_word(nbits)
 
         idx = (0 ... nwords).to_a
         idx.reverse! if (endian == :big)
 
         parts = (0 ... nwords).collect do |i|
-                  if i.zero?
-                    "ints.at(#{idx[i]})"
-                  else
-                    "(ints.at(#{idx[i]}) << #{bits_per_word * i})"
-                  end
+                  "(ints.at(#{idx[i]}) << #{bits_per_word(nbits) * i})"
                 end
+        parts[0].sub!(/ << 0\b/, "")  # Remove " << 0" for optimisation
 
         assemble_str = parts.join(" + ")
       end
@@ -105,25 +111,29 @@ module BinData
         # special case 8bit integers for speed
         return "(val & 0xff).chr" if nbits == 8
 
-        bits_per_word = bytes_per_word(nbits) * 8
-        nwords        = nbits / bits_per_word
-        mask          = (1 << bits_per_word) - 1
-
-        vals = (0 ... nwords).collect do |i|
-                 i.zero? ? "val" : "val >> #{bits_per_word * i}"
-               end
-        vals.reverse! if (endian == :big)
+        pack_directive = pack_directive(nbits, endian, signed)
+        words          = val_as_packed_words(nbits, endian, signed)
+        pack_str       = "[#{words}].pack('#{pack_directive}')"
 
-        array_str = "[" + vals.collect { |val| "#{val} & #{mask}" }.join(", ") + "]" # TODO: "& mask" is needed to work around jruby bug
-        pack_str  = "#{array_str}.pack('#{pack_directive(nbits, endian, signed)}')"
-
-        if need_conversion_code?(nbits, signed)
+        if need_signed_conversion_code?(nbits, signed)
           "#{create_int2uint_code(nbits)} ; #{pack_str}"
         else
           pack_str
         end
       end
 
+      def val_as_packed_words(nbits, endian, signed)
+        nwords = nbits / bits_per_word(nbits)
+        mask   = (1 << bits_per_word(nbits)) - 1
+
+        vals = (0 ... nwords).collect { |i| "val >> #{bits_per_word(nbits) * i}" }
+        vals[0].sub!(/ >> 0\b/, "")  # Remove " >> 0" for optimisation
+        vals.reverse! if (endian == :big)
+
+        vals = vals.collect { |val| "#{val} & #{mask}" }  # TODO: "& mask" is needed to work around jruby bug. Remove this line when fixed.
+        vals.join(",")
+      end
+
       def create_int2uint_code(nbits)
         "val &= #{(1 << nbits) - 1}"
       end
@@ -132,40 +142,30 @@ module BinData
         "(val >= #{1 << (nbits - 1)}) ? val - #{1 << nbits} : val"
       end
 
-      def bytes_per_word(nbits)
-        (nbits % 64).zero? ? 8 :
-        (nbits % 32).zero? ? 4 :
-        (nbits % 16).zero? ? 2 :
-                             1
+      def bits_per_word(nbits)
+        (nbits % 64).zero? ? 64 :
+        (nbits % 32).zero? ? 32 :
+        (nbits % 16).zero? ? 16 :
+                              8
       end
 
       def pack_directive(nbits, endian, signed)
-        bits_per_word = bytes_per_word(nbits) * 8
-        nwords        = nbits / bits_per_word
-
-        if (nbits % 64).zero?
-          d = (endian == :big) ? 'Q>' : 'Q<'
-        elsif (nbits % 32).zero?
-          d = (endian == :big) ? 'L>' : 'L<'
-        elsif (nbits % 16).zero?
-          d = (endian == :big) ? 'S>' : 'S<'
-        else
-          d = 'C'
-        end
+        nwords = nbits / bits_per_word(nbits)
+
+        directives = { 8 => "C", 16 => "S", 32 => "L", 64 => "Q" }
+
+        d = directives[bits_per_word(nbits)]
+        d << ((endian == :big) ? ">" : "<") unless d == "C"
 
-        if pack_directive_signed?(nbits, signed)
+        if signed == :signed and directives.has_key?(nbits)
           (d * nwords).downcase
         else
           d * nwords
         end
       end
 
-      def need_conversion_code?(nbits, signed)
-        signed == :signed and not pack_directive_signed?(nbits, signed)
-      end
-
-      def pack_directive_signed?(nbits, signed)
-        signed == :signed and [64, 32, 16, 8].include?(nbits)
+      def need_signed_conversion_code?(nbits, signed)
+        signed == :signed and not [64, 32, 16].include?(nbits)
       end
     end
   end

data/lib/bindata/registry.rb

@@ -5,8 +5,16 @@ module BinData
   # This registry contains a register of name -> class mappings.
   #
   # Numerics (integers and floating point numbers) have an endian property as
-  # part of their name (e.g. int32be, float_le).  The lookup can either be
-  # on the full name, or on the shortened name plus endian (e.g. "int32", :big)
+  # part of their name (e.g. int32be, float_le).
+  #
+  # Classes can be looked up based on their full name or an abbreviated +name+
+  # with +hints+.
+  #
+  # There are two hints supported, :endian and :search_prefix.
+  #
+  #   #lookup("int32", { endian: :big }) will return Int32Be.
+  #
+  #   #lookup("my_type", { search_prefix: :ns }) will return NsMyType.
   #
   # Names are stored in under_score_style, not camelCase.
   class Registry
@@ -28,21 +36,11 @@ module BinData
       @registry.delete(underscore_name(name))
     end
 
-    def lookup(name, endian = nil)
-      key = normalize_name(name, endian)
+    def lookup(name, hints = {})
+      key = normalize_name(name, hints)
       @registry[key] || raise(UnRegisteredTypeError, name.to_s)
     end
 
-    def normalize_name(name, endian = nil)
-      name = underscore_name(name)
-      return name if is_registered?(name)
-
-      name = name_with_endian(name, endian)
-      return name if is_registered?(name)
-
-      name
-    end
-
     # Convert CamelCase +name+ to underscore style.
     def underscore_name(name)
       name.to_s.sub(/.*::/, "").
@@ -55,6 +53,32 @@ module BinData
     #---------------
     private
 
+    def normalize_name(name, hints)
+      name = underscore_name(name)
+
+      if not is_registered?(name)
+        search_prefix = [""].concat(Array(hints[:search_prefix]))
+        search_prefix.each do |prefix|
+          n = name_with_endian(name_with_prefix(name, prefix), hints[:endian])
+          if is_registered?(n)
+            name = n
+            break
+          end
+        end
+      end
+
+      name
+    end
+
+    def name_with_prefix(name, prefix)
+      prefix = prefix.to_s.chomp("_")
+      if prefix == ""
+        name
+      else
+        "#{prefix}_#{name}"
+      end
+    end
+
     def name_with_endian(name, endian)
       return name if endian.nil?
 

data/lib/bindata/sanitize.rb

@@ -6,21 +6,24 @@ module BinData
   class SanitizedParameter; end
 
   class SanitizedPrototype < SanitizedParameter
-    def initialize(obj_type, obj_params, endian)
-      endian = endian.endian if endian.respond_to? :endian
+    def initialize(obj_type, obj_params, hints)
+      raw_hints = hints.dup
+      if raw_hints[:endian].respond_to?(:endian)
+        raw_hints[:endian] = raw_hints[:endian].endian
+      end
       obj_params ||= {}
 
       if BinData::Base === obj_type
         obj_class = obj_type
       else
-        obj_class = RegisteredClasses.lookup(obj_type, endian)
+        obj_class = RegisteredClasses.lookup(obj_type, raw_hints)
       end
 
       if BinData::Base === obj_class
         @factory = obj_class
       else
         @obj_class  = obj_class
-        @obj_params = SanitizedParameters.new(obj_params, @obj_class, endian)
+        @obj_params = SanitizedParameters.new(obj_params, @obj_class, hints)
       end
     end
 
@@ -41,9 +44,9 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedField < SanitizedParameter
-    def initialize(name, field_type, field_params, endian)
+    def initialize(name, field_type, field_params, hints)
       @name      = name
-      @prototype = SanitizedPrototype.new(field_type, field_params, endian)
+      @prototype = SanitizedPrototype.new(field_type, field_params, hints)
     end
 
     attr_reader :prototype
@@ -69,16 +72,16 @@ module BinData
   class SanitizedFields < SanitizedParameter
     include Enumerable
 
-    def initialize(endian)
+    def initialize(hints)
       @fields = []
-      @endian = endian
+      @hints  = hints
     end
     attr_reader :fields
 
     def add_field(type, name, params)
       name = nil if name == ""
 
-      @fields << SanitizedField.new(name, type, params, @endian)
+      @fields << SanitizedField.new(name, type, params, @hints)
     end
 
     def [](idx)
@@ -124,14 +127,14 @@ module BinData
   #----------------------------------------------------------------------------
 
   class SanitizedChoices < SanitizedParameter
-    def initialize(choices, endian)
+    def initialize(choices, hints)
       @choices = {}
       choices.each_pair do |key, val|
         if SanitizedParameter === val
           prototype = val
         else
           type, param = val
-          prototype = SanitizedPrototype.new(type, param, endian)
+          prototype = SanitizedPrototype.new(type, param, hints)
         end
 
         if key == :default
@@ -183,16 +186,23 @@ module BinData
         if SanitizedParameters === parameters
           parameters
         else
-          SanitizedParameters.new(parameters, the_class, nil)
+          SanitizedParameters.new(parameters, the_class, {})
         end
       end
     end
 
-    def initialize(parameters, the_class, endian)
+    def initialize(parameters, the_class, hints)
       parameters.each_pair { |key, value| self[key.to_sym] = value }
 
       @the_class = the_class
-      @endian    = endian
+
+      if hints[:endian]
+        self[:endian] ||= hints[:endian]
+      end
+
+      if hints[:search_prefix]
+        self[:search_prefix] = Array(self[:search_prefix]).concat(Array(hints[:search_prefix]))
+      end
 
       sanitize!
     end
@@ -235,10 +245,12 @@ module BinData
       end
     end
 
-    def endian
-      @endian || self[:endian]
+    def hints
+      {
+        :endian => self[:endian],
+        :search_prefix => self[:search_prefix],
+      }
     end
-    attr_writer :endian
 
     def create_sanitized_endian(endian)
       if endian == :big
@@ -253,19 +265,19 @@ module BinData
     end
 
     def create_sanitized_params(params, the_class)
-      SanitizedParameters.new(params, the_class, self.endian)
+      SanitizedParameters.new(params, the_class, hints)
     end
 
     def create_sanitized_choices(choices)
-      SanitizedChoices.new(choices, self.endian)
+      SanitizedChoices.new(choices, hints)
     end
 
     def create_sanitized_fields
-      SanitizedFields.new(self.endian)
+      SanitizedFields.new(hints)
     end
 
     def create_sanitized_object_prototype(obj_type, obj_params)
-      SanitizedPrototype.new(obj_type, obj_params, self.endian)
+      SanitizedPrototype.new(obj_type, obj_params, hints)
     end
 
     #---------------

data/lib/bindata/string.rb

@@ -56,6 +56,14 @@ module BinData
     mutually_exclusive_parameters :read_length, :length
     mutually_exclusive_parameters :length, :value
 
+    def initialize_shared_instance
+      if (has_parameter?(:value) || has_parameter?(:asserted_value)) &&
+          ! has_parameter?(:read_length)
+        extend WarnNoReadLengthPlugin
+      end
+      super
+    end
+
     def assign(val)
       super(binary_string(val))
     end
@@ -141,4 +149,12 @@ module BinData
       pad_byte
     end
   end
+
+  # Warns when reading if :value && no :read_length
+  module WarnNoReadLengthPlugin
+    def read_and_return_value(io)
+      warn "#{debug_name} does not have a :read_length parameter - returning empty string"
+      ""
+    end
+  end
 end

data/lib/bindata/struct.rb

@@ -42,6 +42,9 @@ module BinData
   # <tt>:endian</tt>::   Either :little or :big.  This specifies the default
   #                      endian of any numerics in this struct, or in any
   #                      nested data objects.
+  # <tt>:search_prefix</tt>::  Allows abbreviated type names.  If a type is
+  #                            unrecognised, then each prefix is applied until
+  #                            a match is found.
   #
   # == Field Parameters
   #
@@ -56,7 +59,7 @@ module BinData
     arg_processor :struct
 
     mandatory_parameter :fields
-    optional_parameters :endian, :hide
+    optional_parameters :endian, :search_prefix, :hide
 
     # These reserved words may not be used as field names
     RESERVED = Hash[*
@@ -333,6 +336,7 @@ module BinData
   class StructArgProcessor < BaseArgProcessor
     def sanitize_parameters!(obj_class, params)
       sanitize_endian(params)
+      sanitize_search_prefix(params)
       sanitize_fields(obj_class, params)
       sanitize_hide(params)
     end
@@ -344,7 +348,18 @@ module BinData
       if params.needs_sanitizing?(:endian)
         endian = params.create_sanitized_endian(params[:endian])
         params[:endian] = endian
-        params.endian   = endian # sync params[:endian] and params.endian
+      end
+    end
+
+    def sanitize_search_prefix(params)
+      if params.needs_sanitizing?(:search_prefix)
+        search_prefix = []
+        Array(params[:search_prefix]).each do |prefix|
+          prefix = prefix.to_s.chomp("_")
+          search_prefix << prefix if prefix != ""
+        end
+
+        params[:search_prefix] = search_prefix
       end
     end
 

data/lib/bindata/version.rb

@@ -1,3 +1,3 @@
 module BinData
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end