aurum 0.1.0 → 0.1.1

data/example/expression/expression.rb

@@ -19,11 +19,17 @@ class ExpressionGrammar < Aurum::Grammar
 		expression expression, '/', expression {expression.value = expression1.value / expression2.value}
 		expression '(', expression, ')'
 		expression _number {expression.value = _number.value.to_i}
-	end
+		expression '+', _number {expression.value = _number.value.to_i}
+		expression '-', _number {expression.value = -_number.value.to_i}
+	end		
 end
 
 puts ExpressionGrammar.parse_expression('1 + 2').value
+puts ExpressionGrammar.parse_expression('(1 + 2)').value
+puts ExpressionGrammar.parse_expression('-1 - 2').value
 puts ExpressionGrammar.parse_expression('1 + 2 * 3').value
 puts ExpressionGrammar.parse_expression('1 * 2 + 3').value
 puts ExpressionGrammar.parse_expression('1 * (2 + 3)').value
-puts ExpressionGrammar.parse_expression('1 + (2 + 3) * 4').value
+puts ExpressionGrammar.parse_expression('1 + (2 + 3) * 4').value
+puts ExpressionGrammar.parse_expression('1 * - 5').value
+puts ExpressionGrammar.parse_expression('(1+3) - - 5').value

data/example/expression/lisp.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'aurum'
+
+class LispGrammar < Aurum::Grammar
+	tokens do
+		ignore string(' ').one_or_more 
+		_number range(?0, ?9).one_or_more
+	end
+		
+	productions do
+		expression '(', tuple, ')'
+		tuple '+', atom, atom {tuple.value = atom1.value + atom2.value}
+		tuple tuple, atom {tuple.value = tuple1.value + atom.value}
+		atom _number {atom.value = _number.value.to_i}
+		atom expression
+	end		
+end
+
+puts LispGrammar.parse_expression('(+ 1 3 4) ').value
+#puts LispGrammar.parse_expression('-1 - 2').value
+#puts LispGrammar.parse_expression('1 + 2 * 3').value
+#puts LispGrammar.parse_expression('1 * 2 + 3').value
+#puts LispGrammar.parse_expression('1 * (2 + 3)').value
+#puts LispGrammar.parse_expression('1 + (2 + 3) * 4').value
+#puts LispGrammar.parse_expression('1 * - 5').value
+#puts LispGrammar.parse_expression('(1+3) - - 5').value

data/lib/aurum/engine.rb

@@ -27,7 +27,7 @@ module Aurum
 	end
 	
 	Symbol.class_eval {attr_accessor :value}
-	
+	Unknown = Symbol.new '$unknown', true
 	class Lexer
 		def initialize table, accepts, lexical_states, input
 			@table, @accepts, @lexical_states, @input  = table, accepts, lexical_states, input			 
@@ -44,11 +44,12 @@ module Aurum
 					state, char = next_state, @input.get_char
 					next_state = goto state, char 		
 				end				
-				@input.pushback char				
-				if @accepts[state].first == IgnoreAction
+				@input.pushback char
+				return Unknown unless actions = @accepts[state]
+				if actions.first == IgnoreAction
 					lexeme = ''
 				else
-					@accepts[state].first.execute self
+					actions.first.execute self, lexeme
 				end					 				
 			end
 			@recognized.value = lexeme unless @recognized.value 
@@ -71,23 +72,24 @@ module Aurum
 		
 		def recognize token
 			@recognized = Aurum::Symbol.new token, true
-		end
+		end		
 	end		
 	
 	RecognizeTokenAction.class_eval do
-		def execute lexer
-			lexer.recognize token
+		def execute lexer, lexeme
+			recognized = lexer.recognize token
+			action.call recognized, lexeme if action
 		end
 	end
 	
 	ChangeStateAction.class_eval do
-		def execute lexer
+		def execute lexer, lexeme
 			lexer.shift_to state
 		end
 	end
 	
 	RecognizeTokenAndChangeStateAction.class_eval do
-		def execute lexer
+		def execute lexer, lexeme
 			lexer.recognize token
 			lexer.shift_to state
 		end
@@ -118,13 +120,13 @@ module Aurum
 						lookahead = lexer.next_symbol
 					end
 					state_stack.slice! -handle.symbols.length..-1
-					symbols = symbol_stack.slice! -handle.symbols.length..-1
+					symbols = symbol_stack.slice! -handle.symbols.length..-1					
 					handle.nonterminal == Aurum::START and return value_stack.pop
 					if handle.action
 						context = {handle.nonterminal.name => [SemanticAttributes.new]}
-						handle.symbols.each_with_index do |symbol, index|
+						handle.symbols.reverse.each_with_index do |symbol, index|
 							context[symbol.name] = [] unless context.has_key? symbol.name
-							context[symbol.name] << (symbol.is_terminal ? symbols[index] : value_stack.pop)
+							context[symbol.name] << (symbol.is_terminal ? symbols[-index-1] : value_stack.pop)
 						end
 						SemanticActionContext.new(context).instance_eval &handle.action
 						value_stack.push context[handle.nonterminal.name][0] if context[handle.nonterminal.name]
@@ -152,7 +154,7 @@ module Aurum
 			def method_missing name, *args
 				name_string = name.to_s
 				index = name_string =~ /\d+/ ? name_string.slice!(/\d+/).to_i : 0
-				@hash[name_string][index] and return @hash[name_string][index]
+				@hash[name_string][-index] and return @hash[name_string][-index]
 				SemanticAttributes.new
 			end
 		end

data/lib/aurum/grammar.rb

@@ -4,39 +4,8 @@ module Aurum
     class << nil
         attr_accessor :action
     end
-
-    module GrammarDefinition
-        instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
-
-        def method_missing name, *args, &block
-            name_string = name.to_s
-            symbol =
-            case name_string
-            when /^[a-z]/
-                Aurum::Symbol.new name_string, false
-            when '_'
-                nil
-            when /_.+/
-                Aurum::Symbol.new name_string, true
-            end
-            symbol.action = block if block_given?
-            (args.empty? || name_string == '_') and return symbol
-            symbols = args.map do |sym|
-                case sym
-                when String
-                    Aurum::Symbol.new "$literal_#{sym}", true
-                when Aurum::Symbol
-                    sym
-                end
-            end
-            action = symbols.last.action
-            @definition = {} unless @definition
-            @definition[symbol] = [].to_set unless @definition.has_key? symbol
-            production = Aurum::Production.new symbol, symbols.compact
-            production.action = action if action
-            @definition[symbol] << production
-        end
-    end
+	
+	Aurum::RecognizeTokenAction.class_eval {attr_accessor :action}
 
     class CharacterClassDefinition    	
         instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
@@ -52,24 +21,25 @@ module Aurum
             CharacterSet::Interval.new(a, b).to_char_set
         end
 
-        def string a
+        def enum a
             result = CharacterSet.new
             result << a
             result            
         end
-
+		
         def method_missing name, char_set, &block
             @definitions[name] = char_set unless @definitions.has_key? name
         end
     end
 
 	class LexicalSpecification		
+		alias __extend extend
 		instance_methods.each { |m| undef_method m unless m =~ /^__/ || m == 'new' || m=='instance_eval'}
 		attr_reader :definitions, :character_classes
 			
 		def initialize definition = {:initial => {}}, state = :initial 
 			@definitions, @character_classes = definition, CharacterClassDefinition.new
-			@lexical_definition = @definitions[state]
+			@lexical_definition, @patterns = @definitions[state], {}
 		end
 			
 		def range a, b
@@ -80,8 +50,12 @@ module Aurum
 			Pattern.from_string literal
 		end
 		
-		def the name
-			Pattern.from_char_set @character_classes.definitions[name] 
+		def enum literal
+			Pattern.from_enum literal
+		end
+				
+		def cat *patterns
+			Pattern.concat *(patterns.collect {|x| x.kind_of?(Pattern) ? x : Pattern.from_string(x.to_s)})
 		end
 					
 		def shift_to state, *patterns, &config
@@ -109,8 +83,21 @@ module Aurum
 			__create_pattern RecognizeTokenAndChangeStateAction.new(token.to_s, state), *patterns
 		end
 			
-		def method_missing name, *patterns, &action
-			__create_pattern RecognizeTokenAction.new(name.to_s), *patterns
+		def method_missing name, *patterns, &action 
+			return __get_pattern(name) if patterns.empty?
+			pattern = Pattern.concat *(patterns.collect {|x| x.kind_of?(Pattern) ? x : Pattern.from_string(x.to_s)}) 			
+			@patterns[name] = pattern
+			if name.to_s =~ /^_/ 
+				recognize_action = RecognizeTokenAction.new(name.to_s)
+				recognize_action.action = action
+				@lexical_definition[pattern] = recognize_action
+			end 
+			pattern
+		end
+		
+		def __get_pattern name
+			return @patterns[name] if @patterns.has_key? name
+			Pattern.from_char_set @character_classes.definitions[name]  
 		end
 					
 		def __create_pattern action, *patterns 
@@ -150,10 +137,12 @@ module Aurum
 		end
 		
 		def __associativity direction, *operators
+			symbols = []
 			for operator in operators
-				symbol = __get_symbol operator
-				@associativities[direction] << symbol unless @associativities[direction].include? symbol 
-			end									
+				symbols << (symbol = __get_symbol(operator))
+				@associativities[direction] << symbol unless @associativities[direction].include? symbol				 
+			end			
+			@precedences << symbols.uniq
 		end
 	end
 	
@@ -190,8 +179,8 @@ module Aurum
 	
 	class Grammar		 			 			
 		def self.character_classes &block
-			@lexical_sepcification = LexicalSpecification.new unless @lexical_sepcification 
-			@lexical_sepcification.character_classes.instance_eval &block
+			@lexical_sepcification = LexicalSpecification.new unless @lexical_sepcification
+			@lexical_sepcification.character_classes.instance_eval &block			
 		end
 		
 		def self.tokens &block
@@ -210,6 +199,7 @@ module Aurum
 		end
 		
 		def self.lexer input
+			@productions = ProductionDefinition.new unless @productions			
 			@lexical_sepcification.definitions[:initial].merge!(@productions.__literals)
 			generator = Aurum::LexicalTableGenerator.new @lexical_sepcification.definitions
 			table, accepts = generator.lexical_table
@@ -217,6 +207,8 @@ module Aurum
 		end
 		
 		def self.start_from start_symbol
+			@productions = ProductionDefinition.new unless @productions
+			@precedences = OperatorPrecedenceDefinition.new unless @precedences
 			generator = Aurum::ParsingTableGenerator.new @productions.__definitions, @precedences.precedences, @precedences.associativities
 			productions = generator.start_from(Aurum::Symbol.new(start_symbol.to_s, false)).productions
 			table, lookeahead_level = generator.parsing_table

data/lib/aurum/lexical_table_generator.rb

@@ -12,7 +12,7 @@ module Aurum
         end
 
         def lexical_table
-            construct_automata
+            construct_automata			
             make_initial_partitions
             refine_partitions
             @partitions.size < @lexical_automata.table.size ? construct_minimize_automata : [@lexical_automata.table, @accept_states]
@@ -104,6 +104,12 @@ module Aurum
             automata.connect 0, set, 1
             new automata, 1
         end
+		
+		def self.from_enum enum_literal
+			automata = Automata.new enum_literal.length + 2
+			enum_literal.each_byte {|byte| automata.connect 0, CharacterSet::Interval.new(byte).to_char_set, 1}
+			new automata, 1
+		end		
 
         def self.concat *patterns
             automata, index = Automata.new, 0

data/lib/aurum/parsing_table_generator.rb

@@ -1,11 +1,16 @@
 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)
+    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
 
@@ -17,19 +22,20 @@ module Aurum
         end
 
         def start_from start
-            @start_production = Aurum::Production.new START, [start]
-            @symbols, @productions, @nullables, @first_sets = [], [@start_production], [], {START => []}
-            find_all_used_symbols_and_productions 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
-            if @states.any? {|x| !x.consistent? }
+			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 if @states.any? {|x| x.conflicted?}
+                compute_LALR_n_lookahead unless @conflicts.empty?
             end
             parsing_table = []
             for state in @states do
@@ -40,67 +46,102 @@ module Aurum
             return parsing_table, @lookahead_level
         end
 
-        private        
-        def find_all_used_symbols_and_productions start
-            unvisited = [start]
-            while !unvisited.empty?
-                visiting = unvisited.pop
-                @symbols << visiting
-                @first_sets[visiting] = visiting.is_terminal ? [visiting] : []
-                for production in @definition[visiting] do
-                    @productions << production
-                    for symbol in production.symbols do
-                        unvisited << symbol unless @symbols.include? symbol
-                    end
-                end unless visiting.is_terminal
-            end
-        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
-            begin
-                changed = false
-                for production in @productions
-                    if production.symbols.all? {|s| nullable? s}
-                        @nullables << production.nonterminal
-                        changed = true
-                    end unless nullable? production.nonterminal
-                end
-            end    while changed
+        	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
-            begin
-                changed = false
-                for production in @productions do
-                    set = @first_sets[production.nonterminal]
-                    for symbol in production.symbols do
-                        changed |= set.length != set.replace(set | @first_sets[symbol]).length
-                        break unless nullable? symbol
-                    end
-                end
-            end while changed
+        	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? symbol
-            @nullables.include? symbol
+        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, unvisited = [start_state], [start_state]
-            while !unvisited.empty?
-                visiting = unvisited.pop
-                visiting.grep_each '!x.handle?' do |item|
+            @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(@productions.index(read_reduce), true)
+                    	visiting[symbol] << ReduceAction.new(read_reduce.index, true)
                     else
                         if index = @states.index(new_state)
                             new_state = @states[index]
                         else
-                            [@states, unvisited].each {|x| x << new_state}
+                        	@states << new_state
+							@inconsistents << new_state if new_state.inconsistent?
+							unvisited << new_state
                             index = @states.length - 1
                         end
                         visiting[symbol] << ShiftAction.new(index, false)
@@ -109,101 +150,124 @@ module Aurum
                 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 = 1
+        	@lookahead_level, @conflicts = 1, []
             @lookahead_config_stack, @lookahead_indicitor, @lookahead_result = [], {}, {}
-            @states.grep_each '!x.consistent?' do |state|
-                state.grep_each 'x.handle?' do |handle|
-                    production = handle.production
-                    for predsucceor in state.predsucceors production.symbols.reverse
-                        for lookahead in compute_follow_set predsucceor, production.nonterminal
-                            if state.only_shift?(lookahead) && @precedence_table.operator?(lookahead)
-                                if @precedence_table.compare(production.operator, lookahead) >= 0
-                                    state[lookahead].clear
-                                    state[lookahead] << ReduceAction.new(@productions.index(production), false)
-                                end
-                            else
-                                state[lookahead] << ReduceAction.new(@productions.index(production), false)
-                            end
-                        end
-                    end
-                end
+			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 compute_LALR_n_lookahead
-            @stack_seen = []
-            @states.grep_each 'x.conflicted?' do |state|
-                @current_lookahead_level = 1
-                for lookahead, actions in state.conflicted_actions do
-                    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 do
-                                @follow_sources_visited = []
-                                sources[action] |= follow_sources [predsucceor], handle.nonterminal, lookahead
-                            end
-                        end
-                    end
-                    resolve_conficts state, lookahead, sources
-                end
-                @lookahead_level = [@current_lookahead_level, @lookahead_level].max
+		
+		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 closure items
-            result, unmarked = items.dup, items.dup
-            while !unmarked.empty?
-                visiting = unmarked.pop
-                for production in @definition[visiting.dot_symbol] do
-                    item = LRItem.new production, 0
-                    [result, unmarked].each {|x| x << item} unless result.include? item
-                end unless visiting.handle? || visiting.dot_symbol.is_terminal
-            end
+		
+        def read_set state, symbol
+            result = []
+            each_read_by(state, symbol) {|q, y| result |= @first_sets[y] }
             result
         end
 
-        def goto items, symbol
-            result = State.new []
-            items.each {|item| result << LRItem.new(item.production, item.position + 1) if item.dot_symbol == symbol}
-            closure result
+        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 compute_follow_set state, nonterminal = nil
-            if state.kind_of? Configuration
-                config = state
-                state, nonterminal = config.state, config.symbol
-            else
-                config = Configuration.new state, nonterminal
-            end
-            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 |p, b|
-                    new_config = Configuration.new p, b
-                    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]
+		
+		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
-                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
+                @lookahead_level = [@current_lookahead_level, @lookahead_level].max
             end
-            @lookahead_result[config]
         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
@@ -217,15 +281,17 @@ module Aurum
                 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.grep_each(lambda {|x| x.kernel? && !x.start? && x.dot_symbol == nonterminal})  do |item|
-                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
+			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
 
@@ -237,7 +303,7 @@ module Aurum
                 for stk in stacks
                     raise 'not LALR(n)' if @stack_seen.include? stk
                     @stack_seen << stk
-                    for a in next_lookaheads stk, lookahead do
+                    for a in next_lookaheads stk, lookahead
                         lookahead_state[a] << action
                     end
                 end
@@ -246,7 +312,7 @@ module Aurum
                 new_sources = {}
                 for action in actions do
                     new_sources[action] = [].to_set
-                    for stk in source[action] do
+                    for stk in sources[action] do
                         @follow_sources_visited = []
                         new_sources[action] |= follow_sources stk, lookahead, next_lookahead
                     end
@@ -259,53 +325,28 @@ module Aurum
             EOF == lookahead and return [EOF]
             top = stack.last
             lookaheads = read_set top, lookahead
-            top.grep_each(lambda {|x| x.kernel? && !x.start? && x.dot_symbol == lookahead}) do |item|
-                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 q, c }
-                end
+			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 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
-                symbols = item.production.symbols
-                symbols.reverse.each_with_index do |symbol, index|
-                    first_part = symbols.slice 0, symbols.length - index - 1
-                    state.predsucceors(first_part.reverse).each {|s| yield s, item.production.nonterminal} if nonterminal == symbol
-                    nullable? symbol or break
-                end
-            end if state
-        end
-
         def default_action state
             if !state.empty?
                 handle = nil
                 for x in state
                     p = x.production
-                    handle = x if x.handle? && p.nonterminal != START && (!handle || handle.production.symbols.length > p.symbols.length)
+                    handle = x if x.is_handle && p.nonterminal != START && (!handle || handle.production.symbols.length > p.symbols.length)
                 end
-                default_action = handle ? ReduceAction.new(@productions.index(handle.production), false) : nil
+                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 }
@@ -346,30 +387,31 @@ module Aurum
         end
 
         class State < Array
-            attr_reader :actions
+        	attr_reader :actions, :handles, :non_handles, :kernels, :read_reduce, :direct_read
             def initialize elements
                 super elements
-                @actions, @predsucceors = {}, []
+				@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 consistent?
-                handles, kernels = 0, 0
-                for item in self do
-                    handles += 1 if item.handle?
-                    kernels += 1 if item.kernel?
-                    handles > 1 || (handles == 1 && handles != kernels) and return false
-                end
-                true
-            end
-
-            def conflicted?
-                !consistent? && @actions.any? {|symbol, actions| actions.length > 1}
-            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}
@@ -379,10 +421,6 @@ module Aurum
                 !self[symbol].empty? && @actions[symbol].all? {|x| x.kind_of? ShiftAction}
             end
 
-            def read_reduce
-                length == 1 && first.handle? ? first.production : nil
-            end
-
             def goto symbol
                 shift = self[symbol].find {|x| x.kind_of? Aurum::ShiftAction }
                 shift.state if shift
@@ -392,54 +430,35 @@ module Aurum
                 symbols or return @predsucceors
                 result = [self]
                 for symbol in symbols
-                    new_result = result.inject [] do |sum, x|
-                        sum | x.predsucceors.find_all {|predsucceor| predsucceor.any? {|item| item.dot_symbol == symbol}}
-                    end
+                	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 direct_read
-                inject [] do |result, item|
-                    item.dot_symbol ? result | [item.dot_symbol] : result
-                end
-            end
-
+			
             def == other
-                other.kind_of? State or return false
-                equal? other and return true
-                length == other.length or return false
-                all? {|x| other.include? x}
+            	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
-            def dot_symbol
-                production.symbols[position]
-            end
-
-            def start?
-                production.nonterminal == START
-            end
-
-            def handle?
-                position >= production.symbols.length
-            end
-
-            def kernel?
-                handle? || position != 0
-            end
-
-            def first_part
-                production.symbols.slice(0, position)
-            end
-
-            def second_part
-                handle? ? [] : production.symbols.slice(position..-1)
-            end
+        	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

data/test/engine/lexer_test.rb

@@ -43,6 +43,13 @@ class LexerTest < Test::Unit::TestCase
 		lexer = create_lexer specification, ''
 		assert_equal terminal('$eof'), lexer.next_symbol				
 	end
+	
+	def test_should_return_unknown_if_not_recognized
+		specification = {:initial => {PATTERN_A => Aurum::RecognizeTokenAction.new('tokenA'),
+									  PATTERN_B => Aurum::IgnoreAction}}
+		lexer = create_lexer specification, 'whatever'
+		assert_equal terminal('$unknown'), lexer.next_symbol		
+	end
 			
 	def create_lexer specification, input
 		generator = Aurum::LexicalTableGenerator.new specification

data/test/grammar_definition/character_class_definition_test.rb

@@ -8,7 +8,7 @@ class CharacterClassDefinitionTest < Test::Unit::TestCase
 
     def test_should_add_char_class_to_definition
         @character_class.instance_eval do
-            alpha range(?a, ?z) + string('ABCDEF')
+            alpha range(?a, ?z) + enum('ABCDEF')
         end
         assert_equal 1, @character_class.definitions.size
         alpha = @character_class.definitions[:alpha]

data/test/grammar_definition/grammar_definition_test.rb

@@ -1,6 +1,6 @@
 $:.unshift(File.dirname(__FILE__) + '/../')
 require 'test_helper'
-
+=begin
 class ExpressionGrammar < Aurum::Grammar
 	character_classes do
 		number range(?0, ?9)
@@ -8,7 +8,7 @@ class ExpressionGrammar < Aurum::Grammar
 	
 	tokens do
 		ignore string(' ').one_or_more 
-		_number the(:number).one_or_more
+		_number number.one_or_more
 	end
 	
 	precedences do
@@ -51,4 +51,5 @@ class GrammarDefinitionTest < Test::Unit::TestCase
 		assert_equal token, symbol
 		assert_equal lexeme, symbol.value
 	end
-end
+end
+=end

data/test/lexical_table_generator/pattern_test.rb

@@ -85,6 +85,12 @@ class PatternTest < Test::Unit::TestCase
         assert match?('comments */', pattern)
         assert !match?('everything', pattern)
     end
+	
+	def test_should_match_every_char_in_enum_literal
+		pattern = Aurum::Pattern.from_enum('*/')
+		assert match?('*', pattern)
+		assert match?('/', pattern)
+	end
 
     def match? expected_string, pattern
         states = closure pattern.automata.table, [0]

data/test/lexical_table_generator/table_generator_test.rb

@@ -112,7 +112,7 @@ class LexicalTableGeneratorTest < Test::Unit::TestCase
         assert recognize?(:state_a, 'pattern_b')
         assert !recognize?(:all, 'pattern_b')
     end
-
+	
     def recognize? lexical_state, source
         begin
             lexical_state = - @lexical_states.index(lexical_state) - 1

data/test/parsing_table_generator/augmented_grammar_test.rb

@@ -7,7 +7,7 @@ Aurum::ParsingTableGenerator.class_eval do
 end
 
 class AugmentedGrammarTest < Test::Unit::TestCase   
-    def atest_should_find_all_used_symbols
+    def test_should_find_all_used_symbols
         generator = parser_generator E=>[production(E, T)], T=>[production(T, F)], F=>[production(F, ID)]
         generator.start_from E
         assert_equal [E, T, F, ID], generator.symbols
@@ -15,7 +15,7 @@ class AugmentedGrammarTest < Test::Unit::TestCase
         assert_equal [T, F, ID], generator.symbols
     end
 
-    def atest_should_find_all_used_productions
+    def test_should_find_all_used_productions
         generator = parser_generator E=>[production(E, T)], T=>[production(T, F)], F=>[production(F, ID)]
         generator.start_from E
         assert_equal [production(START, E), production(E, T), production(T, F), production(F, ID)].to_set, generator.productions.to_set
@@ -31,13 +31,13 @@ class AugmentedGrammarTest < Test::Unit::TestCase
         assert_equal [T].to_set, generator.nullables.to_set
     end
 
-    def atest_first_set_should_contain_terminals_left_depends_on_nt_dirctly
+    def test_first_set_should_contain_terminals_left_depends_on_nt_dirctly
         generator = parser_generator E=>[production(E, T, ID), production(E, T, T, T, terminal('other'))], T=>[production(T)]
         generator.start_from E
         assert_equal [ID, terminal('other')].to_set, generator.first_sets[E].to_set
     end
 
-    def atest_should_contain_fist_set_of_nt_which_left_depends_on_nt_dirctly
+    def test_should_contain_fist_set_of_nt_which_left_depends_on_nt_dirctly
         generator = parser_generator E=>[production(E, T, ID), production(E, T, T, T, terminal('other'))], T=>[production(T)], F=>[production(F, T, E)]
         generator.start_from F
         assert_equal generator.first_sets[F].to_set, generator.first_sets[E].to_set

data/test/parsing_table_generator/lalr_n_computation_test.rb

@@ -11,7 +11,7 @@ class LALRLookaheadComputationTest < Test::Unit::TestCase
         generator = parser_generator EXPRESSION_GRAMMAR_LALR1
         generator.start_from E
         generator.construct_LR0_automata
-        states = generator.states.find_all {|x| !x.consistent?}
+        states = generator.states.find_all {|x| x.inconsistent?}
         generator.compute_LALR_1_lookahead
         assert_equal [reduce(0)].to_set, states[0][terminal('$eof')]
         assert_equal [reduce(2)].to_set, states[1][terminal('+')]
@@ -25,10 +25,10 @@ class LALRLookaheadComputationTest < Test::Unit::TestCase
         generator.start_from BNF
         generator.construct_LR0_automata
         generator.compute_LALR_1_lookahead
-        conflicted_state = (generator.states.find_all {|x| x.conflicted? })[0]
+        conflicted_state = (generator.states.find_all {|x| x.conflict? })[0]
         generator.compute_LALR_n_lookahead
         assert_equal [lookahead_shift(generator.states.length - 1)].to_set, conflicted_state[terminal('s')]
-        assert !conflicted_state.conflicted?
+        assert !conflicted_state.conflict?
     end
 
     def test_should_add_reduce_action_to_lookahead_state
@@ -62,6 +62,9 @@ class LALRLookaheadComputationTest < Test::Unit::TestCase
         assert_equal 1, level
         generator = parser_generator IF_GRAMMAR_LALR2
         table, level = generator.start_from(STATEMENT).parsing_table
+        assert_equal 2, level		
+        generator = parser_generator BNF_GRAMMAR_LALR2
+        table, level = generator.start_from(BNF).parsing_table
         assert_equal 2, level
     end
 	

data/test/parsing_table_generator/lr_0_automata_test.rb

@@ -6,7 +6,7 @@ Aurum::ParsingTableGenerator.class_eval do
 	public :closure, :goto, :read_set, :construct_LR0_automata
 end
 
-class LR0AutomataTest < Test::Unit::TestCase
+class LR0AutomataTest < Test::Unit::TestCase		
     def test_closure_should_contain_items_themselves
         generator = parser_generator E=>[production(E, ID)]
         assert_equal [LR_item(0, E, ID)], generator.closure([LR_item(0, E, ID)])
@@ -14,17 +14,20 @@ class LR0AutomataTest < Test::Unit::TestCase
 
     def test_closure_should_contain_all_right_most_lr_items_of_dot_symbol
         generator = parser_generator E=>[production(E, T)], T=>[production(T, ID), production(T, terminal('other'))]
+		generator.start_from E
         closure = generator.closure [LR_item(0, E, T)]
         [LR_item(0, T, ID), LR_item(0, T, terminal('other'))].each {|x| assert closure.include?(x)}
     end
 
     def test_should_return_goto_items_if_expected_symbol_given
         generator = parser_generator E=>[production(E, T)], T=>[production(T, ID), production(T, terminal('other'))]
+		generator.start_from E
         assert_equal [LR_item(1, E, T)], generator.goto([LR_item(0, E, T)], T)
     end
 
     def test_goto_items_should_be_closured_if_expected_symbol_given
         generator = parser_generator E=>[production(E, T, T)], T=>[production(T, ID), production(T, terminal('other'))]
+		generator.start_from E
         goto = generator.goto [LR_item(0, E, T, T)], T
         [LR_item(0, T, ID), LR_item(0, T, terminal('other'))].each {|x| assert goto.include?(x)}
     end
@@ -39,7 +42,7 @@ class LR0AutomataTest < Test::Unit::TestCase
         assert [LR_item(1, T, terminal('+'), T)], states[1]
         assert [LR_item(2, T, terminal('+'), T), LR_item(0, T, ID)], states[2]
     end
-
+	
     def test_should_add_shift_action_to_states
         generator = parser_generator SIMPLE_GRAMMAR_LR0
         generator.start_from E
@@ -54,7 +57,7 @@ class LR0AutomataTest < Test::Unit::TestCase
         generator.start_from E
         generator.construct_LR0_automata
         states = generator.states
-         assert_equal [read_reduce(0)].to_set, states[0][E]
+        assert_equal [read_reduce(0)].to_set, states[0][E]
         assert_equal [read_reduce(2)].to_set, states[0][ID]
         assert_equal [read_reduce(2)].to_set, states[2][ID]
         assert_equal [read_reduce(1)].to_set, states[2][T]
@@ -87,5 +90,5 @@ class LR0AutomataTest < Test::Unit::TestCase
         generator.construct_LR0_automata
         states = generator.states
         assert_equal [terminal('id'), terminal('(')].to_set, generator.read_set(states[2], terminal('*')).to_set
-    end
+    end					
 end

data/test/parsing_table_generator/lr_item_test.rb

@@ -8,23 +8,17 @@ class LRItemTest < Test::Unit::TestCase
     end
 
     def test_should_be_handle_if_at_right_most_position
-        assert LR_item(2, E, T, ID).handle?
-        assert !LR_item(1, E, T, ID).handle?
-        assert LR_item(0, E).handle?
+        assert LR_item(2, E, T, ID).is_handle
+        assert !LR_item(1, E, T, ID).is_handle
+        assert LR_item(0, E).is_handle
     end
 
     def test_should_be_kernel_if_not_at_left_most_position
-        assert LR_item(2, E, T, ID).kernel?
-        assert LR_item(1, E, T, ID).kernel?
-        assert !LR_item(0, E, T, ID).kernel?
+        assert LR_item(2, E, T, ID).is_kernel
+        assert LR_item(1, E, T, ID).is_kernel
+        assert !LR_item(0, E, T, ID).is_kernel
     end   
 
-    def test_should_return_zero_to_position_as_first_part
-        assert_equal [], LR_item(0, E, T, ID).first_part
-        assert_equal [T], LR_item(1, E, T, ID).first_part
-        assert_equal [T, ID], LR_item(2, E, T, ID).first_part
-    end
-
     def test_should_return_position_to_end_as_second_part
         assert_equal [T, ID], LR_item(0, E, T, ID).second_part
         assert_equal [ID], LR_item(1, E, T, ID).second_part

data/test/parsing_table_generator/parsing_table_state_test.rb

@@ -9,7 +9,7 @@ class ParsingTableStateTest < Test::Unit::TestCase
     end
 
     def test_should_be_read_reducable_if_contains_one_and_only_one_handle
-        assert parsing_table_state(LR_item(1, E, T)).read_reduce
+        assert parsing_table_state(LR_item(1, E, ID)).read_reduce
         assert !parsing_table_state(LR_item(1, E, T, T)).read_reduce
         assert !parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).read_reduce
     end
@@ -22,18 +22,18 @@ class ParsingTableStateTest < Test::Unit::TestCase
     end
 
     def test_should_be_consistent_if_contains_one_and_only_one_handle
-        assert  parsing_table_state(LR_item(1, E, T)).consistent?
+        assert  !parsing_table_state(LR_item(1, E, T)).inconsistent?
     end
 
     def test_should_be_consistent_if_contains_no_handle
-        assert  parsing_table_state(LR_item(1, E, T, ID), LR_item(1, E, F, ID), LR_item(1, E, ID, F)).consistent?
+        assert  !parsing_table_state(LR_item(1, E, T, ID), LR_item(1, E, F, ID), LR_item(1, E, ID, F)).inconsistent?
     end
 
     def test_should_be_inconsistent_if_contains_handle_and_other_kernal_items
-        assert !parsing_table_state(LR_item(1, E, T), LR_item(1, E, T, ID)).consistent?
+        assert parsing_table_state(LR_item(1, E, T), LR_item(1, E, T, ID)).inconsistent?
     end
 
     def test_should_return_all_direct_read_symbols
-        assert_equal [T], parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).direct_read
+    	assert_equal [T].to_set, parsing_table_state(LR_item(1, E, T, T), LR_item(1, E, T)).direct_read
     end
 end

data/test/test_helper.rb

@@ -10,8 +10,8 @@ def nonterminal name
     Aurum::Symbol.new name, false
 end
 
-def production nt, *symbols
-    Aurum::Production.new nt, symbols
+def production nt, *symbols 
+	Aurum::Production.new nt, symbols 
 end
 
 def LR_item position, nt, *symbols

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: aurum
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-05-20 00:00:00 +10:00
+  version: 0.1.1
+date: 2007-05-26 00:00:00 +10:00
 summary: Aurum is a LALR(n) parser generator written in Ruby.
 require_paths: 
 - lib
@@ -31,37 +31,41 @@ authors:
 files: 
 - example/expression
 - example/expression/expression.rb
+- example/expression/lisp.rb
 - lib/aurum
 - lib/aurum/lexical_table_generator.rb
 - lib/aurum/parsing_table_generator.rb
-- lib/aurum/grammar.rb
 - lib/aurum/engine.rb
+- lib/aurum/grammar.rb
+- lib/grammars
 - lib/aurum.rb
 - test/parsing_table_generator
 - test/parsing_table_generator/augmented_grammar_test.rb
-- test/parsing_table_generator/lr_0_automata_test.rb
+- test/parsing_table_generator/precedence_table_test.rb
 - test/parsing_table_generator/production_test.rb
+- test/parsing_table_generator/lr_0_automata_test.rb
+- test/parsing_table_generator/lalr_n_computation_test.rb
 - test/parsing_table_generator/parsing_table_state_test.rb
 - test/parsing_table_generator/lr_item_test.rb
-- test/parsing_table_generator/precedence_table_test.rb
-- test/parsing_table_generator/lalr_n_computation_test.rb
+- test/engine
+- test/engine/lexer_test.rb
+- test/engine/semantic_attributes_test.rb
+- test/grammars
+- test/grammars/ruby
 - test/grammar_definition
 - test/grammar_definition/grammar_definition_test.rb
+- test/grammar_definition/production_definition_test.rb
+- test/grammar_definition/operator_precedence_definition_test.rb
 - test/grammar_definition/character_class_definition_test.rb
 - test/grammar_definition/lexical_definition_test.rb
-- test/grammar_definition/operator_precedence_definition_test.rb
-- test/grammar_definition/production_definition_test.rb
 - test/lexical_table_generator
 - test/lexical_table_generator/interval_test.rb
+- test/lexical_table_generator/subset_determinizer_test.rb
 - test/lexical_table_generator/character_set_test.rb
 - test/lexical_table_generator/automata_test.rb
 - test/lexical_table_generator/pattern_test.rb
-- test/lexical_table_generator/subset_determinizer_test.rb
 - test/lexical_table_generator/table_generator_test.rb
 - test/test_helper.rb
-- test/engine
-- test/engine/semantic_attributes_test.rb
-- test/engine/lexer_test.rb
 test_files: []
 
 rdoc_options: []