rstruct 0.1.0

data/lib/rstruct/base_types/type.rb

@@ -0,0 +1,55 @@
+module Rstruct
+  class Type
+    attr_reader :name, :params
+
+    def initialize(name, params={}, &block)
+      @params = params.dup
+      @name = name.to_sym
+
+      reg = @params.delete(:register)
+      aliases = @params.delete(:alias)
+      regnames = ((aliases)? ([aliases] << @name).flatten : [@name]).uniq.compact
+
+      reg=nil if reg==true
+      register(regnames, reg) unless reg == false
+
+      instance_eval &block if block
+    end
+
+    def register(names=nil, reg=nil)
+      names ||= to_sym
+      reg ||= Registry::DEFAULT_REGISTRY
+      reg.register(self, *names)
+    end
+
+    def groupable?
+      @groupable or false
+    end
+
+    def container?
+      @container or false
+    end
+
+    def claim_value(vals, predecessors=nil)
+      if @claim_cb
+        @claim_cb.call(vals, predecessors)
+      else
+        vals.shift
+      end
+    end
+
+    def sizeof
+      self.size
+    end
+
+    private
+      # sets up a call back for claiming values out of an unpacked
+      # value array
+      def claim(&block)
+        @claim_cb = block
+      end
+
+  end
+
+end
+

data/lib/rstruct/field.rb

@@ -0,0 +1,22 @@
+module Rstruct
+  class Field
+    attr_reader :name, :typ_name, :typ, :args, :block
+
+    def initialize(name, typ, typ_name, args, block)
+      @name=name
+      @typ=typ
+      @typ_name = typ_name || typ
+      @args=args
+      @block=block
+    end
+
+    def respond_to?(arg)
+      super(arg) || @typ.respond_to?(arg)
+    end
+
+    def method_missing(name, *args, &block)
+      @typ.__send__(name, *args, &block)
+    end
+  end
+end
+

data/lib/rstruct/registry.rb

@@ -0,0 +1,66 @@
+require 'set'
+
+module Rstruct
+  class TypeConflictError < StandardError
+  end
+
+  class InvalidTypeError < StandardError
+  end
+
+  class Registry
+    attr_reader :name, :inherits
+
+    def initialize(name, *inherits)
+      @name = name.to_sym
+      @registry = Hash.new()
+
+      @inherits = []
+      if @name != :default
+        @inherits << DEFAULT_REGISTRY 
+      end
+      @inherits.concat(inherits).uniq!
+    end
+
+    def typedef(p,t,opts={})
+      if (pt = get(p))
+        set(t, pt)
+      else
+        raise(InvalidTypeError, "unknown type: #{p}")
+      end
+    end
+
+    def get(typ)
+      if t=@registry[typ] 
+        return t
+      else
+        @inherits.each do |inc|
+          if t=inc.get(typ)
+            return t
+          end
+        end
+        return nil
+      end
+    end
+
+    alias [] get
+
+    def set(n,typ)
+      if n.nil?
+        raise(TypeConflictError, "can't register nil type")
+      elsif v=get(n)
+        raise(TypeConflictError, "type already registered: #{n} => #{v.inspect}" ) 
+      end
+      @registry[n]=typ
+    end
+
+    alias []= set
+
+    def register(typ, *names)
+      names.each do |n|
+        set(n.to_sym,typ)
+      end
+    end
+
+    DEFAULT_REGISTRY=new(:default)
+  end
+end

data/lib/rstruct/struct_builder.rb

@@ -0,0 +1,30 @@
+require 'rstruct/registry'
+require 'rstruct/field'
+
+module Rstruct
+
+  class StructBuilder
+    attr_reader :__fields, :__registry
+
+    def initialize(registry=nil, &block)
+      @__fields = []
+      @__registry = registry || Registry::DEFAULT_REGISTRY
+      instance_eval &block
+    end
+
+    def field(name, typ, typ_name, *args, &block)
+      @__fields << Field.new(name,typ,typ_name,args,block)
+    end
+
+    def method_missing(typ_arg, *args, &block)
+      name = args.shift
+      unless typ = @__registry.get(typ_arg)
+        raise(InvalidTypeError, "invalid field type: #{typ_arg}")
+      end
+
+      field(name, typ, typ_arg, *args, &block)
+    end
+  end
+
+end
+

data/lib/rstruct/structure.rb

@@ -0,0 +1,59 @@
+require 'rstruct/base_types'
+require 'rstruct/struct_builder'
+require 'rstruct/registry'
+
+module Rstruct
+  class StructError < StandardError
+  end
+
+  class Structure < ContainerType
+    attr_reader :fields
+
+    def initialize(name, opts={}, &block)
+      lkupreg = (opts[:fields_from]) # allow a seperate reg for member types
+      builder = opts[:builder] || StructBuilder
+      reg = opts[:register]
+      reg=nil if reg==true
+
+      # pass a nil block to super to ensure we're claiming the caller's
+      super(name, opts, &(nil))
+
+      @fields = builder.new((lkupreg || reg), &block).__fields
+      raise(StructError, "no fields were defined") if @fields.empty?
+
+      # set up our internal struct container class
+      # we are taking the field name 'structure' 
+      # to reference ourselves
+      @mystruct = Struct.new(*self.field_names)
+    end
+
+    def instance(values=nil)
+      values ||= {}
+      vals = []
+      self.fields.each do |f|
+        v = values[f.name]
+        vals << (f.typ.respond_to?(:instance) ? f.typ.instance(v) : v)
+      end
+      s = @mystruct.new(*vals).extend(ContainerMixins)
+      s.rstruct_type = self
+      yield(s) if block_given?
+      return s
+    end
+
+    def claim_value(vals, obj=nil)
+      if @claim_cb
+        @claim_cb.call(vals, obj)
+      else
+        # create our struct container
+        s = instance()
+
+        # iterate through the fields assigning values in the
+        # container and pass it along with values to each
+        # field's claim_value method.
+        self.fields.do {|f| s[f.name] = f.typ.claim_value(vals,s) }
+
+        return s
+      end
+    end
+  end
+end

data/lib/rstruct/types.rb

@@ -0,0 +1,44 @@
+require 'rstruct/base_types'
+
+module Rstruct
+  Char = PackedType.new(:char, 1, "A", :alias => [:char, :char_t])
+
+  Byte = PackedType.new(:byte, 1, "c", :alias => [:BYTE, :signed_byte])
+
+  Ubyte = PackedType.new(:ubyte, 1, "C", :alias => [:UBYTE, :unsigned_byte])
+
+  Int = PackedType.new(:int, [0].pack("i_").size, "i_", :alias => [:int_t, :bool, :BOOL, :signed_int])
+
+  Uint = PackedType.new(:uint, [0].pack("I_").size, "I_", :alias => [:uint_t, :unsigned_int])
+
+  Short = PackedType.new(:short, [0].pack("s_").size, "s_", :alias => [:short_t, :signed_short])
+
+  Ushort = PackedType.new(:ushort, [0].pack("S_").size, "S_", :alias => [:ushort_t, :unsigned_short])
+
+  Long = PackedType.new(:long, [0].pack("l_").size, "l_", :alias => [:long_t, :signed_long])
+
+  Ulong = PackedType.new(:ulong, [0].pack("L_").size, "L_", :alias => [:ulong_t, :unsigned_long])
+
+  Int16 = PackedType.new(:int16, 2, 's', :alias => [:int16_t, :i16, :i16_t, :signed_int16])
+
+  Uint16 = PackedType.new(:uint16, 2, 'S', :alias => [:uint16_t, :u16, :u16_t, :unsigned_int16])
+
+  Int32 = PackedType.new(:int32, 4, "l", :alias => [:int32_t, :i32, :i32_t, :signed_int32])
+
+  Uint32 = PackedType.new(:uint32, 4, "L", :alias => [:uint32_t, :u32, :u32_t, :unsigned_int32])
+
+  Int64 = PackedType.new(:int64, 8, "q", :alias => [:int64_t, :i64, :i64_t, :signed_int64])
+
+  Uint64 = PackedType.new(:uint64, 8, "Q", :alias => [:uint64_t, :u64, :u64_t, :unsigned_int64])
+
+  Uint16le = PackedType.new(:uint16le, 2, "v", :alias => [:uint16_le, :ul16, :le16])
+
+  Uint32le = PackedType.new(:uint32le, 4, "V", :alias => [:uint32_le, :ul32, :le32])
+
+  Uint16be = PackedType.new(:uint16be, 2, "n", :alias => [:uint16_be, :ub16, :be16])
+
+  Uint32be = PackedType.new(:uint32be, 4, "N", :alias => [:uint32_be, :ub32, :be32])
+
+  Pointer = PackedType.new(:pointer, [0].pack("L_").size , "L_", :alias => :pointer)
+
+end

data/samples/fatparse.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# A basic Rstruct example using Apple's FAT file structure.
+# To compare the structs to their C counterparts, see:
+#   http://fxr.watson.org/fxr/source/EXTERNAL_HEADERS/mach-o/fat.h?v=xnu-1228
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rstruct'
+extend Rstruct::ClassMethods
+
+FAT_MAGIC = 0xcafebabe
+
+fat_header = struct(:fat_header) {
+  uint32be  :magic;      # FAT_MAGIC
+  uint32be  :nfat_arch;  # number of structs that follow
+}
+
+typedef :uint32be, :cpu_type_t
+typedef :uint32be, :cpu_subtype_t
+
+fat_arch = struct(:fat_arch) {
+  cpu_type_t     :cputype    # cpu specifier (int)
+  cpu_subtype_t  :cpusubtype # machine specifier (int)
+  uint32be       :offset     # file offset to this object file
+  uint32be       :size       # size of this object file
+  uint32be       :align      # alignment as a power of 2
+}
+
+typedef :uint32le, :cpu_type_le
+typedef :uint32le, :cpu_subtype_le
+
+mach_header = struct(:mach_header) { # little endian this time
+  uint32le       :magic      # mach magic number identifier
+  cpu_type_le    :cputype    # cpu specifier
+  cpu_subtype_le :cpusubtype # machine specifier
+  uint32le       :filetype   # type of file
+  uint32le       :ncmds      # number of load commands
+  uint32le       :sizeofcmds # the size of all the load commands
+  uint32le       :flags      # flags
+}
+
+# a basic helper to produce textual dumps of fields
+def dump(struct)
+  struct.each_pair.map {|k,v| "  #{k} = 0x%0.8x" % v}
+end
+
+ARGV.each do |fname|
+  File.open(fname,'r') do |f|
+
+    # Read and dump the FAT header from the file
+    head = fat_header.read(f)
+    unless head.magic == FAT_MAGIC
+      STDERR.puts "Error: #{fname} does not look like a FAT binary"
+      next
+    end
+    puts "File: #{fname}", "FAT header:", dump(head)
+    puts
+
+    # parse the architectures located after the FAT header
+    (head.nfat_arch).times do |i|
+      arch = fat_arch.read(f)
+      puts "  Architecture #{i}:"
+      puts "  " << dump(arch).join("\n  ")
+      puts
+
+      # dump the mach header
+      opos = f.pos        # save our file position so we get the next arch
+      f.pos = arch.offset # jump to where the mach header should be
+      mach = mach_header.read(f)  # parse a mach_header struct
+      f.pos = opos # return to saved architecture position
+
+      puts "    Mach Header:"
+      puts "    " << dump(mach).join("\n    ")
+      puts
+
+    end
+  end
+end

data/spec/registry_behaviors.rb

@@ -0,0 +1,64 @@
+
+shared_examples_for "a basic Rstruct registry" do
+  it "should have a name" do
+    @registry.name.should == @reg_name
+  end
+
+  it "should have basic types already registered or inherited" do
+    @registry.get(:byte).should == Rstruct::Byte
+    @registry.get(:char).should == Rstruct::Char
+    @registry.get(:int).should  == Rstruct::Int
+    @registry.get(:short).should == Rstruct::Short
+    @registry.get(:long).should  == Rstruct::Long
+    @registry.get(:uint).should  == Rstruct::Uint
+    @registry.get(:ushort).should == Rstruct::Ushort
+    @registry.get(:ulong).should == Rstruct::Ulong
+  end
+
+  it "should allow types to be retrieved with 'get' or '[]'" do
+    (a=@registry[:byte]).should == Rstruct::Byte
+    @registry.get(:byte).should == a
+  end
+
+  it "should allow new types to be defined with 'register' or '[]='" do
+    typ1 = :"create_#{@registry.name}_1"
+    c1 = Class.new(Rstruct::Type)
+    @registry[typ1]= c1
+    @registry[typ1].should == c1
+
+    typ2 = :"create_#{@registry.name}_2"
+    c2 = Class.new(Rstruct::Type)
+    @registry.register(c2, typ2)
+    @registry[typ2].should == c2
+  end
+
+  it "should allow multiple names to be registered at once with 'register'" do
+    typ1 = :"create_#{@registry.name}_3"
+    typ2 = :"create_#{@registry.name}_4"
+    c = Class.new(Rstruct::Type)
+    @registry.register(c, typ1, typ2)
+    @registry[typ1].should == c
+    @registry[typ2].should == c
+  end
+
+  it "should raise an exception when a type is defined which already exists" do
+    typ = :"create_#{@registry.name}_5"
+    c = Class.new(Rstruct::Type)
+    @registry[typ] = c
+    @registry[typ].should == c
+    c2 = Class.new(Rstruct::Type)
+    lambda{ @registry[typ] = c2 }.should raise_error(Rstruct::TypeConflictError)
+  end
+
+  it "should allow type aliases to be defined with 'typedef'" do
+    typ = :"typedef_#{@registry.name}_1"
+    @registry.typedef :int, typ
+    @registry[:int].should == @registry[typ]
+  end
+
+  it "should raise an exception when invalid types are aliased in 'typedef'" do
+    typ = :"typedef_#{@registry.name}_2"
+    lambda{ @registry.typedef :not_a_type, typ}.should raise_error(Rstruct::InvalidTypeError)
+  end
+
+end

data/spec/registry_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'registry_behaviors'
+
+describe Rstruct::Registry do
+  before(:all) do
+    @dflt_reg = Rstruct::Registry::DEFAULT_REGISTRY
+  end
+
+  it "should have a default registry" do
+    @dflt_reg.should be_a(Rstruct::Registry)
+  end
+
+  context "default registry" do
+    before(:all) do
+      @registry = @dflt_reg
+      @reg_name = :default
+    end
+
+    it_should_behave_like "a basic Rstruct registry"
+
+  end
+
+  context "creating a new registry" do
+    before(:all) do
+      @reg_name = :rspec_test_registry
+      @preg = Rstruct::Registry.new(:parent_reg)
+      @registry = Rstruct::Registry.new(@reg_name)
+    end
+
+    it "should inherit types from the default registry" do
+      @registry[:byte].should == Rstruct::Byte
+      @registry[:int].should == Rstruct::Int
+      @registry.inherits.should == [Rstruct.default_registry]
+    end
+
+    it "should inherit types from arbitrary registries" do
+      begin
+        @registry.inherits.unshift(@preg)
+        c=Rstruct::Type.new(:some_parent_reg_type, :register => @preg)
+        @preg[:some_parent_reg_type].should == c
+        @registry[:some_parent_reg_type].should == c
+        Rstruct.default_registry[c].should be_nil
+      ensure
+        @registry.inherits.delete(@preg)
+      end
+        
+    end
+
+    it "should register types only to its own registry" do
+      typ = :"test_parent_reg_#{@registry.name}_1"
+      obj=Class.new(Rstruct::Type)
+
+      @registry.register(obj,typ)
+      @registry[typ].should == obj
+      Rstruct.default_registry[typ].should be_nil
+    end
+
+    it_should_behave_like "a basic Rstruct registry"
+
+  end
+end