bones-compiler 1.1.0 → 1.3.1

data/examples/benchmarks/overview.txt

@@ -1,38 +0,0 @@
-
-== Benchmarks with full parallelism
-linear-algebra/kernels/2mm...........2 species...[fully classified]
-linear-algebra/kernels/3mm...........3 species...[fully classified]
-linear-algebra/kernels/atax..........2 species...[fully classified]
-linear-algebra/kernels/bicg..........2 species...[fully classified]
-linear-algebra/kernels/doitgen.......2 species...[fully classified]
-linear-algebra/kernels/gemm..........1 species...[fully classified]
-linear-algebra/kernels/gemver........4 species...[fully classified]
-linear-algebra/kernels/gesummv.......1 species...[fully classified]
-linear-algebra/kernels/mvt...........2 species...[fully classified]
-linear-algebra/kernels/syr2k.........1 species...[fully classified]
-linear-algebra/kernels/syrk..........1 species...[fully classified]
-stencils/fdtd-2d.....................4 species...[fully classified]
-stencils/jacobi-1d-imper.............2 species...[fully classified]
-stencils/jacobi-2d-imper.............2 species...[fully classified]
-
-== Benchmarks with significant parallelism
-linear-algebra/kernels/cholesky......3 species...[no outer-loop parallelism, inner-loops only classified]
-linear-algebra/kernels/symm..........1 species...[no outer-loop parallelism, inner-loops only classified]
-linear-algebra/kernels/trisolv.......1 species...[no outer-loop parallelism, inner-loops only classified]
-linear-algebra/kernels/trmm..........1 species...[no outer-loop parallelism, inner-loops only classified]
-linear-algebra/solvers/gramschmidt...4 species...[no outer-loop parallelism, inner-loops only classified]
-linear-algebra/solvers/lu............3 species...[no outer-loop parallelism, inner-loops only classified]
-linear-algebra/solvers/ludcmp........4 species...[no outer-loop parallelism, inner-loops only classified]
-datamining/correlation...............5 species...[most parts classified, final part inner-loop only]
-datamining/covariance................4 species...[most parts classified, final part inner-loop only]
-medley/reg_detect....................2 species...[partly classified, several parts have no parallelism]
-
-== Benchmarks with very little parallelism
-linear-algebra/solvers/durbin........2 species...[partly classified, most parts have no parallelism]
-linear-algebra/solvers/dynprog.......1 species...[partly classified, most parts have no parallelism]
-stencils/adi.........................2 species...[partly classified, most parts have no parallelism]
-stencils/fdtd-ampl...................1 species...[partly classified, most parts have no parallelism]
-
-== Benchmarks without parallelism
-medley/floyd-warshall................0 species...[no parallelism]
-stencils/seidel-2d...................0 species...[no parallelism]

data/lib/castaddon/node.rb

@@ -1,753 +0,0 @@
-# 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
-