aurum 0.1.0

data/lib/aurum/lexical_table_generator.rb

@@ -0,0 +1,423 @@
+module Aurum
+	RecognizeTokenAction, ChangeStateAction, UserDefinedAction = Struct.new(:token), Struct.new(:state), Struct.new(:action)
+	RecognizeTokenAndChangeStateAction = Struct.new :token, :state
+	IgnoreAction = RecognizeTokenAction.new '$ignore'
+
+    class LexicalTableGenerator
+        attr_reader :lexical_states
+        def initialize specification
+            @specification, @accept_states  = specification, {}
+            @lexical_states = @specification.keys - [:all]
+            @patterns_for_all = specification[:all] ? specification[:all] : {}
+        end
+
+        def lexical_table
+            construct_automata
+            make_initial_partitions
+            refine_partitions
+            @partitions.size < @lexical_automata.table.size ? construct_minimize_automata : [@lexical_automata.table, @accept_states]
+        end
+
+        private
+        def construct_automata
+            automata, accepts = Automata.new(1), {}, {}
+            @lexical_states.each_with_index do |lexcial_state, index|
+                lexical_state_start = automata.new_state
+                automata.connect 0, CharacterSet::Interval.new(-index - 1).to_char_set, lexical_state_start
+                @patterns_for_all.merge(@specification[lexcial_state]).each do |pattern, action|
+                    pattern_start = automata.merge! pattern.automata
+                    automata.connect lexical_state_start, Epsilon, pattern_start
+                    accepts[pattern_start + pattern.accept] = action
+                end
+            end
+            @lexical_automata, deterministic_accepts = automata.determinize accepts.keys
+            deterministic_accepts.each {|d, n| @accept_states[d] = n.inject([]){|r, x| r << accepts[x]}}
+        end
+
+        def make_initial_partitions
+            partitions = {}
+            @accept_states.each do |state, action|
+                partitions[action] = [] unless partitions.has_key? action
+                partitions[action] << state
+            end
+            @partitions = [[0], @lexical_automata.all_states - @accept_states.keys - [0]] + partitions.values
+            @partitions.delete []
+        end
+
+        def refine_partitions
+            reverse_automata, working_list = @lexical_automata.reverse, @partitions.dup
+            until working_list.empty?
+                reverse_automata.alphabet(working_list.pop) do |ia, symbols|
+                    @partitions.grep_each 'x.size > 1' do |r|
+                        r1, r2 = r & ia, r - ia
+                        unless r2.empty? || r2 == r
+                            replace @partitions, r => [r1, r2]
+                            if working_list.include? r
+                                replace working_list, r => [r1, r2]
+                            else
+                                working_list << (r1.size <= r2.size ? r1 : r2)
+                            end
+                            working_list.uniq!
+                        end
+                    end
+                end
+            end
+        end
+
+        def construct_minimize_automata
+            automata, accepts = Automata.new(@partitions.size), {}
+            choose_representatives do |representative, index|
+                @lexical_automata.table[representative].each do |transition|
+                    automata.connect index, transition.symbols, partition_contains(transition.destination)
+                end
+                accepts[index] = @accept_states[representative] if @accept_states.has_key? representative
+            end
+            return automata.table, accepts
+        end
+
+        def choose_representatives
+            @partitions.each_with_index {|partition, index| yield partition.first, index}
+        end
+
+        def partition_contains state
+            @partitions.each_with_index {|partition, index| return index if partition.include? state}
+        end
+
+        def replace array, replacements
+            replacements.each do |old, new|
+                array.delete old
+                new.each {|x| array << x}
+            end
+        end
+    end
+
+    class Pattern
+        attr_reader :automata, :accept
+        def self.from_string literal
+            automata, index = Automata.new(literal.length + 1), 0
+            literal.each_byte {|byte|automata.connect index, CharacterSet::Interval.new(byte).to_char_set, (index += 1)}
+            new automata, index
+        end
+
+        def self.from_char_set set
+            automata = Automata.new 2
+            automata.connect 0, set, 1
+            new automata, 1
+        end
+
+        def self.concat *patterns
+            automata, index = Automata.new, 0
+            patterns.each do |pattern|
+                index = automata.connect(index, Epsilon, automata.merge!(pattern.automata)) + pattern.accept
+            end
+            new automata, index
+        end
+
+        def initialize automata, accept
+            @automata, @accept = automata, accept
+        end
+
+        def kleene
+            kleene_automata = @automata.dup
+            kleene_automata.connect 0, Epsilon, @accept
+            kleene_automata.connect @accept, Epsilon, 0
+            Pattern.new kleene_automata, @accept
+        end
+        alias :zero_or_more :kleene
+
+        def iterate
+            iterate_automata = @automata.dup
+            iterate_automata.connect @accept, Epsilon, 0
+            Pattern.new iterate_automata, @accept
+        end
+		alias :one_or_more :iterate
+
+        def opt
+            opt_automata = @automata.dup
+            opt_automata.connect 0, Epsilon, @accept
+            Pattern.new opt_automata, @accept
+        end
+        alias :zero_or_one :opt
+
+        def negate
+            deterministic, accepts = automata.determinize [@accept]
+            sink = deterministic.new_state
+            deterministic.connect sink, CharacterSet.any, sink
+            sink.times do |state|
+                joint = CharacterSet.any
+                deterministic.table[state].each {|tran| joint.delete tran.symbols}
+                deterministic.connect state, joint, sink unless joint.empty?
+            end
+            accept = deterministic.new_state
+            accept.times {|state| deterministic.connect state, Epsilon, accept unless accepts.include? state }
+            Pattern.new deterministic, accept
+        end
+        alias :not :negate
+
+        def [] least, most = least
+            Pattern.concat *([self] * least + [self.opt] * (most-least))
+        end
+
+        def | other
+            automata = Automata.new 2
+            [self, other].each do |pattern|
+                automata.connect automata.connect(0, Epsilon, automata.merge!(pattern.automata)) + pattern.accept, Epsilon, 1
+            end
+            Pattern.new automata, 1
+        end
+
+        def ~
+            any = Pattern.from_char_set(CharacterSet.any).kleene
+            return Pattern.concat(Pattern.concat(any, self, any).negate, self)
+        end
+    end
+
+    class Automata
+        attr_reader :table
+        Transition = Struct.new(:symbols, :destination)
+
+        def initialize(table=[])
+            case table
+            when Array
+                @table = table
+            when Fixnum
+                @table = []
+                table.times {@table << []}
+            end
+        end
+
+        def connect start, symbols, destination
+            @table[start]  << Transition.new(symbols, destination)
+            destination
+        end
+
+        def merge! other
+            start = @table.length
+            other_table = other.instance_eval{@table}
+            other_table.each do |trans|
+                @table << []
+                trans.each {|tran| @table.last << Transition.new(tran.symbols, tran.destination + start)}
+            end
+            start
+        end
+
+        def reverse
+            reverse = []
+            @table.length.times {reverse << []}
+            @table.each_with_index do |trans, index|
+                trans.each {|tran| reverse[tran.destination] << Transition.new(tran.symbols, index)}
+            end
+            Automata.new reverse
+        end
+
+        def dup
+            dup_table = []
+            @table.each {|x| dup_table << x.dup}
+            Automata.new dup_table
+        end
+
+        def alphabet states
+            points = states.inject([]) do |result, state|
+                @table[state].inject(result){|r, s|r += s.symbols.to_points s.destination}
+            end
+            points.sort! do |x, y|
+                x.char == y.char ? (x.is_start ? (y.is_start ? 0 : -1) : (y.is_start ? 1 : 0)) : (x.char < y.char ? -1 : 1)
+            end
+            reachable_states = []
+            points.each_with_index do |point, index|
+                if point.is_start
+                    reachable_states << point.destination
+                else
+                    reachable_states.delete point.destination
+                    next if reachable_states.empty?
+                end
+                symbols = range(point, points[index + 1])
+                yield reachable_states.uniq, symbols if symbols
+            end
+        end
+
+        def determinize accepts
+            SubsetDeterminizer.new(self, accepts).determinize
+        end
+
+        def new_state
+            @table << []
+            @table.length - 1
+        end
+
+        def all_states
+            (0..table.length - 1).to_a
+        end
+
+        private
+        def range point_a, point_b
+            start_point = point_a.is_start ? point_a.char : (point_a.char + 1)
+            end_point = point_b.is_start ? point_b.char - 1 : point_b.char
+            start_point > end_point ? nil : CharacterSet::Interval.new(start_point, end_point).to_char_set
+        end
+    end
+
+    class SubsetDeterminizer
+        def initialize nondeterministic, accepts
+            @unmarked, @dstates, @accepts = [], [], accepts
+            @nondeterministic, @deterministic, @accept_states = nondeterministic, Automata.new, {}
+            unmark closure([0])
+        end
+
+        def determinize
+            until @unmarked.empty?
+                start = @unmarked.pop
+                @nondeterministic.alphabet(@dstates[start]) do |states, symbols|
+                    destination_state = closure(states)
+                    destination = unmark destination_state unless destination = @dstates.index(destination_state)
+                    @deterministic.connect start, symbols, destination
+                end
+            end
+            return @deterministic, @accept_states
+        end
+        private
+        def unmark states
+            @dstates << states
+            @unmarked.push @deterministic.new_state
+            accepts = states.find_all {|x| @accepts.include? x}
+            @accept_states[@unmarked.last] = accepts unless accepts.empty?
+            @unmarked.last
+        end
+
+        def closure states
+            closure, unvisited = states.dup, states.dup
+            until unvisited.empty? do
+                @nondeterministic.table[unvisited.pop].each do |tran|
+                    if tran.symbols == Epsilon && !closure.include?(tran.destination)
+                        closure << tran.destination
+                        unvisited << tran.destination
+                    end
+                end
+            end
+            closure.sort!
+        end
+    end
+
+    class CharacterSet
+        attr_reader :intervals
+        def self.any
+            Interval.new(0, 65535).to_char_set
+        end
+
+        def + other
+            result = self.dup
+            if (other.kind_of? CharacterSet)
+                for interval in other.intervals
+                    result.add_interval interval.first, interval.last
+                end
+            else
+                other.to_s.each_byte do |byte|
+                    result.add_interval byte
+                end
+            end
+            result
+        end
+
+        def - other
+            result = self.dup
+            if (other.kind_of? CharacterSet)
+                for interval in other.intervals
+                    result.delete_interval interval.first, interval.last
+                end
+            else
+                other.to_s.each_byte do |byte|
+                    result.delete_interval byte
+                end
+            end
+            result
+        end
+
+        def initialize *intervals
+            @intervals = intervals
+        end
+
+        def << obj
+            obj.kind_of?(Range) ? add_interval(obj.first, obj.last) : obj.to_s.each_byte {|x| add_interval x}
+        end
+
+        def delete obj
+            case obj
+            when Range
+                delete_interval obj.first, obj.last
+            when Aurum::CharacterSet
+                obj.intervals.each {|interval| delete_interval interval.first, interval.last}
+            else
+                obj.to_s.each_byte {|x| delete_interval x}
+            end
+        end
+
+        def include? char
+            @intervals.any? {|x| x.include? char}
+        end
+
+        def empty?
+            return @intervals.empty?
+        end
+
+        def to_points destination
+            @intervals.inject [] do |points, interval|
+                points << Point.new(interval.first, true, destination)
+                points << Point.new(interval.last, false, destination)
+            end
+        end
+
+        def dup
+            intervals = []
+            for interval in @intervals
+                intervals << interval.dup
+            end
+            CharacterSet.new *intervals
+        end
+
+        protected
+        def add_interval first, last = first
+            interval = Interval.new first, last
+            @intervals << interval unless @intervals.any? {|x| x.merge! interval}
+        end
+
+        def delete_interval first, last = first
+            interval = Interval.new first, last
+            return unless to_be_replaced = @intervals.find {|x| x.include?(interval.first) || x.include?(interval.last)}
+            @intervals.delete to_be_replaced
+            add_new_interval to_be_replaced.first, interval.first - 1
+            add_new_interval interval.last + 1, to_be_replaced.last
+        end
+
+        def add_new_interval first, last
+            @intervals << Interval.new(first, last) if first <= last
+        end
+
+        Interval, Point = Struct.new(:first, :last), Struct.new(:char, :is_start, :destination)
+
+        Interval.class_eval do
+            def initialize first, last = first
+                super first, last
+            end
+
+            def include? char
+                char = char[0] if char.kind_of? String
+                self.first <= char && char <= self.last
+            end
+
+            def merge! other
+                if include?(other.first) || include?(other.last) || other.first - self.last == 1 || self.first - other.last == 1
+                    self.first = [self.first, other.first].min
+                    self.last = [self.last, other.last].max
+                    return true;
+                end
+                false
+            end
+
+            def to_char_set
+                CharacterSet.new self
+            end
+        end
+    end
+
+    Epsilon = CharacterSet.new
+end

data/lib/aurum/parsing_table_generator.rb

@@ -0,0 +1,445 @@
+require 'set'
+
+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)
+	
+	START, EOF = Symbol.new('$start', false), Symbol.new('$eof', true)
+	
+    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
+            @start_production = Aurum::Production.new START, [start]
+            @symbols, @productions, @nullables, @first_sets = [], [@start_production], [], {START => []}
+            find_all_used_symbols_and_productions start
+            compute_nullable_symbols
+            compute_first_sets
+            self
+        end
+
+        def parsing_table
+            construct_LR0_automata
+            if @states.any? {|x| !x.consistent? }
+                compute_LALR_1_lookahead
+                compute_LALR_n_lookahead if @states.any? {|x| x.conflicted?}
+            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        
+        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
+
+        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
+        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
+        end
+
+        def nullable? symbol
+            @nullables.include? symbol
+        end
+
+        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|
+                    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)
+                    else
+                        if index = @states.index(new_state)
+                            new_state = @states[index]
+                        else
+                            [@states, unvisited].each {|x| x << new_state}
+                            index = @states.length - 1
+                        end
+                        visiting[symbol] << ShiftAction.new(index, false)
+                        new_state.predsucceors << visiting
+                    end
+                end
+            end
+        end
+
+        def compute_LALR_1_lookahead
+            @lookahead_level = 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
+            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
+            end
+        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
+            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
+        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]
+                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 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.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
+            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 do
+                        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 source[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.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
+            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)
+                end
+                default_action = handle ? ReduceAction.new(@productions.index(handle.production), 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
+            def initialize elements
+                super elements
+                @actions, @predsucceors = {}, []
+            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 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 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
+            end
+
+            def predsucceors(symbols = nil)
+                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
+                    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}
+            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
+        end
+    end
+end