bones-compiler 1.3.1 → 1.6.0

data/lib/adarwin/preprocessor.rb

@@ -20,7 +20,7 @@ module Adarwin
 			@header_code = ''
 			@parsed_code = ''
 			@target_code = ''
-			@scop_code = ''
+			@scop_code = []
 		end
 		
 		# This is the method to perform the actual preprocessing. This method takes
@@ -30,6 +30,7 @@ module Adarwin
 		# could have a commented-out SCoP or define or include.
 		def process
 			scop = false
+			scop_code = ''
 			scop_in_code = false
 			
 			# Process the file line by line
@@ -55,12 +56,14 @@ module Adarwin
 					# Found the end of a SCoP
 					elsif line =~ /^#{WHITESPACE}#{SCOP_END}/
 						scop = false
+						@scop_code.push(scop_code)
+						scop_code = ''
 						@parsed_code += '}'+NL
 					end
 					
 				# Nothing special in the code going on here
 				else
-					@scop_code += line if scop
+					scop_code += line if scop
 					@parsed_code += line
 					@target_code += line
 				end

data/lib/adarwin/reference.rb

@@ -28,7 +28,7 @@ module Adarwin
 		# * It constructs the sets of loops (all,inner,outer) for this reference
 		# * It computes the bounds based on loop data and on if-statements
 		# * It computes the domain (D), number of elements (E), and step (S)
-		def initialize(reference,id,inner_loops,outer_loops,verbose)
+		def initialize(reference,id,inner_loops,outer_loops,var_declarations,verbose)
 			@id = id
 			
 			# Initialise the 5-tuple (already fill in N and A)
@@ -44,6 +44,9 @@ module Adarwin
 			@all_loops = reference[:loop_data]
 			@inner_loops = inner_loops & @all_loops
 			@outer_loops = outer_loops
+
+			# Set the list of all local variables
+			@var_declarations = var_declarations
 			
 			# Set the indices of the array reference (e.g. 2*i+4). The size of this
 			# array is equal to the number of dimensions of the array.
@@ -56,11 +59,11 @@ module Adarwin
 			@all_loops.each do |loop_data|
 				conditions = [loop_data[:min],loop_data[:max]]
 				reference[:if_statements].each do |if_statement|
-					condition_if = if_statement.map{ |c| solve(c,loop_data[:var],loop_vars) }
-					conditions = [
-						max(conditions[0],condition_if[0]),
-						min(conditions[1],condition_if[1])
-					]
+					if !array_includes_local_vars(if_statement,loop_vars)
+						condition_if = if_statement.map{ |c| solve(c,loop_data[:var],loop_vars) }
+						conditions[0] = max(conditions[0],condition_if[0])
+						conditions[1] = min(conditions[1],condition_if[1])
+					end
 				end
 				@bounds << { :var => loop_data[:var], :min => conditions[0], :max => conditions[1] }
 			end
@@ -103,6 +106,47 @@ module Adarwin
 					@tS[index] = '0'
 				end
 			end
+
+			# Check for local variables in the domain. If they exist ask the user to fill
+			# in the bounds.
+			# TODO: Make this a command-line question asked to the user. For now, several
+			# known values are simply put here - for ease of automated testing.
+			@tD.each do |bounds|
+
+				# Bounds are equal (e.g. [t:t])
+				if bounds.a == bounds.b && string_includes_local_vars(bounds.a)
+
+					# Default (assume 'char')
+					a = '0'
+					b = '255'
+
+					# Overrides (see notice above)
+					b = 'NUM_CLUSTERS-1' if bounds.a == 'cluster_index'
+					b = 'no_of_nodes-1' if bounds.b == 'id'
+
+					# Output a warning
+					puts WARNING+"Bounds of '#{bounds.a}' variable unknown, assuming #{a}:#{b}"
+					bounds.a = a
+					bounds.b = b
+
+				# Not equal but both problematic
+				elsif string_includes_local_vars(bounds.a) && string_includes_local_vars(bounds.b)
+
+					# Default (assume 'char')
+					a = '0'
+					b = '255'
+
+					# Overrides (see notice above)
+					b = 'no_of_nodes-1' if bounds.a == 'val2'
+
+					# Output a warning
+					puts WARNING+"Bounds of '#{bounds.a}' and '#{bounds.b}' variables unknown, assuming #{a}:#{b}"
+					bounds.a = a
+					bounds.b = b
+
+				end
+			end
+
 			
 			# Print the result
 			puts MESSAGE+"Found: #{to_arc}" if verbose
@@ -256,6 +300,27 @@ module Adarwin
 			end
 			return false
 		end
+
+		# Method to find if local variables are included
+		def array_includes_local_vars(array, loop_vars)
+			vars = @var_declarations - loop_vars
+			array.each do |string|
+				vars.each do |decl|
+					if string =~ /\b#{decl}\b/
+						return true
+					end
+				end
+			end
+			return false
+		end
+		def string_includes_local_vars(string)
+			@var_declarations.each do |decl|
+				if string =~ /\b#{decl}\b/
+					return true
+				end
+			end
+			return false
+		end
 		
 	end
 end

data/lib/bones/algorithm.rb

@@ -40,7 +40,7 @@ module Bones
 			@lists = {:host_name => [],:host_definition => [], :argument_name => [], :argument_definition => [], :golden_name => []}
 			@arrays = Variablelist.new()
 			@constants = Variablelist.new()
-			@merge_factor = nil
+			@merge_factor = 0
 			@register_caching_enabled = 1
 			@function_code = ''
 			@function_name = ''
@@ -64,6 +64,7 @@ module Bones
 					@function_name = function.name
 				end
 			end
+			raise_error("Incorrect code found in body of #{@name}, something wrong with the classification?") if @function_code == ""
 		end
 		
 		# This method performs the code transformations according
@@ -146,12 +147,17 @@ module Bones
 				
 				# Perform transformations for reduction operations (conditionally do this)
 				if transformation[1,1].to_i >= 1
-					new_code = new_code.transform_reduction(@arrays.select(INPUT)[0],@arrays.select(OUTPUT)[0],transformation[1,1].to_i)
+					input = @arrays.select(INPUT)[0]
+					@arrays.select(OUTPUT).each do |output|
+						if output.species.shared?
+							new_code = new_code.transform_reduction(input,output,transformation[1,1].to_i)
+						end
+					end
 				end
 				
 				# Perform thread-merging (experimental)
 				# TODO: Solve the problem related to constants (e.g chunk/example1.c)
-				if @merge_factor == nil
+				if @merge_factor == 0
 					if transformation[0,1] == '4' && @hash[:parallelism].to_i >= 1024*1024
 						@merge_factor = 4
 					else
@@ -159,7 +165,7 @@ module Bones
 					end
 				end
 				if @merge_factor > 1
-					puts @hash[:parallelism]
+					#puts @hash[:parallelism]
 					if new_code.has_conditional_statements?
 						puts MESSAGE+'Not coarsening ('+@merge_factor.to_s+'x) because of conditional statements in kernel body.'
 					# TODO: Fix this temporary hack for multiple loops with mismatching bounds
@@ -405,7 +411,11 @@ module Bones
 			
 			DIRECTIONS.each do |direction|
 				species = @species.structures(direction)
-				arrays = @arrays.select(direction)
+				if direction == INPUT && @species.shared?
+					arrays = @arrays.inputs_only
+				else
+					arrays = @arrays.select(direction)
+				end
 				if !arrays.empty?
 					
 					# Check if the amount of input/ouput arrays is equal to the amount of input/output species
@@ -439,6 +449,11 @@ module Bones
 								array = free_array if structure.name == free_array.name
 							end
 						end
+
+						# Still haven't found anything, raise an error
+						if !array
+							raise_error("Could not find a matching array in C-code for a species with name '#{species.first.name}'")
+						end
 						
 						# Process the assignment
 						array.species = structure

data/lib/bones/copy.rb

@@ -3,9 +3,10 @@ module Bones
 	
 	# Class copyin/out
 	class Copy
-		attr_accessor :name, :domain, :deadline, :direction, :id
+		attr_accessor :scop, :name, :domain, :deadline, :direction, :id
 		
-		def initialize(name,domain,deadline,direction,id)
+		def initialize(scop,name,domain,deadline,direction,id)
+			@scop = scop
 			@name = name
 			@domain = domain
 			@deadline = deadline

data/lib/bones/engine.rb

@@ -91,16 +91,16 @@ module Bones
 				opt :measurements,    'Enable/disable timers',                                :short => 'm', :default => false
 				opt :verify,          'Verify correctness of the generated code',             :short => 'c', :default => false
 				opt :only_alg_number, 'Only generate code for the x-th species (99 -> all)',  :short => 'o', :type => Integer, :default => 99
-				opt :merge_factor,    'Thread merge factor, default is 1 (==disabled)',       :short => 'f', :type => Integer, :default => 1
+				opt :merge_factor,    'Thread merge factor, default is 1 (==disabled)',       :short => 'f', :type => Integer, :default => 0
 				opt :register_caching,'Enable register caching: 1:enabled (default), 0:disabled',      :short => 'r', :type => Integer, :default => 1
 				opt :zero_copy       ,'Enable OpenCL zero-copy: 1:enabled (default), 0:disabled',      :short => 'z', :type => Integer, :default => 1
 				opt :skeletons       ,'Enable non-default skeletons: 1:enabled (default), 0:disabled', :short => 's', :type => Integer, :default => 1
 			end
 			Trollop::die 'no input file supplied (use: --application)'              if !@options[:application_given]
 			Trollop::die 'no target supplied (use: --target)'                       if !@options[:target_given]
-			Trollop::die 'input file "'+@options[:application]+'"does not exist '   if !File.exists?(@options[:application])
+			Trollop::die 'input file "'+@options[:application]+'" does not exist'   if !File.exists?(@options[:application])
 			Trollop::die 'target not supported, supported targets are: '+pp_targets if !targets.include?(@options[:target].upcase)
-			@options[:name] = @options[:application].split('/').last.split('.').first
+			@options[:name] = File.basename(@options[:application], ".*")
 			@options[:target] = @options[:target].upcase
 			
 			# Extension for the host files corresponding to the target.
@@ -204,9 +204,10 @@ module Bones
 				# Perform code generation (memory allocs)
 				allocs = []
 				preprocessor.copies.each do |copy|
-					if !allocs.include?(copy.name)
+					name_scop = Set.new([copy.name, copy.scop])
+					if !allocs.include?(name_scop)
 						generate_memory('alloc',copy,arrays,0)
-						allocs << copy.name
+						allocs << name_scop
 					end
 				end
 				
@@ -219,9 +220,10 @@ module Bones
 				# Perform code generation (memory frees)
 				frees = []
 				preprocessor.copies.each do |copy|
-					if !frees.include?(copy.name)
+					name_scop = Set.new([copy.name, copy.scop])
+					if !frees.include?(name_scop)
 						generate_memory('free',copy,arrays,0)
-						frees << copy.name
+						frees << name_scop
 					end
 				end
 			
@@ -240,7 +242,7 @@ module Bones
 		def write_output
 			
 			# Create a new directory for the output
-			directory = @options[:application].split('.').first+'_'+@options[:target]
+			directory = @options[:application].rpartition('.').first+'_'+@options[:target]
 			Dir.mkdir(directory,0744) unless File.directory?(directory)
 			
 			parser = C::Parser.new
@@ -273,13 +275,14 @@ module Bones
 			end
 			
 			# Populate the target file (host)
+			
 			File.open(File.join(directory,@options[:name]+OUTPUT_HOST+@extension),'w') do |target|
 				target.puts '#include <cuda_runtime.h>'+NL if @options[:target] == 'GPU-CUDA'
 				target.puts "#define ZEROCOPY 0"+NL if @options[:zero_copy] == 0 && @options[:target] == 'CPU-OPENCL-INTEL'
 				target.puts "#define ZEROCOPY 1"+NL if @options[:zero_copy] == 1 && @options[:target] == 'CPU-OPENCL-INTEL'
 				target.puts @result[:header_code]
 				target.puts
-				target.puts @result[:host_device_mem_globals]
+				target.puts @result[:host_device_mem_globals].uniq
 				target.puts
 				target.puts @result[:algorithm_declarations]
 				target.puts @result[:host_code_lists]

data/lib/bones/preprocessor.rb

@@ -67,117 +67,147 @@ module Bones
 			species = nil
 			found = 0
 			alloc_index, free_index = 0, 0
+			block_comment = false
+			a_scop_was_found = false
+			scop = 0
+			scop_copies = []
 			
 			# Process the file line by line
 			@source_code.each_line.with_index do |line,index|
-				if line =~ /^#{WHITESPACE}#/
-					
-					# Keep 'include' statements as header code
-					if line =~ /^#{WHITESPACE}#include/
-						@header_code += line
-						if line =~ /"(.*)"/
-							process_header($1)
-						end
-					
-					# Process 'define' statements for the algorithm code, but also keep as header code
-					elsif line =~ /^#{WHITESPACE}#define/
-						@header_code += line
-						@device_header += line
-						match = line.split(/\/\//)[0].scan(/^#{WHITESPACE}#define\s+(\w+)\s+(\S*)/)
-						@defines[match.first[0].to_sym] = match.first[1]
-					
-					# Found the start of algorithm marker
-					elsif line =~ /^#{WHITESPACE}#{SPECIES_START}/
-						if found == 0
-							line = replace_defines(line,@defines)
-							prefix, input, output = marker_to_algorithm(line)
-							puts MESSAGE+'Found algorithm "'+(prefix+' '+input+' '+ARROW+' '+output).lstrip+'"' if VERBOSE
-							species = Bones::Species.new(prefix,input,output)
-							@found_algorithms = @found_algorithms + 1
-						end
-						found = found + 1
-						#@target_code << "int bones_temp_species_start = '#{line.gsub(NL,'')}';"+NL
-					
-					# Found the end of algorithm marker
-					elsif line =~ /^#{WHITESPACE}#{SPECIES_END}/
-						if found == 1
-							name = line.strip.scan(/^#{WHITESPACE}#{SPECIES_END} (.+)/).join
-							name = DEFAULT_NAME if name == ''
-							@algorithms.push(Bones::Algorithm.new(name,@filename,index.to_s,species,algorithm_code))
-							algorithm_code = ''
-						end
-						found = found - 1
-						#@target_code << "int bones_temp_species_end = '#{line.gsub(NL,'')}';"+NL
-						
-					# Found a sync marker
-					elsif @scheduler && line =~ /^#{WHITESPACE}#{SYNC}/
-						sync = line.strip.scan(/^#{WHITESPACE}#{SYNC} (.+)/).join
-						@target_code << "bones_synchronize(#{sync});"+NL
-						
-					# Found a copyin marker
-					elsif @scheduler && line =~ /^#{WHITESPACE}#{COPYIN}/
-						copies = line.strip.scan(/^#{WHITESPACE}#{COPYIN} (.+)/).join.split(WEDGE).map{ |c| c.strip }
-						copies.each_with_index do |copy,copynum|
-							name = copy.split('[').first
-							domain = copy.scan(/\[(.+)\]/).join.split(DIM_SEP)
-							deadline = copy.split('|').last
-							@copies.push(Bones::Copy.new(name,domain,deadline,'in',"#{index*100+copynum}"))
-							@target_code << "bones_copyin_#{index*100+copynum}_#{name}(#{name});"+NL
+
+				# Don't consider one-line comments
+				if !(line =~ /^#{WHITESPACE}\/\//)
+
+					# Found the start of a block comment
+					if line =~ /\/\*/
+						block_comment = true
+					end
+
+					# Search for the end of the block comment
+					if block_comment
+						if line =~ /\*\//
+							block_comment = false
 						end
-						
-					# Found a copyout marker
-					elsif @scheduler && line =~ /^#{WHITESPACE}#{COPYOUT}/
-						copies = line.strip.scan(/^#{WHITESPACE}#{COPYOUT} (.+)/).join.split(WEDGE).map{ |c| c.strip }
-						copies.each_with_index do |copy,copynum|
-							name = copy.split('[').first
-							domain = copy.scan(/\[(.+)\]/).join.split(DIM_SEP)
-							deadline = copy.split('|').last
-							@copies.push(Bones::Copy.new(name,domain,deadline,'out',"#{index*100+copynum}"))
-							@target_code << "bones_copyout_#{index*100+copynum}_#{name}(#{name});"+NL
+						@target_code << line
+
+					# Not in a block-comment
+					else
+
+						if line =~ /^#{WHITESPACE}#/
+							
+							# Keep 'include' statements as header code
+							if line =~ /^#{WHITESPACE}#include/
+								@header_code += line
+								if line =~ /"(.*)"/
+									process_header($1)
+								end
+							
+							# Process 'define' statements for the algorithm code, but also keep as header code
+							elsif line =~ /^#{WHITESPACE}#define/
+								@header_code += line
+								@device_header += line
+								match = line.split(/\/\//)[0].scan(/^#{WHITESPACE}#define\s+(\w+)\s+(\S*)/)
+								@defines[match.first[0].to_sym] = match.first[1]
+							
+							# Found the start of algorithm marker
+							elsif line =~ /^#{WHITESPACE}#{SPECIES_START}/
+								if found == 0
+									line = replace_defines(line,@defines)
+									prefix, input, output = marker_to_algorithm(line)
+									puts MESSAGE+'Found algorithm "'+(prefix+' '+input+' '+ARROW+' '+output).lstrip+'"' if VERBOSE
+									species = Bones::Species.new(prefix,input,output)
+									@found_algorithms = @found_algorithms + 1
+								end
+								found = found + 1
+								#@target_code << "int bones_temp_species_start = '#{line.gsub(NL,'')}';"+NL
+							
+							# Found the end of algorithm marker
+							elsif line =~ /^#{WHITESPACE}#{SPECIES_END}/
+								if found == 1
+									name = line.strip.scan(/^#{WHITESPACE}#{SPECIES_END} (.+)/).join
+									name = DEFAULT_NAME if name == ''
+									@algorithms.push(Bones::Algorithm.new(name,@filename,index.to_s,species,algorithm_code))
+									algorithm_code = ''
+								end
+								found = found - 1
+								#@target_code << "int bones_temp_species_end = '#{line.gsub(NL,'')}';"+NL
+								
+							# Found a sync marker
+							elsif @scheduler && line =~ /^#{WHITESPACE}#{SYNC}/
+								sync = line.strip.scan(/^#{WHITESPACE}#{SYNC} (.+)/).join
+								@target_code << "bones_synchronize(#{sync});"+NL
+								
+							# Found a copyin marker
+							elsif @scheduler && line =~ /^#{WHITESPACE}#{COPYIN}/
+								copies = line.strip.scan(/^#{WHITESPACE}#{COPYIN} (.+)/).join.split(WEDGE).map{ |c| c.strip }
+								copies.each_with_index do |copy,copynum|
+									name = copy.split('[').first
+									domain = copy.scan(/\[(.+)\]/).join.split(DIM_SEP)
+									deadline = copy.split('|').last
+									@copies.push(Bones::Copy.new(scop,name,domain,deadline,'in',"#{index*100+copynum}"))
+									scop_copies.push(@copies[-1])
+									@target_code << "bones_copyin_#{index*100+copynum}_#{name}(#{name});"+NL
+								end
+								
+							# Found a copyout marker
+							elsif @scheduler && line =~ /^#{WHITESPACE}#{COPYOUT}/
+								copies = line.strip.scan(/^#{WHITESPACE}#{COPYOUT} (.+)/).join.split(WEDGE).map{ |c| c.strip }
+								copies.each_with_index do |copy,copynum|
+									name = copy.split('[').first
+									domain = copy.scan(/\[(.+)\]/).join.split(DIM_SEP)
+									deadline = copy.split('|').last
+									@copies.push(Bones::Copy.new(scop,name,domain,deadline,'out',"#{index*100+copynum}"))
+									scop_copies.push(@copies[-1])
+									@target_code << "bones_copyout_#{index*100+copynum}_#{name}(#{name});"+NL
+								end
+							end
+							
+							# Check if it was a 'pragma scop' / 'pragma endscop' line
+							if line =~ /^#{WHITESPACE}#{SCOP_START}/
+								scop += 1
+								scop_copies = []
+								alloc_index = @target_code.length
+								a_scop_was_found = true
+								@target_code << 'bones_timer_start();'+NL
+							elsif line =~ /^#{WHITESPACE}#{SCOP_END}/
+								free_index = @target_code.length
+								@target_code << 'bones_timer_stop();'+NL
+								
+								# Add frees and mallocs
+								if @scheduler
+									alloc_code, free_code = '', ''
+									included_copies = []
+									scop_copies.each do |copy|
+										if !included_copies.include?(copy.name)
+											alloc_code += copy.get_function_call('alloc')+NL
+											free_code += copy.get_function_call('free')+NL
+											included_copies << copy.name
+										end
+									end
+									@target_code.insert(alloc_index, alloc_code)
+									@target_code << free_code
+								end
+							end
+							
+						else
+							if found > 0
+								algorithm_line = replace_defines(line,@defines)
+								@target_code << algorithm_line
+								algorithm_code += algorithm_line if line !~ /^#{WHITESPACE}#/
+							else
+								@target_code << line
+							end
 						end
 					end
-					
-					# Check if it was a 'pragma scop' / 'pragma endscop' line
-					if line =~ /^#{WHITESPACE}#{SCOP_START}/
-						alloc_index = index
-					elsif line =~ /^#{WHITESPACE}#{SCOP_END}/
-						free_index = @target_code.length
-					end
-					
 				else
-					if found > 0
-						algorithm_line = replace_defines(line,@defines)
-						@target_code << algorithm_line
-						algorithm_code += algorithm_line if line !~ /^#{WHITESPACE}#/
-					else
-						@target_code << line
-					end
+					@target_code << line
 				end
 			end
 			puts WARNING+'Begin/end kernel mismatch ('+@found_algorithms.to_s+' versus '+@algorithms.length.to_s+'), probably missing a "'+SPECIES_END+'"' unless @algorithms.length == @found_algorithms
 			
-			# Add frees and mallocs
-			if @scheduler
-				alloc_code, free_code = '', ''
-				included_copies = []
-				copies.each do |copy|
-					if !included_copies.include?(copy.name)
-						alloc_code += copy.get_function_call('alloc')+NL
-						free_code += copy.get_function_call('free')+NL
-						included_copies << copy.name
-					end
-				end
-			end
-			
-			# Add timers (whole scop timing) and frees/mallocs to the code
-			offset = @header_code.lines.count
-			@target_code.insert(alloc_index-offset, 'bones_timer_start();'+NL)
-			if @scheduler
-				@target_code.insert(alloc_index-offset+1, alloc_code)
-				@target_code.insert(free_index+2, free_code)
-				@target_code.insert(free_index+3, 'bones_timer_stop();'+NL)
-			else
-				@target_code.insert(free_index+2, 'bones_timer_stop();'+NL)
+			# Print warning if there is no SCoP found
+			if !a_scop_was_found
+				puts WARNING+'No "#pragma scop" and "#pragma endscop" found!'
 			end
 			
 			# Join the array
@@ -191,28 +221,48 @@ module Bones
 			ifdefs = [true]
 			
 			# Process the file line by line
+			block_comment = false
 			File.read(File.join(@directory,filename)).each_line.with_index do |line,index|
-				if line =~ /^#{WHITESPACE}#/
-					
-					# Process 'include' statements
-					if line =~ /^#{WHITESPACE}#include/ && ifdefs.last
-						if line =~ /"(.*)"/
-							process_header($1)
+				
+				# Don't consider one-line comments
+				if !(line =~ /^#{WHITESPACE}\/\//)
+
+					# Found the start of a block comment
+					if line =~ /\/\*/
+						block_comment = true
+					end
+
+					# Search for the end of the block comment
+					if block_comment
+						if line =~ /\*\//
+							block_comment = false
+						end
+
+					# Not in a block-comment
+					else
+						if line =~ /^#{WHITESPACE}#/
+							
+							# Process 'include' statements
+							if line =~ /^#{WHITESPACE}#include/ && ifdefs.last
+								if line =~ /"(.*)"/
+									process_header($1)
+								end
+							
+							# Process 'define' statements
+							elsif line =~ /^#{WHITESPACE}#define/ && ifdefs.last
+								match = line.split(/\/\//)[0].scan(/^#{WHITESPACE}#define\s+(\w+)\s+(\S*)/)
+								@defines[match.first[0].to_sym] = match.first[1].strip
+							
+							# Process 'ifdef' statements
+							elsif line =~ /^#{WHITESPACE}#ifdef#{WHITESPACE}(\w+)/
+								valid = (ifdefs.last) ? @defines.has_key?($1.to_sym) : false
+								ifdefs.push(valid)
+								
+							# Process 'endif' statements
+							elsif line =~ /^#{WHITESPACE}#endif/
+								ifdefs.pop
+							end
 						end
-					
-					# Process 'define' statements
-					elsif line =~ /^#{WHITESPACE}#define/ && ifdefs.last
-						match = line.split(/\/\//)[0].scan(/^#{WHITESPACE}#define\s+(\w+)\s+(\S*)/)
-						@defines[match.first[0].to_sym] = match.first[1].strip
-					
-					# Process 'ifdef' statements
-					elsif line =~ /^#{WHITESPACE}#ifdef#{WHITESPACE}(\w+)/
-						valid = (ifdefs.last) ? @defines.has_key?($1.to_sym) : false
-						ifdefs.push(valid)
-						
-					# Process 'endif' statements
-					elsif line =~ /^#{WHITESPACE}#endif/
-						ifdefs.pop
 					end
 				end
 			end