rltk 2.1.1 → 2.2.0

data/README.md

@@ -358,9 +358,9 @@ Here we can see the definition of several AST node classes that might be used to
 		child :right, Expression
 	end
 
-The assignment functions that are generated for the children and values perform type checking to make sure that the AST is well-formed.  The type of a child must be a subclass of the {RLTK::ASTNode} class, whereas the type of a value must NOT be a subclass of the {RLTK::ASTNode} class.  While child and value objects are stored as instance variables it is unsafe to assign to these variables directly, and it is strongly recommended to always use the accessor functions.
+The assignment functions that are generated for the children and values perform type checking to make sure that the AST is well-formed.  The type of a child must be a subclass of the {RLTK::ASTNode} class, whereas the type of a value must **NOT** be a subclass of the {RLTK::ASTNode} class.  While child and value objects are stored as instance variables it is unsafe to assign to these variables directly, and it is strongly recommended to always use the accessor functions.
 
-When instantiating a subclass of {RLTK::ASTNode} the arguments to the constructor should be the node's values (in order of definition) followed by the node's children (in order of definition).  Example:
+When instantiating a subclass of {RLTK::ASTNode} the arguments to the constructor should be the node's values (in order of definition) followed by the node's children (in order of definition).  If a constructor is given fewer arguments then the number of values and children the remaining arguments are assumed to be `nil`.  Example:
 
 	class Foo < RLTK::ASTNode
 		value :a, Fixnum
@@ -369,9 +369,11 @@ When instantiating a subclass of {RLTK::ASTNode} the arguments to the constructo
 		child :d, Bar
 	end
 	
-	Foo.new(1, 'baz', nil, nil)
-
-You may notice that in the above example the children were set to **nil** instead of an instance of the Bar class.  This allows you to specify optional children.
+	class Bar < RLTK::ASTNode
+		value :a, String
+	end
+	
+	Foo.new(1, 'baz', Bar.new)
 
 Lastly, the type of a child or value can be defined as an array of objects of a specific type as follows:
 
@@ -379,11 +381,30 @@ Lastly, the type of a child or value can be defined as an array of objects of a
 		value :strings, [String]
 	end
 
+### Tree Iteration and Mapping
+
+RLTK Abstract Syntax Trees may be [traversed](http://en.wikipedia.org/wiki/Tree_traversal) in three different ways:
+
+* Pre-order
+* Post-order
+* Level-order
+
+The order you wish to traverse the tree can be specified by passing the appropriate symbol to {RLTK::ASTNode#each}: `:pre`, `:post`, or `:level`.
+
+You can also map one tree to another tree using the {RLTK::ASTNode#map} and {RLTK::ASTNode#map!} methods.  In the former case a new tree is created and returned; in the latter case the current tree is transformed and the result of calling the provided block on the root node is returned.  These methods will always visit nodes in *post-order*, so that all children of a node are visited before the node itself.
+
 ## Code Generation
 
 RLTK supports the generation of native code and LLVM IR, as well as JIT compilation and execution, through the {RLTK::CG} module.  This module is built on top of bindings to [LLVM](http://llvm.org) and provides much, though not all, of the functionality of the LLVM libraries.
 
-A very small amount of the functionality of the RLTK::CG module (currently only the {RLTK::CG::Support.load_library} method) requires the [LLVM Extended C Bindings](https://github.com/chriswailes/llvm-ecb) library.  If this library is missing the rest of the module should behave properly, but this functionality will be missing.
+A small amount of the functionality of the RLTK::CG module requires the [LLVM Extended C Bindings](https://github.com/chriswailes/llvm-ecb) library.  If this library is missing the rest of the module should behave properly, but this functionality will be missing.  The features that require this library are:
+
+* **Shared Library Loading** - Load shared libraries into the process so that their exported symbols are visible to LLVM via the {RLTK::CG::Support.load\_library} method.
+* **ASM Printer and Parser Initialization** - Available through the {RLTK::CG::LLVM.init\_asm\_parser} and {RLTK::CG::LLVM.init\_asm\_printer} methods.
+* **LLVM IR Loading** - LLVM IR files can be loaded into RLTK via the {RLTK::CG::Module.read\_ir\_file} method.
+* **Value Printing** - Print any value's LLVM IR to a given file descriptor using {RLTK::CG::Value#print}.
+* **Targets, Target Data, and Target Machines** - Manipulate LLVM structures that contain data about the target environment.
+* **Object File Generation** - LLVM Modules can be compiled to object files via the {RLTK::CG::Module#compile} method.
 
 ### Acknowledgments and Discussion
 
@@ -392,9 +413,9 @@ Before we get started with the details, I would like to thank [Jeremy Voorhis](h
 Why did I fork ruby-llvm, and why might you want to use the RLTK bindings over ruby-llvm?  There are a couple of reasons:
 
 * **Cleaner Codebase** - The RLTK bindings present a cleaner interface to the LLVM library by conforming to more standard Ruby programming practices, providing better abstractions and cleaner inheritance hierarchies, overloading constructors and other methods properly, and performing type checking on objects to better aid in debugging.
-* **Documentation** - RLTK's bindings provide slightly better documentation.
-* **Completeness** - The RLTK bindings provide several features that are missing from the ruby-llvm project.  These include the ability to initialize LLVM for architectures besides x86 (RLTK supports all architectures supported by LLVM), the presence of all of LLVM's optimization passes, and the ability to print the LLVM IR representation of modules and values to files.
-* **Ease of Use** - Several features have been added to make generating code easier.
+* **Documentation** - RLTK's bindings provide better documentation.
+* **Completeness** - The RLTK bindings provide several features that are missing from the ruby-llvm project.  These include the ability to initialize LLVM for architectures besides x86 (RLTK supports all architectures supported by LLVM), the presence of all of LLVM's optimization passes, the ability to print the LLVM IR representation of modules and values to files and load modules *from* files, easy initialization of native architectures, initialization for ASM printers and parsers, and compiling modules to object files.
+* **Ease of Use** - Several features have been added to make generating code easier such as automatic management of memory resources used by LLVM.
 * **Speed** - The RLTK bindings are ever so slightly faster due to avoiding unnecessary FFI calls.
 
 Before you dive into generating code, here are some resources you might want to look over to build up some background knowledge on how LLVM works:
@@ -487,7 +508,7 @@ Now that you have a basic block you need to add instructions to it.  This is acc
 
 To add instructions using a builder directly (this is most similar to how it is done using C/C++) you create the builder, position it where you want to add instructions, and then build them:
 
-	fun = mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
+	fun = mod.functions.add('add', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
 	bb  = fun.blocks.append('entry')
 	
 	builder = RLTK::CG::Builder.new
@@ -502,35 +523,35 @@ To add instructions using a builder directly (this is most similar to how it is
 
 You can get rid of some of those references to the builder by using the {RLTK::CG::Builder#build} method:
 
-	fun = mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
+	fun = mod.functions.add('add', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
 	bb  = fun.blocks.append('entry')
 	
 	builder = RLTK::CG::Builder.new
 	
-	builder.build(fun) do |fun|
+	builder.build(bb) do
 		ret add(fun.params[0], fun.params[1])
 	end
 
 To get rid of more code:
 
-	fun = mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
+	fun = mod.functions.add('add', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
 	bb  = fun.blocks.append('entry')
 	
-	RLTK::CG::Builder.new do
+	RLTK::CG::Builder.new(bb) do
 		ret add(fun.params[0], fun.params[1])
 	end
 
 Or:
 
-	fun = mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
-	fun.blocks.append('entry') do |fun|
+	fun = mod.functions.add('add', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
+	fun.blocks.append('entry') do
 		ret add(fun.params[0], fun.params[1])
 	end
 
 Or even:
 
-	mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do
-		blocks.append('entry', nil, nil, self) do |fun|
+	mod.functions.add('add', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do
+		blocks.append('entry') do |fun|
 			ret add(fun.params[0], fun.params[1])
 		end
 	end
@@ -539,9 +560,10 @@ In the last two examples a new builder object is created for the block.  It is p
 
 	builder = RLTK::CG::Builder.new
 	
-	fun = mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType])
-	fun.blocks.append('entry', nil, builder) do
-		ret add(fun.params[0], fun.params[1])
+	mod.functions.add('add', RLTK:CG::NativeIntType, [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do
+		blocks.append('entry', builder) do |fun|
+			ret add(fun.params[0], fun.params[1])
+		end
 	end
 
 For an example of where this is useful, see the Kazoo tutorial.

data/lib/rltk/ast.rb

@@ -333,6 +333,9 @@ module RLTK # :nodoc:
 		# were declared) and then the children as the remaining arguments (in
 		# the order they were declared).
 		#
+		# If a node has 2 values and 2 children and is passed only a single
+		# value the remaining values and children are assumed to be nil.
+		#
 		# @param [Array<Object>] objects The values and children of this node.
 		def initialize(*objects)
 			if self.class == RLTK::ASTNode
@@ -352,11 +355,34 @@ module RLTK # :nodoc:
 			end
 		end
 		
-		# Maps the children of the ASTNode from one value to another.
+		# Create a new tree by using the provided Proc object to map the
+		# nodes of this tree to new nodes.  This is always done in
+		# post-order, meaning that all children of a node are visited before
+		# the node itself.
 		#
-		# @return [void]
-		def map
-			self.children = self.children.map { |c| yield c }
+		# @note This does not modify the current tree.
+		#
+		# @return [Object] The result of calling the given block on the root node.
+		def map(&block)
+			new_children	= self.children.map { |c| if c.nil? then block.call(c) else c.map(&block) end }
+			new_node		= self.class.new(*self.values, *new_children)
+			
+			block.call(new_node)
+		end
+		
+		# Map the nodes in an AST to new nodes using the provided Proc
+		# object.  This is always done in post-order, meaning that all
+		# children of a node are visited before the node itself.
+		#
+		# @note The root node can not be replaced and as such the result of
+		#	calling the provided block on the root node is used as the
+		#	return value.
+		#
+		# @return [Object] The result of calling the given block on the root node.
+		def map!(&block)
+			self.children = self.children.map { |c| if c.nil? then block.call(c) else c.map!(&block) end }
+			
+			block.call(self)
 		end
 		
 		# @return [ASTNode] Root of the abstract syntax tree.

data/lib/rltk/cg/basic_block.rb

@@ -35,11 +35,11 @@ module RLTK::CG # :nodoc:
 		# @param [FFI::Pointer, Function, BasicBlock] overloaded Overloaded paramater that determines creation behaviour.
 		#
 		# @param [String]		name			Name of this BasicBlock.
-		# @param [Context, nil]	context		Context in which to create the block.
 		# @param [Builder, nil]	builder		Builder to be used by {#build}.
+		# @param [Context, nil]	context		Context in which to create the block.
 		# @param [Array<Object>]	block_args	Arguments to be passed when block is invoked.
 		# @param [Proc]		block		Block to be invoked by {#build}.
-		def initialize(overloaded, name = '', context = nil, builder = nil, *block_args, &block)
+		def initialize(overloaded, name = '', builder = nil, context = nil, *block_args, &block)
 			check_type(context, Context, 'context') if context
 			
 			@ptr =
@@ -83,17 +83,7 @@ module RLTK::CG # :nodoc:
 		#
 		# @return [Object] Value the block evaluates to.  Usually an {Instruction}
 		def build(builder = nil, *block_args, &block)
-			if builder
-				builder.build(self, *block_args, &block)
-				
-			else
-				builder	= Builder.new
-				last_inst	= builder.build(self, *block_args, &block)
-				
-				builder.dispose
-				
-				last_inst
-			end
+			if builder then builder else Builder.new end.build(self, *block_args, &block)
 		end
 		
 		# Creates a new BasicBlock inserted immediately before this block.

data/lib/rltk/cg/builder.rb

@@ -21,29 +21,29 @@ module RLTK::CG # :nodoc:
 	class Builder
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_builder(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		# @return [Builder] A global Builder object.
 		def self.global
 			@@global_builder ||= Builder.new
 		end
 		
 		# Creates a new Builder object, optionally positioning it at the end
-		# of *block*.
+		# of *block*.  If a block is given it will be executed as if it was
+		# passed to the #build method.
 		#
-		# @param [BasicBlock, nil] block BasicBlock used to position the Builder. 
-		def initialize(block = nil)
+		# @param [BasicBlock, nil]	bb			BasicBlock used to position the Builder.
+		# @param [Array<Object>]		block_args	Arguments to be passed to *block*.
+		# @param [Proc, nil]		block		Block to execute in the context of this Builder. 
+		def initialize(bb = nil, *block_args, &block)
 			@ptr = Bindings.create_builder
 			
-			position_at_end(block) if block
-		end
-		
-		# Frees the resources used by LLVM for this Builder.
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				Bindings.dispose_builder(@ptr)
-				@ptr = nil
-			end
+			# Define a finalizer to free the memory used by LLVM for this
+			# builder.
+			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
+			
+			if block then self.build(bb, *block_args, &block) elsif bb then position_at_end(bb) end
 		end
 		
 		# Executes a given block inside the context of this builder.  If the
@@ -73,22 +73,22 @@ module RLTK::CG # :nodoc:
 		
 		# Position the Builder after the given instruction.
 		#
-		# @param [BasicBlock]	block
+		# @param [BasicBlock]	bb
 		# @param [Instruction]	instruction
 		#
 		# @return [Builder] self
-		def position(block, instruction)
-			Bindings.position_builder(@ptr, block, instruction)
+		def position(bb, instruction)
+			Bindings.position_builder(@ptr, bb, instruction) if check_type(bb, BasicBlock, 'bb')
 			self
 		end
 		
 		# Position the Builder at the end of the given BasicBlock.
 		#
-		# @param [BasicBlock] block
+		# @param [BasicBlock] bb
 		#
 		# @return [Bulder] self
-		def position_at_end(block)
-			Bindings.position_builder_at_end(@ptr, block)
+		def position_at_end(bb)
+			Bindings.position_builder_at_end(@ptr, bb) if check_type(bb, BasicBlock, 'bb')
 			self
 		end
 		

data/lib/rltk/cg/context.rb

@@ -20,6 +20,9 @@ module RLTK::CG # :nodoc:
 	class Context
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.context_dispose(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		#################
 		# Class Methods #
 		#################
@@ -36,16 +39,10 @@ module RLTK::CG # :nodoc:
 		# @param [FFI::Pointer, nil] ptr Pointer representing a context.  If nil, a new context is created.
 		def initialize(ptr = nil)
 			@ptr = ptr || Bindings.context_create()
-		end
-		
-		# Frees the resources used by LLVM for this context.
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				Bindings.context_dispose(@ptr)
-				@ptr = nil
-			end
+			
+			# Define a finalizer to free the memory used by LLVM for this
+			# context.
+			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
 	end
 end

data/lib/rltk/cg/execution_engine.rb

@@ -29,6 +29,9 @@ module RLTK::CG # :nodoc:
 		include AbstractClass
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_execution_engine(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		# @return [Module]
 		attr_reader :module
 		
@@ -53,7 +56,10 @@ module RLTK::CG # :nodoc:
 				
 				# Associate this engine with the provided module.
 				@module.engine = self
-		
+				
+				# Define a finalizer to free the memory used by LLVM for
+				# this execution engine.
+				ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 			else
 				errorp  = error.read_pointer
 				message = errorp.null? ? 'Unknown' : errorp.read_string
@@ -66,17 +72,6 @@ module RLTK::CG # :nodoc:
 			end
 		end
 		
-		# Frees the resources used by LLVM for this execution engine..
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				Bindings.dispose_execution_engine(@ptr)
-				
-				@ptr = nil
-			end
-		end
-		
 		# Builds a pointer to a global value.
 		#
 		# @param [GlobalValue] global Value you want a pointer to.
@@ -95,24 +90,15 @@ module RLTK::CG # :nodoc:
 		#
 		# @return [GenericValue]
 		def run_function(fun, *args)
-			new_values = Array.new
-			
 			new_args =
 			fun.params.zip(args).map do |param, arg|
-				if arg.is_a?(GenericValue)
-					arg
-					
-				else
-					returning(GenericValue.new(arg)) { |val| new_values << val }
-				end
+				if arg.is_a?(GenericValue) then arg else GenericValue.new(arg) end
 			end
 			
 			args_ptr = FFI::MemoryPointer.new(:pointer, args.length)
 			args_ptr.write_array_of_pointer(new_args)
 			
-			returning(GenericValue.new(Bindings.run_function(@ptr, fun, args.length, args_ptr))) do
-				new_values.each { |val| val.dispose }
-			end
+			GenericValue.new(Bindings.run_function(@ptr, fun, args.length, args_ptr))
 		end
 		alias :run :run_function
 		

data/lib/rltk/cg/function.rb

@@ -120,15 +120,18 @@ module RLTK::CG # :nodoc:
 			
 			# Add a {BasicBlock} to the end of this function.
 			#
+			# @note The first argument to any proc passed to this function
+			#	will be the function the block is being appended to.
+			#
 			# @param [String]		name			Name of the block in LLVM IR.
-			# @param [Context, nil]	context		Context in which to create the block.
 			# @param [Builder, nil]	builder		Builder to be used in evaluating *block*.
-			# @param [Array<Object>]	block_args	Arguments to be passed to *block*.
+			# @param [Context, nil]	context		Context in which to create the block.
+			# @param [Array<Object>]	block_args	Arguments to be passed to *block*.  The function the block is appended to is automatically added to the front of this list.
 			# @param [Proc]		block		Block to be evaluated using *builder* after positioning it at the end of the new block.
 			#
 			# @return [BasicBlock] New BasicBlock.
-			def append(name = '', context = nil, builder = nil, *block_args, &block)
-				BasicBlock.new(@fun, name, context, builder, *block_args, &block)
+			def append(name = '', builder = nil, context = nil, *block_args, &block)
+				BasicBlock.new(@fun, name, builder, context, @fun, *block_args, &block)
 			end
 			
 			# An iterator for each block inside this collection.

data/lib/rltk/cg/generic_value.rb

@@ -27,6 +27,9 @@ module RLTK::CG # :nodoc:
 	class GenericValue
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_generic_value(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		# @return [Type] LLVM type of this GenericValue.
 		attr_reader :type
 		
@@ -57,16 +60,10 @@ module RLTK::CG # :nodoc:
 			when FalseClass
 				[Bindings.create_generic_value_of_int(Int1Type, 0, 0), Int1Type]
 			end
-		end
-		
-		# Frees the resources used by LLVM for this value.
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				Bindings.dispose_generic_value(@ptr)
-				@ptr = nil
-			end
+			
+			# Define a finalizer to free the memory used by LLVM for this
+			# generic value.
+			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
 		
 		# @param [Boolean] signed Treat the GenericValue as a signed integer.

data/lib/rltk/cg/memory_buffer.rb

@@ -20,6 +20,9 @@ module RLTK::CG # :nodoc:
 	class MemoryBuffer
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_memory_buffer(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		# Create a new memory buffer.
 		#
 		# @param [FFI::Pointer, String, nil] overloaded This parameter may be either a pointer to an existing memory
@@ -46,17 +49,10 @@ module RLTK::CG # :nodoc:
 				
 				buf_ptr.get_pointer(0)
 			end
-		end
-		
-		# Frees the resources used by LLVM for this memory buffer.
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				Bindings.dispose_memory_buffer(@ptr)
-				
-				@ptr = nil
-			end
+			
+			# Define a finalizer to free the memory used by LLVM for this
+			# memory buffer.
+			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
 	end
 end

data/lib/rltk/cg/module.rb

@@ -22,6 +22,9 @@ module RLTK::CG # :nodoc:
 	class Module
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_module(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		# @!attribute [rw] engine
 		#   @return [ExecutionEngine, nil] Execution engine associated with this module.
 		attr_accessor :engine
@@ -76,6 +79,10 @@ module RLTK::CG # :nodoc:
 				end
 			end
 			
+			# Define a finalizer to free the memory used by LLVM for this
+			# module.
+			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
+			
 			self.instance_exec(&block) if block
 		end
 		
@@ -97,17 +104,6 @@ module RLTK::CG # :nodoc:
 			Context.new(Bindings.get_module_context(@ptr))
 		end
 		
-		# Frees the resources used by LLVM for this module.
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				Bindings.dispose_module(@ptr)
-				
-				@ptr = nil
-			end
-		end
-		
 		# Print the LLVM IR representation of this value to standard error.
 		# This function is the debugging version of the more general purpose
 		# {#print} method.

data/lib/rltk/cg/pass_manager.rb

@@ -21,6 +21,9 @@ module RLTK::CG # :nodoc:
 	class PassManager
 		include BindingClass
 		
+		# The Proc object called by the garbage collector to free resources used by LLVM.
+		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_pass_manager(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
+		
 		# A list of passes that are available to be added to the pass
 		# manager via the {PassManager#add} method.
 		PASSES = {
@@ -85,19 +88,10 @@ module RLTK::CG # :nodoc:
 			
 			# RLTK Initialization
 			@enabled = Array.new
-		end
-		
-		# Frees the resources used by LLVM for this pass manager.
-		#
-		# @return [void]
-		def dispose
-			if @ptr
-				self.finalize
-				
-				Bindings.dispose_pass_manager(@ptr)
-				
-				@ptr = nil
-			end
+			
+			# Define a finalizer to free the memory used by LLVM for this
+			# pass manager.
+			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
 		
 		# Add a pass or passes to this pass manager.  Passes may either be

data/lib/rltk/version.rb

@@ -5,7 +5,7 @@
 
 module RLTK # :nodoc:
 	# The version number of the RLTK library.
-	VERSION			= '2.1.1'
+	VERSION			= '2.2.0'
 	# The version of LLVM targeted by RLTK.
 	LLVM_TARGET_VERSION	= '3.0'
 end

data/test/tc_ast.rb

@@ -42,8 +42,9 @@ class ASTNodeTester < Test::Unit::TestCase
 		
 		@tree1 = ANode.new(BNode.new(CNode.new), BNode.new)
 		@tree2 = ANode.new(BNode.new, BNode.new(CNode.new))
+		@tree3 = ANode.new(CNode.new(BNode.new), CNode.new)
 		
-		@tree3 =	SNode.new('F',
+		@tree4 =	SNode.new('F',
 					SNode.new('B',
 						SNode.new('A'),
 						SNode.new('D',
@@ -58,6 +59,14 @@ class ASTNodeTester < Test::Unit::TestCase
 						)
 					)
 				)
+		
+		@bc_proc = Proc.new do |n|
+			case n
+			when BNode then	CNode.new(n.left, n.right)
+			when CNode then	BNode.new(n.left, n.right)
+			else				n
+			end
+		end
 	end
 	
 	def test_children
@@ -68,16 +77,6 @@ class ASTNodeTester < Test::Unit::TestCase
 		node.children = (expected_children = [BNode.new, CNode.new])
 		
 		assert_equal(node.children, expected_children)
-		
-		node.map do |child|
-			if child.is_a?(BNode)
-				CNode.new
-			else
-				BNode.new
-			end
-		end
-		
-		assert_equal(node.children, expected_children.reverse)
 	end
 	
 	def test_dump
@@ -92,21 +91,21 @@ class ASTNodeTester < Test::Unit::TestCase
 		# Test pre-order
 		nodes	= []
 		expected	= ['F', 'B', 'A', 'D', 'C', 'E', 'G', 'I', 'H']
-		@tree3.each(:pre) { |n| nodes << n.string }
+		@tree4.each(:pre) { |n| nodes << n.string }
 		
 		assert_equal(expected, nodes)
 		
 		# Test post-order
 		nodes	= []
 		expected	= ['A', 'C', 'E', 'D', 'B', 'H', 'I', 'G', 'F']
-		@tree3.each(:post) { |n| nodes << n.string }
+		@tree4.each(:post) { |n| nodes << n.string }
 		
 		assert_equal(expected, nodes)
 		
 		# Test level-order
 		nodes	= []
 		expected	= ['F', 'B', 'G', 'A', 'D', 'I', 'C', 'E', 'H']
-		@tree3.each(:level) { |n| nodes << n.string }
+		@tree4.each(:level) { |n| nodes << n.string }
 		
 		assert_equal(expected, nodes)
 	end
@@ -118,11 +117,31 @@ class ASTNodeTester < Test::Unit::TestCase
 	
 	def test_initialize
 		assert_raise(RuntimeError) { RLTK::ASTNode.new }
-		assert_nothing_raised(RuntimeError) { ANode.new(nil, nil) }
+		assert_nothing_raised(RuntimeError) { ANode.new }
+	end
+	
+	def test_map
+		mapped_tree = @tree1.map(&@bc_proc)
+		
+		assert_equal(@tree0, @tree1)
+		assert_equal(@tree3, mapped_tree)
+	end
+	
+	def test_map!
+		tree1_clone = @tree1.clone
+		tree1_clone.map!(&@bc_proc)
+		
+		assert_not_equal(@tree1, tree1_clone)
+		assert_equal(@tree3, tree1_clone)
+		
+		replace_node = BNode.new
+		replace_node = replace_node.map!(&@bc_proc)
+		
+		assert_equal(CNode.new, replace_node)
 	end
 	
 	def test_notes
-		node = ANode.new(nil, nil)
+		node = ANode.new
 		
 		assert_nil(node[:a])
 		assert_equal(node[:a] = :b, :b)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rltk
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-07 00:00:00.000000000 Z
+date: 2012-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi