bindata 1.1.0 → 1.2.0

data/lib/bindata/int.rb

@@ -9,16 +9,14 @@ module BinData
       def define_class(nbits, endian, signed)
         name = class_name(nbits, endian, signed)
         unless BinData.const_defined?(name)
-          int_type = (signed == :signed) ? 'int' : 'uint'
-          creation_method = "create_#{int_type}_methods"
-
           BinData.module_eval <<-END
             class #{name} < BinData::BasePrimitive
-              register(self.name, self)
-              Int.#{creation_method}(self, #{nbits}, :#{endian.to_s})
+              register_self
+              Int.define_methods(self, #{nbits}, :#{endian}, :#{signed})
             end
           END
         end
+
         BinData.const_get(name)
       end
 
@@ -29,37 +27,51 @@ module BinData
         "#{base}#{nbits}#{endian_str}"
       end
 
-      def create_uint_methods(int_class, nbits, endian)
+      def define_methods(int_class, nbits, endian, signed)
         raise "nbits must be divisible by 8" unless (nbits % 8).zero?
 
-        min = 0
-        max = (1 << nbits) - 1
+        int_class.module_eval <<-END
+          #---------------
+          private
 
-        clamp = create_clamp_code(min, max)
-        read = create_read_code(nbits, endian)
-        to_binary_s = create_to_binary_s_code(nbits, endian)
+          def _assign(val)
+            #{create_clamp_code(nbits, signed)}
+            super(val)
+          end
 
-        define_methods(int_class, nbits / 8, clamp, read, to_binary_s)
-      end
+          def _do_num_bytes
+            #{nbits / 8}
+          end
 
-      def create_int_methods(int_class, nbits, endian)
-        raise "nbits must be divisible by 8" unless (nbits % 8).zero?
+          def sensible_default
+            0
+          end
 
-        max = (1 << (nbits - 1)) - 1
-        min = -(max + 1)
+          def value_to_binary_string(val)
+            #{create_clamp_code(nbits, signed)}
+            #{create_int2uint_code(nbits) if signed == :signed}
+            #{create_to_binary_s_code(nbits, endian)}
+          end
 
-        clamp = create_clamp_code(min, max)
-        read = create_read_code(nbits, endian)
-        to_binary_s = create_to_binary_s_code(nbits, endian)
+          def read_and_return_value(io)
+            val = #{create_read_code(nbits, endian)}
+            #{create_uint2int_code(nbits) if signed == :signed}
+          end
+        END
+      end
 
-        int2uint = create_int2uint_code(nbits)
-        uint2int = create_uint2int_code(nbits)
+      #-------------
+      private
 
-        define_methods(int_class, nbits / 8, clamp, read, to_binary_s,
-                         int2uint, uint2int)
-      end
+      def create_clamp_code(nbits, signed)
+        if signed == :signed
+          max = (1 << (nbits - 1)) - 1
+          min = -(max + 1)
+        else
+          min = 0
+          max = (1 << nbits) - 1
+        end
 
-      def create_clamp_code(min, max)
         "val = (val < #{min}) ? #{min} : (val > #{max}) ? #{max} : val"
       end
 
@@ -75,31 +87,22 @@ module BinData
       end
 
       def create_read_code(nbits, endian)
-        # 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
-
-        bits_per_word = bytes_per_word * 8
+        bits_per_word = bytes_per_word(nbits) * 8
         nwords        = nbits / bits_per_word
         nbytes        = nbits / 8
 
         idx = (0 ... nwords).to_a
         idx.reverse! if (endian == :big)
 
-        unpack_str = "a = io.readbytes(#{nbytes}).unpack('#{d * nwords}')"
-
         parts = (0 ... nwords).collect do |i|
-                  i.zero? ? "a.at(#{idx[i]})" :
-                            "(a.at(#{idx[i]}) << #{bits_per_word * i})"
+                  if i.zero?
+                    "a.at(#{idx[i]})"
+                  else
+                    "(a.at(#{idx[i]}) << #{bits_per_word * i})"
+                  end
                 end
+
+        unpack_str = "a = io.readbytes(#{nbytes}).unpack('#{pack_directive(nbits, endian)}')"
         assemble_str = parts.join(" + ")
 
         "(#{unpack_str}; #{assemble_str})"
@@ -109,19 +112,7 @@ module BinData
         # 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
-
-        bits_per_word = bytes_per_word * 8
+        bits_per_word = bytes_per_word(nbits) * 8
         nwords        = nbits / bits_per_word
         mask          = (1 << bits_per_word) - 1
 
@@ -133,39 +124,26 @@ module BinData
         parts = (0 ... nwords).collect { |i| "#{vals[i]} & #{mask}" }
         array_str = "[" + parts.join(", ") + "]"
 
-        "#{array_str}.pack('#{d * nwords}')"
+        "#{array_str}.pack('#{pack_directive(nbits, endian)}')"
       end
 
-      def define_methods(int_class, nbytes, clamp, read, to_binary_s,
-                           int2uint = nil, uint2int = nil)
-        int_class.module_eval <<-END
-          #---------------
-          private
-
-          def _assign(val)
-            #{clamp}
-            super(val)
-          end
-
-          def _do_num_bytes
-            #{nbytes}
-          end
+      def bytes_per_word(nbits)
+        (nbits % 32).zero? ? 4 : (nbits % 16).zero? ? 2 : 1
+      end
 
-          def sensible_default
-            0
-          end
+      def pack_directive(nbits, endian)
+        bits_per_word = bytes_per_word(nbits) * 8
+        nwords        = nbits / bits_per_word
 
-          def value_to_binary_string(val)
-            #{clamp}
-            #{int2uint unless int2uint.nil?}
-            #{to_binary_s}
-          end
+        if (nbits % 32).zero?
+          d = (endian == :big) ? 'N' : 'V'
+        elsif (nbits % 16).zero?
+          d = (endian == :big) ? 'n' : 'v'
+        else
+          d = 'C'
+        end
 
-          def read_and_return_value(io)
-            val = #{read}
-            #{uint2int unless uint2int.nil?}
-          end
-        END
+        d * nwords
       end
     end
   end
@@ -173,14 +151,14 @@ module BinData
 
   # Unsigned 1 byte integer.
   class Uint8 < BinData::BasePrimitive
-    register(self.name, self)
-    Int.create_uint_methods(self, 8, :little)
+    register_self
+    Int.define_methods(self, 8, :little, :unsigned)
   end
 
   # Signed 1 byte integer.
   class Int8 < BinData::BasePrimitive
-    register(self.name, self)
-    Int.create_int_methods(self, 8, :little)
+    register_self
+    Int.define_methods(self, 8, :little, :signed)
   end
 
   # Create classes on demand

data/lib/bindata/params.rb

@@ -1,82 +1,135 @@
 require 'bindata/lazy'
 
 module BinData
-  # BinData objects accept parameters when initializing.  AcceptedParameters
-  # allow a BinData class to declaratively identify accepted parameters as
-  # mandatory, optional, default or mutually exclusive.
-  class AcceptedParameters
-
-    def self.invalid_parameter_names
-      unless defined? @invalid_names
-        all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
-        all_names.collect! { |name| name.to_s }
-        allowed_names = ["type"]
-        @invalid_names = all_names - allowed_names
-      end
-      @invalid_names
+  module AcceptedParametersMixin
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
     end
 
-    def initialize(ancestor_params = nil)
-      @mandatory = ancestor_params ? ancestor_params.mandatory : []
-      @optional  = ancestor_params ? ancestor_params.optional  : []
-      @default   = ancestor_params ? ancestor_params.default   : Hash.new
-      @mutually_exclusive = ancestor_params ?
-                                     ancestor_params.mutually_exclusive : []
-    end
+    # Class methods to mix in to BinData::Base
+    module ClassMethods
+      # Mandatory parameters must be present when instantiating a data object.
+      def mandatory_parameters(*args)
+        accepted_parameters.mandatory(*args)
+      end
 
-    def mandatory(*args)
-      if not args.empty?
-        ensure_valid_names(args)
-        @mandatory.concat(args.collect { |arg| arg.to_sym })
-        @mandatory.uniq!
+      # Optional parameters may be present when instantiating a data object.
+      def optional_parameters(*args)
+        accepted_parameters.optional(*args)
       end
-      @mandatory.dup
-    end
 
-    def optional(*args)
-      if not args.empty?
-        ensure_valid_names(args)
-        @optional.concat(args.collect { |arg| arg.to_sym })
-        @optional.uniq!
+      # Default parameters can be overridden when instantiating a data object.
+      def default_parameters(*args)
+        accepted_parameters.default(*args)
       end
-      @optional.dup
-    end
 
-    def default(args = {})
-      if not args.empty?
-        ensure_valid_names(args.keys)
-        args.each_pair do |param, value|
-          @default[param.to_sym] = value
+      # Mutually exclusive parameters may not all be present when
+      # instantiating a data object.
+      def mutually_exclusive_parameters(*args)
+        accepted_parameters.mutually_exclusive(*args)
+      end
+
+      alias_method :mandatory_parameter, :mandatory_parameters
+      alias_method :optional_parameter, :optional_parameters
+      alias_method :default_parameter, :default_parameters
+
+      def accepted_parameters #:nodoc:
+        unless defined? @accepted_parameters
+          ancestor_params = superclass.respond_to?(:accepted_parameters) ?
+                              superclass.accepted_parameters : nil
+          @accepted_parameters = AcceptedParameters.new(ancestor_params)
         end
+        @accepted_parameters
       end
-      @default.dup
     end
 
-    def mutually_exclusive(*args)
-      arg1, arg2 = args
-      if arg1 != nil && arg2 != nil
-        @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
-        @mutually_exclusive.uniq!
+    # BinData objects accept parameters when initializing.  AcceptedParameters
+    # allow a BinData class to declaratively identify accepted parameters as
+    # mandatory, optional, default or mutually exclusive.
+    class AcceptedParameters
+
+      def initialize(ancestor_parameters = nil)
+        if ancestor_parameters
+          @mandatory = ancestor_parameters.mandatory.dup
+          @optional  = ancestor_parameters.optional.dup
+          @default   = ancestor_parameters.default.dup
+          @mutually_exclusive = ancestor_parameters.mutually_exclusive.dup
+        else
+          @mandatory = []
+          @optional  = []
+          @default   = Hash.new
+          @mutually_exclusive = []
+        end
       end
-      @mutually_exclusive.dup
-    end
 
-    def all
-      (@mandatory + @optional + @default.keys).uniq
-    end
+      def mandatory(*args)
+        if not args.empty?
+          @mandatory.concat(to_syms(args))
+          @mandatory.uniq!
+        end
+        @mandatory
+      end
 
-    #---------------
-    private
+      def optional(*args)
+        if not args.empty?
+          @optional.concat(to_syms(args))
+          @optional.uniq!
+        end
+        @optional
+      end
 
-    def ensure_valid_names(names)
-      invalid_names = self.class.invalid_parameter_names
-      names.each do |name|
-        name = name.to_s
-        if invalid_names.include?(name)
-          raise NameError.new("Rename parameter '#{name}' " +
-                              "as it shadows an existing method.", name)
+      def default(args = {})
+        if not args.empty?
+          to_syms(args.keys)  # call for side effect of validating names
+          args.each_pair do |param, value|
+            @default[param.to_sym] = value
+          end
         end
+        @default
+      end
+
+      def mutually_exclusive(*args)
+        arg1, arg2 = args
+        if arg1 != nil && arg2 != nil
+          @mutually_exclusive.push([arg1.to_sym, arg2.to_sym])
+          @mutually_exclusive.uniq!
+        end
+        @mutually_exclusive
+      end
+
+      def all
+        (@mandatory + @optional + @default.keys).uniq
+      end
+
+      #---------------
+      private
+
+      def to_syms(args)
+        syms = args.collect { |el| el.to_sym }
+        ensure_valid_names(syms)
+        syms
+      end
+
+      def ensure_valid_names(names)
+        invalid_names = self.class.invalid_parameter_names
+        names.each do |name|
+          if invalid_names.include?(name)
+            raise NameError.new("Rename parameter '#{name}' " +
+                                "as it shadows an existing method.", name)
+          end
+        end
+      end
+
+      def self.invalid_parameter_names
+        unless defined? @invalid_names
+          all_names = LazyEvaluator.instance_methods(true) + Kernel.methods
+          allowed_names = ["type", :type] # ruby 1.8 vs 1.9
+          invalid_names = (all_names - allowed_names).uniq
+          @invalid_names = Hash[*invalid_names.collect { |key| [key.to_sym, true] }.flatten]
+        end
+        @invalid_names
       end
     end
   end
 end
+

data/lib/bindata/primitive.rb

@@ -1,4 +1,5 @@
 require 'bindata/base_primitive'
+require 'bindata/dsl'
 require 'bindata/struct'
 
 module BinData
@@ -59,98 +60,21 @@ module BinData
   # Primitive objects accept all the parameters that BinData::BasePrimitive do.
   #
   class Primitive < BasePrimitive
+    include DSLMixin
 
-    class << self
-
-      def inherited(subclass) #:nodoc:
-        # Register the names of all subclasses of this class.
-        register(subclass.name, subclass)
-      end
-
-      def endian(endian = nil)
-        @endian ||= default_endian
-        if [:little, :big].include?(endian)
-          @endian = endian
-        elsif endian != nil
-          raise ArgumentError,
-                  "unknown value for endian '#{endian}' in #{self}", caller(1)
-        end
-        @endian
-      end
-
-      def fields #:nodoc:
-        @fields ||= default_fields
-      end
-
-      def method_missing(symbol, *args) #:nodoc:
-        name, params = args
-
-        if name.is_a?(Hash)
-          params = name
-          name = nil
-        end
-
-        type = symbol
-        name = name.to_s
-        params ||= {}
-
-        append_field(type, name, params)
-      end
+    register_subclasses
+    dsl_parser :multiple_fields, :optional_fieldnames, :sanitize_fields
 
+    class << self
       def sanitize_parameters!(params, sanitizer) #:nodoc:
-        struct_params = {}
-        struct_params[:fields] = fields
-        struct_params[:endian] = endian unless endian.nil?
-        
-        params[:struct_params] = struct_params
-      end
-
-      #-------------
-      private
-
-      def parent_primitive
-        ancestors[1..-1].find { |cls|
-          cls.ancestors[1..-1].include?(BinData::Primitive)
-        }
-      end
-
-      def default_endian
-        prim = parent_primitive
-        prim ? prim.endian : nil
-      end
-
-      def default_fields
-        prim = parent_primitive
-        if prim
-          Sanitizer.new.clone_sanitized_fields(prim.fields)
-        else
-          Sanitizer.new.create_sanitized_fields
-        end
-      end
-
-      def append_field(type, name, params)
-        ensure_valid_name(name)
-
-        fields.add_field(type, name, params, endian)
-      rescue UnknownTypeError => err
-        raise TypeError, "unknown type '#{err.message}' for #{self}", caller(2)
-      end
-
-      def ensure_valid_name(name)
-        if fields.field_names.include?(name)
-          raise SyntaxError, "duplicate field '#{name}' in #{self}", caller(3)
-        end
-        if self.instance_methods.collect { |meth| meth.to_s }.include?(name)
-          raise NameError.new("", name),
-                "field '#{name}' shadows an existing method in #{self}", caller(3)
-        end
+        params[:struct_params] = sanitizer.create_sanitized_params(to_struct_params, BinData::Struct)
       end
     end
 
     mandatory_parameter :struct_params
 
-    def initialize(params = {}, parent = nil)
-      super(params, parent)
+    def initialize(parameters = {}, parent = nil)
+      super
 
       @struct = BinData::Struct.new(get_parameter(:struct_params), self)
     end
@@ -163,10 +87,6 @@ module BinData
       debug_name + "-internal-"
     end
 
-    def offset_of(child) #:nodoc:
-      @struct.offset_of(child)
-    end
-
     #---------------
     private