antlr4 0.9.2

data/lib/antlr4/base.rb

@@ -0,0 +1,60 @@
+
+module Antlr4
+  INVALID_INTERVAL = Range.new(-1, -2)
+end
+
+class Range
+  def stop
+    last
+  end
+  def start
+    first
+  end
+  def length
+      size
+  end
+  def a
+    first
+  end
+  def b
+    last
+  end
+end
+
+
+class String
+  def is_uppercase?
+    self == self.upcase
+  end
+  def escapeWhitespace(escapeSpaces=false)
+    if escapeSpaces then
+      c = "\xB7"
+    else
+      c = " "
+    end
+    gsub(" ", c).gsub("\t","\\t").gsub("\n","\\n").gsub("\r","\\r")
+  end
+end
+
+class Hash
+  def get(x,y)
+    return fetch(x) if self.has_key? x
+    return y
+  end
+end
+
+
+class Set
+  def remove(a)
+    delete(a)
+  end
+end
+
+class Object
+
+  def type_check(o, t)
+    unless o.kind_of? t 
+      raise Exception.new("Fail Type Check! #{o.class} is not kind of #{t}" )
+    end
+  end
+end

data/lib/antlr4/dfa/DFA.rb

@@ -0,0 +1,128 @@
+
+class DFA
+    attr_accessor :atnStartState, :decision, :_states, :s0, :precedenceDfa 
+    def initialize(_atnStartState, _decision=0)
+        raise Exception.new("atnStartState is nil") if _atnStartState.nil?
+        type_check(_decision, Fixnum)
+        type_check(_atnStartState, ATNState)
+        # From which ATN state did we create this DFA?
+        @atnStartState = _atnStartState
+        @decision = _decision
+        # A set of all DFA states. Use {@link Map} so we can get old state back
+        #  ({@link Set} only allows you to see if it's there).
+        @_states = Hash.new
+        @s0 = nil
+        # {@code true} if this DFA is for a precedence decision; otherwise,
+        # {@code false}. This is the backing field for {@link #isPrecedenceDfa},
+        # {@link #setPrecedenceDfa}.
+        @precedenceDfa = false
+    end
+    def isPrecedenceDfa
+        @precedenceDfa
+    end
+    # Get the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @return The start state corresponding to the specified precedence, or
+    # {@code null} if no start state exists for the specified precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+
+    def getPrecedenceStartState(precedence)
+        if not self.precedenceDfa then
+            raise IllegalStateException.new("Only precedence DFAs may contain a precedence start state.")
+        end
+        # s0.edges is never null for a precedence DFA
+        if precedence < 0 or precedence >= self.s0.edges.length then
+            return nil
+        end
+        return self.s0.edges[precedence]
+    end
+
+    # Set the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @param startState The start state corresponding to the specified
+    # precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+    #
+    def setPrecedenceStartState(precedence, startState)
+        if not self.precedenceDfa then
+            raise IllegalStateException.new("Only precedence DFAs may contain a precedence start state.")
+        end
+        if precedence < 0
+            return
+        end
+        # synchronization on s0 here is ok. when the DFA is turned into a
+        # precedence DFA, s0 will be initialized once and not updated again
+        # s0.edges is never null for a precedence DFA
+        self.s0.edges[precedence] = startState
+    end
+    #
+    # Sets whether this is a precedence DFA. If the specified value differs
+    # from the current DFA configuration, the following actions are taken;
+    # otherwise no changes are made to the current DFA.
+    #
+    # <ul>
+    # <li>The {@link #states} map is cleared</li>
+    # <li>If {@code precedenceDfa} is {@code false}, the initial state
+    # {@link #s0} is set to {@code null}; otherwise, it is initialized to a new
+    # {@link DFAState} with an empty outgoing {@link DFAState#edges} array to
+    # store the start states for individual precedence values.</li>
+    # <li>The {@link #precedenceDfa} field is updated</li>
+    # </ul>
+    #
+    # @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+    # {@code false}
+
+    def setPrecedenceDfa(_precedenceDfa)
+        if self.precedenceDfa != _precedenceDfa then
+            self._states = Hash.new
+            if _precedenceDfa then
+                precedenceState = DFAState.new(nil, ATNConfigSet.new())
+                precedenceState.edges = Array.new
+                precedenceState.isAcceptState = false
+                precedenceState.requiresFullContext = false
+                self.s0 = precedenceState
+            else
+                self.s0 = nil
+            end
+            self.precedenceDfa = _precedenceDfa
+        end
+    end
+
+    def states()
+        self._states
+    end
+
+    # Return a list of all states in this DFA, ordered by state number.
+    def sortedStates()
+        return self._states.keys().sort {|a,b| a.stateNumber <=> b.stateNumber}
+    end
+
+    def to_s
+       toString()
+    end
+    def inspect
+        "<DFA #{atnStartState.inspect} decision(#{@decision}) states(#{states.length}) >"
+    end
+
+    def toString(tokenNames=nil)
+        if self.s0.nil? then
+            return ''
+        end
+        serializer = DFASerializer.new(self,tokenNames)
+        return serializer.to_s
+    end
+
+    def toLexerString
+        if self.s0.nil? then
+            return ''
+        end
+        serializer = LexerDFASerializer.new(self)
+        return serializer.to_s
+    end
+end

data/lib/antlr4/dfa/DFASerializer.rb

@@ -0,0 +1,77 @@
+# A DFA walker that knows how to dump them to serialized strings.
+
+class DFASerializer
+
+    attr_accessor :dfa, :tokenNames
+    def initialize(dfa, tokenNames=nil)
+        @dfa = dfa
+        @tokenNames = tokenNames
+    end
+
+    def to_s
+        return nil if self.dfa.s0.nil? 
+        StringIO.open do |buf|
+            self.dfa.sortedStates().each do |s|
+                n = 0
+                if not s.edges.nil? 
+                    n = s.edges.length
+                end
+                for i in 0..(n-1) do 
+                    t = s.edges[i]
+                    if not t.nil? and t.stateNumber != 0x7FFFFFFF then
+                        buf.write(self.getStateString(s))
+                        label = self.getEdgeLabel(i)
+                        buf.write("-")
+                        buf.write(label)
+                        buf.write("->")
+                        buf.write(self.getStateString(t))
+                        buf.write("\n")
+                    end
+                end
+            end
+            output = buf.string()
+            if output.length == 0
+                return nil
+            else
+                return output
+            end
+        end
+    end
+
+    def getEdgeLabel(i)
+        return "EOF" if i==0
+        if not self.tokenNames.nil? then
+            return self.tokenNames[i-1]
+        else
+            return (i-1).to_s
+        end
+    end
+
+    def getStateString(s)
+#        s_acceptState = nil
+#        s_acceptState = ":" if s.isAcceptState 
+        s_requireContext = nil
+        s_requireContext = "^" if s.requiresFullContext 
+        baseStateStr = "s#{s.stateNumber}#{s_requireContext}"
+        if s.isAcceptState then
+            if not s.predicates.nil? then 
+                return ":#{baseStateStr}=>#{s.predicates}"
+            else
+                return ":#{baseStateStr}=>#{s.prediction}"
+            end
+        else
+            return baseStateStr
+        end
+    end
+end
+
+class LexerDFASerializer < DFASerializer
+
+    def initialize(dfa)
+        super(dfa, nil)
+    end
+
+    def getEdgeLabel(i)
+        return "'#{[i].pack('U')}'"
+    end
+end

data/lib/antlr4/dfa/DFAState.rb

@@ -0,0 +1,133 @@
+# Map a predicate to a predicted alternative.
+
+class PredPrediction
+    attr_accessor :pred, :alt
+    def initialize(pred, alt)
+        @alt = alt
+        @pred = pred
+    end
+
+    def to_s
+      "(#{self.pred}, #{self.alt})"
+    end
+end
+# A DFA state represents a set of possible ATN configurations.
+#  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+#  to keep track of all possible states the ATN can be in after
+#  reading each input symbol.  That is to say, after reading
+#  input a1a2..an, the DFA is in a state that represents the
+#  subset T of the states of the ATN that are reachable from the
+#  ATN's start state along some path labeled a1a2..an."
+#  In conventional NFA→DFA conversion, therefore, the subset T
+#  would be a bitset representing the set of states the
+#  ATN could be in.  We need to track the alt predicted by each
+#  state as well, however.  More importantly, we need to maintain
+#  a stack of states, tracking the closure operations as they
+#  jump from rule to rule, emulating rule invocations (method calls).
+#  I have to add a stack to simulate the proper lookahead sequences for
+#  the underlying LL grammar from which the ATN was derived.
+#
+#  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+#  is both a state (ala normal conversion) and a RuleContext describing
+#  the chain of rules (if any) followed to arrive at that state.</p>
+#
+#  <p>A DFA state may have multiple references to a particular state,
+#  but with different ATN contexts (with same or different alts)
+#  meaning that state was reached via a different set of rule invocations.</p>
+#/
+class DFAState
+    attr_accessor :stateNumber, :configs, :edges, :isAcceptState, :prediction
+    attr_accessor :lexerActionExecutor, :requiresFullContext, :predicates 
+    def initialize(state_number=nil, _configs=ATNConfigSet.new())
+        if state_number.nil? then
+          @stateNumber = -1
+        else
+          @stateNumber = state_number
+        end
+        self.configs = _configs
+        # {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+        #  {@link Token#EOF} maps to {@code edges[0]}.
+        self.edges = nil
+        self.isAcceptState = false
+        # if accept state, what ttype do we match or alt do we predict?
+        #  This is set to {@link ATN#INVALID_ALT_NUMBER} when {@link #predicates}{@code !=null} or
+        #  {@link #requiresFullContext}.
+        self.prediction = 0
+        self.lexerActionExecutor = nil
+        # Indicates that this state was created during SLL prediction that
+        # discovered a conflict between the configurations in the state. Future
+        # {@link ParserATNSimulator#execATN} invocations immediately jumped doing
+        # full context prediction if this field is true.
+        self.requiresFullContext = false
+        # During SLL parsing, this is a list of predicates associated with the
+        #  ATN configurations of the DFA state. When we have predicates,
+        #  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
+        #  on-the-fly. If this is not null, then {@link #prediction} is
+        #  {@link ATN#INVALID_ALT_NUMBER}.
+        #
+        #  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
+        #  means we know from the context (it's $ or we don't dip into outer
+        #  context) that it's an ambiguity not a conflict.</p>
+        #
+        #  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
+        self.predicates = nil
+    end
+
+    # Get the set of all alts mentioned by all ATN configurations in this
+    #  DFA state.
+    def getAltSet()
+        alts = Set.new
+        if not self.configs.nil?
+            for c in self.configs do
+                alts.add(c.alt)
+            end
+        end
+        if alts.empty?
+            return nil
+        else
+            return alts
+        end
+    end
+    def <=>(other)
+      self.configs <=> other.configs
+    end
+    def hash()
+        self.configs.hash
+    end
+    # Two {@link DFAState} instances are equal if their ATN configuration sets
+    # are the same. This method is used to see if a state already exists.
+    #
+    # <p>Because the number of alternatives and number of ATN configurations are
+    # finite, there is a finite number of DFA states that can be processed.
+    # This is necessary to show that the algorithm terminates.</p>
+    #
+    # <p>Cannot test the DFA state numbers here because in
+    # {@link ParserATNSimulator#addDFAState} we need to know if any other state
+    # exists that has this exact set of ATN configurations. The
+    # {@link #stateNumber} is irrelevant.</p>
+    def eql?(other)
+        self == other
+    end
+    def ==(other)
+      # compare set of ATN configurations in this set with other
+      return true if self.equal?(other)
+      other.kind_of?(DFAState) and self.configs==other.configs
+    end
+
+    def to_s
+        StringIO.open do |buf|
+            buf.write(self.stateNumber.to_s)
+            buf.write(":")
+            buf.write(self.configs.to_s ) 
+            if self.isAcceptState then
+                buf.write("=>")
+                if self.predicates then
+                    buf.write(self.predicates.to_s)
+                else
+                    buf.write(self.prediction.to_s)
+                end
+            end
+            return buf.string
+        end
+    end
+end

data/lib/antlr4/error.rb

@@ -0,0 +1,151 @@
+
+class UnsupportedOperationException < Exception
+end
+
+class IllegalStateException < Exception 
+end
+
+class CancellationException < IllegalStateException
+end
+
+# The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+#  3 kinds of errors: prediction errors, failed predicate errors, and
+#  mismatched input errors. In each case, the parser knows where it is
+#  in the input, where it is in the ATN, the rule invocation stack,
+#  and what kind of problem occurred.
+
+class RecognitionException < Exception
+
+    attr_accessor :recognizer, :input, :ctx, :offendingState, :offendingToken 
+    # used by subclassees
+    attr_accessor :deadEndConfigs, :startToken 
+    def initialize(message=nil, recognizer=nil, input=nil, ctx=nil)
+        super(message) 
+        @recognizer = recognizer
+        @input = input
+        @ctx = ctx
+        # The current {@link Token} when an error occurred. Since not all streams
+        # support accessing symbols by index, we have to track the {@link Token}
+        # instance itself.
+        @offendingToken = nil
+        # Get the ATN state number the parser was in at the time the error
+        # occurred. For {@link NoViableAltException} and
+        # {@link LexerNoViableAltException} exceptions, this is the
+        # {@link DecisionState} number. For others, it is the state whose outgoing
+        # edge we couldn't match.
+        @offendingState = -1
+        if recognizer then
+            @offendingState = recognizer.state
+        end
+    end
+
+    # <p>If the state number is not known, this method returns -1.</p>
+
+    #
+    # Gets the set of input symbols which could potentially follow the
+    # previously matched symbol at the time this exception was thrown.
+    #
+    # <p>If the set of expected tokens is not known and could not be computed,
+    # this method returns {@code null}.</p>
+    #
+    # @return The set of token types that could potentially follow the current
+    # state in the ATN, or {@code null} if the information is not available.
+    #/
+    def getExpectedTokens()
+        if self.recognizer then
+            @offendingState = recognizer.state
+            return self.recognizer.atn.getExpectedTokens(self.offendingState, self.ctx)
+        else
+            return nil
+        end
+    end
+end
+
+
+class LexerNoViableAltException < RecognitionException
+
+    attr_accessor :startIndex
+    def initialize(lexer, input, startIndex, deadEndConfigs)
+        super(nil, lexer, input, nil)
+        @startIndex = startIndex
+        @deadEndConfigs = deadEndConfigs
+    end
+
+    def to_s
+        symbol = nil
+        if self.startIndex >= 0 and self.startIndex < self.input.size() then
+            symbol = self.input.getText(self.startIndex, self.startIndex)
+            # TODO symbol = Utils.escapeWhitespace(symbol, false);
+        end
+        return "LexerNoViableAltException #{symbol}" 
+    end
+end
+# Indicates that the parser could not decide which of two or more paths
+#  to take based upon the remaining input. It tracks the starting token
+#  of the offending input and also knows where the parser was
+#  in the various paths when the error. Reported by reportNoViableAlternative()
+#
+class NoViableAltException < RecognitionException
+
+    def initialize(recognizer, input=nil, startToken=nil, offendingToken=nil, deadEndConfigs=nil, ctx=nil)
+        ctx = recognizer.ctx if ctx.nil?
+        offendingToken = recognizer.getCurrentToken() if offendingToken.nil?
+        startToken = recognizer.getCurrentToken() if startToken.nil?
+        input = recognizer.getInputStream() if input.nil?
+        super(nil,recognizer, input, ctx)
+        # Which configurations did we try at input.index() that couldn't match input.LT(1)?#
+        @deadEndConfigs = deadEndConfigs
+        # The token object at the start index; the input stream might
+        # 	not be buffering tokens so get a reference to it. (At the
+        #  time the error occurred, of course the stream needs to keep a
+        #  buffer all of the tokens but later we might not have access to those.)
+        @startToken = startToken
+        @offendingToken = offendingToken
+    end
+end
+# This signifies any kind of mismatched input exceptions such as
+#  when the current input does not match the expected token.
+#
+class InputMismatchException < RecognitionException
+
+    def initiailze(recognizer)
+        super(nil, recognizer, recognizer.getInputStream(), recognizer.ctx)
+        @offendingToken = recognizer.getCurrentToken()
+    end
+end
+
+# A semantic predicate failed during validation.  Validation of predicates
+#  occurs when normally parsing the alternative just like matching a token.
+#  Disambiguating predicate evaluation occurs when we test a predicate during
+#  prediction.
+
+class FailedPredicateException < RecognitionException
+
+    attr_accessor :ruleIndex,:predicateIndex, :predicate
+    def initialize(recognizer, predicate=nil, message=nil)
+        super(self.formatMessage(predicate,message), recognizer,
+                         recognizer.getInputStream(), recognizer.ctx)
+        s = recognizer.interp.atn.states[recognizer.state]
+        trans = s.transitions[0]
+        if trans.kind_of? PredicateTransition then
+            @ruleIndex = trans.ruleIndex
+            @predicateIndex = trans.predIndex
+        else
+            @ruleIndex = 0
+            @predicateIndex = 0
+        end
+        @predicate = predicate
+        @offendingToken = recognizer.getCurrentToken()
+    end
+
+    def formatMessage(predicate, message)
+        if message.nil?
+            "failed predicate: {" + predicate + "}?"
+        else
+            message
+        end
+    end
+end
+
+class ParseCancellationException < CancellationException
+end