Class: Preprocessor::Define

Inherits:

Object

• Object
• Preprocessor::Define

Defined in:

lib/caphir/define.rb

Overview

class

Class Method Summary

• .resolve_argument(resolving, tokens, defines) ⇒ Object

Instance Method Summary

• #initialize(params, tokens) ⇒ Define constructor

  A new instance of Define.

• #takes_args? ⇒ Boolean
• #value(stack) ⇒ Object

  returns a copy of the macro’s value with parameters substituted.

Constructor Details

#initialize(params, tokens) ⇒ Define

Returns a new instance of Define.

# File 'lib/caphir/define.rb', line 241

def initialize(params, tokens)
	tokens = tokens.to_s
	tokens.strip!
	@value = CTokenizer::Lexer.new(tokens).to_a
	if params
		unless params.class == Parameters
			@parameters = Parameters.new
			params.each { |p| @parameters << p }
		else
			@parameters = params
		end
	else
		# will not contain any parameters
		@value = parse(@value, nil)
		@parameters = nil
	end
	@value.freeze
end

Class Method Details

.resolve_argument(resolving, tokens, defines) ⇒ Object

# File 'lib/caphir/define.rb', line 210

def Define.resolve_argument(resolving, tokens, defines)
	return tokens if tokens.empty?
	# this is important, as it sets the resolving value
	# for the rest of the token
	out = [ [:RESOLVING, resolving].freeze ]
	stack = MacroTokens.new(resolving, tokens)
	until stack.empty?
		t = stack.shift
		if t[0] == :IDENTIFIER and macro = defines[t_str = t[1]] \
		and not stack.resolving?(t_str)
			if macro.takes_args?
				unless stack.args_given?
					# no arguments given, don't resolve token
					out << t
					next
				end
				stack.add_function_macro(t_str, macro.value(stack) do |a|
					Define.resolve_argument(resolving, a, defines)
				end)
			else
				stack.add_object_macro(t_str, macro.value(stack))
			end
			# since we are saving out, must output this resolving token
			out << [:RESOLVING, stack.resolving].freeze
		else
			out << t
		end
	end # until
	out
end

Instance Method Details

#takes_args? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/caphir/define.rb', line 260

def takes_args?
	# if @parameters is empty still want to scan for '(' and ')'
	@parameters
end

#value(stack) ⇒ Object

returns a copy of the macro’s value with parameters substituted

# File 'lib/caphir/define.rb', line 266

def value(stack)
	if takes_args?
		args = @parameters.arguments(stack).collect! do |a|
			# yield parameter tokens to be resolved
			v = a.collect do |t|
				case t[0]
					when :RESOLVING
						# these tokens are removed
					when :COMMENT, :NEWLINE then ' '
					else t[1]
				end
			end.join
			v.strip! # whitespace should be removed
			[:PARAMETER, v, yield(a)]
			# [ :PARAMETER, token text, resolved token ]
			# ie [ :PARAMETER, '__LINE__', [[:CONSTANT, 10]] ]
		end
	
		# do argument substitution
		parse( \
			@value.collect do |t|
				if t[0] == :IDENTIFIER and idx = @parameters.index(t[1])
					args[idx]
				else
					t
				end
			end , stack.resolving )
	else
		@value.dup
	end
end