bones-compiler 1.1.0

data/lib/bones/variablelist.rb

@@ -0,0 +1,72 @@
+
+module Bones
+	# This class is based on the standard Array class. It is
+	# meant to contain a list of elements of the Variable class.
+	# In that sense, using the Array class will suffice. However,
+	# this class extends the list with a small number of addi-
+	# tional methods. These methods involve selecting a subset
+	# of the list or sorting the list.
+	class Variablelist < Array
+		attr_accessor :representative
+		
+		# This method returns a subset of the list, based on the
+		# argument +direction+ given. It either returns a list of
+		# input variables or a list of output variables.
+		def select(direction)
+			array = Variablelist.new()
+			self.each do |element|
+				array.push(element) if ((direction == INPUT) && (element.input?)) || ((direction == OUTPUT) && (element.output?))
+			end
+			return array
+		end
+		
+		# Method to set a representative variable for this variable-
+		# list. It is set based on the variable's species-name, e.g.
+		# 'in0' or 'out2'.
+		def set_representative(ids)
+			@representative = select(ids.to_s.scan(/\D+/).join)[ids.to_s.scan(/\d+/).join.to_i]
+		end
+		
+		# This method is a short-hand version to select a list of
+		# input variables. It calls the +select+ method internally.
+		def inputs
+			select(INPUT)
+		end
+		
+		# This method is a short-hand version to select a list of
+		# output variables. It calls the +select+ method internally.
+		def outputs
+			select(OUTPUT)
+		end
+		
+		# This method is a short-hand version to select a list of
+		# input only variables. It calls the +select+ method
+		# internally.
+		def inputs_only
+			self-select(OUTPUT)
+		end
+		
+		# This method is a short-hand version to select a list of
+		# input only variables. It calls the +select+ method
+		# internally.
+		def outputs_only
+			self-select(INPUT)
+		end
+		
+		# This method sorts the list of variables based on its
+		# species' pattern (e.g. element or chunk). An alphabet
+		# is based as an argument to this method to specify the
+		# prefered order. This alphabet must be an array of strings.
+		def sort_by(alphabet)
+			clone = self.clone
+			self.clear
+			alphabet.each do |letter|
+				clone.each do |array|
+					self.push(array) if array.species.pattern == letter
+				end
+			end
+		end
+		
+	end
+	
+end

data/lib/castaddon.rb

@@ -0,0 +1,27 @@
+# Include the CAST gem, which provides a C99-parser. The gem
+# is based on an intermediate representation in the form of
+# an abstract syntax tree (AST). The gem provides C to AST
+# and AST to C.
+module C
+end
+require 'rubygems'
+require 'cast'
+
+# Include the extentions to the CAST gem provided by the author
+# of Bones. These extentions provide a significant amount of
+# functionality for Bones itself.
+require 'castaddon/node.rb'
+require 'castaddon/type.rb'
+require 'castaddon/index.rb'
+
+# Modify the NodeArray and NodeChain lists to output correct
+# code when printed to a file.
+class C::NodeList
+	# Modify the 'to_s' method to output correct code when printed
+	# to a file. Originally, it would separate instances of the list
+	# with a ','. Instead, a newline command is added.
+	def to_s
+		self.join("\n")
+	end
+end
+

data/lib/castaddon/index.rb

@@ -0,0 +1,40 @@
+# This class provides an extention to the CAST index class.
+# The class contains a number of functions applicable to array
+# accesses of the form 'array[x][y]' or 'vector[i]'.
+#
+# The provided methods are helpers to extend the CAST functionality
+# and to clean-up the Bones classes.
+class C::Index
+	
+	# This method is a recursive method which *gets* the name of
+	# a variable from the index definition. Depending on the
+	# number of dimensions, it will go deeper into the structure
+	# and eventually return the name.
+	def variable_name
+		return (self.expr.variable?) ? self.expr.name : self.expr.variable_name
+	end
+	
+	# This method is a recursive method which *sets* the name of
+	# a variable from the index definition. Depending on the
+	# number of dimensions, it will go deeper into the structure
+	# and eventually set the name.
+	def variable_name=(name)
+		(self.expr.variable?) ? self.expr.name = name : self.expr.variable_name=(name)
+	end
+	
+	# This method returns the dimension of an index expression.
+	# It starts at dimension 1, but if it can find a new dimension
+	# it will increment the count and call itself again.
+	def dimension(count=1)
+		return (self.expr.index?) ? self.expr.dimension(count+1) : count
+	end
+	
+	# This method returns the index itself at a given dimension.
+	# It uses recursion to iterate through the dimensions, but
+	# will eventually return a new index node.
+	def index_at_dimension(dimension)
+		return (dimension == 0) ? self.index : self.expr.index_at_dimension(dimension-1)
+	end
+	
+end
+

data/lib/castaddon/node.rb

@@ -0,0 +1,753 @@
+# This class provides an extension to the CAST node class, which
+# is a parent class for all other CAST classes. The extension
+# consists of three different types of methods:
+# * Methods starting with +transform_+, handling the major code transformations.
+# * Methods to obtain information on variables, such as their direction and whether they are defined or not.
+# * Helper methods, among others those that indicate whether a node is of a certain class.
+class C::Node
+	
+	# Pre-process method. It currently pre-processes a piece of
+	# code (typically the kernel code) to replace particular
+	# code structures with others, which can be handled (better)
+	# by Bones. For now, the pre-process method performs the
+	# following transformations:
+	# * Replaces all incrementors (i++) outside for loops with an assignment (i=i+1).
+	# * Replaces all decrementors (i--) outside for loops with an assignment (i=i-1).
+	def preprocess
+		self.preorder do |node|
+			if node.postinc? || node.preinc?
+				node.replace_with(C::AssignmentExpression.parse(node.expr.to_s+' = '+node.expr.to_s+' + 1')) unless node.parent.for_statement?
+			elsif node.postdec? || node.predec?
+				node.replace_with(C::AssignmentExpression.parse(node.expr.to_s+' = '+node.expr.to_s+' - 1')) unless node.parent.for_statement?
+			end
+		end
+	end
+	
+	# Method to obtain a list of all functions in the code. If
+	# no functions can be found, an empty array is returned. For
+	# every function found, the function itself is pushed to the
+	# list. This method also makes sure that there is at least one
+	# function with the name 'main'. If this is not the case, an
+	# error is raised.
+	def get_functions
+		includes_main = false
+		function_list = []
+		self.preorder do |node|
+			if node.function_definition?
+				function_list.push(node)
+				includes_main = true if (node.name == 'main' || node.name == Bones::VARIABLE_PREFIX+'main')
+			end
+		end
+		raise_error('No "main"-function detected in the input file') if !includes_main
+		return function_list
+	end
+	
+	# Method to enable the use of local memory for a list of
+	# array variables which is given as an argument to the method.
+	# The method walks through the node. First, it checks whether: 
+	# * The node represents an array access (+node.index?+)
+	# * The node has a parent node (+node.parent+)
+	# Then, the method loops over all array variables. It checks
+	# one more thing: whether the array variable's name is the
+	# same as the name found in the array access node.
+	#
+	# If all conditions are met, the method performs two replacements:
+	# * The variable name is changed to correspond to local memory
+	# * The index names are changed to correspond to local indices
+	#
+	# The method performs the transformation on the node itself.
+	# Any old data is thus lost.
+	def transform_use_local_memory(arrays)
+		self.preorder do |node|
+			if (node.index?) && (node.parent)
+				arrays.each do |array|
+					if node.variable_name == array.name
+						node.variable_name = Bones::LOCAL_MEMORY+'_'+array.name
+						array.species.dimensions.each_with_index do |dimension,num_dimension|
+							node.replace_variable(Bones::GLOBAL_ID+'_'+num_dimension.to_s,Bones::LOCAL_ID+'_'+num_dimension.to_s)
+						end
+					end
+				end
+			end
+		end
+	end
+	
+	# This method transforms multi-dimensional arrays into 1D
+	# arrays. The target array variable list is given as argument.
+	# The method walks through the node. First, it checks whether:
+	# * The node represents an array access (+node.index?+)
+	# * The node has a parent node (+node.parent+)
+	# Then, the method loops over all array variables. It then
+	# checks two more things:
+	# * Whether the given name is the same as the name found in the array access node (+node.variable_name == array.name+)
+	# * Whether the dimensions of the given array are the same as the dimensions of the node (+node.dimension == array.dimension+)
+	#
+	# Then, the method is ready to perform the flattening. It
+	# first gets the index for the first dimension and then
+	# iterates over all remaining dimensions. For those dimensions,
+	# the index is multiplied by the size of the previous
+	# dimension.
+	#
+	# The method performs the transformation on the node itself.
+	# Any old data is thus lost.
+	def transform_flatten(array)
+		self.preorder do |node|
+			if (node.index?) && (node.parent)
+				if (node.variable_name == array.name) && (node.dimension == array.dimensions)
+					
+					# Compute the new index
+					results = array.species.dimensions.each_with_index.map { |d,n| '('+node.index_at_dimension(n).to_s+')'+array.factors[n] }
+					replacement = array.name+'['+results.join(' + ')+']'
+					
+					# Replace the node
+					node.replace_with(C::Index.parse(replacement))
+				end
+			end
+		end
+	end
+	
+	# Method to transform array accesses into register accesses.
+	# This is only valid for the local loop body and could have
+	# been done by the actual compiler in a number of cases.
+	def transform_substitution(array,inout)
+		replacement = 'register_'+array.name
+		original_name = ''
+		
+		# Change the variable names
+		self.stmts.preorder do |node|
+			if (node.index?) && (node.parent)
+				
+				# First time replacement
+				if original_name == ''
+					if node.variable_name == array.name
+						node.replace_with(C::Variable.parse(replacement))
+						original_name = node.to_s
+					end
+					
+				# Second, third, etc. replacement
+				else
+					if original_name == node.to_s
+						node.replace_with(C::Variable.parse(replacement))
+					end
+				end
+			end
+		end
+		
+		# Add prologue and epilogue code
+		if original_name != ''
+			if inout
+				self.stmts[0].insert_prev(C::Declaration.parse(array.type_name+' '+replacement+'='+original_name+';'))
+			else
+				self.stmts[0].insert_prev(C::Declaration.parse(array.type_name+' '+replacement+';'))
+			end
+			self.stmts[self.stmts.length-1].insert_next(C::ExpressionStatement.parse(original_name+' = '+replacement+';'))
+		end
+	end
+	
+	# Method to shuffle a 2D array access (e.g. transform from
+	# A[i][j] into A[j][i]).
+	def transform_shuffle(arrays)
+		arrays.each do |array|
+		
+			# Change the variable names
+			self.stmts.preorder do |node|
+				if (node.index?) && (node.parent)
+					if node.variable_name == array.name && node.expr.index?
+						replacement = node.variable_name.to_s+'['+node.index.to_s+']['+node.expr.index.to_s+']'
+						node.replace_with(C::Index.parse(replacement))
+					end
+				end
+			end
+		
+		end
+	end
+	
+	# Method to merge the computations of multiple threads.
+	def transform_merge_threads(amount,excludes)
+		self.preorder do |node|
+			if node.statement?
+				replacement = C::NodeArray.new
+				amount.times do |i|
+					replacement.push(node.clone.rename_variables('_m'+i.to_s,excludes))
+				end
+				node.replace_with(replacement)
+			end
+		end
+	end
+	def rename_variables(suffix,excludes)
+		self.preorder do |node|
+			if (node.variable? || node.declarator?) && !(excludes.include?(node.name)) && (!node.parent.call?)
+				node.name = node.name+suffix
+			end
+		end
+	end
+	
+	# This method provides the transformations necessary to
+	# perform reduction type of operations. The transformations
+	# involved in this function are on variable names and index
+	# locations. The argument +id+ specifies which transformation
+	# to be performed.
+	#
+	# Accepted inputs at this point: 2, 3 and 4 (CUDA/OPENCL)
+	# Also accepted input: 8 (CUDA), 9 (OPENCL) (to create an atomic version of the code)
+	# TODO: Complete the atomic support, e.g. add support for multiplications and ternary operators
+	def transform_reduction(input_variable,output_variable,id)
+		
+		# Pre-process assign-add type constructions
+		if self.stmts[0].expr.addassign?
+			self.stmts[0].expr.replace_with(C::Assign.parse(self.stmts[0].expr.lval.to_s+'='+self.stmts[0].expr.lval.to_s+'+'+self.stmts[0].expr.rval.to_s))
+		end
+		
+		# Create atomic code
+		if id == 8 || id == 9
+			function_name = (id == 8) ? 'atomicAdd' : 'atomic_add'
+			self.preorder do |node|
+				if node.assign?
+					if node.lval.index? && node.lval.variable_name == output_variable.name
+						if node.rval.add?
+							if node.rval.expr1.variable_name == output_variable.name
+								node.replace_with(C::Call.parse(function_name+'(&'+node.rval.expr1.to_s+','+node.rval.expr2.to_s+')'))
+							elsif node.rval.expr2.variable_name == output_variable.name
+								node.replace_with(C::Call.parse(function_name+'(&'+node.rval.expr2.to_s+','+node.rval.expr1.to_s+')'))
+							end
+						elsif node.rval.subtract?
+							if node.rval.expr1.variable_name == output_variable.name
+								node.replace_with(C::Call.parse(function_name+'(&'+node.rval.expr1.to_s+',-'+node.rval.expr2.to_s+')'))
+							elsif node.rval.expr2.variable_name == output_variable.name
+								node.replace_with(C::Call.parse(function_name+'(&'+node.rval.expr2.to_s+',-'+node.rval.expr1.to_s+')'))
+							end
+						else
+							raise_error('Unsupported atomic reduction operator: '+node.rval.type.inspect)
+						end
+					end
+				end
+			end
+			return self
+		else
+		
+			# Split the statement into an operation, the input, and the output
+			results = []
+			operation = self.stmts[0].expr.rval.class
+			[self.stmts[0].expr.rval.expr1.detach,self.stmts[0].expr.rval.expr2.detach].each do |nodes|
+				nodes.preorder do |node|
+					if (node.index?)
+						results[0] = nodes if node.variable_name == input_variable.name
+						results[1] = nodes if node.variable_name == output_variable.name
+					end
+				end
+			end
+			
+			# Process the input part
+			results[0].preorder do |node|
+				if (node.index?) && (node.variable_name == input_variable.name)
+					temporary = C::Variable.parse(Bones::VARIABLE_PREFIX+'temporary')
+					results[0] = C::Index.parse(Bones::LOCAL_MEMORY+'['+Bones::VARIABLE_PREFIX+'offset_id]') if id == 3
+					results[0] = temporary if id == 5
+					if id == 2 || id == 4
+						if node.parent
+							node.replace_with(temporary)
+						else
+							results[0] = temporary
+						end
+					end
+				end
+			end
+			
+			# Process the output part
+			results[1] = C::Variable.parse(Bones::PRIVATE_MEMORY)                          if id == 2 || id == 5
+			results[1] = C::Index.parse(Bones::LOCAL_MEMORY+'['+Bones::LOCAL_ID+']')       if id == 3
+			results[1] = '0'                                                               if id == 4
+			
+			# Merge the results together with the operation
+			return C::Expression.parse(results[1].to_s+'+'+results[0].to_s) if id == 3 || id == 5
+			case operation.to_s
+				when 'C::Add'      then return C::Expression.parse(results[1].to_s+'+'+results[0].to_s)
+				when 'C::Subtract' then return C::Expression.parse(results[1].to_s+'-'+results[0].to_s)
+				else raise_error('Unsupported reduction operation '+operation.to_s+'.')
+			end
+		end
+	end
+	
+	# This method returns the complexity of a piece of code in
+	# terms of the amount of ALU operations (multiplications,
+	# additions, etc.).
+	def get_complexity
+		count = 0
+		self.preorder do |node|
+			count += 1 if node.alu?
+		end
+		return count
+	end
+	
+	# This method returns the type of a variable (e.g. int, float).
+	# The method requires the name of a variable as an argument.
+	# It first tries to find a declaration for the variable in
+	# by walking through the node. If it cannot find it, it will
+	# search for a parameter definition from a function call. If
+	# that cannot be found either, the method will return 'nil',
+	# meaning that the variable is not defined at all in the
+	# current node.
+	def variable_type(variable_name)
+		self.preorder do |node|
+			if node.declarator? || node.parameter?
+				return node.type if node.name == variable_name
+			end
+		end
+		return nil
+	end
+	
+	# This method returns the sizes of a variable as defined
+	# at the initialization of the array. There are multiple
+	# possibilities:
+	# * Static arrays (e.g. int array[12])
+	# * Static arrays with defines (e.g. int input[N1][N2][N3])
+	# * Variable length arrays (e.g. float temp[n][m])
+	# * Dynamically allocated arrays (e.g. int *a = (int *)malloc(size*4))
+	def size(variable_name)
+		self.preorder do |node|
+			if node.declarator? && node.name == variable_name
+				if node.indirect_type
+					if node.indirect_type.array?
+						return node.indirect_type.lengths
+					elsif node.indirect_type.pointer?
+						node.preorder do |inner_node|
+							if inner_node.call? && inner_node.expr.name == 'malloc'
+								if !node.indirect_type.type # This is a check to ensure single-pointer only
+									string = '('+inner_node.args.to_s+'/sizeof('+node.type.to_s.gsub('*','').strip+'))'
+									string.gsub!(/sizeof\(int\)\/sizeof\(int\)/,'1')
+									string.gsub!(/sizeof\(unsigned int\)\/sizeof\(unsigned int\)/,'1')
+									string.gsub!(/sizeof\(char\)\/sizeof\(char\)/,'1')
+									string.gsub!(/sizeof\(unsigned char\)\/sizeof\(unsigned char\)/,'1')
+									string.gsub!(/sizeof\(double\)\/sizeof\(double\)/,'1')
+									string.gsub!(/sizeof\(float\)\/sizeof\(float\)/,'1')
+									return [string]
+								end
+							end
+						end
+					end
+				end
+			end
+		end
+		return []
+	end
+	
+	# This is a helper method which calls itself recursively,
+	# depending on the dimensions of the variable. It stores
+	# the resulting array sizes in an array 'result'.
+	def lengths(result = [])
+		found = '('+self.length.to_s+')'
+		result.push(found)
+		return (self.type && self.type.array?) ? self.type.lengths(result) : result
+	end
+	
+	# This method returns a list of undefined variables in the
+	# node. It walks the node tree until it finds a node that
+	# full-fills the following:
+	# * The node is a variable (+node.variable?+)
+	# * The variable is not in a function call (+!node.parent.call?+)
+	# * The variable is not defined in the code (+!self.variable_type(node.name)+)
+	def undefined_variables
+		variables = []
+		self.preorder do |node|
+			variables.push(node.name) if (node.variable?) && (!node.parent.call?) && (!self.variable_type(node.name))
+		end
+		return variables.uniq
+	end
+	
+	# This method finds the direction of a variable based on the
+	# node information. The direction of a variable can be either:
+	# * +in:+ - The variable is accessed read-only.
+	# * +out:+ - The variable is accessed write-only.
+	#
+	# The method takes the name of a variable and walks through
+	# the node to search for expressions (assignments and binary
+	# expressions). For each expression it takes the first and
+	# second part of the expression and stores it in a list.
+	# Afterwards, the expressions in the list are analysed for
+	# occurrences of the variable.
+	#
+	# The method raises an error if the variable does not appear
+	# at all: it is neither input nor output.
+	def direction(variable_name)
+		result = {:in => false, :out => false }
+		expressions = {:in => [], :out => []}
+		output_nodes = []
+		self.preorder do |node|
+			
+			# First find out if the current node actually contains the target variable somewhere
+			name_match = false
+			node.preorder do |match_node|
+				name_match = true if (match_node.variable?) && (match_node.name == variable_name)
+			end
+			
+			# If there is a match and the current node is of an assignment/binary/declarator type, we can start processing
+			if (name_match) && (node.assignment_expression? || node.binary_expression? || node.declarator?)
+				
+				# First find out if this node can be considered an input (see sum/acc/temp register variable problem - chunk/example1 vs chunk/example5)
+				possible_input = true
+				node.preorder do |test_node|
+					output_nodes.each do |output_node|
+						possible_input = false if test_node =~ output_node
+					end
+				end
+				
+				# Store the node's data in a list (input/output lists are separated)
+				if node.assignment_expression?
+					output_nodes << node.lval
+					expressions[:out] << node.lval.remove_index
+					expressions[:in] << node.rval                if possible_input
+					if !node.assign?
+						expressions[:in] << node.lval              if possible_input
+					end
+				elsif node.binary_expression?
+					expressions[:in] << node.expr1               if possible_input
+					expressions[:in] << node.expr2.remove_index  if possible_input
+				elsif node.declarator? && node.init
+					expressions[:in] << node.init                if possible_input
+				end
+			end
+		end
+		
+		# Set the result according to the list of nodes
+		expressions.each do |key,expression_list|
+			expression_list.each do |expression|
+				expression.preorder do |node|
+					if (node.variable?) && (node.name == variable_name)
+						result[key] = true
+					end
+				end
+			end
+		end
+		
+		# Return the result
+		return Bones::INOUT if result[:in] && result[:out]
+		return Bones::INPUT if result[:in]
+		return Bones::OUTPUT if result[:out]
+		raise_error('Variable "'+variable_name+'" is neither input nor output')
+	end
+	
+	# This method walks through the node and finds the first
+	# for-loop. If it is found, it returns the contents of the
+	# for-loop and the name of the loop variable. Obtaining the
+	# loop variable is conditional because it can either be an
+	# assignment ('k=0') or a variable definition ('int k=0').
+	#
+	# The method raises an error when no for-loop can be found.
+	# It also raises an error if the loop is not in canonical
+	# form.
+	def remove_loop(from,to)
+		bones_common = Bones::Common.new()
+		self.preorder do |node|
+			if node.for_statement?
+				from_statement = (node.init.assign?) ? node.init.rval : node.init.declarators[0].init
+				from_loop = (from_statement.variable?) ? from_statement.name : from_statement.to_s
+				to_loop = (node.cond.expr2.variable?) ? node.cond.expr2.name : ((node.cond.expr2.intliteral?) ? node.cond.expr2.val.to_s : node.cond.expr2.to_s)
+				to_loop = to_loop.gsub(/\s/,'')
+				to_loop = '('+to_loop+')-1' if node.cond.less?
+				to_loop = bones_common.simplify(to_loop)
+				from_loop = bones_common.simplify(from_loop)
+				puts Bones::WARNING+'The loop iterator starts at: "'+from_loop+'" (expected "'+from+'")' if from_loop != from
+				puts Bones::WARNING+'The loop iterator ends at: "'+to_loop+'" (expected "'+to+'")' if to_loop != to
+				raise_error('The loop increment must be 1') if !(node.iter.unit_increment?)
+				name = (node.init.assign?) ? node.init.lval.name : node.init.declarators.first.name
+				return node.stmt, name
+			end
+		end
+		raise_error('Unexpected number of for-loops')
+	end
+	
+	# This method searches for a variable name in the node and
+	# replaces it with the method's argument, which is given as
+	# a string. The node itself is modified. The method checks
+	# whether:
+	# * The node is a variable (+node.variable?+)
+	# * The variable has the correct name (+node.name == variable_name+)
+	# * The variable is not in a function call (+!node.parent.call?+)
+	def replace_variable(variable_name,replacement)
+		self.preorder do |node|
+			node.name = replacement if (node.variable?) && (node.name == variable_name) && (!node.parent.call?)
+		end
+	end
+	
+	# This method searches for a target node and replaces it with
+	# a replacement node. Both the target node and the replacement
+	# node are given as arguments to the method. The method walks
+	# through the node and checks whether:
+	# * The node's class is the same as the target class (+node.class == target.class+)
+	# * The node has a parent (+node.parent != nil+)
+	# * The node is equal to the target node (+node.match?(target)+)
+	# If all checks are successful, the node will be replaced with
+	# the replacement node and the method will return immediately.
+	#
+	# The method returns itself if the target node cannot be
+	# found.
+	def seach_and_replace_node(target,replacements)
+		self.preorder do |node|
+			if (node.class == target.class) && (node.parent != nil) && (node.match?(target))
+				node.replace_with(replacements)
+				return self
+			end
+		end
+		return self
+	end
+	
+	# This method searches for a target node and checks whether it
+	# exists. The input to the method is the target node. The method
+	# walks through the node and checks whether:
+	# * The node's class is the same as the target class (+node.class == target.class+)
+	# * The node has a parent (+node.parent != nil+)
+	# * The node is equal to the target node (+node.match?(target)+)
+	# If all checks are successful, the method will return the value
+	# 'true' immediately. If the target node cannot be found, the
+	# method returns 'false'.
+	def node_exists?(target)
+		self.preorder do |node|
+			if (node.class == target.class) && (node.parent != nil) && (node.match?(target))
+				return true
+			end
+		end
+		return false
+	end
+	
+	# This method searches for a target function call and replaces
+	# it with another. Both the target and the replacement function
+	# call are given as arguments to the method. The method walks
+	# through the node and checks whether:
+	# * The node's class is the same as the target class (+node.class == target.class+)
+	# * The node has a parent which is a function call (+node.parent.call?+)
+	# * The node is equal to the target node (+node.match?(target)+)
+	# If all checks are successful, the node will be replaced with
+	# the replacement node. The method will continue searching for
+	# other occurrences of the function call.
+	#
+	# The method returns itself.
+	def seach_and_replace_function_call(target,replacements)
+		self.preorder do |node|
+			if (node.class == target.class) && (node.parent.call?) && (node.match?(target))
+				node.replace_with(replacements)
+			end
+		end
+		return self
+	end
+	
+	# This method searches for a target function name and replaces
+	# it with another name. Both the target and the replacement
+	# name are given as arguments to the method. The method walks
+	# through the node and checks whether:
+	# * The node's class is a function definition or declaration
+	# * The node's name is equal to the target node's name
+	# If the checks are successful, the node's name will be replaced
+	# The method will continue searching for other occurrences of
+	# functions with the same name.
+	#
+	# The method returns itself.
+	def seach_and_replace_function_definition(old_name,new_name)
+		self.preorder do |node|
+			if (node.function_definition? || node.function_declaration?) && (node.name == old_name)
+				node.name = new_name
+			end
+		end
+		return self
+	end
+	
+	# This method is a small helper function to remove index
+	# nodes from a node. It first clones to original node in
+	# order to not overwrite it, then walks the node and removes
+	# index nodes. Finally, it returns a new node.
+	def remove_index
+		node_clone = self.clone
+		node_clone.preorder do |node|
+			node.index.detach if node.index?
+		end
+		return node_clone
+	end
+	
+	# This method is a small helper function which simply strips
+	# any outer brackets from a node. If no outer brackets are
+	# found, then nothing happens and the node itself is returned.
+	def strip_brackets
+		return (self.block?) ? self.stmts : self
+	end
+	
+	# This method returns 'true' if the node is of the 'Variable'
+	# class. Otherwise, it returns 'false'.
+	def variable? ; (self.class == C::Variable) end
+	
+	# This method returns 'true' if the node is of the 'Array'
+	# class. Otherwise, it returns 'false'.
+	def array?
+		return (self.class == C::Array)
+	end
+	
+	# This method returns 'true' if the node is of the 'Pointer'
+	# class. Otherwise, it returns 'false'.
+	def pointer?
+		return (self.class == C::Pointer)
+	end
+	
+	# This method returns 'true' if the node is of the 'Parameter'
+	# class. Otherwise, it returns 'false'.
+	def parameter?
+		return (self.class == C::Parameter)
+	end
+	
+	# This method returns 'true' if the node is of the 'Declarator'
+	# class. Otherwise, it returns 'false'.
+	def declarator?
+		return (self.class == C::Declarator)
+	end
+	
+	# This method returns 'true' if the node is of the 'Declaration'
+	# class. Otherwise, it returns 'false'.
+	def declaration?
+		return (self.class == C::Declaration)
+	end
+	
+	# This method returns 'true' if the node is of the 'Index'
+	# class. Otherwise, it returns 'false'.
+	def index?
+		return (self.class == C::Index)
+	end
+	
+	# This method returns 'true' if the node is of the 'Call'
+	# class. Otherwise, it returns 'false'.
+	def call?
+		return (self.class == C::Call)
+	end
+	
+	# This method returns 'true' if the node is of the 'FunctionDef'
+	# class. Otherwise, it returns 'false'.
+	def function_definition?
+		return (self.class == C::FunctionDef)
+	end
+	
+	# This method returns 'true' if the node is of the 'Declarator'
+	# class with its 'indirect_type' equal to 'Function' . Otherwise,
+	# it returns 'false'.
+	def function_declaration?
+		return (self.class == C::Declarator && self.indirect_type.class == C::Function)
+	end
+	
+	# This method returns 'true' if the node is of the 'Block'
+	# class. Otherwise, it returns 'false'.
+	def block?
+		return (self.class == C::Block)
+	end
+	
+	# This method returns 'true' if the node is of the 'For'
+	# class. Otherwise, it returns 'false'.
+	def for_statement?
+		return (self.class == C::For)
+	end
+	
+	# This method returns 'true' if the node is of the 'Less'
+	# class. Otherwise, it returns 'false'.
+	def less?
+		return (self.class == C::Less)
+	end
+	
+	# This method returns 'true' if the node is of the 'Add'
+	# class. Otherwise, it returns 'false'.
+	def add?
+		return (self.class == C::Add)
+	end
+	
+	# This method returns 'true' if the node is of the 'Subtract'
+	# class. Otherwise, it returns 'false'.
+	def subtract?
+		return (self.class == C::Subtract)
+	end
+	
+	# This method returns 'true' if the node is of the 'AddAssign'
+	# class. Otherwise, it returns 'false'.
+	def addassign?
+		return (self.class == C::AddAssign)
+	end
+	
+	# This method returns 'true' if the node is of the 'PostInc'
+	# class. Otherwise, it returns 'false'.
+	def postinc?
+		return (self.class == C::PostInc)
+	end
+	
+	# This method returns 'true' if the node is of the 'PreInc'
+	# class. Otherwise, it returns 'false'.
+	def preinc?
+		return (self.class == C::PreInc)
+	end
+	
+	# This method returns 'true' if the node is of the 'PostDec'
+	# class. Otherwise, it returns 'false'.
+	def postdec?
+		return (self.class == C::PostDec)
+	end
+	
+	# This method returns 'true' if the node is of the 'PreDec'
+	# class. Otherwise, it returns 'false'.
+	def predec?
+		return (self.class == C::PreDec)
+	end
+	
+	# This method returns 'true' if the node is of the 'IntLiteral'
+	# class. Otherwise, it returns 'false'.
+	def intliteral?
+		return (self.class == C::IntLiteral)
+	end
+	
+	# This method returns 'true' if the node is of the 'Assign'
+	# class. Otherwise, it returns 'false'.
+	def assign?
+		return (self.class == C::Assign)
+	end
+	
+	# This method returns 'true' if the node is of the 'Call'
+	# class. Otherwise, it returns 'false'.
+	def call?
+		return (self.class == C::Call)
+	end
+	
+	# This method returns 'true' if the node's class inherits
+	# from the 'BinaryExpression' class. Otherwise, it returns
+	# 'false'.
+	def binary_expression?
+		return (self.class.superclass == C::BinaryExpression)
+	end
+	
+	# This method returns 'true' if the node's class inherits
+	# from the 'AssignmentExpression' class. Otherwise, it returns
+	# 'false'.
+	def assignment_expression?
+		return (self.class.superclass == C::AssignmentExpression)
+	end
+	
+	# This method returns 'true' if the node is of the 'PostInc', 'PreInc'
+	# class or if it is of the 'Assign' class and adds with a value of 1.
+	# Otherwise, it returns 'false'.
+	def unit_increment?
+		return (self.class == C::PostInc) || (self.class == C::PreInc) || (self.class == C::Assign && self.rval.class == C::Add && self.rval.expr2.class == C::IntLiteral && self.rval.expr2.val == 1)
+	end
+	
+	# This method returns 'true' if the node is performing an ALU
+	# operation. Otherwise, it returns 'false'.
+	def alu?
+		return add? || subtract? || addassign? || postinc? || postdec? || preinc? || predec? || binary_expression?
+	end
+	
+	# This method returns 'true' if the node is of the 'ExpressionStatement'
+	# class. Otherwise, it returns 'false'.
+	def statement?
+		return (self.class == C::ExpressionStatement) || (self.class == C::Declaration)
+	end
+	
+# From this point on are the private methods.
+private
+	
+	# Override the existing 'indent' method to set the indent size
+	# manually.
+	def indent s, levels=1
+		space = Bones::INDENT
+		s.gsub(/^/, space)
+	end
+	
+end
+