ruby-macho 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18e0719447412b4c6fea5f4ca08f5f0e316e34c1
-  data.tar.gz: e42a6a11cc91a374693cd13d6d5ff8b07d5dec9c
+  metadata.gz: 83843cf163d14c552c318a7d2d4787cee484ad88
+  data.tar.gz: 73313735ad3e7647fdc5aab78e17e1065e8b1d44
 SHA512:
-  metadata.gz: 6a77b43c73461ed816155a184230f27cb4a8130117f41c9f209033eb89cc09c1581849eb58b5fec55a58a7e8d444e1c0da16576fda19463b9d7c7843b0f21082
-  data.tar.gz: 80ac6b3e2c76001e7a61076b7a6cfc72be034f418636d1ac195ee7f24144749ad4453ec67b3d0382e325a9f99fe88e0618db92696d7881051d93f01a2ef1b8d6
+  metadata.gz: a2f3c64080a15318bcc1c78a341899b8d141c7368b017094bb20fe58ba824130a6ecc5a366a78759a6c251d61a5da62ccf6c35452f77317c58351d3497f316b2
+  data.tar.gz: a86b0a030d58848ce69c5eb4eac8eb5268f6cefd03904ca69a3c18ad83e60b40db446360719c45879777c62142877036af891699cc0685976d7043b7f7598f3b

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup-provider=redcarpet --markup=markdown - README.md LICENSE

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 William Woodruff <william @ tuffbizz.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+ruby-macho
+================
+
+[![Gem Version](https://badge.fury.io/rb/ruby-macho.svg)](http://badge.fury.io/rb/ruby-macho)
+[![Build Status](https://drone.io/github.com/woodruffw/ruby-macho/status.png)](https://drone.io/github.com/woodruffw/ruby-macho/latest)
+
+A Ruby library for examining and modifying Mach-O files.
+
+### What is a Mach-O file?
+
+The [Mach-O file format](https://en.wikipedia.org/wiki/Mach-O) is used by OS X
+and iOS (among others) as a general purpose binary format for object files,
+executables, dynamic libraries, and so forth.
+
+### Documentation
+
+Full documentation is available on [RubyDoc](http://www.rubydoc.info/gems/ruby-macho/).
+
+A quick example of what ruby-macho can do:
+
+```ruby
+require 'macho'
+
+file = MachO::MachOFile.open("/path/to/my/binary")
+
+# get the file's type (MH_OBJECT, MH_DYLIB, MH_EXECUTE, etc)
+file.filetype # => "MH_EXECUTE"
+
+# get all load commands in the file and print their offsets:
+file.load_commands.each do |lc|
+	puts "#{lc}: offset #{lc.offset}, size: #{lc.cmdsize}"
+end
+
+# access a specific load command
+lc_vers = file['LC_VERSION_MIN_MACOSX'].first
+puts lc_vers.version_string # => "10.10.0"
+```
+
+### What works?
+
+* Reading data from x86/x86_64 Mach-O files
+* Changing the IDs of Mach-O dylibs
+* Changing install names in Mach-O files
+
+### What might work?
+
+* Reading *some* data from PPC Mach-O files.
+* Reading data from "Fat" files.
+
+### What doesn't work yet?
+
+* Reading data from any other architecure's Mach-O files (probably).
+* Changing anything in "Fat" files (at least not correctly).
+
+### What needs to be done?
+
+* Documentation.
+* Rpath modification.
+* Many, many things.
+
+Attribution:
+
+* `lib/macho/cstruct.rb` was taken from Sami Samhuri's
+[compiler](https://github.com/samsonjs/compiler) repository.
+(No license provided).
+* Constants were taken from Apple, Inc's
+[`loader.h` in `cctools/include/mach-o`](http://www.opensource.apple.com/source/cctools/cctools-870/include/mach-o/loader.h).
+(Apple Public Source License 2.0).
+
+### License
+
+`ruby-macho` is licensed under the MIT License.
+
+For the exact terms, see the [license](LICENSE) file.

data/lib/macho.rb

@@ -1,6 +1,5 @@
-require "#{File.dirname(__FILE__)}/cstruct"
-require "#{File.dirname(__FILE__)}/macho/headers"
 require "#{File.dirname(__FILE__)}/macho/structure"
+require "#{File.dirname(__FILE__)}/macho/headers"
 require "#{File.dirname(__FILE__)}/macho/load_commands"
 require "#{File.dirname(__FILE__)}/macho/sections"
 require "#{File.dirname(__FILE__)}/macho/macho_file"

data/lib/macho/fat_file.rb

@@ -119,17 +119,14 @@ module MachO
 
 		# Obtain the fat header from raw file data.
 		# @return [MachO::FatHeader] the fat header
+		# @raise [MachO::MagicError] if the magic is not valid Mach-O magic
+		# @raise [MachO::MachOBinaryError] if the magic is for a non-fat Mach-O file
 		# @private
 		def get_fat_header
 			magic, nfat_arch = @raw_data[0..7].unpack("N2")
 
-			if !MachO.magic?(magic)
-				raise MagicError.new(magic)
-			end
-
-			if !MachO.fat_magic?(magic)
-				raise MachOBinaryError.new
-			end
+			raise MagicError.new(magic) unless MachO.magic?(magic)
+			raise MachOBinaryError.new unless MachO.fat_magic?(magic)
 
 			FatHeader.new(magic, nfat_arch)
 		end
@@ -140,7 +137,7 @@ module MachO
 		def get_fat_archs
 			archs = []
 
-			header[:nfat_arch].times do |i|
+			header.nfat_arch.times do |i|
 				fields = @raw_data[8 + (FatArch.bytesize * i), FatArch.bytesize].unpack("N5")
 				archs << FatArch.new(*fields)
 			end
@@ -155,7 +152,7 @@ module MachO
 			machos = []
 
 			fat_archs.each do |arch|
-				machos << MachOFile.new_from_bin(@raw_data[arch[:offset], arch[:size]])
+				machos << MachOFile.new_from_bin(@raw_data[arch.offset, arch.size])
 			end
 
 			machos
@@ -168,7 +165,7 @@ module MachO
 			machos.each_with_index do |macho, i|
 				arch = fat_archs[i]
 
-				@raw_data[arch[:offset], arch[:size]] = macho.serialize
+				@raw_data[arch.offset, arch.size] = macho.serialize
 			end
 		end
 	end

data/lib/macho/headers.rb

@@ -234,29 +234,62 @@ module MachO
 	}
 
 	# Fat binary header structure
-	class FatHeader < CStruct
-		uint32 :magic
-		uint32 :nfat_arch # number of FatArchs that follow
+	class FatHeader < MachOStructure
+		attr_reader :magic
+		attr_reader :nfat_arch # number of FatArchs that follow
+
+		@format = "VV"
+		@sizeof = 8
+
+		def initialize(magic, nfat_arch)
+			@magic = magic
+			@nfat_arch = nfat_arch
+		end
 	end
 
 	# Fat binary header architecture structure
-	class FatArch < CStruct
-		int32 :cputype
-		int32 :cpusubtype
-		uint32 :offset
-		uint32 :size
-		uint32 :align
+	class FatArch < MachOStructure
+		attr_reader :cputype
+		attr_reader :cpusubtype
+		attr_reader :offset
+		attr_reader :size
+		attr_reader :align
+
+		@format = "VVVVV"
+		@sizeof = 20
+
+		def initialize(cputype, cpusubtype, offset, size, align)
+			@cputype = cputype
+			@cpusubtype = cpusubtype
+			@offset = offset
+			@size = size
+			@align = align
+		end
 	end
 
 	# 32-bit Mach-O file header structure
-	class MachHeader < CStruct
-		uint32 :magic
-		int32 :cputype
-		int32 :cpusubtype
-		uint32 :filetype
-		uint32 :ncmds
-		uint32 :sizeofcmds
-		uint32 :flags
+	class MachHeader < MachOStructure
+		attr_reader :magic
+		attr_reader :cputype
+		attr_reader :cpusubtype
+		attr_reader :filetype
+		attr_reader :ncmds
+		attr_reader :sizeofcmds
+		attr_reader :flags
+
+		@format = "VVVVVVV"
+		@sizeof = 28
+
+		def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds,
+				flags)
+			@magic = magic
+			@cputype = cputype
+			@cpusubtype = cpusubtype
+			@filetype = filetype
+			@ncmds = ncmds
+			@sizeofcmds = sizeofcmds
+			@flags = flags
+		end
 
 		# @example
 		#  puts "this mach-o has position-independent execution" if header.flag?(MH_PIE)
@@ -268,15 +301,30 @@ module MachO
 	end
 
 	# 64-bit Mach-O file header structure
-	class MachHeader64 < CStruct
-		uint32 :magic
-		int32 :cputype
-		int32 :cpusubtype
-		uint32 :filetype
-		uint32 :ncmds
-		uint32 :sizeofcmds
-		uint32 :flags
-		uint32 :reserved
+	class MachHeader64 < MachOStructure
+		attr_reader :magic
+		attr_reader :cputype
+		attr_reader :cpusubtype
+		attr_reader :filetype
+		attr_reader :ncmds
+		attr_reader :sizeofcmds
+		attr_reader :flags
+		attr_reader :reserved
+
+		@format = "VVVVVVVV"
+		@sizeof = 32
+
+		def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds,
+				flags, reserved)
+			@magic = magic
+			@cputype = cputype
+			@cpusubtype = cpusubtype
+			@filetype = filetype
+			@ncmds = ncmds
+			@sizeofcmds = sizeofcmds
+			@flags = flags
+			@reserved = reserved
+		end
 
 		# @example
 		#  puts "this mach-o has position-independent execution" if header.flag?(MH_PIE)

data/lib/macho/macho_file.rb

@@ -50,67 +50,67 @@ module MachO
 
 		# @return [Boolean] true if the Mach-O has 32-bit magic, false otherwise
 		def magic32?
-			MachO.magic32?(header[:magic])
+			MachO.magic32?(header.magic)
 		end
 
 		# @return [Boolean] true if the Mach-O has 64-bit magic, false otherwise
 		def magic64?
-			MachO.magic64?(header[:magic])
+			MachO.magic64?(header.magic)
 		end
 
 		# @return [Boolean] true if the Mach-O is of type `MH_EXECUTE`, false otherwise
 		def executable?
-			header[:filetype] == MH_EXECUTE
+			header.filetype == MH_EXECUTE
 		end
 
 		# @return [Boolean] true if the Mach-O is of type `MH_DYLIB`, false otherwise
 		def dylib?
-			header[:filetype] == MH_DYLIB
+			header.filetype == MH_DYLIB
 		end
 
 		# @return [Boolean] true if the Mach-O is of type `MH_BUNDLE`, false otherwise
 		def bundle?
-			header[:filetype] == MH_BUNDLE
+			header.filetype == MH_BUNDLE
 		end
 
 		# @return [Fixnum] the Mach-O's magic number
 		def magic
-			header[:magic]
+			header.magic
 		end
 
 		# @return [String] a string representation of the Mach-O's magic number
 		def magic_string
-			MH_MAGICS[header[:magic]]
+			MH_MAGICS[header.magic]
 		end
 
 		# @return [String] a string representation of the Mach-O's filetype
 		def filetype
-			MH_FILETYPES[header[:filetype]]
+			MH_FILETYPES[header.filetype]
 		end
 
 		# @return [String] a string representation of the Mach-O's CPU type
 		def cputype
-			CPU_TYPES[header[:cputype]]
+			CPU_TYPES[header.cputype]
 		end
 
 		# @return [String] a string representation of the Mach-O's CPU subtype
 		def cpusubtype
-			CPU_SUBTYPES[header[:cpusubtype]]
+			CPU_SUBTYPES[header.cpusubtype]
 		end
 
 		# @return [Fixnum] the number of load commands in the Mach-O's header
 		def ncmds
-			header[:ncmds]
+			header.ncmds
 		end
 
 		# @return [Fixnum] the size of all load commands, in bytes
 		def sizeofcmds
-			header[:sizeofcmds]
+			header.sizeofcmds
 		end
 
 		# @return [Fixnum] execution flags set by the linker
 		def flags
-			header[:flags]
+			header.flags
 		end
 
 		# All load commands of a given name.
@@ -173,16 +173,7 @@ module MachO
 		# All shared libraries linked to the Mach-O.
 		# @return [Array<String>] an array of all shared libraries
 		def linked_dylibs
-			dylibs = []
-			dylib_cmds = command("LC_LOAD_DYLIB")
-
-			dylib_cmds.each do |dylib_cmd|
-				dylib = dylib_cmd.name.to_s
-
-				dylibs << dylib
-			end
-
-			dylibs
+			command("LC_LOAD_DYLIB").map(&:name).map(&:to_s)
 		end
 
 		# Changes the shared library `old_name` to `new_name`
@@ -193,13 +184,8 @@ module MachO
 		# @return [void]
 		# @raise [MachO::DylibUnknownError] if no shared library has the old name
 		def change_install_name(old_name, new_name)
-			idx = linked_dylibs.index(old_name)
-			raise DylibUnknownError.new(old_name) if idx.nil?
-
-			# this is a bit of a hack - since there is a 1-1 ordered association
-			# between linked_dylibs and command('LC_LOAD_DYLIB'), we can use
-			# their indices interchangeably to avoid having to loop.
-			dylib_cmd = command("LC_LOAD_DYLIB")[idx]
+			dylib_cmd = command("LC_LOAD_DYLIB").find { |d| d.name.to_s == old_name }
+			raise DylibUnknownError.new(old_name) if dylib_cmd.nil?
 
 			set_name_in_dylib(dylib_cmd, old_name, new_name)
 		end
@@ -287,13 +273,8 @@ module MachO
 		def get_magic
 			magic = @raw_data[0..3].unpack("N").first
 
-			if !MachO.magic?(magic)
-				raise MagicError.new(magic)
-			end
-			
-			if MachO.fat_magic?(magic)
-				raise FatBinaryError.new
-			end
+			raise MagicError.new(magic) unless MachO.magic?(magic)
+			raise FatBinaryError.new if MachO.fat_magic?(magic)
 
 			magic
 		end
@@ -305,9 +286,7 @@ module MachO
 		def get_cputype
 			cputype = @raw_data[4..7].unpack("V").first
 
-			if !CPU_TYPES.has_key?(cputype)
-				raise CPUTypeError.new(cputype)
-			end
+			raise CPUTypeError.new(cputype) unless CPU_TYPES.key?(cputype)
 
 			cputype
 		end
@@ -318,13 +297,9 @@ module MachO
 		# @private
 		def get_cpusubtype
 			cpusubtype = @raw_data[8..11].unpack("V").first
+			cpusubtype &= ~CPU_SUBTYPE_LIB64 # this mask isn't documented!
 
-			# this mask isn't documented!
-			cpusubtype &= ~CPU_SUBTYPE_LIB64
-
-			if !CPU_SUBTYPES.has_key?(cpusubtype)
-				raise CPUSubtypeError.new(cpusubtype)
-			end
+			raise CPUSubtypeError.new(cpusubtype) unless CPU_SUBTYPES.key?(cpusubtype)
 
 			cpusubtype
 		end
@@ -336,9 +311,7 @@ module MachO
 		def get_filetype
 			filetype = @raw_data[12..15].unpack("V").first
 
-			if !MH_FILETYPES.has_key?(filetype)
-				raise FiletypeError.new(filetype)
-			end
+			raise FiletypeError.new(filetype) unless MH_FILETYPES.key?(filetype)
 
 			filetype
 		end
@@ -347,27 +320,21 @@ module MachO
 		# @return [Fixnum] the number of load commands
 		# @private
 		def get_ncmds
-			ncmds = @raw_data[16..19].unpack("V").first
-
-			ncmds
+			@raw_data[16..19].unpack("V").first
 		end
 
 		# The size of all load commands, in bytes.
 		# return [Fixnum] the size of all load commands
 		# @private
 		def get_sizeofcmds
-			sizeofcmds = @raw_data[20..23].unpack("V").first
-
-			sizeofcmds
+			@raw_data[20..23].unpack("V").first
 		end
 
 		# The Mach-O header's flags.
 		# @return [Fixnum] the flags
 		# @private
 		def get_flags
-			flags = @raw_data[24..27].unpack("V").first
-
-			flags
+			@raw_data[24..27].unpack("V").first
 		end
 
 		# All load commands in the file.
@@ -375,15 +342,13 @@ module MachO
 		# @raise [MachO::LoadCommandError] if an unknown load command is encountered
 		# @private
 		def get_load_commands
-			offset = header.bytesize
+			offset = header.class.bytesize
 			load_commands = []
 
-			header[:ncmds].times do
+			header.ncmds.times do
 				cmd = @raw_data.slice(offset, 4).unpack("V").first
 
-				if !LC_STRUCTURES.has_key?(cmd)
-					raise LoadCommandError.new(cmd)
-				end
+				raise LoadCommandError.new(cmd) unless LC_STRUCTURES.key?(cmd)
 
 				# why do I do this? i don't like declaring constants below
 				# classes, and i need them to resolve...
@@ -420,7 +385,7 @@ module MachO
 				cmd_round = 8
 			end
 
-			new_sizeofcmds = header[:sizeofcmds]
+			new_sizeofcmds = header.sizeofcmds
 			old_name = old_name.dup
 			new_name = new_name.dup
 
@@ -449,7 +414,7 @@ module MachO
 				end
 			end
 
-			if new_sizeofcmds + header.bytesize > low_fileoff
+			if new_sizeofcmds + header.class.bytesize > low_fileoff
 				raise HeaderPadError.new(@filename)
 			end
 
@@ -469,9 +434,9 @@ module MachO
 			null_pad = old_name.size - new_name.size
 
 			if null_pad < 0
-				@raw_data.slice!(new_sizeofcmds + header.bytesize, null_pad.abs)
+				@raw_data.slice!(new_sizeofcmds + header.class.bytesize, null_pad.abs)
 			else
-				@raw_data.insert(new_sizeofcmds + header.bytesize, "\x00" * null_pad)
+				@raw_data.insert(new_sizeofcmds + header.class.bytesize, "\x00" * null_pad)
 			end
 
 			# synchronize fields with the raw data

data/lib/macho/tools.rb

@@ -0,0 +1,42 @@
+module MachO
+	# A collection of convenient methods for common operations on Mach-O and Fat binaries.
+	module Tools
+		# @param filename [String] the Mach-O or Fat binary being read
+		# @return [Array<String>] an array of all dylibs linked to the binary
+		def self.dylibs(filename)
+			file = MachO.open(filename)
+
+			file.linked_dylibs
+		end
+
+		# Changes the dylib ID of a Mach-O or Fat binary, overwriting the source file.
+		# @param filename [String] the Mach-O or Fat binary being modified
+		# @param new_id [String] the new dylib ID for the binary
+		# @return [void]
+		def self.change_dylib_id(filename, new_id)
+			file = MachO.open(filename)
+
+			if File.is_a? MachO::MachOFile
+				file.dylib_id = new_id
+				file.write!
+			else
+				raise MachOError.new("changing dylib ids for fat binaries is incomplete")
+			end
+		end
+
+		# Changes a shared library install name in a Mach-O or Fat binary, overwriting the source file.
+		# @param filename [String] the Mach-O or Fat binary being modified
+		# @param old_name [String] the old shared library name
+		# @param new_name [String] the new shared library name
+		# @return [void]
+		def self.change_install_name(filename, old_name, new_name)
+			file = MachO.open(filename)
+
+			if File.is_a? MachO::MachOFile
+				file.change_install_name(old_name, new_name)
+			else
+				raise MachOError.new("changing install names for fat binaries is incomplete")
+			end
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-macho
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - William Woodruff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies: []
 description: A library for viewing and manipulating Mach-O files in Ruby.
 email: william@tuffbizz.com
@@ -16,7 +16,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/cstruct.rb
+- ".yardopts"
+- LICENSE
+- README.md
 - lib/macho.rb
 - lib/macho/exceptions.rb
 - lib/macho/fat_file.rb
@@ -25,6 +27,7 @@ files:
 - lib/macho/macho_file.rb
 - lib/macho/sections.rb
 - lib/macho/structure.rb
+- lib/macho/tools.rb
 - lib/macho/utils.rb
 homepage: https://github.com/woodruffw/ruby-macho
 licenses:

data/lib/cstruct.rb

@@ -1,318 +0,0 @@
-# Struct does some trickery with custom allocators so we can't
-# subclass it without writing C.  Instead we define a CStruct class
-# that does something similar enough for our purpose.  It is
-# subclassed just like any other class.  A nice side-effect of this
-# syntax is that it is always clear that a CStruct is just a class and
-# instances of the struct are objects.
-#    
-# Some light metaprogramming is used to make the following syntax possible:
-#
-# class MachHeader < CStruct
-#   uint :magic
-#   int  :cputype
-#   int  :cpusubtype
-#    ...
-#   int  :flags
-# end
-#
-# Inheritance works as you would expect.
-#
-# class LoadCommand < CStruct
-#   uint32 :cmd
-#   uint32 :cmdsize
-# end
-# 
-# # inherits cmd and cmdsize as the first 2 fields
-# class SegmentCommand < LoadCommand
-#   string :segname, 16
-#   uint32 :vmaddr
-#   uint32 
-# end
-#
-# Nothing tricky or confusing there.  Members of a CStruct class are
-# declared in the class definition.  A different definition using a
-# more static approach probably wouldn't be very hard...  if
-# performance is critical ... but then why are you using Ruby? ;-)
-#
-#
-# TODO support bit fields
-#
-# Bit fields should be supported by passing the number of bits a field
-# should occupy. Perhaps we could use the size 'pack' for the rest of
-# the field.
-#
-# class RelocationInfo < CStruct
-#   int32  :address
-#   uint32 :symbolnum, 24
-#   pack   :pcrel,      1
-#   pack   :length,     2
-#   pack   :extern,     1
-#   pack   :type,       4
-# end
-
-class CStruct
-
-
-  ###################
-  # Class Constants #
-  ###################
-  
-  # Size in bytes.
-  SizeMap = {
-    :int8   => 1,
-    :uint8  => 1,
-    :int16  => 2,
-    :uint16 => 2,
-    :int32  => 4,
-    :uint32 => 4,
-    :int64  => 8,
-    :uint64 => 8,
-    :string => lambda { |*opts| opts.first }, # first opt is size
-    # the last 3 are to make the language more C-like
-    :int    => 4,
-    :uint   => 4,
-    :char   => 1
-  }
-
-  # 32-bit
-  PackMap = {
-    :int8   => 'c',
-    :uint8  => 'C',
-    :int16  => 's',
-    :uint16 => 'S',
-    :int32  => 'i',
-    :uint32 => 'I',
-    :int64  => 'q',
-    :uint64 => 'Q',
-    :string => lambda do |str, *opts|
-                        len = opts.first
-                        str.ljust(len, "\0")[0, len]
-                      end,
-    # a few C-like names
-    :int    => 'i',
-    :uint   => 'I',
-    :char   => 'C'
-  }
-  
-  # Only needed when unpacking is different from packing, i.e. strings w/ lambdas in PackMap.
-  UnpackMap = {
-    :string => lambda do |str, *opts|
-                        len = opts.first
-                        val = str[0, len-1].sub(/\0*$/, '')
-                        str.slice!((len-1)..-1)
-                        val
-                      end
-  }
-  
-  ##########################
-  # Class Instance Methods #
-  ##########################
-  
-  # Note: const_get and const_set are used so the constants are bound
-  #       at runtime, to the real class that has subclassed CStruct.
-  #       I figured Ruby would do this but I haven't looked at the
-  #       implementation of constants so it might be tricky.
-  #
-  #       All of this could probably be avoided with Ruby 1.9 and
-  #       private class variables.  That is definitely something to
-  #       experiment with.
-  
-  class <<self
-    
-    def inherited(subclass)
-      subclass.instance_eval do
-        
-        # These "constants" are only constant references.  Structs can
-        # be modified.  After the struct is defined it is still open,
-        # but good practice would be not to change a struct after it
-        # has been defined.
-        # 
-        # To support inheritance properly we try to get these
-        # constants from the enclosing scope (and clone them before
-        # modifying them!), and default to empty, er, defaults.
-        
-        members = const_get(:Members).clone rescue []
-        member_index = const_get(:MemberIndex).clone rescue {}
-        member_sizes = const_get(:MemberSizes).clone rescue {}
-        member_opts = const_get(:MemberOptions).clone rescue {}
-        
-        const_set(:Members, members)
-        const_set(:MemberIndex, member_index)
-        const_set(:MemberSizes, member_sizes)
-        const_set(:MemberOptions, member_opts)
-        
-      end
-    end
-
-
-    # Define a method for each size name, and when that method is called it updates
-    # the struct class accordingly.
-    SizeMap.keys.each do |type|
-      
-      define_method(type) do |name, *args|
-        name = name.to_sym
-        const_get(:MemberIndex)[name] = const_get(:Members).size
-        const_get(:MemberSizes)[name] = type
-        const_get(:MemberOptions)[name] = args
-        const_get(:Members) << name
-      end
-      
-    end
-    
-    
-    # Return the number of members.
-    def size
-      const_get(:Members).size
-    end
-    alias_method :length, :size
-    
-    # Return the number of bytes occupied in memory or on disk.
-    def bytesize
-      const_get(:Members).inject(0) { |size, name| size + sizeof(name) }
-    end
-        
-    def sizeof(name)
-      value = SizeMap[const_get(:MemberSizes)[name]]
-      value.respond_to?(:call) ? value.call(*const_get(:MemberOptions)[name]) : value
-    end
-
-    def new_from_bin(bin)
-      new_struct = new
-      new_struct.unserialize(bin)
-    end
-
-  end
-  
-
-  ####################
-  # Instance Methods #
-  ####################
-  
-  attr_reader :values
-  
-  def initialize(*args)
-    @values = args
-  end
-
-  def serialize
-    vals = @values.clone
-    membs = members.clone
-    pack_pattern.map do |patt|
-      name = membs.shift
-      if patt.is_a?(String)
-        [vals.shift].pack(patt)
-      else
-        patt.call(vals.shift, *member_options[name])
-      end      
-    end.join
-  end
-
-  def unserialize(bin)
-    bin = bin.clone
-    @values = []
-    membs = members.clone
-    unpack_pattern.each do |patt|
-      name = membs.shift
-      if patt.is_a?(String)
-        @values += bin.unpack(patt)
-        bin.slice!(0, sizeof(name))
-      else
-        @values << patt.call(bin, *member_options[name])
-      end
-    end
-    self
-  end
-  
-  def pack_pattern
-    members.map { |name| PackMap[member_sizes[name]] }
-  end
-  
-  def unpack_pattern
-    members.map { |name| UnpackMap[member_sizes[name]] || PackMap[member_sizes[name]] }
-  end
-  
-  def [](name_or_idx)
-    case name_or_idx
-      
-    when Numeric
-      idx = name_or_idx
-      @values[idx]
-      
-    when String, Symbol
-      name = name_or_idx.to_sym
-      @values[member_index[name]]
-      
-    else
-      raise ArgumentError, "expected name or index, got #{name_or_idx.inspect}"
-    end
-  end
-  
-  def []=(name_or_idx, value)
-    case name_or_idx
-      
-    when Numeric
-      idx = name_or_idx
-      @values[idx] = value
-      
-    when String, Symbol
-      name = name_or_idx.to_sym
-      @values[member_index[name]] = value
-      
-    else
-      raise ArgumentError, "expected name or index, got #{name_or_idx.inspect}"
-    end
-  end
-  
-  def ==(other)
-    puts @values.inspect
-    puts other.values.inspect
-    other.is_a?(self.class) && other.values == @values
-  end
-
-  # Some of these are just to quack like Ruby's built-in Struct.  YAGNI, but can't hurt either.
-
-  def each(&block)
-    @values.each(&block)
-  end
-  
-  def each_pair(&block)
-    members.zip(@values).each(&block)
-  end
-  
-  def size
-    members.size
-  end
-  alias_method :length, :size
-  
-  def sizeof(name)
-    self.class.sizeof(name)
-  end
-
-  def bytesize
-    self.class.bytesize
-  end
-
-  alias_method :to_a, :values
-
-
-  # A few convenience methods.
-
-  def members
-    self.class::Members
-  end
-  
-  def member_index
-    self.class::MemberIndex
-  end
-  
-  def member_sizes
-    self.class::MemberSizes
-  end
- 
-  def member_options
-    self.class::MemberOptions
-  end
- 
-  # The last expression is returned, so return self instead of junk.
-  self  
-end