rltk 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7aea9d6131d23f28ce6f81eabf14d4074719716
-  data.tar.gz: da39fb4ebfa9591f50889406b5b71f50beb7d42f
+  metadata.gz: 99843025256c5d1cdcd1b826714ccc48fc2ebd36
+  data.tar.gz: fd8b9750f1fa95c9a810a3395820c4c9e88c6e99
 SHA512:
-  metadata.gz: ad2d8ada835e7e81b2565ef9eec47d63c85460adff03336b85bddbb9bd05ab13ce3b82d26808bbf389f9babd22618ab396f95a717e33d9dd925efcb62a361bea
-  data.tar.gz: eba4da2a9be4bb468e5c1127394320af284efa014b7a0a49e1967885db3c52817d2e62c689ebf4ed0a7820c3ffbf591cd32c0a8f5a3d8bd2a6cc451b114ce8d5
+  metadata.gz: 6bfb8a1cad07ed24d3f26453a028878e4e18875ad1c417d55aa9c42f065f9b2bdcf5491139bf0355b0d6b4027317309823983dbd7ca164e00b8c3320980ea614
+  data.tar.gz: 6e55e4df8368b686d966aa6bcd2d5431b81b59d25327f41b20bd1df3c23c89e4fac12d8d4d4e6b0836ad7b2467170582a30fc2f5bdce30f2fda6d41b0c77c354

data/Rakefile

@@ -1,7 +1,7 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Ruby Language Toolkit
-# Date:		2011/04/06
-# Description:	This is RLTK's Rakefile.
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Ruby Language Toolkit
+# Date:        2011/04/06
+# Description: This is RLTK's Rakefile.
 
 ##############
 # Rake Tasks #
@@ -91,7 +91,7 @@ end
 request_file('yard', 'Yard is not installed.') do
 	YARD::Rake::YardocTask.new do |t|
 		yardlib = File.join(File.dirname(__FILE__), 'yardlib/rltk.rb')
-		
+
 		t.options	= [
 			'-e',       yardlib,
 			'--title',  'The Ruby Language Toolkit',
@@ -99,7 +99,7 @@ request_file('yard', 'Yard is not installed.') do
 			'-M',       'redcarpet',
 			'--private'
 		]
-		
+
 		t.files = Dir['lib/**/*.rb'] +
 		          ['-'] +
 		          Dir['examples/kazoo/**/*.md'].sort
@@ -113,20 +113,20 @@ end
 desc 'Generate the bindings for LLVM.'
 task :gen_bindings do
 	require 'ffi_gen'
-	
+
 	# Generate the standard LLVM bindings.
-	
+
 	deprecated = [
 		# BitReader.h
 		'LLVMGetBitcodeModuleProviderInContext',
 		'LLVMGetBitcodeModuleProvider',
-		
+
 		# BitWriter.h
 		'LLVMWriteBitcodeToFileHandle',
-		
+
 		# Core.h
 		'LLVMCreateFunctionPassManager',
-		
+
 		# ExectionEngine.h
 		'LLVMCreateExecutionEngine',
 		'LLVMCreateInterpreter',
@@ -134,10 +134,10 @@ task :gen_bindings do
 		'LLVMAddModuleProvider',
 		'LLVMRemoveModuleProvider'
 	]
-	
+
 	headers = [
 		'llvm-c/Core.h',
-		
+
 		'llvm-c/Analysis.h',
 		'llvm-c/BitReader.h',
 		'llvm-c/BitWriter.h',
@@ -151,13 +151,13 @@ task :gen_bindings do
 		'llvm-c/Support.h',
 		'llvm-c/Target.h',
 		'llvm-c/TargetMachine.h',
-		
+
 		'llvm-c/Transforms/IPO.h',
 		'llvm-c/Transforms/PassManagerBuilder.h',
 		'llvm-c/Transforms/Scalar.h',
 		'llvm-c/Transforms/Vectorize.h'
 	]
-	
+
 	FFIGen.generate(
 		module_name: 'RLTK::CG::Bindings',
 		ffi_lib:     "LLVM-#{RLTK::LLVM_TARGET_VERSION}",
@@ -171,28 +171,27 @@ end
 
 desc 'Find LLVM bindings with a regular expression.'
 task :find_bind, :part do |t, args|
-	
+
 	# Get the task argument.
 	part = Regexp.new(args[:part])
-	
+
 	# Require the Bindings module.
 	require 'rltk/cg/bindings'
-	
+
 	syms =
 	Symbol.all_symbols.select do |sym|
 		sym = sym.to_s.downcase
-		
+
 		sym[0..3] == 'llvm' and sym[4..-1] =~ part
 	end.sort
-	
+
 	puts
 	if not syms.empty?
 		puts "Matching bindings [#{syms.length}]:"
 		syms.each { |sym| puts "\t#{sym}" }
-	
+
 	else
 		puts 'No matching bindings.'
 	end
 	puts
 end
-

data/lib/rltk/ast.rb

@@ -12,6 +12,7 @@ require 'filigree/abstract_class'
 require 'filigree/class'
 require 'filigree/match'
 require 'filigree/types'
+require 'filigree/visitor'
 
 #######################
 # Classes and Modules #
@@ -20,22 +21,29 @@ require 'filigree/types'
 module RLTK
 	# This class is a good start for all your abstract syntax tree node needs.
 	class ASTNode
-		
+
+		include Filigree::Visitable
+
 		extend Filigree::AbstractClass
 		extend Filigree::Destructurable
-		
+
 		# @return [ASTNode]  Reference to the parent node.
 		attr_accessor :parent
-		
+
 		# @return [Hash]  The notes hash for this node.
 		attr_reader :notes
-		
+
 		#################
 		# Class Methods #
 		#################
-		
+
 		class << self
-			
+
+			# @return [Array<Symbol>]  List of members (children and values) that have array types
+			def array_members
+				@array_members
+			end
+
 			# Check to make sure a name isn't re-defining a value or child.
 			#
 			# @raise [ArgumentError]  Raised if the name is already used for an existing value or child
@@ -43,30 +51,38 @@ module RLTK
 				if @child_names.include? name
 					raise ArgumentError, "Class #{self} or one of its superclasses already defines a child named #{name}"
 				end
-				
+
 				if @value_names.include?(name)
 					raise ArgumentError, "Class #{self} or one of its superclasses already defines a value named #{name}"
 				end
 			end
-			
-			# Installs instance class varialbes into a class.
+
+			# Installs instance class variables into a class.
 			#
 			# @return [void]
 			def install_icvars
 				if self.superclass == ASTNode
-					@child_names = Array.new
-					@child_types = Array.new
-					@value_names = Array.new
-					@value_types = Array.new
+					@child_names   = Array.new
+					@value_names   = Array.new
+					@array_members = Array.new
+
+					@member_order = :values
+					@def_order    = Array.new
+					@inc_children = Array.new
+					@inc_values   = Array.new
 				else
-					@child_names = self.superclass.child_names.clone
-					@child_types = self.superclass.child_types.clone
-					@value_names = self.superclass.value_names.clone
-					@value_types = self.superclass.value_types.clone
+					@child_names   = self.superclass.child_names.clone
+					@value_names   = self.superclass.value_names.clone
+					@array_members = self.superclass.array_members.clone
+
+					@member_order = (v = self.superclass.member_order).is_a?(Symbol) ? v : v.clone
+					@def_order    = self.superclass.def_order.clone
+					@inc_children = self.superclass.inc_children.clone
+					@inc_values   = self.superclass.inc_values.clone
 				end
 			end
 			protected :install_icvars
-			
+
 			# Called when the Lexer class is sub-classed, it installes
 			# necessary instance class variables.
 			#
@@ -76,50 +92,56 @@ module RLTK
 			def inherited(klass)
 				klass.install_icvars
 			end
-			
+
 			# Defined a child for this AST class and its subclasses.
 			# The name of the child will be used to define accessor
 			# methods that include type checking.  The type of this
 			# child must be a subclass of the ASTNode class.
 			#
-			# @param [String, Symbol]  name  Name of child node.
+			# @param [String, Symbol]  name  Name of child node
 			# @param [Class]           type  Type of child node.  Must be a subclass of ASTNode.
+			# @param [Boolean]         omit  Include the child in the constructor or not
 			#
 			# @return [void]
-			def child(name, type)
+			def child(name, type, omit = false)
 				check_odr(name)
-				
+
 				if type.is_a?(Array) and type.length == 1
 					t = type.first
-				
+
 				elsif type.is_a?(Class)
 					t = type
-					
+
 				else
 					raise 'Child and Value types must be a class name or an array with a single class name element.'
 				end
-				
-				# Check to make sure that type is a subclass of
-				# ASTNode.
+
+				# Check to make sure that type is a subclass of ASTNode.
 				if not t.subclass_of?(ASTNode)
 					raise "A child's type specification must be a subclass of ASTNode."
 				end
-				
-				@child_names << name
-				@child_types << type
+
+				@child_names   << name
+				@array_members << name if type.is_a?(Array)
+
+				if not omit
+					@def_order    << name
+					@inc_children << name
+				end
+
 				define_accessor(name, type, true)
 			end
-			
+
 			# @return [Array<Symbol>]  Array of the names of this node class's children
 			def child_names
 				@child_names
 			end
-			
-			# @return [Array]  Array of types of this node class's children
-			def child_types
-				@child_types
+
+			# @return [Array<Symbol>]  Array of names of values/children in the order they were defined
+			def def_order
+				@def_order
 			end
-			
+
 			# This method defines a type checking accessor named *name*
 			# with type *type*.
 			#
@@ -130,31 +152,31 @@ module RLTK
 			# @return [void]
 			def define_accessor(name, type, set_parent = false)
 				ivar_name = ('@' + name.to_s).to_sym
-				
+
 				define_method(name) do
 					self.instance_variable_get(ivar_name)
 				end
-				
+
 				if type.is_a?(Class)
 					if set_parent
 						define_method((name.to_s + '=').to_sym) do |value|
 							self.instance_variable_set(ivar_name, check_type(value, type, nil, true))
 							value.parent = self if value
 						end
-						
+
 					else
 						define_method((name.to_s + '=').to_sym) do |value|
 							self.instance_variable_set(ivar_name, check_type(value, type, nil, true))
 						end
 					end
-					
+
 				else
 					if set_parent
 						define_method((name.to_s + '=').to_sym) do |value|
 							self.instance_variable_set(ivar_name, check_array_type(value, type.first, nil, true))
 							value.each { |c| c.parent = self }
 						end
-						
+
 					else
 						define_method((name.to_s + '=').to_sym) do |value|
 							self.instance_variable_set(ivar_name, check_array_type(value, type.first, nil, true))
@@ -163,48 +185,87 @@ module RLTK
 				end
 			end
 			private :define_accessor
-			
+
+			# Define a custom ordering for the class to use when building the
+			# default constructor and destructurer.
+			#
+			# @param [Array<Symbol>]  members  List of member names
+			#
+			# @return [void]
+			def custom_order(*members)
+				@member_order = members
+			end
+
+			# @return [Array<Symbol>]  Array of the names of children that should be included in the constructor
+			def inc_children
+				@inc_children
+			end
+
+			# @return [Array<Symbol>]  Array of the names of values that should be included in the constructor
+			def inc_values
+				@inc_values
+			end
+
+			# A getter and setter for a class's initialization order.  If the
+			# order value is `:values` the constructor will expect all of the
+			# values and then the children.  If it is `:children` then the
+			# constructor expects children and then values.  If it is `:def`
+			# the constructor expects to values and children in the order that
+			# they were defined.  If val is nil the current value will be
+			# returned.
+			#
+			# The default ordering is `:values`, which matches the behavior of
+			# previous versions of RLTK.
+			#
+			# @param [:values, :children, :def]  val  The new initialization order
+			#
+			# @return [:values, :children, :def]  The current initialization order
+			def member_order(val = nil)
+				if val
+					@member_order = val
+				else
+					@member_order
+				end
+			end
+			alias :order :member_order
+
 			# Defined a value for this AST class and its subclasses.
 			# The name of the value will be used to define accessor
 			# methods that include type checking.
 			#
 			# @param [String, Symbol]  name  Name of value
 			# @param [Class]           type  Type of value
+			# @param [Boolean]         omit  Include the value in the constructor or not
 			#
 			# @return [void]
-			def value(name, type)
+			def value(name, type, omit = false)
 				check_odr(name)
-				
-				if type.is_a?(Array) and type.length == 1
-					t = type.first
-				
-				elsif type.is_a?(Class)
-					t = type
-					
-				else
+
+				if not (type.is_a?(Class) or (type.is_a?(Array) and type.length == 1))
 					raise 'Child and Value types must be a class name or an array with a single class name element.'
 				end
-				
-				@value_names << name
-				@value_types << type
+
+				@value_names   << name
+				@array_members << name if type.is_a?(Array)
+
+				if not omit
+					@def_order  << name
+					@inc_values << name
+				end
+
 				define_accessor(name, type)
 			end
-			
+
 			# @return [Array<Symbol>]  Array of the names of this node class's values
 			def value_names
 				@value_names
 			end
-			
-			# @return [Array<Symbol>]  Array of the types of this node class's values
-			def value_types
-				@value_types
-			end
 		end
-		
+
 		####################
 		# Instance Methods #
 		####################
-		
+
 		# Used for AST comparison, this function will return true if the two
 		# nodes are of the same class and all of their values and children
 		# are equal.
@@ -215,41 +276,42 @@ module RLTK
 		def ==(other)
 			self.class == other.class and self.values == other.values and self.children == other.children
 		end
-		
+
 		# @return [Object]  Note with the name *key*
 		def [](key)
 			@notes[key]
 		end
-		
+
 		# Sets the note named *key* to *value*.
 		def []=(key, value)
 			@notes[key] = value
 		end
-		
+
 		# This method allows ASTNodes to be destructured for pattern matching.
-		def call(arity)
-			if arity == self.values.length
-				self.values
-			else
-				[*self.values, *self.children]
-			end
+		def destructure(arity)
+			case self.class.member_order
+			when :values   then (self.class.inc_values + self.class.inc_children)
+			when :children then (self.class.inc_children + self.class.inc_values)
+			when :def      then self.class.def_order
+			when Array     then self.class.member_order
+			end.map { |m| self.send m }
 		end
-		
+
 		# @param [Class] as The type that should be returned by the method.  Must be either Array or hash.
 		#
 		# @return [Array<ASTNode>, Hash{Symbol => ASTNode}] Array or Hash of this node's children.
 		def children(as = Array)
 			if as == Array
 				self.class.child_names.map { |name| self.send(name) }
-			
+
 			elsif as == Hash
 				self.class.child_names.inject(Hash.new) { |h, name| h[name] = self.send(name); h }
-			
+
 			else
 				raise 'Children can only be returned as an Array or a Hash.'
 			end
 		end
-		
+
 		# Assigns an array or hash of AST nodes as the children of this node.
 		# If a hash is provided as an argument the key is used as the name of
 		# the child a object should be assigned to.
@@ -263,11 +325,11 @@ module RLTK
 				if children.length != self.class.child_names.length
 					raise 'Wrong number of children specified.'
 				end
-			
+
 				self.class.child_names.each_with_index do |name, i|
 					self.send((name.to_s + '=').to_sym, children[i])
 				end
-				
+
 			when Hash
 				children.each do |name, val|
 					if self.class.child_names.include?(name)
@@ -278,14 +340,14 @@ module RLTK
 				end
 			end
 		end
-		
+
 		# Produce an exact copy of this tree.
 		#
 		# @return [ASTNode] A copy of the tree.
 		def copy
 			self.map { |c| c }
 		end
-		
+
 		# Removes the note *key* from this node.  If the *recursive* argument
 		# is true it will also remove the note from the node's children.
 		#
@@ -295,7 +357,7 @@ module RLTK
 			if recursive
 				self.children.each do |child|
 					next if not child
-					
+
 					if child.is_a?(Array)
 						child.each { |c| c.delete_note(key, true) }
 					else
@@ -303,10 +365,10 @@ module RLTK
 					end
 				end
 			end
-			
+
 			@notes.delete(key)
 		end
-		
+
 		# This method is a simple wrapper around Marshal.dump, and is used
 		# to serialize an AST.  You can use Marshal.load to reconstruct a
 		# serialized AST.
@@ -324,7 +386,7 @@ module RLTK
 			else	            raise TypeError, "AST#dump expects nil, a String, or an IO object for the dest parameter."
 			end
 		end
-		
+
 		# An iterator over the node's children.  The AST may be traversed in
 		# the following orders:
 		#
@@ -339,31 +401,31 @@ module RLTK
 			case order
 			when :pre
 				yield self
-				
+
 				self.children.flatten.compact.each { |c| c.each(:pre, &block) }
-				
+
 			when :post
 				self.children.flatten.compact.each { |c| c.each(:post, &block) }
-				
+
 				yield self
-				
+
 			when :level
 				level_queue = [self]
-				
+
 				while node = level_queue.shift
 					yield node
-					
+
 					level_queue += node.children.flatten.compact
 				end
 			end
 		end
-		
+
 		# Tests to see if a note named *key* is present at this node.
 		def has_note?(key)
 			@notes.has_key?(key)
 		end
 		alias :'note?' :'has_note?'
-		
+
 		# Instantiates a new ASTNode object.  The arguments to this method are
 		# split into two lists: the set of values for this node and a list of
 		# its children.  If the node has 2 values and 3 children you would
@@ -383,22 +445,27 @@ module RLTK
 		def initialize(*objects, &block)
 			@notes  = Hash.new()
 			@parent = nil
-			
-			# Pad out the objects array with nil values and empty
-			# arrays.
-			all_types       = self.class.value_types + self.class.child_types
-			remaining_types = all_types[objects.length..-1]
-			
-			objects += remaining_types.map { |type| type.is_a?(Array) ? [] : nil }
-			
-			pivot = self.class.value_names.length
-			
-			self.values   = objects[0...pivot]
-			self.children = objects[pivot..-1]
-			
+
+			pairs =
+			case self.class.member_order
+			when :values   then (self.class.inc_values + self.class.inc_children)
+			when :children then (self.class.inc_children + self.class.inc_values)
+			when :def      then self.class.def_order
+			when Array     then self.class.member_order
+			end.zip(objects).first(objects.length)
+
+			pairs.each do |name, value|
+				self.send("#{name}=", value)
+			end
+
+			self.class.array_members.each do |member|
+				ivar_name = '@' + member.to_s
+				self.instance_variable_set(ivar_name, []) if self.instance_variable_get(ivar_name).nil?
+			end
+
 			self.instance_exec(&block) if not block.nil?
 		end
-		
+
 		# 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
@@ -409,7 +476,7 @@ module RLTK
 		# @return [Object]  Result of calling the given block on the root node
 		def map(&block)
 			new_values = self.values.map { |v| v.clone }
-			
+
 			new_children =
 			self.children.map do |c0|
 				case c0
@@ -418,13 +485,13 @@ module RLTK
 				when NilClass then nil
 				end
 			end
-			
+
 			new_node		= self.class.new(*new_values, *new_children)
 			new_node.notes = self.notes
-			
+
 			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.
@@ -443,10 +510,10 @@ module RLTK
 				when NilClass then nil
 				end
 			end
-			
+
 			block.call(self)
 		end
-		
+
 		# Set the notes for this node from a given hash.
 		#
 		# @param [Hash]  new_notes  The new notes for this node.
@@ -455,27 +522,27 @@ module RLTK
 		def notes=(new_notes)
 			@notes = new_notes.clone
 		end
-		
+
 		# @return [ASTNode] Root of the abstract syntax tree.
 		def root
 			if @parent then @parent.root else self end
 		end
-		
+
 		# @param [Class]  as  The type that should be returned by the method.  Must be either Array or hash.
 		#
 		# @return [Array<Object>, Hash{Symbol => Object}] Array or Hash of this node's values.
 		def values(as = Array)
 			if as == Array
 				self.class.value_names.map { |name| self.send(name) }
-			
+
 			elsif as == Hash
 				self.class.value_names.inject(Hash.new) { |h, name| h[name] = self.send(name); h }
-			
+
 			else
 				raise 'Values can only be returned as an Array or a Hash.'
 			end
 		end
-		
+
 		# Assigns an array or hash of objects as the values of this node.  If
 		# a hash is provided as an argument the key is used as the name of
 		# the value an object should be assigned to.
@@ -487,11 +554,11 @@ module RLTK
 				if values.length != self.class.value_names.length
 					raise 'Wrong number of values specified.'
 				end
-			
+
 				self.class.value_names.each_with_index do |name, i|
 					self.send((name.to_s + '=').to_sym, values[i])
 				end
-				
+
 			when Hash
 				values.each do |name, val|
 					if self.class.value_names.include?(name)