bit-struct 0.13.1

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

@@ -0,0 +1,45 @@
+require 'bit-struct/char-field'
+
+class BitStruct
+  # Class for char fields that can be accessed with values like
+  # "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
+
+    def add_accessors_to(cl, attr = name) # :nodoc:
+      attr_chars = "#{attr}_chars"
+      super(cl, attr_chars)
+      sep   = self.class::SEPARATOR
+      base  = self.class::BASE
+      fmt   = self.class::FORMAT
+      
+      cl.class_eval do
+        define_method attr do ||
+          ary = []
+          send(attr_chars).each_byte do  |c|
+            ary << fmt % c
+          end
+          ary.join(sep)
+        end
+        
+        old_writer = "#{attr_chars}="
+
+        define_method "#{attr}=" do |val|
+          data = val.split(sep).map{|s|s.to_i(base)}.pack("c*")
+          send(old_writer, data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+class BitStruct
+  # Class for fixed length padding.
+  class PadField < Field
+    # Used in describe.
+    def self.class_name
+      @class_name ||= "padding"
+    end
+
+    def add_accessors_to(cl, attr = name) # :nodoc:
+      # No accessors for padding.
+    end
+
+    def inspectable?; false; end
+  end
+end

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

@@ -0,0 +1,258 @@
+class BitStruct
+  # Class for signed integers in network order, 1-16 bits, or 8n bits.
+  # Declared with BitStruct.signed.
+  class SignedField < Field
+    # Used in describe.
+    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
+      when "native"
+        ctl = length_byte <= 2 ? "s" : "l"
+        if length == 16 or length == 32
+          to_signed = proc {|n| n}
+          # with pack support, to_signed can be replaced with no-op
+        end
+      when "little"
+        ctl = length_byte <= 2 ? "v" : "V"
+      when "network", "big", ""
+        ctl = length_byte <= 2 ? "n" : "N"
+      else
+        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]
+        mask2 = ["1"*offset_bit + "0"*length + "1"*rest].pack("B8")[0]
+        
+        cl.class_eval do
+          if divisor
+            define_method attr do ||
+              to_signed[(self[offset_byte] & mask) >> rest] / divisor_f
+            end
+
+            define_method "#{attr}=" do |val|
+              val = (val * divisor).round
+              self[offset_byte] =
+                (self[offset_byte] & mask2) | ((val<<rest) & mask)
+            end
+
+          else
+            define_method attr do ||
+              to_signed[(self[offset_byte] & mask) >> rest]
+            end
+
+            define_method "#{attr}=" do |val|
+              self[offset_byte] =
+                (self[offset_byte] & mask2) | ((val<<rest) & mask)
+            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
+            if divisor
+              define_method attr do ||
+                to_signed[self[offset_byte]] / divisor_f
+              end
+
+              define_method "#{attr}=" do |val|
+                val = (val * divisor).round
+                self[offset_byte] = val
+              end
+          
+            else
+              define_method attr do ||
+                to_signed[self[offset_byte]]
+              end
+
+              define_method "#{attr}=" do |val|
+                self[offset_byte] = val
+              end
+            end
+        
+          when 16, 32
+            if divisor
+              define_method attr do ||
+                to_signed[self[byte_range].unpack(ctl).first] / divisor_f
+              end
+
+              define_method "#{attr}=" do |val|
+                val = (val * divisor).round
+                self[byte_range] = [val].pack(ctl)
+              end
+            
+            else
+              define_method attr do ||
+                to_signed[self[byte_range].unpack(ctl).first]
+              end
+
+              define_method "#{attr}=" do |val|
+                self[byte_range] = [val].pack(ctl)
+              end
+            end
+          
+          else
+            reader_helper = proc do |substr|
+              bytes = substr.unpack("C*")
+              bytes.reverse! unless data_is_big_endian
+              bytes.inject do |sum, byte|
+                (sum << 8) + byte
+              end
+            end
+            
+            writer_helper = proc do |val|
+              bytes = []
+              val += max_unsigned if val < 0
+              while val > 0
+                bytes.push val % 256
+                val = val >> 8
+              end
+              if bytes.length < length_byte
+                bytes.concat [0] * (length_byte - bytes.length)
+              end
+
+              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
+            end
+          end
+        end
+
+      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
+
+        cl.class_eval do
+          if divisor
+            define_method attr do ||
+              to_signed[(self[byte_range].unpack(ctl).first & mask) >> rest] /
+                 divisor_f
+            end
+
+            define_method "#{attr}=" do |val|
+              val = (val * divisor).round
+              x = (self[byte_range].unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)
+            end
+
+          else
+            define_method attr do ||
+              to_signed[(self[byte_range].unpack(ctl).first & mask) >> rest]
+            end
+
+            define_method "#{attr}=" do |val|
+              x = (self[byte_range].unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)
+            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
+
+        cl.class_eval do
+          if divisor
+            define_method attr do ||
+              bytes = self[byte_range]
+              bytes << 0
+              to_signed[((bytes.unpack(ctl).first & mask) >> rest)] /
+                 divisor_f
+            end
+
+            define_method "#{attr}=" do |val|
+              val = (val * divisor).round
+              bytes = self[byte_range]
+              bytes << 0
+              x = (bytes.unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)[0..2]
+            end
+
+          else
+            define_method attr do ||
+              bytes = self[byte_range]
+              bytes << 0
+              to_signed[(bytes.unpack(ctl).first & mask) >> rest]
+            end
+
+            define_method "#{attr}=" do |val|
+              bytes = self[byte_range]
+              bytes << 0
+              x = (bytes.unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)[0..2]
+            end
+          end
+        end
+      
+      else
+        raise "unsupported: #{inspect}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+class BitStruct
+  # Class for null-terminated printable text strings.
+  # Declared with BitStruct.text.
+  class TextField < Field
+    # Used in describe.
+    def self.class_name
+      @class_name ||= "text"
+    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 % 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
+      byte_range = offset_byte..last_byte
+      val_byte_range = 0..length_byte-1
+
+      cl.class_eval do
+        define_method attr do ||
+          self[byte_range].sub(/\0*$/, "").to_s
+        end
+
+        define_method "#{attr}=" do |val|
+          val = val.to_s
+          if val.length < length_byte
+            val += "\0" * (length_byte - val.length)
+          end
+          self[byte_range] = val[val_byte_range]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+class BitStruct
+  # Class for unsigned integers in network order, 1-16 bits, or 8n bits.
+  # Declared with BitStruct.unsigned.
+  class UnsignedField < Field
+    # Used in describe.
+    def self.class_name
+      @class_name ||= "unsigned"
+    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
+      
+      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
+      when "native"
+        ctl = length_byte <= 2 ? "S" : "L"
+      when "little"
+        ctl = length_byte <= 2 ? "v" : "V"
+      when "network", "big", ""
+        ctl = length_byte <= 2 ? "n" : "N"
+      else
+        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]
+        mask2 = ["1"*offset_bit + "0"*length + "1"*rest].pack("B8")[0]
+        
+        cl.class_eval do
+          if divisor
+            define_method attr do ||
+              ((self[offset_byte] & mask) >> rest) / divisor_f
+            end
+
+            define_method "#{attr}=" do |val|
+              val = (val * divisor).round
+              self[offset_byte] =
+                (self[offset_byte] & mask2) | ((val<<rest) & mask)
+            end
+
+          else
+            define_method attr do ||
+              (self[offset_byte] & mask) >> rest
+            end
+
+            define_method "#{attr}=" do |val|
+              self[offset_byte] =
+                (self[offset_byte] & mask2) | ((val<<rest) & mask)
+            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
+            if divisor
+              define_method attr do ||
+                self[offset_byte] / divisor_f
+              end
+
+              define_method "#{attr}=" do |val|
+                val = (val * divisor).round
+                self[offset_byte] = val
+              end
+          
+            else
+              define_method attr do ||
+                self[offset_byte]
+              end
+
+              define_method "#{attr}=" do |val|
+                self[offset_byte] = val
+              end
+            end
+        
+          when 16, 32
+            if divisor
+              define_method attr do ||
+                self[byte_range].unpack(ctl).first / divisor_f
+              end
+
+              define_method "#{attr}=" do |val|
+                val = (val * divisor).round
+                self[byte_range] = [val].pack(ctl)
+              end
+            
+            else
+              define_method attr do ||
+                self[byte_range].unpack(ctl).first
+              end
+
+              define_method "#{attr}=" do |val|
+                self[byte_range] = [val].pack(ctl)
+              end
+            end
+          
+          else
+            reader_helper = proc do |substr|
+              bytes = substr.unpack("C*")
+              bytes.reverse! unless data_is_big_endian
+              bytes.inject do |sum, byte|
+                (sum << 8) + byte
+              end
+            end
+            
+            writer_helper = proc do |val|
+              bytes = []
+              while val > 0
+                bytes.push val % 256
+                val = val >> 8
+              end
+              if bytes.length < length_byte
+                bytes.concat [0] * (length_byte - bytes.length)
+              end
+
+              bytes.reverse! if data_is_big_endian
+              bytes.pack("C*")
+            end
+            
+            if divisor
+              define_method attr do ||
+                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 ||
+                reader_helper[self[byte_range]]
+              end
+              
+              define_method "#{attr}=" do |val|
+                self[byte_range] = writer_helper[val]
+              end
+            end
+          end
+        end
+
+      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
+
+        cl.class_eval do
+          if divisor
+            define_method attr do ||
+              ((self[byte_range].unpack(ctl).first & mask) >> rest) /
+                 divisor_f
+            end
+
+            define_method "#{attr}=" do |val|
+              val = (val * divisor).round
+              x = (self[byte_range].unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)
+            end
+
+          else
+            define_method attr do ||
+              (self[byte_range].unpack(ctl).first & mask) >> rest
+            end
+
+            define_method "#{attr}=" do |val|
+              x = (self[byte_range].unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)
+            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
+
+        cl.class_eval do
+          if divisor
+            define_method attr do ||
+              bytes = self[byte_range]
+              bytes << 0
+              ((bytes.unpack(ctl).first & mask) >> rest) /
+                 divisor_f
+            end
+
+            define_method "#{attr}=" do |val|
+              val = (val * divisor).round
+              bytes = self[byte_range]
+              bytes << 0
+              x = (bytes.unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)[0..2]
+            end
+
+          else
+            define_method attr do ||
+              bytes = self[byte_range]
+              bytes << 0
+              (bytes.unpack(ctl).first & mask) >> rest
+            end
+
+            define_method "#{attr}=" do |val|
+              bytes = self[byte_range]
+              bytes << 0
+              x = (bytes.unpack(ctl).first & mask2) |
+                ((val<<rest) & mask)
+              self[byte_range] = [x].pack(ctl)[0..2]
+            end
+          end
+        end
+      
+      else
+        raise "unsupported: #{inspect}"
+      end
+    end
+  end
+end