aurum 0.1.1 → 0.2.0

data/lib/aurum/parsing_table_generator.rb

@@ -1,464 +0,0 @@
-require 'set'
-require 'logger'
-
-module Aurum
-    Symbol, Production= Struct.new(:name, :is_terminal), Struct.new(:nonterminal, :symbols)
-    ShiftAction, ReduceAction = Struct.new(:state, :is_lookahead_shift), Struct.new(:handle, :is_read_reduce)	
-	Production.class_eval {attr_accessor :index}
-	
-	START, EOF = Symbol.new('$start', false), Symbol.new('$eof', true)
-	
-	Log = Logger.new(STDOUT)
-	Log.level = Logger::INFO
-	
-    class ParsingTableGenerator
-        attr_reader :symbols, :productions
-
-        DEFAULT_ASSOCIATIVITIES = {:left => [], :right => []}
-
-        def initialize(definition, precedences = [], associativities = DEFAULT_ASSOCIATIVITIES)
-            @definition = definition
-            @precedence_table = PrecedenceTable.new precedences, associativities
-        end
-
-        def start_from start
-        	initialize_augmented_grammar start
-            compute_nullable_symbols
-            compute_first_sets
-            self
-        end
-
-        def parsing_table
-        	Log.debug 'Start constructing LR(0) automata.'
-            construct_LR0_automata
-			Log.debug "Finished, #{@states.size} LR(0) states constructed."
-			Log.debug "#{@inconsistents.size} inconsistent states found."
-            if @inconsistents.size > 0
-                compute_LALR_1_lookahead
-                compute_LALR_n_lookahead unless @conflicts.empty?
-            end
-            parsing_table = []
-            for state in @states do
-                actions = Hash.new default_action(state)
-                state.actions.each {|symbol, action| actions[symbol] = action.to_a.first}
-                parsing_table << actions
-            end
-            return parsing_table, @lookahead_level
-        end
-
-        private        	
-		# BEGIN utils methods			
-		def fixed_point				
-			1 until !yield false 
-		end
-				
-		def working_list unvisited			
-			yield unvisited, unvisited.pop while !unvisited.empty?
-		end
-				
-		def mark_working_list uvisited, result, item
-			unless result.include? item
-				result << item
-				uvisited << item								
-			end
-		end		
-		# END utils methods
-		
-		# BEGIN augmented grammar
-		def initialize_augmented_grammar start
-			@symbols, @productions = [start], []
-			@start_production = add_production Production.new(START, [start]) 
-			@nullables, @first_sets, @closures = [].to_set, {START => []}, {}            						
-			working_list [start] do |unvisited, visiting|
-				@first_sets[visiting], @closures[visiting] = visiting.is_terminal ? [visiting] : [], []
-				for production in @definition[visiting]										       						
-					add_production(production).symbols.each {|symbol| mark_working_list unvisited, @symbols, symbol}
-					@closures[visiting] += closure([LRItem.new(production, 0)])
-				end unless visiting.is_terminal
-			end	
-	    end
-		
-		def add_production production
-			production.index = @productions.size
-			(@productions << production).last
-		end														
-
-        def compute_nullable_symbols
-        	fixed_point do |changed|
-        		@productions.each do |production|
-					changed |= @nullables.add? production.nonterminal if nullable? production.symbols
-				end
-				changed
-        	end
-        end
-
-        def compute_first_sets
-        	fixed_point do |changed|
-				for production in @productions do
-					set = @first_sets[production.nonterminal]
-					for symbol in production.symbols do
-						changed |= set.size != set.replace(set | @first_sets[symbol]).size
-						break unless nullable? [symbol]
-					end
-				end
-				changed				        		
-        	end
-        end
-
-        def nullable? symbols        	
-        	return true if symbols.empty?
-            symbols.all?{|symbol| @nullables.include? symbol }
-        end
-		
-		def closure items
-			result = items.dup
-			working_list items.dup do |unvisited, visiting|
-				if @closures[visiting.dot_symbol]
-					result |= @closures[visiting.dot_symbol] 
-				else
-					@definition[visiting.dot_symbol].each {|x| mark_working_list unvisited, result, LRItem.new(x, 0)}						
-				end unless visiting.is_handle || visiting.dot_symbol.is_terminal
-			end
-			result
-		end			
-		# END augmented grammar
-
-		# BEGIN LR(0) automata construction
-        def construct_LR0_automata
-            @lookahead_level = 0
-            start_state = State.new closure([LRItem.new(@start_production, 0)])
-            @states = [start_state]
-			@inconsistents = start_state.inconsistent? ? [start_state] : []
-			working_list [start_state] do |unvisited, visiting|
-				for item in visiting.non_handles
-                    symbol = item.dot_symbol
-                    new_state = goto visiting, symbol
-                    if (read_reduce = new_state.read_reduce)
-                    	visiting[symbol] << ReduceAction.new(read_reduce.index, true)
-                    else
-                        if index = @states.index(new_state)
-                            new_state = @states[index]
-                        else
-                        	@states << new_state
-							@inconsistents << new_state if new_state.inconsistent?
-							unvisited << new_state
-                            index = @states.length - 1
-                        end
-                        visiting[symbol] << ShiftAction.new(index, false)
-                        new_state.predsucceors << visiting
-                    end
-                end
-            end
-        end
-		
-        def goto items, symbol
-            result = []
-			for item in items 
-				result << LRItem.new(item.production, item.position + 1) if symbol == item.dot_symbol 
-			end
-            State.new closure(result)
-        end
-		# END LR(0) automata construction
-
-		# BEGIN lookahead computation
-        def compute_LALR_1_lookahead
-        	@lookahead_level, @conflicts = 1, []
-            @lookahead_config_stack, @lookahead_indicitor, @lookahead_result = [], {}, {}
-			handle_each @inconsistents do |state, handle|            
-				lookahead_each(state, handle.production) do |production, lookahead|
-					if state.only_shift?(lookahead) && @precedence_table.operator?(lookahead)
-						if @precedence_table.compare(production.operator, lookahead) >= 0
-							state[lookahead].clear
-							state[lookahead] << ReduceAction.new(production.index, false)
-						end
-					else
-						state[lookahead] << ReduceAction.new(production.index, false)
-					end						
-				end
-				@conflicts << state if state.conflict?
-            end
-        end
-		
-		def handle_each states
-			states.each {|state| state.handles.each {|handle| yield state, handle}}	
-		end
-		
-		def lookahead_each state, production
-			for predsucceor in state.predsucceors production.symbols.reverse
-				config = Configuration.new predsucceor, production.nonterminal
-				(@lookahead_indicitor[config] ? @lookahead_result[config] : compute_follow_set(config)).each {|x| yield production, x}
-			end
-		end						
-
-        def compute_follow_set config
-        	state, nonterminal = config.state, config.symbol
-            if START == nonterminal
-               	@lookahead_indicitor[config] = 65535
-               	@lookahead_result[config] = [EOF]
-            else
-            	@lookahead_config_stack.push config
-               	@lookahead_indicitor[config] = (d = @lookahead_config_stack.length)
-               	@lookahead_result[config] = read_set state, nonterminal
-               	each_included_by state, nonterminal do |new_config|
-                   	compute_follow_set new_config unless @lookahead_indicitor[new_config]
-                   	@lookahead_indicitor[config] = [@lookahead_indicitor[config], @lookahead_indicitor[new_config]].min 
-                   	@lookahead_result[config] |= @lookahead_result[new_config]
-               	end
-               	connected = nil
-               	until connected == config
-                   	connected = @lookahead_config_stack.pop
-                   	@lookahead_result[connected] = @lookahead_result[config].dup
-                   	@lookahead_indicitor[connected] = 65535
-               	end if @lookahead_indicitor[config] == d
-            end
-            @lookahead_result[config]
-        end
-		
-        def read_set state, symbol
-            result = []
-            each_read_by(state, symbol) {|q, y| result |= @first_sets[y] }
-            result
-        end
-
-        def each_read_by state, symbol
-            index = state.goto symbol
-            for item in @states[index]
-                for symbol in item.second_part
-                    yield state, symbol
-                    nullable? [symbol] or break
-                end
-            end if index
-        end
-		
-		def each_included_by state, nonterminal
-			for item in state
-				if item.dot_symbol == nonterminal && nullable?(item.second_part[1..-1])
-					first_part = item.production.symbols.slice 0, item.position
-					predsucceors = state.predsucceors first_part.reverse
-					predsucceors.each {|s| yield Configuration.new(s, item.production.nonterminal) }
-				end
-			end
-		end
-		
-        def compute_LALR_n_lookahead
-            @stack_seen = []
-            @conflicts.each do |state|
-                @current_lookahead_level = 1
-                for lookahead, actions in state.conflicted_actions do
-                    resolve_conficts state, lookahead, sources_of(state, lookahead, actions)
-                end
-                @lookahead_level = [@current_lookahead_level, @lookahead_level].max
-            end
-        end
-		
-		def sources_of state, lookahead, actions
-			sources = {}
-			for action in actions do
-				if action.kind_of? ShiftAction
-					sources[action] = [[state]].to_set
-				else
-					handle = @productions[action.handle]
-					sources[action] = action.is_read_reduce ? [[state]].to_set : [].to_set
-					for predsucceor in state.predsucceors handle.symbols.reverse
-						@follow_sources_visited = []
-						sources[action].merge follow_sources([predsucceor], handle.nonterminal, lookahead)
-					end
-				end
-			end	
-			sources								
-		end
-		
-        def follow_sources stack, nonterminal, lookahead
-            top = stack.last
-            if stack.length == 1
-                config = Configuration.new top, nonterminal
-                @follow_sources_visited.include?(config) and return []
-                @follow_sources_visited |= [config]
-            end
-            stacks = [].to_set
-            if q_index = top.goto(nonterminal)
-                q = @states[q_index]
-                stacks = [stack + [q]].to_set if q.direct_read.include?(lookahead)
-            end
-            each_read_by(top, nonterminal) {|q, y| stacks |= follow_sources stack+[q], y, lookahead unless y.is_terminal}
-			top.kernels.each do |item|
-				if !item.is_start && item.dot_symbol == nonterminal
-					c = item.production.nonterminal
-					if item.position < stack.length
-						stacks |= follow_sources stack.slice(0..-item.position-1), c, lookahead
-					else
-						first_part = item.production.symbols.slice 0..-stack.length-1
-						stack[0].predsucceors(first_part).reverse.each {|q| stacks |= follow_sources [q], c, lookahead }
-					end										
-				end
-			end
-            stacks
-        end
-
-        def resolve_conficts state, lookahead, sources
-            @current_lookahead_level += 1
-            @states << (lookahead_state = State.new([]))
-            state[lookahead].replace [ShiftAction.new((@states.length - 1), true)]
-            for action, stacks in sources
-                for stk in stacks
-                    raise 'not LALR(n)' if @stack_seen.include? stk
-                    @stack_seen << stk
-                    for a in next_lookaheads stk, lookahead
-                        lookahead_state[a] << action
-                    end
-                end
-            end
-            for next_lookahead, actions in lookahead_state.conflicted_actions
-                new_sources = {}
-                for action in actions do
-                    new_sources[action] = [].to_set
-                    for stk in sources[action] do
-                        @follow_sources_visited = []
-                        new_sources[action] |= follow_sources stk, lookahead, next_lookahead
-                    end
-                    resolve_conficts lookahead_state, next_lookahead, new_sources
-                end
-            end
-        end
-
-        def next_lookaheads stack, lookahead
-            EOF == lookahead and return [EOF]
-            top = stack.last
-            lookaheads = read_set top, lookahead
-			top.kernels.each do |item|
-				if !item.is_start && item.dot_symbol == lookahead			
-                	c = item.production.nonterminal
-                	if item.position < stack.length
-                    	lookaheads |= next_lookaheads stack.slice(0..-item.position-1), c
-                	else
-                    	first_part = item.production.symbols.slice 0..-stack.length-1
-                    	stack[0].predsucceors(first_part).reverse.each {|q| lookaheads |= compute_follow_set Configuration.new(q, c) }
-                	end
-				end
-            end
-            lookaheads
-        end
-
-        def default_action state
-            if !state.empty?
-                handle = nil
-                for x in state
-                    p = x.production
-                    handle = x if x.is_handle && p.nonterminal != START && (!handle || handle.production.symbols.length > p.symbols.length)
-                end
-                default_action = handle ? ReduceAction.new(handle.production.index, false) : nil
-            else
-                candidates = state.actions.values.inject [] do |candidates, actions|
-                    candidates |= actions.find_all {|x| x.kind_of?(Aurum::ReduceAction) && !x.is_read_reduce }
-                end
-                default_action = candidates.min {|x, y| @productions[x].handle.length <=> @productions[y].handle.length}
-            end
-            default_action
-        end
-
-        class PrecedenceTable
-            def initialize precedences, associativities
-                @precedence_table, @associativities = {}, associativities
-                precedences.reverse.each_with_index do |terminals, index|
-                    for terminal in terminals
-                        @precedence_table[terminal] = index
-                    end
-                end
-            end
-
-            def operator? symbol
-                @precedence_table.has_key? symbol
-            end
-
-            def compare current, lookahead
-                if @precedence_table[current] == @precedence_table[lookahead]
-                    return (@associativities[:right].include?(current) &&
-                    @associativities[:right].include?(lookahead)) ? -1 : 1
-                end
-                @precedence_table[current] <=> @precedence_table[lookahead]
-            end
-        end
-
-        Production.class_eval do
-            attr_accessor :action
-            def operator
-                symbols.reverse.find {|x| x.is_terminal}
-            end
-        end
-
-        class State < Array
-        	attr_reader :actions, :handles, :non_handles, :kernels, :read_reduce, :direct_read
-            def initialize elements
-                super elements
-				@actions, @predsucceors, @read_reduce = {}, [], nil
-				@handles, @non_handles, @kernels, @direct_read = [], [], [], [].to_set		
-				for item in elements
-					(item.is_handle ? @handles : @non_handles) << item 
-					@kernels << item if item.is_kernel
-					@direct_read << item.dot_symbol if item.dot_symbol 
-				end                
-				@read_reduce = first.production if size == 1 && first.is_handle
-            end
-
-            def [] symbol
-                @actions[symbol] = Set.new([]) unless @actions.has_key? symbol
-                @actions[symbol]
-            end
-			
-			def inconsistent?
-				@handles.size > 1 || (@handles.size == 1 && @kernels.size != 1) 
-			end
-			
-			def conflict?
-				inconsistent? && @actions.any? {|symbol, actions| actions.length > 1}
-			end
-
-            def conflicted_actions
-                @actions.find_all {|symbol, actions| actions.length > 1}
-            end
-
-            def only_shift? symbol
-                !self[symbol].empty? && @actions[symbol].all? {|x| x.kind_of? ShiftAction}
-            end
-
-            def goto symbol
-                shift = self[symbol].find {|x| x.kind_of? Aurum::ShiftAction }
-                shift.state if shift
-            end
-
-            def predsucceors(symbols = nil)
-                symbols or return @predsucceors
-                result = [self]
-                for symbol in symbols
-                	new_result = []
-					for x in result
-						new_result |= x.predsucceors.find_all {|predsucceor| predsucceor.any? {|item| item.dot_symbol == symbol}}
-					end
-                    result.replace new_result
-                end
-                result
-            end
-			
-            def == other
-            	return false unless other.kind_of?(State) && (@kernels.size == other.kernels.size)
-				return true if equal? other  
-                @kernels.all? {|x| other.kernels.include? x}
-            end
-        end
-
-        LRItem, Configuration = Struct.new(:production, :position), Struct.new(:state, :symbol)
-
-        LRItem.class_eval do
-        	attr_reader :dot_symbol, :second_part, :is_handle, :is_kernel, :is_start
-			
-        	def initialize production, position
-        		super production, position
-				@dot_symbol = production.symbols[position]
-				@is_handle = position >= production.symbols.length
-				@is_kernel = @is_handle || (position != 0)     
-				@is_start = production.nonterminal == START   		 
-				@second_part = @is_handle ? [] : production.symbols.slice(position..-1)
-        	end			
-        end
-    end
-end