bit-struct 0.15.0 → 0.16

data/lib/bit-struct/char-field.rb

@@ -5,7 +5,7 @@ class BitStruct
     #def self.default
     #  don't define this, since it must specify N nulls and we don't know N
     #end
-    
+
     # Used in describe.
     def self.class_name
       @class_name ||= "char"
@@ -17,13 +17,13 @@ class BitStruct
           "Bad offset, #{offset}, for #{self.class} #{name}." +
           " Must be multiple of 8."
       end
-      
+
       unless length % 8 == 0
         raise ArgumentError,
           "Bad length, #{length}, for #{self.class} #{name}." +
           " Must be multiple of 8."
       end
-      
+
       offset_byte = offset / 8
       length_byte = length / 8
       last_byte = offset_byte + length_byte - 1

data/lib/bit-struct/field.rb

@@ -0,0 +1,94 @@
+
+class BitStruct
+  class Field
+    # Offset of field in bits.
+    attr_reader :offset
+
+    # Length of field in bits.
+    attr_reader :length
+    alias size length
+
+    # Name of field (used for its accessors).
+    attr_reader :name
+
+    # Options, such as :default (varies for each field subclass).
+    # In general, options can be provided as strings or as symbols.
+    attr_reader :options
+
+    # Display name of field (used for printing).
+    attr_reader :display_name
+
+    # Default value.
+    attr_reader :default
+
+    # Format for printed value of field.
+    attr_reader :format
+
+    # Subclasses can override this to define a default for all fields of this
+    # class, not just the one currently being added to a BitStruct class, a
+    # "default default" if you will. The global default, if #default returns
+    # nil, is to fill the field with zero. Most field classes just let this
+    # default stand. The default can be overridden per-field when a BitStruct
+    # class is defined.
+    def self.default; nil; end
+
+    # Used in describe.
+    def self.class_name
+      @class_name ||= name[/\w+$/]
+    end
+
+    # Used in describe. Can be overridden per-subclass, as in NestedField.
+    def class_name
+      self.class.class_name
+    end
+
+    # Yield the description of this field, as an array of 5 strings: byte
+    # offset, type, name, size, and description. The opts hash may have:
+    #
+    # :expand ::  if the value is true, expand complex fields
+    #
+    # (Subclass implementations may yield more than once for complex fields.)
+    #
+    def describe opts
+      bits = size
+      if bits > 32 and bits % 8 == 0
+        len_str = "%dB" % (bits/8)
+      else
+        len_str = "%db" % bits
+      end
+
+      byte_offset = offset / 8 + (opts[:byte_offset] || 0)
+
+      yield ["@%d" % byte_offset, class_name, name, len_str, display_name]
+    end
+
+    # Options are _display_name_, _default_, and _format_ (subclasses of Field
+    # may add other options).
+    def initialize(offset, length, name, opts = {})
+      @offset, @length, @name, @options =
+        offset, length, name, opts
+
+      @display_name = opts[:display_name] || opts["display_name"]
+      @default      = opts[:default] || opts["default"] || self.class.default
+      @format       = opts[:format] || opts["format"]
+    end
+
+    # Inspect the value of this field in the specified _obj_.
+    def inspect_in_object(obj, opts)
+      val = obj.send(name)
+      str =
+        begin
+          val.inspect_with_options(opts)
+        rescue NoMethodError
+          val.inspect
+        end
+      (f=@format) ? (f % str) : str
+    end
+
+    # Normally, all fields show up in inspect, but some, such as padding,
+    # should not.
+    def inspectable?; true; end
+  end
+end
+
+

data/lib/bit-struct/fields.rb

@@ -94,24 +94,24 @@ class BitStruct
     #   n.x = 3
     #   a.n = n
     #   p a  # ==> #<A n=#<Sub x=3>>
-    # 
+    #
     def nest(name, *rest, &block)
       nested_class = rest.grep(Class).find {|cl| cl <= BitStruct}
       rest.delete nested_class
       opts = parse_options(rest, name, NestedField)
       nested_class = opts[:nested_class] ||= nested_class
-      
+
       unless (block and not nested_class) or (nested_class and not block)
         raise ArgumentError,
           "nested field must have either a nested_class option or a block," +
           " but not both"
       end
-      
+
       unless nested_class
         nested_class = Class.new(BitStruct)
         nested_class.class_eval(&block)
       end
-      
+
       opts[:default] ||= nested_class.initial_value.dup
       opts[:nested_class] = nested_class
       field = add_field(name, nested_class.bit_length, opts)
@@ -250,17 +250,17 @@ class BitStruct
     #         entry.y = -456
     #       vec[2] = entry
     #     pkt.v = vec
-    # 
+    #
     def vector(name, *rest, &block)
       opts = parse_options(rest, name, nil)
       cl = opts[:field_class]
       opts[:field_class] = VectorField
-      
+
       unless (block and not cl) or (cl and not block)
         raise ArgumentError,
           "vector must have either a class or a block, but not both"
       end
-      
+
       case
       when cl == nil
         vector_class = Class.new(BitStruct::Vector)
@@ -272,12 +272,12 @@ class BitStruct
 
       when cl < BitStruct::Vector
         vector_class = cl
-      
+
       else raise ArgumentError, "Bad vector class: #{cl.inspect}"
       end
-      
+
       vector_class.default_options default_options
-      
+
       length = opts[:length] || rest.grep(Integer).first
         ## what about :length => :lenfield
       unless length
@@ -287,14 +287,14 @@ class BitStruct
 
       opts[:default] ||= vector_class.new(length) ## nil if variable length
       opts[:vector_class] = vector_class
-      
+
       bit_length = vector_class.struct_class.round_byte_length * 8 * length
-      
+
       field = add_field(name, bit_length, opts)
       field
     end
     BitStruct.autoload :VectorField, "bit-struct/vector-field"
   end
-  
+
   autoload :Vector, "bit-struct/vector"
 end

data/lib/bit-struct/float-field.rb

@@ -6,20 +6,20 @@ class BitStruct
     def self.class_name
       @class_name ||= "float"
     end
-    
+
     def add_accessors_to(cl, attr = name) # :nodoc:
       unless offset % 8 == 0
         raise ArgumentError,
           "Bad offset, #{offset}, for #{self.class} #{name}." +
           " Must be multiple of 8."
       end
-      
+
       unless length == 32 or length == 64
         raise ArgumentError,
           "Bad length, #{length}, for #{self.class} #{name}." +
           " Must be 32 or 64."
       end
-      
+
       offset_byte = offset / 8
       length_byte = length / 8
       last_byte = offset_byte + length_byte - 1
@@ -46,7 +46,7 @@ class BitStruct
         raise ArgumentError,
           "Unrecognized endian option: #{endian.inspect}"
       end
-      
+
       cl.class_eval do
         define_method attr do ||
           self[byte_range].unpack(ctl).first

data/lib/bit-struct/hex-octet-field.rb

@@ -1,18 +1,18 @@
-require 'bit-struct/char-field'
+require 'bit-struct/octet-field'
 
 class BitStruct
   # Class for char fields that can be accessed with values like
   # "xx:xx:xx:xx", where each xx is up to 2 hex digits representing a
   # single octet. The original string-based accessors are still available with
   # the <tt>_chars</tt> suffix.
-  # 
+  #
   # Declared with BitStruct.hex_octets.
   class HexOctetField < BitStruct::OctetField
     # Used in describe.
     def self.class_name
       @class_name ||= "hex_octets"
     end
-    
+
     SEPARATOR = ":"
     FORMAT    = "%02x"
     BASE      = 16

data/lib/bit-struct/nested-field.rb

@@ -7,16 +7,16 @@ class BitStruct
     def initialize(*args)
       super
     end
-    
+
     # Used in describe.
     def self.class_name
       @class_name ||= "nest"
     end
-    
+
     def class_name
       @class_name ||= nested_class.name[/\w+$/]
     end
-    
+
     def nested_class
       @nested_class ||= options[:nested_class] || options["nested_class"]
     end
@@ -38,20 +38,20 @@ class BitStruct
           "Bad offset, #{offset}, for nested field #{name}." +
           " Must be multiple of 8."
       end
-      
+
       unless length % 8 == 0
         raise ArgumentError,
           "Bad length, #{length}, for nested field #{name}." +
           " Must be multiple of 8."
       end
-      
+
       offset_byte = offset / 8
       length_byte = length / 8
       last_byte = offset_byte + length_byte - 1
       byte_range = offset_byte..last_byte
 
       nc = nested_class
-      
+
       cl.class_eval do
         define_method attr do ||
           nc.new(self[byte_range])
@@ -62,12 +62,12 @@ class BitStruct
             raise ArgumentError, "Size mismatch in nested struct assignment " +
               "to #{attr} with value #{val.inspect}"
           end
-          
+
           if val.class != nc
             warn "Type mismatch in nested struct assignment " +
               "to #{attr} with value #{val.inspect}"
           end
-          
+
           self[byte_range] = val
         end
       end

data/lib/bit-struct/octet-field.rb

@@ -5,14 +5,14 @@ class BitStruct
   # "xxx.xxx.xxx.xxx", where each xxx is up to 3 decimal digits representing a
   # single octet. The original string-based accessors are still available with
   # the <tt>_chars</tt> suffix.
-  # 
+  #
   # Declared with BitStruct.octets.
   class OctetField < BitStruct::CharField
     # Used in describe.
     def self.class_name
       @class_name ||= "octets"
     end
-    
+
     SEPARATOR = "."
     FORMAT    = "%d"
     BASE      = 10
@@ -23,7 +23,7 @@ class BitStruct
       sep   = self.class::SEPARATOR
       base  = self.class::BASE
       fmt   = self.class::FORMAT
-      
+
       cl.class_eval do
         define_method attr do ||
           ary = []
@@ -32,7 +32,7 @@ class BitStruct
           end
           ary.join(sep)
         end
-        
+
         old_writer = "#{attr_chars}="
 
         define_method "#{attr}=" do |val|

data/lib/bit-struct/signed-field.rb

@@ -6,25 +6,20 @@ class BitStruct
     def self.class_name
       @class_name ||= "signed"
     end
-    
+
     def add_accessors_to(cl, attr = name) # :nodoc:
       offset_byte = offset / 8
       offset_bit = offset % 8
-      
+
       length_bit = offset_bit + length
       length_byte = (length_bit/8.0).ceil
       last_byte = offset_byte + length_byte - 1
-      max = 2**length-1
       mid = 2**(length-1)
       max_unsigned = 2**length
       to_signed = proc {|n| (n>=mid) ? n - max_unsigned : n}
-#      to_signed = proc {|n| (n>=mid) ? -((n ^ max) + 1) : n}
-      
+
       divisor = options[:fixed] || options["fixed"]
       divisor_f = divisor && divisor.to_f
-#      if divisor and not divisor.is_a? Fixnum
-#        raise ArgumentError, "fixed-point divisor must be a fixnum"
-#      end
 
       endian = (options[:endian] || options["endian"]).to_s
       case endian
@@ -42,15 +37,15 @@ class BitStruct
         raise ArgumentError,
           "Unrecognized endian option: #{endian.inspect}"
       end
-      
+
       data_is_big_endian =
         ([1234].pack(ctl) == [1234].pack(length_byte <= 2 ? "n" : "N"))
-      
+
       if length_byte == 1
         rest = 8 - length_bit
         mask  = ["0"*offset_bit + "1"*length + "0"*rest].pack("B8")[0].ord
         mask2 = ["1"*offset_bit + "0"*length + "1"*rest].pack("B8")[0].ord
-        
+
         cl.class_eval do
           if divisor
             define_method attr do ||
@@ -74,11 +69,11 @@ class BitStruct
             end
           end
         end
-      
+
       elsif offset_bit == 0 and length % 8 == 0
         field_length = length
         byte_range = offset_byte..last_byte
-        
+
         cl.class_eval do
           case field_length
           when 8
@@ -91,7 +86,7 @@ class BitStruct
                 val = (val * divisor).round
                 self[offset_byte] = val
               end
-          
+
             else
               define_method attr do ||
                 to_signed[self[offset_byte]]
@@ -101,7 +96,7 @@ class BitStruct
                 self[offset_byte] = val
               end
             end
-        
+
           when 16, 32
             if divisor
               define_method attr do ||
@@ -112,7 +107,7 @@ class BitStruct
                 val = (val * divisor).round
                 self[byte_range] = [val].pack(ctl)
               end
-            
+
             else
               define_method attr do ||
                 to_signed[self[byte_range].unpack(ctl).first]
@@ -122,7 +117,7 @@ class BitStruct
                 self[byte_range] = [val].pack(ctl)
               end
             end
-          
+
           else
             reader_helper = proc do |substr|
               bytes = substr.unpack("C*")
@@ -131,7 +126,7 @@ class BitStruct
                 (sum << 8) + byte
               end
             end
-            
+
             writer_helper = proc do |val|
               bytes = []
               val += max_unsigned if val < 0
@@ -146,21 +141,21 @@ class BitStruct
               bytes.reverse! if data_is_big_endian
               bytes.pack("C*")
             end
-            
+
             if divisor
               define_method attr do ||
                 to_signed[reader_helper[self[byte_range]] / divisor_f]
               end
-              
+
               define_method "#{attr}=" do |val|
                 self[byte_range] = writer_helper[(val * divisor).round]
               end
-            
+
             else
               define_method attr do ||
                 to_signed[reader_helper[self[byte_range]]]
               end
-              
+
               define_method "#{attr}=" do |val|
                 self[byte_range] = writer_helper[val]
               end
@@ -171,10 +166,10 @@ class BitStruct
       elsif length_byte == 2 # unaligned field that fits within two whole bytes
         byte_range = offset_byte..last_byte
         rest = 16 - length_bit
-        
+
         mask  = ["0"*offset_bit + "1"*length + "0"*rest]
         mask = mask.pack("B16").unpack(ctl).first
-        
+
         mask2 = ["1"*offset_bit + "0"*length + "1"*rest]
         mask2 = mask2.pack("B16").unpack(ctl).first
 
@@ -204,14 +199,14 @@ class BitStruct
             end
           end
         end
-      
+
       elsif length_byte == 3 # unaligned field that fits within 3 whole bytes
         byte_range = offset_byte..last_byte
         rest = 32 - length_bit
-        
+
         mask  = ["0"*offset_bit + "1"*length + "0"*rest]
         mask = mask.pack("B32").unpack(ctl).first
-        
+
         mask2 = ["1"*offset_bit + "0"*length + "1"*rest]
         mask2 = mask2.pack("B32").unpack(ctl).first
 
@@ -249,7 +244,7 @@ class BitStruct
             end
           end
         end
-      
+
       else
         raise "unsupported: #{inspect}"
       end