rltk 2.2.1 → 3.0.0

data/lib/rltk/parser.rb

@@ -14,8 +14,8 @@ require 'rltk/cfg'
 # Classes and Modules #
 #######################
 
-module RLTK # :nodoc:
-	
+# The RLTK root module
+module RLTK
 	# A BadToken error indicates that a token was observed in the input stream
 	# that wasn't used in the grammar's definition.
 	class BadToken < StandardError
@@ -29,9 +29,28 @@ module RLTK # :nodoc:
 	# for a given token stream.  In other words, the input string is not in the
 	# defined language.
 	class NotInLanguage < StandardError
+		
+		# @return [Array<Token>]  List of tokens that have been successfully parsed
+		attr_reader :seen
+		
+		# @return [Token]  Token that caused the parser to stop
+		attr_reader :current
+		
+		# @return [Array<Token>]  List of tokens that have yet to be seen
+		attr_reader :remaining
+		
+		# @param [Array<Token>]  seen       Tokens that have been successfully parsed
+		# @param [Token]         current    Token that caused the parser to stop
+		# @param [Array<Token>]  remaining  Tokens that have yet to be seen
+		def initialize(seen, current, remaining)
+			@seen      = seen
+			@current   = current
+			@remaining = remaining
+		end
+		
 		# @return [String] String representation of the error.
 		def to_s
-			'String not in language.'
+			"String not in language.  Token info:\n\tSeen: #{@seen}\n\tCurrent: #{@current}\n\tRemaining: #{@remaining}"
 		end
 	end
 	
@@ -80,57 +99,53 @@ module RLTK # :nodoc:
 			#
 			# @return [void]
 			def install_icvars
-				@curr_lhs		= nil
-				@curr_prec	= nil
+				@curr_lhs  = nil
+				@curr_prec = nil
 				
-				@conflicts	= Hash.new {|h, k| h[k] = Array.new}
-				@grammar		= CFG.new
+				@conflicts = Hash.new {|h, k| h[k] = Array.new}
+				@grammar   = CFG.new
 				
-				@lh_sides		= Hash.new
-				@procs		= Array.new
-				@states		= Array.new
+				@lh_sides  = Hash.new
+				@procs     = Array.new
+				@states    = Array.new
 				
 				# Variables for dealing with precedence.
-				@prec_counts		= {:left => 0, :right => 0, :non => 0}
-				@production_precs	= Array.new
-				@token_precs		= Hash.new
+				@prec_counts      = {:left => 0, :right => 0, :non => 0}
+				@production_precs = Array.new
+				@token_precs      = Hash.new
 				
-				# Set the default argument handling policy.
-				@args = :splat
+				# Set the default argument handling policy.  Valid values
+				# are :array and :splat.
+				@default_arg_type = :splat
 				
-				@grammar.callback do |p, type, num|
-					@procs[p.id] =
-					[
+				@grammar.callback do |type, which, p, sels = []|
+					@procs[p.id] = [
 						case type
-						when :*
-							case num
-							when :first then	Proc.new { ||           [] }
-							else				Proc.new { |os, o| os << o }
-							end
-							
-						when :+
-							case num
-							when :first then	Proc.new { |o|         [o] }
-							else				Proc.new { |os, o| os << o }
-							end
-							
-						when :'?'
-							case num
-							when :first then	Proc.new { ||  nil }
-							else				Proc.new { |o|   o }
+						when :optional
+							case which
+							when :empty then ProdProc.new { ||  nil }
+							else             ProdProc.new { |o|   o }
 							end
 							
 						when :elp
-							case num
-							when :first then	Proc.new { ||         [] }
-							else				Proc.new { |prime| prime }
+							case which
+							when :empty then ProdProc.new { ||         [] }
+							else             ProdProc.new { |prime| prime }
 							end
 							
 						when :nelp
-							case num
-							when :first	then	Proc.new { |el|                                         [el] }
-							when :second	then	Proc.new { |els, _, el|                           els + [el] }
-							else				Proc.new { |*el| if el.length == 1 then el.first else el end }
+							case which
+							when :single
+								ProdProc.new { |el| [el] }
+								
+							when :multiple
+								ProdProc.new(:splat, sels) do |*syms|
+									el = syms[1..-1]
+									syms.first << (el.length == 1 ? el.first : el)
+								end
+								
+							else
+								ProdProc.new { |*el|   el.length == 1 ? el.first : el }
 							end
 						end,
 						p.rhs.length
@@ -168,58 +183,6 @@ module RLTK # :nodoc:
 				end
 			end
 			
-			# Calling this method will cause the parser to pass right-hand
-			# side values as arrays instead of splats.  This method must be
-			# called before ANY calls to Parser.production.
-			#
-			# @return [void]
-			def array_args
-				if @grammar.productions.length == 0
-					@args = :array
-					
-					@grammar.callback do |p, type, num|
-						@procs[p.id] =
-						[
-							case type
-							when :*
-								case num
-								when :first then	Proc.new { |v|           [] }
-								else				Proc.new { |v| v[0] << v[1] }
-								end
-							
-							when :+
-								case num
-								when :first then	Proc.new { |v|       [v[0]] }
-								else				Proc.new { |v| v[0] << v[1] }
-								end
-							
-							when :'?'
-								case num
-								when :first then	Proc.new { |v|  nil }
-								else				Proc.new { |v| v[0] }
-								end
-							
-							when :elp
-								case num
-								when :first then	Proc.new { |v|   [] }
-								else				Proc.new { |v| v[0] }
-								end
-							
-							when :nelp
-								case num
-								when :first	then	Proc.new { |v|                                        v }
-								when :second	then	Proc.new { |v|                            v[0] + [v[2]] }
-								else				Proc.new { |v| if v.length == 1 then v.first else v end }
-								end
-							end,
-							p.rhs.length
-						]
-						
-						@production_precs[p.id] = p.last_terminal
-					end
-				end
-			end
-			
 			# Build a hash with the default options for Parser.finalize
 			# and then update it with the values from *opts*.
 			#
@@ -230,10 +193,10 @@ module RLTK # :nodoc:
 				opts[:explain]	= self.get_io(opts[:explain])
 				
 				{
-					:explain		=> false,
-					:lookahead	=> true,
-					:precedence	=> true,
-					:use			=> false
+					explain:    false,
+					lookahead:  true,
+					precedence: true,
+					use:        false
 				}.update(opts)
 			end
 			private :build_finalize_opts
@@ -245,14 +208,14 @@ module RLTK # :nodoc:
 			#
 			# @return [Hash{Symbol => Object}]
 			def build_parse_opts(opts)
-				opts[:parse_tree]	= self.get_io(opts[:parse_tree])
-				opts[:verbose]		= self.get_io(opts[:verbose])
+				opts[:parse_tree] = self.get_io(opts[:parse_tree])
+				opts[:verbose]    = self.get_io(opts[:verbose])
 				
 				{
-					:accept		=> :first,
-					:env			=> self::Environment.new,
-					:parse_tree	=> false,
-					:verbose		=> false
+					accept:     :first,
+					env:        self::Environment.new,
+					parse_tree: false,
+					verbose:    false
 				}.update(opts)
 			end
 			private :build_parse_opts
@@ -275,7 +238,7 @@ module RLTK # :nodoc:
 				end
 				
 				# Check the actions in each state.
-				@states.each do |state|
+				each_state do |state|
 					state.actions.each do |sym, actions|
 						if CFG::is_terminal?(sym)
 							# Here we check actions for terminals.
@@ -312,14 +275,14 @@ module RLTK # :nodoc:
 			# This method checks to see if the parser would be in parse state
 			# *dest* after starting in state *start* and reading *symbols*.
 			#
-			# @param [Symbol]		start	Symbol representing a CFG production.
-			# @param [Symbol]		dest		Symbol representing a CFG production.
-			# @param [Array<Symbol>]	symbols	Grammar symbols.
+			# @param [Symbol]         start    Symbol representing a CFG production.
+			# @param [Symbol]         dest     Symbol representing a CFG production.
+			# @param [Array<Symbol>]  symbols  Grammar symbols.
 			#
 			# @return [Boolean] If the destination symbol is reachable from the start symbol after reading *symbols*.
 			def check_reachability(start, dest, symbols)
-				path_exists	= true
-				cur_state		= start
+				path_exists = true
+				cur_state   = start
 				
 				symbols.each do |sym|
 					
@@ -345,27 +308,30 @@ module RLTK # :nodoc:
 			# production can be changed by setting the *precedence* argument
 			# to some terminal symbol.
 			#
-			# @param [String]	expression	Right-hand side of a production.
-			# @param [Symbol]	precedence	Symbol representing the precedence of this production.
-			# @param [Proc]	action		Action to be taken when the production is reduced.
+			# @param [String, Symbol]  expression  Right-hand side of a production.
+			# @param [Symbol]          precedence  Symbol representing the precedence of this production.
+			# @param [:array, :splat]  arg_type    Method to use when passing arguments to the action.
+			# @param [Proc]            action      Action to be taken when the production is reduced.
 			#
 			# @return [void]
-			def clause(expression, precedence = nil, &action)
+			def clause(expression, precedence = nil, arg_type = @default_arg_type, &action)
 				# Use the curr_prec only if it isn't overridden for this
 				# clause.
 				precedence ||= @curr_prec
 				
-				production = @grammar.clause(expression)
+				production, selections = @grammar.clause(expression)
 				
 				# Check to make sure the action's arity matches the number
 				# of symbols on the right-hand side.
-				if @args == :splat and action.arity != production.rhs.length
-					raise ParserConstructionException, 'Incorrect number of arguments to action.  Action arity must match the number of ' +
-						'terminals and non-terminals in the clause.'
+				expected_arity = (selections.empty? ? production.rhs.length : selections.length)
+				if arg_type == :splat and action.arity != expected_arity
+					raise ParserConstructionException,
+					      "Incorrect number of action parameters.  Expected #{expected_arity} but got #{action.arity}." +
+						  ' Action arity must match the number of terminals and non-terminals in the clause.'
 				end
 				
 				# Add the action to our proc list.
-				@procs[production.id] = [action, production.rhs.length]
+				@procs[production.id] = [ProdProc.new(arg_type, selections, &action), production.rhs.length]
 				
 				# If no precedence is specified use the precedence of the
 				# last terminal in the production.
@@ -382,28 +348,41 @@ module RLTK # :nodoc:
 				@conflicts = nil
 				
 				# Drop the grammar and the grammar'.
-				@grammar		= nil
-				@grammar_prime	= nil
+				@grammar       = nil
+				@grammar_prime = nil
 				
 				# Drop precedence and bookkeeping information.
-				@cur_lhs	= nil
-				@cur_prec	= nil
+				@cur_lhs  = nil
+				@cur_prec = nil
 				
-				@prec_counts		= nil
-				@production_precs	= nil
-				@token_precs		= nil
+				@prec_counts      = nil
+				@production_precs = nil
+				@token_precs      = nil
 				
 				# Drop the items from each of the states.
-				@states.each { |state| state.clean }
+				each_state { |state| state.clean }
+			end
+			
+			# Set the default argument type for the actions associated with
+			# clauses.  All actions defined after this call will be passed
+			# arguments in the way specified here, unless overridden in the
+			# call to {Parser.clause}.
+			#
+			# @param [:array, :splat] type The default argument type.
+			#
+			# @return [void]
+			def default_arg_type(type)
+				@default_arg_type = type if type == :array or type == :splat
 			end
+			alias :dat :default_arg_type
 			
 			# Adds productions and actions for parsing empty lists.
 			#
 			# @see CFG#empty_list_production
-			def empty_list_production(symbol, list_elements, separator)
-				@grammar.empty_list(symbol, list_elements, separator)
+			def build_list_production(symbol, list_elements, separator = '')
+				@grammar.build_list_production(symbol, list_elements, separator)
 			end
-			alias :empty_list :empty_list_production 
+			alias :list :build_list_production 
 			
 			# This function will print a description of the parser to the
 			# provided IO object.
@@ -418,13 +397,21 @@ module RLTK # :nodoc:
 					io.puts('###############')
 					io.puts
 					
+					max_id_length = @grammar.productions(:id).length.to_s.length
+					
 					# Print the productions.
 					@grammar.productions.each do |sym, productions|
+						
+						max_rhs_length = productions.inject(0) { |m, p| if (len = p.to_s.length) > m then len else m end }
+						
 						productions.each do |production|
-							io.print("\tProduction #{production.id}: #{production.to_s}")
+							p_string = production.to_s
+							
+							io.print("\tProduction #{sprintf("%#{max_id_length}d", production.id)}: #{p_string}")
 							
 							if (prec = @production_precs[production.id])
-								io.print(" : (#{prec.first} , #{prec.last})")
+								io.print(' ' * (max_rhs_length - p_string.length))
+								io.print(" : (#{sprintf("%-5s", prec.first)}, #{prec.last})")
 							end
 							
 							io.puts
@@ -438,11 +425,14 @@ module RLTK # :nodoc:
 					io.puts('##########')
 					io.puts
 					
+					max_token_len = @grammar.terms.inject(0) { |m, t| if t.length > m then t.length else m end }
+					
 					@grammar.terms.sort {|a,b| a.to_s <=> b.to_s }.each do |term|
 						io.print("\t#{term}")
 						
 						if (prec = @token_precs[term])
-							io.print(" : (#{prec.first}, #{prec.last})")
+							io.print(' ' * (max_token_len - term.length))
+							io.print(" : (#{sprintf("%-5s", prec.first)}, #{prec.last})")
 						end
 						
 						io.puts
@@ -455,7 +445,7 @@ module RLTK # :nodoc:
 					io.puts('#####################')
 					io.puts
 					
-					io.puts("\tStart symbol: #{@grammar.start_symbol}")
+					io.puts("\tStart symbol: #{@grammar.start_symbol}'")
 					io.puts
 					
 					io.puts("\tTotal number of states: #{@states.length}")
@@ -476,7 +466,7 @@ module RLTK # :nodoc:
 					io.puts('###############')
 					io.puts
 					
-					@states.each do |state|
+					each_state do |state|
 						io.puts("State #{state.id}:")
 						io.puts
 						
@@ -527,18 +517,15 @@ module RLTK # :nodoc:
 			# of states and their actions, and the resolution of conflicts
 			# using lookahead and precedence information.
 			# 
-			# The *opts* hash may contain the following options, which are
-			# described in more detail in the main documentation:
-			# 
-			# * :explain - To explain the parser or not.
-			# * :lookahead - To use lookahead info for conflict resolution.
-			# * :precedence - To use precedence info for conflict resolution.
-			# * :use - A file name or object that is used to load/save the parser.
-			# 
 			# No calls to {Parser.production} may appear after the call to
 			# Parser.finalize.
 			#
-			# @param [Hash{Symbol => Object}] opts Options describing how to finalize the parser.
+			# @param [Hash] opts Options describing how to finalize the parser.
+			#
+			# @option opts [Boolean,String,IO]  :explain     To explain the parser or not.
+			# @option opts [Boolean]            :lookahead   To use lookahead info for conflict resolution.
+			# @option opts [Boolean]            :precedence  To use precedence info for conflict resolution.
+			# @option opts [String,IO]          :use         A file name or object that is used to load/save the parser.
 			#
 			# @return [void]
 			def finalize(opts = {})
@@ -572,13 +559,14 @@ module RLTK # :nodoc:
 					return self.clean
 				end
 				
-				# Grab all of the symbols that comprise the grammar (besides
-				# the start symbol).
+				# Grab all of the symbols that comprise the grammar
+				# (besides the start symbol).
 				@symbols = @grammar.symbols << :ERROR
 				
 				# Add our starting state to the state list.
-				start_production	= @grammar.production(:start, @grammar.start_symbol.to_s).first
-				start_state		= State.new(@symbols, [start_production.to_item])
+				@start_symbol       = (@grammar.start_symbol.to_s + '\'').to_sym
+				start_production, _ = @grammar.production(@start_symbol, @grammar.start_symbol).first
+				start_state         = State.new(@symbols, [start_production.to_item])
 				
 				start_state.close(@grammar.productions)
 				
@@ -586,12 +574,10 @@ module RLTK # :nodoc:
 				
 				# Translate the precedence of productions from tokens to
 				# (associativity, precedence) pairs.
-				@production_precs.each_with_index do |prec, id|
-					@production_precs[id] = @token_precs[prec]
-				end
+				@production_precs.map! { |prec| @token_precs[prec] }
 				
 				# Build the rest of the transition table.
-				@states.each do |state|
+				each_state do |state|
 					#Transition states.
 					tstates = Hash.new { |h,k| h[k] = State.new(@symbols) }
 					
@@ -622,23 +608,17 @@ module RLTK # :nodoc:
 					# Find the Accept and Reduce actions for this state.
 					state.each do |item|
 						if item.at_end?
-							if item.lhs == :start
+							if item.lhs == @start_symbol
 								state.on(:EOS, Accept.new)
 							else
-								state.add_reduction(item.id)
+								state.add_reduction(@grammar.productions(:id)[item.id])
 							end
 						end
 					end
 				end
 				
 				# Build the production.id -> production.lhs map.
-				@grammar.productions(:id).to_a.inject(@lh_sides) do |h, pair|
-					id, production = pair
-					
-					h[id] = production.lhs
-					
-					h
-				end
+				@grammar.productions(:id).each { |id, production| @lh_sides[id] = production.lhs }
 				
 				# Prune the parsing table for unnecessary reduce actions.
 				self.prune(opts[:lookahead], opts[:precedence])
@@ -667,8 +647,8 @@ module RLTK # :nodoc:
 			
 			# Converts an object into an IO object as appropriate.
 			#
-			# @param [Object] o		Object to be converted into an IO object.
-			# @param [String] mode	String representing the mode to open the IO object in.
+			# @param [Object]  o     Object to be converted into an IO object.
+			# @param [String]  mode  String representing the mode to open the IO object in.
 			#
 			# @return [IO, false] The IO object or false if a conversion wasn't possible.
 			def get_io(o, mode = 'w')
@@ -683,7 +663,20 @@ module RLTK # :nodoc:
 				end
 			end
 			
-			# @return [CFG] The grammar that can be parsed by this Parser.
+			# Iterate over the parser's states.
+			#
+			# @yieldparam [State]  state  One of the parser automaton's state objects
+			#
+			# @return [void]
+			def each_state
+				current_state = 0
+				while current_state < @states.count
+					yield @states.at(current_state)
+					current_state += 1
+				end
+			end
+			
+			# @return [CFG]  The grammar that can be parsed by this Parser.
 			def grammar
 				@grammar.clone
 			end
@@ -692,7 +685,7 @@ module RLTK # :nodoc:
 			# calculate the LALR(1) lookahead sets.  Information about this
 			# grammar and its use can be found in the following paper:
 			# 
-			# Simple Computation of LALR(1) Lookahed Sets
+			# Simple Computation of LALR(1) Lookahead Sets
 			# Manuel E. Bermudez and George Logothetis
 			# Information Processing Letters 31 - 1989
 			#
@@ -701,14 +694,14 @@ module RLTK # :nodoc:
 				if not @grammar_prime
 					@grammar_prime = CFG.new
 					
-					@states.each do |state|
+					each_state do |state|
 						state.each do |item|
 							lhs = "#{state.id}_#{item.next_symbol}".to_sym
 							
 							next unless CFG::is_nonterminal?(item.next_symbol) and not @grammar_prime.productions.keys.include?(lhs)
 							
 							@grammar.productions[item.next_symbol].each do |production|
-								rhs = ""
+								rhs = ''
 								
 								cstate = state
 								
@@ -729,9 +722,9 @@ module RLTK # :nodoc:
 			
 			# Inform the parser core that a conflict has been detected.
 			#
-			# @param [Integer]	state_id	ID of the state where the conflict was encountered.
-			# @param [:RR, :SR]	type		Reduce/Reduce or Shift/Reduce conflict.
-			# @param [Symbol]	sym		Symbol that caused the conflict.
+			# @param [Integer]   state_id  ID of the state where the conflict was encountered.
+			# @param [:RR, :SR]  type      Reduce/Reduce or Shift/Reduce conflict.
+			# @param [Symbol]    sym       Symbol that caused the conflict.
 			#
 			# @return [void]
 			def inform_conflict(state_id, type, sym)
@@ -742,7 +735,7 @@ module RLTK # :nodoc:
 			# are left-associative.  Subsequent calls to this method will
 			# give their arguments higher precedence.
 			#
-			# @param [Array<Symbol>] symbols Symbols that are left associative.
+			# @param [Array<Symbol>]  symbols  Symbols that are left associative.
 			#
 			# @return [void]
 			def left(*symbols)
@@ -756,7 +749,7 @@ module RLTK # :nodoc:
 			# This method is used to specify that the symbols in *symbols*
 			# are non-associative.
 			#
-			# @param [Array<Symbol>] symbols Symbols that are non-associative.
+			# @param [Array<Symbol>]  symbols  Symbols that are non-associative.
 			#
 			# @return [void]
 			def nonassoc(*symbols)
@@ -770,29 +763,28 @@ module RLTK # :nodoc:
 			# Adds productions and actions for parsing nonempty lists.
 			#
 			# @see CFG#nonempty_list_production
-			def nonempty_list_production(symbol, list_elements, separator)
-				@grammar.nonempty_list(symbol, list_elements, separator)
+			def build_nonempty_list_production(symbol, list_elements, separator = '')
+				@grammar.build_nonempty_list_production(symbol, list_elements, separator)
 			end
-			alias :nonempty_list :nonempty_list_production 
+			alias :nonempty_list :build_nonempty_list_production 
 			
 			# This function is where actual parsing takes place.  The
 			# _tokens_ argument must be an array of Token objects, the last
 			# of which has type EOS.  By default this method will return the
-			# value computed by the first successful parse tree found.  It is
-			# possible to adjust this behavior using the _opts_ hash as
-			# follows:
+			# value computed by the first successful parse tree found.
 			# 
-			# * :accept - Either :first or :all.
-			# * :env - The environment in which to evaluate the production actions.
-			# * :parse_tree - To print parse trees in the DOT language or not.
-			# * :verbose - To be verbose or not.
-			# 
-			# Additional information for these options can be found in the
-			# main documentation.
+			# Additional information about the parsing options can be found in
+			# the main documentation.
+			#
+			# @param [Array<Token>]  tokens  Tokens to be parsed.
+			# @param [Hash]          opts    Options to use when parsing input.
 			#
-			# @param [Array<Token>] tokens Tokens to be parsed.
+			# @option opts [:first, :all]       :accept      Either :first or :all.
+			# @option opts [Object]             :env         The environment in which to evaluate the production action.
+			# @option opts [Boolean,String,IO]  :parse_tree  To print parse trees in the DOT language or not.
+			# @option opts [Boolean,String,IO]  :verbose     To be verbose or not.
 			#
-			# @return [Object, Array<Object>] Result or results of parsing the given tokens.
+			# @return [Object, Array<Object>]  Result or results of parsing the given tokens.
 			def parse(tokens, opts = {})
 				# Get the full options hash.
 				opts	= build_parse_opts(opts)
@@ -808,18 +800,18 @@ module RLTK # :nodoc:
 				stack_id = 0
 				
 				# Error mode indicators.
-				error_mode		= false
-				reduction_guard	= false
+				error_mode      = false
+				reduction_guard = false
 				
 				# Our various list of stacks.
-				accepted		= []
-				moving_on		= []
-				processing	= [ParseStack.new(stack_id += 1)]
+				accepted   = []
+				moving_on  = []
+				processing = [ParseStack.new(stack_id += 1)]
 				
 				# Iterate over the tokens.  We don't procede to the
 				# next token until every stack is done with the
 				# current one.
-				tokens.each do |token|
+				tokens.each_with_index do |token, index|
 					# Check to make sure this token was seen in the
 					# grammar definition.
 					raise BadToken if not @symbols.include?(token.type)
@@ -937,8 +929,12 @@ module RLTK # :nodoc:
 								args, positions = stack.pop(pop_size)
 								opts[:env].set_positions(positions)
 								
+								if not production_proc.selections.empty?
+									args = args.values_at(*production_proc.selections)
+								end
+								
 								result =
-								if @args == :array
+								if production_proc.arg_type == :array
 									opts[:env].instance_exec(args, &production_proc)
 								else
 									opts[:env].instance_exec(*args, &production_proc)
@@ -994,14 +990,14 @@ module RLTK # :nodoc:
 					
 					v.puts("\n\n") if v
 					
-					processing	= moving_on
-					moving_on		= []
+					processing = moving_on
+					moving_on  = []
 					
 					# If we don't have any active stacks at this point the
 					# string isn't in the language.
 					if opts[:accept] == :first and processing.length == 0
 						v.close if v and v != $stdout
-						raise NotInLanguage
+						raise NotInLanguage.new(tokens[0...index], tokens[index], tokens[index.next..-1])
 					end
 					
 					reduction_guard = false
@@ -1036,21 +1032,28 @@ module RLTK # :nodoc:
 			# Parser.clause.  A precedence can be associate with this
 			# production by setting *precedence* to a terminal symbol.
 			#
-			# @param [Symbol]		symbol		Left-hand side of the production.
-			# @param [String, nil]	expression	Right-hand side of the production.
-			# @param [Symbol, nil]	precedence	Symbol representing the precedence of this produciton.
-			# @param [Proc]		action		Action associated with this production.
+			# @param [Symbol]				symbol		Left-hand side of the production.
+			# @param [String, Symbol, nil]	expression	Right-hand side of the production.
+			# @param [Symbol, nil]			precedence	Symbol representing the precedence of this produciton.
+			# @param [:array, :splat]		arg_type		Method to use when passing arguments to the action.
+			# @param [Proc]				action		Action associated with this production.
 			#
 			# @return [void]
-			def production(symbol, expression = nil, precedence = nil, &action)
+			def production(symbol, expression = nil, precedence = nil, arg_type = @default_arg_type, &action)
 				
 				# Check the symbol.
 				if not (symbol.is_a?(Symbol) or symbol.is_a?(String)) or not CFG::is_nonterminal?(symbol)
-					riase ParserConstructionException, 'Production symbols must be Strings or Symbols and be in all lowercase.'
+					raise ParserConstructionException, 'Production symbols must be Strings or Symbols and be in all lowercase.'
 				end
 				
-				@grammar.curr_lhs	= symbol.to_sym
-				@curr_prec		= precedence
+				@grammar.curr_lhs = symbol.to_sym
+				@curr_prec        = precedence
+				
+				orig_dat = nil
+				if arg_type != @default_arg_type
+					orig_dat = @default_arg_type
+					@default_arg_type = arg_type
+				end
 				
 				if expression
 					self.clause(expression, precedence, &action)
@@ -1058,16 +1061,18 @@ module RLTK # :nodoc:
 					self.instance_exec(&action)
 				end
 				
-				@grammar.curr_lhs	= nil
-				@curr_prec		= nil
+				@default_arg_type = orig_dat if not orig_dat.nil?
+				
+				@grammar.curr_lhs = nil
+				@curr_prec        = nil
 			end
 			alias :p :production
 			
 			# This method uses lookahead sets and precedence information to
 			# resolve conflicts and remove unnecessary reduce actions.
 			#
-			# @param [Boolean] do_lookahead	Prune based on lookahead sets or not.
-			# @param [Boolean] do_precedence	Prune based on precedence or not.
+			# @param [Boolean]  do_lookahead   Prune based on lookahead sets or not.
+			# @param [Boolean]  do_precedence  Prune based on precedence or not.
 			#
 			# @return [void]
 			def prune(do_lookahead, do_precedence)
@@ -1076,7 +1081,7 @@ module RLTK # :nodoc:
 				# If both options are false there is no pruning to do.
 				return if not (do_lookahead or do_precedence)
 				
-				@states.each do |state0|
+				each_state do |state0|
 					
 					#####################
 					# Lookahead Pruning #
@@ -1092,23 +1097,27 @@ module RLTK # :nodoc:
 							lookahead = Array.new
 							
 							# Build the lookahead set.
-							@states.each do |state1|
+							each_state do |state1|
 								if self.check_reachability(state1, state0, production.rhs)
 									lookahead |= self.grammar_prime.follow_set("#{state1.id}_#{production.lhs}".to_sym)
 								end
 							end
 							
-							# Translate the G' follow symbols into G lookahead
-							# symbols.
-							lookahead = lookahead.map { |sym| sym.to_s.split('_').last.to_sym }.uniq
+							# Translate the G' follow symbols into G
+							# lookahead symbols.
+							lookahead = lookahead.map { |sym| sym.to_s.split('_', 2).last.to_sym }.uniq
 							
 							# Here we remove the unnecessary reductions.
 							# If there are error productions we need to
 							# scale back the amount of pruning done.
-							(terms - lookahead).each do |sym|
-								if not (terms.include?(:ERROR) and not state0.conflict_on?(sym))
-									state0.actions[sym].delete(reduction)
+							pruning_candidates = terms - lookahead
+							
+							if terms.include?(:ERROR)
+								pruning_candidates.each do |sym|
+									state0.actions[sym].delete(reduction) if state0.conflict_on?(sym)
 								end
+							else
+								pruning_candidates.each { |sym| state0.actions[sym].delete(reduction) }
 							end
 						end
 					end
@@ -1153,8 +1162,8 @@ module RLTK # :nodoc:
 									#  * The token is left associative and the current action is a Reduce
 									#  * The token is right associative and the current action is a Shift
 									if prec > max_prec or (prec == max_prec and tassoc == (a.is_a?(Shift) ? :right : :left))
-										max_prec			= prec
-										selected_action	= a
+										max_prec        = prec
+										selected_action = a
 										
 									elsif prec == max_prec and assoc == :nonassoc
 										raise ParserConstructionException, 'Non-associative token found during conflict resolution.'
@@ -1282,23 +1291,23 @@ module RLTK # :nodoc:
 			
 			# Instantiate a new ParserStack object.
 			#
-			# @param [Integer]				id			ID for this parse stack.  Used by GLR algorithm.
-			# @param [Array<Object>]			ostack		Output stack.  Holds results of {Reduce} and {Shift} actions.
-			# @param [Array<Integer>]		sstack		State stack.  Holds states that have been shifted due to {Shift} actions.
-			# @param [Array<Integer>]		nstack		Node stack.  Holds dot language IDs for nodes in the parse tree.
-			# @param [Array<Array<Integer>>]	connections	Integer pairs representing edges in the parse tree.
-			# @param [Array<Symbol>]			labels		Labels for nodes in the parse tree.
-			# @param [Array<StreamPosition>]	positions		Position data for symbols that have been shifted.
+			# @param [Integer]                id           ID for this parse stack.  Used by GLR algorithm.
+			# @param [Array<Object>]          ostack       Output stack.  Holds results of {Reduce} and {Shift} actions.
+			# @param [Array<Integer>]         sstack       State stack.  Holds states that have been shifted due to {Shift} actions.
+			# @param [Array<Integer>]         nstack       Node stack.  Holds dot language IDs for nodes in the parse tree.
+			# @param [Array<Array<Integer>>]  connections  Integer pairs representing edges in the parse tree.
+			# @param [Array<Symbol>]          labels       Labels for nodes in the parse tree.
+			# @param [Array<StreamPosition>]  positions    Position data for symbols that have been shifted.
 			def initialize(id, ostack = [], sstack = [0], nstack = [], connections = [], labels = [], positions = [])
 				@id = id
 				
-				@node_stack	= nstack
-				@output_stack	= ostack
-				@state_stack	= sstack
+				@node_stack   = nstack
+				@output_stack = ostack
+				@state_stack  = sstack
 				
-				@connections	= connections
-				@labels		= labels
-				@positions	= positions
+				@connections  = connections
+				@labels       = labels
+				@positions    = positions
 			end
 			
 			# Branch this stack, effectively creating a new copy of its
@@ -1308,8 +1317,24 @@ module RLTK # :nodoc:
 			#
 			# @return [ParseStack]
 			def branch(new_id)
-				ParseStack.new(new_id, @output_stack.clone, @state_stack.clone, @node_stack.clone,
-					@connections.clone, @labels.clone, @positions.clone)
+				# We have to do a deeper copy of the output stack to avoid
+				# interactions between the Proc objects for the different
+				# parsing paths.
+				#
+				# The being/rescue block is needed because some classes
+				# respond to `clone` but always raise an error.
+				new_output_stack = @output_stack.map do |o|
+					# Check to see if we can obtain a deep copy.
+					if 0.respond_to?(:copy)
+						o.copy
+					
+					else
+						begin o.clone rescue o end
+					end
+				end
+				
+				ParseStack.new(new_id, new_output_stack, @state_stack.clone,
+					@node_stack.clone, @connections.clone, @labels.clone, @positions.clone)
 			end
 			
 			# @return [StreamPosition] Position data for the last symbol on the stack.
@@ -1347,7 +1372,7 @@ module RLTK # :nodoc:
 			#
 			# @param [Integer] n Number of object to pop off the stack.
 			#
-			# @return [Array<Array<Object, StreamPosition>>] Values popped from the output and positions stacks.
+			# @return [Array(Object, StreamPosition)] Values popped from the output and positions stacks.
 			def pop(n = 1)
 				@state_stack.pop(n)
 				
@@ -1406,27 +1431,27 @@ module RLTK # :nodoc:
 			# @return [Integer] State's ID.
 			attr_accessor :id
 			
-			# @return [Array<CFG::Item>] Item objects that comprise this state.
+			# @return  [Array<CFG::Item>]  Item objects that comprise this state
 			attr_reader :items
 			
-			# @return [Array<Action>] Action objects that represent the actions that should be taken when various inputs are observed.
+			# @return [Hash{Symbol => Array<Action>}]  Maps lookahead symbols to actions
 			attr_reader :actions
 			
 			# Instantiate a new State object.
 			#
-			# @param [Array<Token>]		tokens	Tokens that represent this state.
-			# @param [Array<CFG::Item>]	items	Items that make up this state.
+			# @param [Array<Symbol>]     tokens  Tokens that represent this state
+			# @param [Array<CFG::Item>]  items   Items that make up this state
 			def initialize(tokens, items = [])
-				@id		= nil
-				@items	= items
-				@actions	= tokens.inject(Hash.new) { |h, t| h[t] = Array.new; h }
+				@id      = nil
+				@items   = items
+				@actions = tokens.inject(Hash.new) { |h, t| h[t] = Array.new; h }
 			end
 			
 			# Compare one State to another.  Two States are equal if they
 			# have the same items or, if the items have been cleaned, if
 			# the States have the same ID.
 			#
-			# @param [State] other Another State to compare to.
+			# @param [State]  other  Another State to compare to
 			#
 			# @return [Boolean]
 			def ==(other)
@@ -1435,11 +1460,11 @@ module RLTK # :nodoc:
 			
 			# Add a Reduce action to the state.
 			#
-			# @param [Integer] production_id ID of production to add to this state.
+			# @param [Production]  production  Production used to perform the reduction
 			#
 			# @return [void]
-			def add_reduction(production_id)
-				action = Reduce.new(production_id)
+			def add_reduction(production)
+				action = Reduce.new(production)
 				
 				# Reduce actions are not allowed for the ERROR terminal.
 				@actions.each { |k, v| if CFG::is_terminal?(k) and k != :ERROR then v << action end }
@@ -1507,7 +1532,11 @@ module RLTK # :nodoc:
 			#
 			# @return [void]
 			def each
-				@items.each {|item| yield item}
+				current_item = 0
+				while current_item < @items.count
+					yield @items.at(current_item)
+					current_item += 1
+				end
 			end
 			
 			# Specify an Action to perform when the input token is *symbol*.
@@ -1535,6 +1564,22 @@ module RLTK # :nodoc:
 			end
 		end
 		
+		# A subclass of Proc that indicates how it should be passed arguments
+		# by the parser.
+		class ProdProc < Proc
+			# @return [:array, :splat]  Method that should be used to pass arguments to this proc.
+			attr_reader :arg_type
+			
+			# @return [Array<Integer>]  Mask for selection of tokens to pass to action.  Empty mask means pass all.
+			attr_reader :selections
+			
+			def initialize(arg_type = :splat, selections = [])
+				super()
+				@arg_type   = arg_type
+				@selections = selections
+			end
+		end
+		
 		# The Action class is used to indicate what action the parser should
 		# take given a current state and input token.
 		class Action
@@ -1568,9 +1613,17 @@ module RLTK # :nodoc:
 		# The Reduce class indicates to the parser that it should reduce the
 		# input stack by the rule specified by Reduce.id.
 		class Reduce < Action
+			
+			# @param [Production]  production  Production to reduce by
+			def initialize(production)
+				super(production.id)
+				
+				@production = production
+			end
+			
 			# @return [String] String representation of this action.
 			def to_s
-				"Reduce by Production #{self.id}"
+				"Reduce by Production #{self.id} : #{@production}"
 			end
 		end