Class: ExcelFormulaParser::DFA

Inherits:

Object

• Object
• ExcelFormulaParser::DFA

Defined in:

lib/surpass/ExcelFormulaParser.rb

Instance Method Summary

• #initialize(eot, eof, min, max, accept, special, transition) ⇒ DFA constructor

  A new instance of DFA.

• #predict(parser, input) ⇒ Object

Constructor Details

#initialize(eot, eof, min, max, accept, special, transition) ⇒ DFA

Returns a new instance of DFA.

# File 'lib/surpass/ExcelFormulaParser.rb', line 506

def initialize(eot, eof, min, max, accept, special, transition)
    @eot = eot
    @eof = eof
    @min = min
    @max = max
    @accept = accept
    @special = special
    @transition = transition
end

Instance Method Details

#predict(parser, input) ⇒ Object

# File 'lib/surpass/ExcelFormulaParser.rb', line 516

def predict(parser, input)
    mark = input.mark()
    s = 0 # we always start at s0
    begin
        loop do
            special_state = @special[s]
            if special_state >= 0
                s = parser.special_state_transition(special_state)
                input.consume()
                next
            end

            if @accept[s] >= 1
                return @accept[s]
            end

            # look for a normal char transition
            c = input.look_ahead(1).to_i
            if c != :EOF && c >= @min[s] && c <= @max[s]
                next_state = @transition[s][c - @min[s]] # move to next state
                if next_state < 0
                    # was in range but not a normal transition
                    # must check EOT, which is like the else clause.
                    # eot[s]>=0 indicates that an EOT edge goes to another
                    # state.
                    if @eot[s] >= 0  # EOT Transition to accept state?
                        s = @eot[s]
                        input.consume()
                        next
                    end
                    raise "No viable alt"
                end
                s = next_state
                input.consume()
                next
            end
            if @eot[s] >= 0   # EOT Transition?
                s = @eot[s]
                input.consume()
                next
            end
            if c == :EOF && @eof[s] >= 0   # EOF Transition to accept state?
                return @accept[@eof[s]]
            end

            # not in range and not EOF/EOT, must be invalid symbol
            raise "No viable alt"
        end
    ensure
        input.rewind(mark)
    end
end