dbc 1.3.0 → 2.0.0

data/lib/caphir/define.rb

@@ -0,0 +1,488 @@
+# Copyright (c) 2004 Charles M Mills
+# This document is licenced under The MIT Licence.
+# THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
+# See included LICENCE file.
+
+require 'caphir/ctokenizer'
+
+module Preprocessor
+
+	class AllTokens
+		
+		include CTokenizer # brings in #error() functions
+
+		def initialize(source, macro_tokens)
+			@source = source
+			@macro_tokens = macro_tokens
+		end
+
+		def shift
+			if @macro_tokens.empty?
+#raise "still resolving? - impossible" unless @macro_tokens.resolving.empty?
+				@source.shift
+			else
+				@macro_tokens.shift
+			end
+		end
+
+		def resolving
+			@macro_tokens.resolving
+		end
+
+		def resolving?(t_str)
+			@macro_tokens.resolving?(t_str)
+		end
+
+		def shift_and_filter
+			if @macro_tokens.empty?
+#raise "still resolving? - impossible" unless @macro_tokens.resolving.empty?
+				@source.shift
+			else
+				t = @macro_tokens.shift
+				t = self.shift_and_filter if t[0] == :RESOLVING
+				t
+			end
+		end
+
+		def empty?
+			@source.empty? and @macro_tokens.empty?
+		end
+
+		def args_given?
+			if t = @macro_tokens.peek_nonspace
+				t[1] == '('
+			else
+				@source.match?(/\s*\(/)
+			end
+		end
+
+		def file; @source.file end
+		def line; @source.line end
+
+		# does not respond to match and scan
+	end
+	
+	class SourceTokens
+		
+		include CTokenizer
+
+		def initialize(source)
+			@tokens = []
+			self.add_source(source)
+		end
+
+		attr_reader :start_line
+
+		def add_source(source)
+			@tokens.push(source)
+			@start_line = true # begining of file
+		end
+
+		def scan(regexp)
+			@tokens.last.scan(regexp)
+		end
+
+		def match?(regexp)
+			@tokens.last.match?(regexp)
+		end
+
+		def base?
+			@tokens.length == 1
+		end
+
+		def empty?
+			@tokens.length == 1 and @tokens.last.empty?
+		end
+		
+		def file
+			@tokens.last.file
+		end
+		def file=(val)
+			@tokens.last.file = val
+		end
+	
+		def line
+			@tokens.last.line
+		end
+		def line=(val)
+			@tokens.last.line = val
+		end
+
+		def shift
+			t = @tokens.last.shift
+			while !t[0] and @tokens.length > 1
+				# we are done with the current file
+				@tokens.pop
+				t = @tokens.last.shift
+			end # while
+			t_sym = t[0]
+			unless t_sym == :SPACE or t_sym == :COMMENT
+				# spaces and comments don't effect @start_line
+				@start_line = (t_sym == :NEWLINE)
+			end
+			t
+		end
+	
+	end # Tokens
+
+
+	class MacroTokens
+	
+		def initialize(resolving=[], tokens=[])
+			# resolving is immutable
+			@resolving = resolving.freeze
+			@tokens = tokens
+		end
+
+		attr_reader :resolving
+
+		def resolving?(t_str)
+			@resolving.index(t_str)
+		end
+
+		# returns :RESOLVING tokens
+		def shift
+			t = @tokens.shift || CTokenizer::EOF_TOKEN
+			@resolving = t[1] if t[0] == :RESOLVING
+			t
+		end
+	
+		def empty?
+			@tokens.empty?
+		end
+
+		def peek_filter
+			@tokens.each do |t|
+				return t unless t[0] == :RESOLVING
+			end
+			nil # is no non-resolving token
+		end
+
+		def peek_nonspace
+			@tokens.each do |t|
+				return t unless t[0] == :SPACE or t[0] == :RESOLVING
+			end
+			nil # is no non-space token
+		end
+	
+		def args_given?
+			t = self.peek_nonspace
+			t and t[1] == '('
+		end
+
+		# IMPORTANT - source is modified by the add_*_macro() methods
+
+		def add_function_macro(t_str, source)
+			# macro should be unresolved, except for parameters
+			# we must add t_str to all resolving lists in the macro
+			unless source.empty?
+				# IMPORTANT - add t_str to each resolving token
+				add_tokens( source.collect! do |t|
+					t[0] == :RESOLVING ? [:RESOLVING, t[1].dup << t_str] : t
+				end )
+				# add t_str to current resolving array
+				@resolving = (@resolving.dup << t_str).freeze
+			end
+			self
+		end
+
+		def add_object_macro(t_str, source)
+			unless source.empty?
+				add_tokens(source)
+				@resolving = (@resolving.dup << t_str).freeze
+			end
+			self
+		end
+
+private
+		def add_tokens(source)
+			# will restore old resolving value
+			source << [:RESOLVING, @resolving].freeze
+			source[source.length, 0] = @tokens # insert at end
+			@tokens = source
+			self
+		end
+	
+	end # class
+	
+	class Define
+		
+		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
+	
+		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
+	
+		def takes_args?
+			# if @parameters is empty still want to scan for '(' and ')'
+			@parameters
+		end
+
+		# returns a copy of the macro's value with parameters substituted
+		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
+	
+private
+	
+		def parse(tokens, resolving)
+			tokens.each_with_index do |v, i|
+				case v[1]
+					when '##'
+						# j == previous non space token index
+						j = i
+						begin
+							j -= 1
+							prev_t = tokens[j]
+						end while prev_t and prev_t[0] == :SPACE
+						# k == next non space token index
+						k = i
+						begin
+							k += 1
+							next_t = tokens[k]
+						end while next_t and next_t[0] == :SPACE
+	
+						if prev_t and next_t
+							# combine the two tokens (regardless of what type they are)
+							tokens.fill(nil, j...k)
+							tokens[k] = [:PASTED_TOKEN, prev_t[1] + next_t[1]].freeze
+						end
+					when '#'
+						k = i
+						begin
+							k += 1
+							next_t = tokens[k]
+						end while next_t and next_t[0] == :SPACE
+						
+						# only stringify parameters
+						if next_t and next_t[0] == :PARAMETER
+							tokens.fill(nil, i...k)
+							tokens[k] = [:STRING, next_t[1].inspect].freeze
+						end
+				end if v # v may be nil
+			end
+			out = []
+			tokens.each  do |t|
+				case t[0]
+					when :RESOVLING
+						resolving = t[1]
+						out << t
+					when :PARAMETER
+						out[out.length, 0] = t[2]
+						out << [:RESOLVING, resolving].freeze
+					when :PASTED_TOKEN
+						out[out.length, 0] = CTokenizer::Lexer.new(t[1]).to_a
+					else
+						out << t
+				end if t # unused tokens were replaced with nil
+			end
+			out
+		end
+	
+	end # class
+
+	class Parameters < Array
+		VA_ARGS = '__VA_ARGS__'.freeze
+		ELLIPSIS = '...'.freeze
+
+		def initialize
+			super
+			@ellipses = nil
+		end
+	
+		def with_ellipses(arg=nil)
+			raise "already has ellipses: #{self}" if ellipses?
+			if arg and arg != ELLIPSIS
+				self << arg
+				@ellipses = arg + ELLIPSIS # if arg is 'i' then 'i...'
+			else
+				self << VA_ARGS
+				@ellipses = ELLIPSIS
+			end
+			self
+		end
+	
+		def ellipses?
+			@ellipses
+		end
+	
+		def to_s
+			if ellipses?
+				self[0, self.length - 1] << @ellipses
+			else
+				self
+			end.join(',')
+		end
+	
+		def inspect
+			"\#<#{self.class}:#{self.to_s}>"
+		end
+
+		# it is important that we keep track of the last resolving status when
+		# splitting up arguments.  That way the argument does not inherit the
+		# last resolving status of the previous tokens when it is substituted.
+		def arguments(tokens)
+
+			# skip whitespace
+			while true
+				t = tokens.shift
+				case t[0]
+					when :RESOLVING, :SPACE, :COMMENT, :NEWLINE
+						# do nothing
+					else
+						break
+				end
+			end
+
+			tokens.error("expecting '('") unless t[1] == '('
+			
+			arguments = [arg = [ [:RESOLVING, tokens.resolving].freeze ] ]
+			
+			while true
+				t = tokens.shift
+				tokens.unmatched_error(')') unless t and t[0]
+
+				# comma and the closing ')' are not outputed
+				# bunch all the remaining parameters into the last parameter
+				if t[1] == ',' and arguments.length < self.length
+					# start of a new argument
+					arguments.push([ [:RESOLVING, tokens.resolving].freeze ])
+					arg = arguments.last
+				elsif t[1] == ')'
+					break # end of parameter list
+				else
+					arg << t
+					case t[1]
+						when '{'
+							Parameters.get_closing_braket(arg, tokens)
+						when '}'
+							tokens.unmatched_error('}')
+						when '('
+							Parameters.get_closing_paren(arg, tokens)
+					end
+				end
+			end
+
+			got = arguments.length
+			expected = self.length
+			if got < expected
+				tokens.error("wrong number of arguments (#{got} for #{expected})") unless ellipses?
+				expected -= 1 # the variable argument list can be blank
+				tokens.error("wrong number of arguments (#{got} for #{expected}+)") \
+						unless got == expected
+				arguments[expected] = [] # last arg is blank
+			end
+
+			arguments
+		end
+
+		def Parameters.get_closing_paren(arg, tokens)
+			begin
+				t = tokens.shift
+				tokens.unmatched_error(')') unless t and t[0]
+			
+				arg << t
+				case t[1]
+					when '{'
+						get_closing_braket(arg, tokens)
+					when '}'
+						tokens.unmatched_error('}')
+					when '('
+						get_closing_paren(arg, tokens)
+				end
+			end until t[1] == ')'
+		end
+
+		def Parameters.get_closing_braket(arg, tokens)
+			begin
+				t = tokens.shift
+				tokens.unmatched_error('}') unless t and t[0]
+
+				arg << t
+				case t[1]
+					when '('
+						get_closing_paren(arg, tokens)
+					when ')'
+						tokens.unmatched_error(')')
+					when '{'
+						get_closing_braket(arg, tokens)
+				end
+			end until t[1] == '}'
+		end
+	
+	end # Parameters
+
+end # module
+