antlr4 0.9.2

data/lib/antlr4/atn/SemanticContext.rb

@@ -0,0 +1,355 @@
+# A tree structure used to record the semantic context in which
+#  an ATN configuration is valid.  It's either a single predicate,
+#  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+#
+#  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+#  {@link SemanticContext} within the scope of this outer class.</p>
+
+class SemanticContext
+    # The default {@link SemanticContext}, which is semantically equivalent to
+    # a predicate of the form {@code {true}?}.
+    @@NONE = nil
+    def self.NONE
+      @@NONE = SemanticContext.new if @@NONE.nil?  
+      @@NONE
+    end
+    attr_accessor :opnds
+    # For context independent predicates, we evaluate them without a local
+    # context (i.e., null context). That way, we can evaluate them without
+    # having to create proper rule-specific context during prediction (as
+    # opposed to the parser, which creates them naturally). In a practical
+    # sense, this avoids a cast exception from RuleContext to myruleContext.
+    #
+    # <p>For context dependent predicates, we must pass in a local context so that
+    # references such as $arg evaluate properly as _localctx.arg. We only
+    # capture context dependent predicates in the context in which we begin
+    # prediction, so we passed in the outer context here in case of context
+    # dependent predicate evaluation.</p>
+    #
+    def eval(parser, outerContext)
+    end
+    #
+    # Evaluate the precedence predicates for the context and reduce the result.
+    #
+    # @param parser The parser instance.
+    # @param outerContext The current parser context object.
+    # @return The simplified semantic context after precedence predicates are
+    # evaluated, which will be one of the following values.
+    # <ul>
+    # <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code null}: if the predicate simplifies to {@code false} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code this}: if the semantic context is not changed as a result of
+    # precedence predicate evaluation.</li>
+    # <li>A non-{@code null} {@link SemanticContext}: the new simplified
+    # semantic context after precedence predicates are evaluated.</li>
+    # </ul>
+    #
+    def evalPrecedence(parser, outerContext)
+        return self
+    end
+
+    def simplify
+        if self.opnds.length == 1 then
+          self.opnds.first 
+        else
+          self
+        end
+    end
+
+    def andContext(b)
+        SemanticContext.andContext(self, b)
+    end
+    def self.andContext(a, b)
+      return b if a.nil? or a.equal? SemanticContext.NONE
+      return a if b.nil? or b.equal? SemanticContext.NONE
+      result = AND.new(a, b)
+      return result.simplify
+    end
+    def orContext(b)
+        SemanticContext.orContext(self, b)
+    end
+    def self.orContext(a, b)
+        return b if a.nil? 
+        return a if b.nil? 
+        if a.equal? SemanticContext.NONE or b.equal? SemanticContext.NONE
+            return SemanticContext.NONE
+        end
+        result = OR.new(a, b)
+        return result.simplify
+    end
+    def  filterPrecedencePredicates(collection)
+        self.class.filterPrecedencePredicates(collection)
+    end
+    def self.filterPrecedencePredicates(collection)
+        collection.map {|context|
+            if context.kind_of? PrecedencePredicate then
+               context
+            end
+        }.compact
+    end
+end
+
+class Predicate < SemanticContext
+
+    attr_accessor :ruleIndex, :predIndex, :isCtxDependent 
+    def initialize(rule_index=-1, pred_index=-1, is_ctx_dependent=false)
+        self.ruleIndex = rule_index
+        self.predIndex = pred_index
+        self.isCtxDependent = is_ctx_dependent # e.g., $i ref in pred
+    end
+
+    def eval(parser, outerContext)
+        #localctx = outerContext if self.isCtxDependent else None
+        if self.isCtxDependent 
+          localctx = outerContext 
+        else 
+          localctx = nil
+        end
+        return parser.sempred(localctx, self.ruleIndex, self.predIndex)
+    end
+    def hash
+        StringIO.open  do |buf|
+            buf.write(self.ruleIndex.to_s)
+            buf.write("/")
+            buf.write(self.predIndex.to_s)
+            buf.write("/")
+            buf.write(self.isCtxDependent.to_s)
+            return buf.string().hash 
+        end
+    end
+    def eql?(other)
+      self == other
+    end
+    def ==(other)
+        self.equal?(other)or other.kind_of?(Predicate) and \
+              self.ruleIndex == other.ruleIndex and \
+               self.predIndex == other.predIndex and \
+               self.isCtxDependent == other.isCtxDependent
+    end
+    def to_s
+      "{#{self.ruleIndex}:#{self.predIndex}}?"
+    end
+end
+
+class PrecedencePredicate < SemanticContext
+
+    attr_accessor :precedence 
+    def initialize(_precedence=0)
+        self.precedence = _precedence
+    end
+
+    def eval(parser, outer_context)
+        return parser.precpred(outer_context, self.precedence)
+    end
+
+    def evalPrecedence(parser, outer_context)
+        if parser.precpred(outer_context, self.precedence)
+            return SemanticContext.NONE
+        else
+            return nil
+        end
+    end
+    def <=>(other)
+        return self.precedence - other.precedence
+    end
+
+    def hash
+        return 31
+    end
+
+    def eql?(other)
+        self == other
+    end
+    def ==(other)
+        self.equal?(other) or (other.kind_of?(PrecedencePredicate) and self.precedence == other.precedence )
+    end
+end
+# A semantic context which is true whenever none of the contained contexts
+# is false.
+#
+class AND < SemanticContext
+
+    def initialize(a, b)
+        operands = Set.new()
+        if a.kind_of? AND then
+            a.opnds.each {|o| operands.add(o) }
+        else
+            operands.add(a)
+        end
+        if b.kind_of? AND then
+            b.opnds.each {|o| operands.add(o) }
+        else
+            operands.add(b)
+        end
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if precedencePredicates.length>0 then
+            # interested in the transition with the lowest precedence
+            reduced = precedencePredicates.min
+            operands.add(reduced)
+        end
+        @opnds = operands.to_a
+    end
+
+    def eql?(other)
+      self == other
+    end
+    def ==(other)
+        self.equal?(other) or \
+        ( other.kind_of?(AND) and self.opnds == other.opnds )
+    end
+    
+    def hash 
+       "#{self.opnds}/AND".hash
+    end
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(parser, outerContext)
+        self.opnds.each {|opnd|
+            if not opnd.eval(parser, outerContext)
+                return false
+            end
+        }
+        return true
+    end
+
+    def evalPrecedence(parser, outerContext)
+        differs = false
+        operands = Array.new
+        self.opnds.each {|context|
+            evaluated = context.evalPrecedence(parser, outerContext)
+            if evaluated.equal? context then
+                differs = false
+            else
+                differs = true
+            end
+#            differs = differs || (! (evaluated.equal? context))
+            # The AND context is false if any element is false
+            return nil if evaluated.nil? 
+            if evaluated.equal? SemanticContext.NONE
+                # Reduce the result by skipping true elements
+                operands.push(evaluated)
+            end
+        }
+        if not differs
+            return self
+        end
+
+        if operands.length()==0
+            # all elements were true, so the AND context is true
+            return SemanticContext.NONE
+        end
+
+        result = nil
+        operands.each {|o| 
+            if result.nil? 
+                result = o 
+            else 
+              result = result.andContext(o)
+            end
+        }
+        return result
+    end
+    def  to_s
+        self.opnds.map(&:to_s).join("&&") 
+    end
+end
+#
+# A semantic context which is true whenever at least one of the contained
+# contexts is true.
+#
+class OR < SemanticContext
+
+    def initialize(a, b)
+        operands = Set.new()
+        if a.kind_of? OR then
+            a.opnds.each {|o| operands.add(o) }
+        else
+            operands.add(a)
+        end
+        if b.kind_of? OR then
+            b.opnds.each {|o| operands.add(o) }
+        else
+            operands.add(b)
+        end
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if precedencePredicates.length() > 0 then
+            # interested in the transition with the highest precedence
+            s = precedencePredicates.sort()
+            reduced = s[-1]
+            operands.add(reduced)
+        end
+        self.opnds = operands.to_a
+    end
+
+    def eql?(other)
+        self == other
+    end
+    def ==(other)
+        self.equal?(other) or other.kind_of?(OR) and self.opnds == other.opnds
+    end
+    def hash
+        "#{self.opnds}/OR".hash
+    end
+
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(parser, outerContext)
+      
+        self.opnds.each {|opnd|
+            if opnd.eval(parser, outerContext)
+                return true
+            end
+        }
+        return false
+    end
+
+    def evalPrecedence(parser, outerContext)
+        differs = false
+        operands = Array.new
+        operands = self.opnds.map {|context|
+            evaluated = context.evalPrecedence(parser, outerContext)
+            if evaluated.equal? context then
+                differs = false
+            else
+                differs = true
+            end
+            #differs = differs || not (evaluated.equal? context)
+            # The OR context is true if any element is true
+            return SemanticContext.NONE if evaluate.equal? SemanticContext.NONE
+            if not evaluated.nil? then 
+                # Reduce the result by skipping false elements
+                evaluated
+            end
+        }.compact
+        return self unless differs
+
+        if operands.empty?
+            # all elements were false, so the OR context is false
+            return nil
+        end
+
+        result = nil
+        operands.each {|o| 
+            if result.nil? 
+                result = o 
+            else 
+              result = result.orContext(o)
+            end
+        }
+        return result
+    end
+    def to_s
+        self.opnds.map(&:to_s).join("||")
+    end
+end
+# SemanticContext.NONE = Predicate()

data/lib/antlr4/atn/Transition.rb

@@ -0,0 +1,297 @@
+#  An ATN transition between any two ATN states.  Subclasses define
+#  atom, set, epsilon, action, predicate, rule transitions.
+#
+#  <p>This is a one way link.  It emanates from a state (usually via a list of
+#  transitions) and has a target state.</p>
+#
+#  <p>Since we never have to change the ATN transitions once we construct it,
+#  we can fix these transitions as specific classes. The DFA transitions
+#  on the other hand need to update the labels as it adds transitions to
+#  the states. We'll use the term Edge for the DFA to distinguish them from
+#  ATN transitions.</p>
+
+class Transition 
+    # constants for serialization
+    EPSILON			= 1
+    RANGE			= 2
+    RULE			= 3
+    PREDICATE		= 4 # e.g., {isType(input.LT(1))}?
+    ATOM			= 5
+    ACTION			= 6
+    SET				= 7 # ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET			= 8
+    WILDCARD		= 9
+    PRECEDENCE		= 10
+
+    @@serializationNames = [
+            "INVALID",
+            "EPSILON",
+            "RANGE",
+            "RULE",
+            "PREDICATE",
+            "ATOM",
+            "ACTION",
+            "SET",
+            "NOT_SET",
+            "WILDCARD",
+            "PRECEDENCE"
+        ]
+    def self.serializationNames 
+      @@serializationNames 
+    end
+
+    @@serializationTypes = nil
+    def self.serializationTypes 
+      @@serializationTypes 
+    end
+    def self.serializationTypes=(newhash)
+        @@serializationTypes = newhash
+    end
+
+    attr_accessor :target, :isEpsilon, :serializationType, :ruleIndex
+    def initialize(target)
+        # The target of this transition.
+        raise Exception.new("target cannot be null.") if target.nil?
+        self.target = target
+        # Are we epsilon, action, sempred?
+        self.isEpsilon = false
+        @ruleIndex = 0
+    end
+    def label
+        nil
+    end
+end
+
+
+# TODO: make all transitions sets? no, should remove set edges
+class AtomTransition < Transition
+
+    attr_accessor :label_
+    def initialize(_target, _label)
+        super(_target)
+        @label_ = _label # The token type or character value; or, signifies special label.
+        @serializationType = Transition::ATOM
+    end
+
+    def label
+        s = IntervalSet.new()
+        s.addOne(self.label_)
+        return s
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        return self.label_ == symbol
+    end
+
+    def to_s
+        return self.label_.to_s
+    end
+end
+class RuleTransition < Transition
+
+    attr_accessor :ruleIndex, :precedence, :followState
+    def initialize(rule_start, rule_index, _precedence, follow_state)
+        super(rule_start)
+        self.ruleIndex = rule_index # ptr to the rule definition object for this rule ref
+        self.precedence = _precedence
+        self.followState = follow_state # what node to begin computations following ref to rule
+        @serializationType = Transition::RULE
+        @isEpsilon = true
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        return false
+    end
+end
+
+
+class EpsilonTransition < Transition
+
+    def initialize(_target)
+        super(_target)
+        self.serializationType = Transition::EPSILON
+        self.isEpsilon = true
+    end
+
+    def matches(symbol, minVocabSymbol,  maxVocabSymbol)
+        return false
+    end
+
+    def to_s
+        return "epsilon"
+    end
+end
+
+class RangeTransition < Transition
+
+    attr_accessor :start, :stop
+    def initialize(_target, _start, _stop)
+        super(_target)
+        self.serializationType = Transition::RANGE
+        self.start = _start
+        self.stop = _stop
+    end
+
+    def label()
+        s = IntervalSet.new()
+        s.addRange(self.start..self.stop)
+        return s
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        symbol >= self.start and symbol <= self.stop
+    end
+
+    def to_s
+        return "'#{self.start.chr}'..'#{self.stop.chr}'"
+    end
+end
+
+class AbstractPredicateTransition < Transition
+
+    def initialize(_target)
+        super(_target)
+    end
+
+end
+
+class PredicateTransition < AbstractPredicateTransition
+
+    attr_accessor :ruleIndex, :predIndex, :isCtxDependent 
+    def initialize(_target, rule_index, pred_index, is_ctx_dependent)
+        super(_target)
+        self.serializationType = Transition::PREDICATE
+        self.ruleIndex = rule_index
+        self.predIndex = pred_index
+        self.isCtxDependent = is_ctx_dependent # e.g., $i ref in pred
+        self.isEpsilon = true
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        return false
+    end
+
+    def getPredicate()
+        return Predicate.new(self.ruleIndex, self.predIndex, self.isCtxDependent)
+    end
+
+    def to_s
+        return "pred_#{self.ruleIndex}:#{self.predIndex}"
+    end
+end
+
+class ActionTransition < Transition
+
+    
+    attr_accessor :ruleIndex, :actionIndex, :isCtxDependent 
+    def initialize(_target, rule_index, action_index=-1, is_ctx_dependent=false)
+        super(_target)
+        self.serializationType = Transition::ACTION
+        self.ruleIndex = rule_index
+        self.actionIndex = action_index
+        self.isCtxDependent = is_ctx_dependent # e.g., $i ref in pred
+        self.isEpsilon = true
+    end
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        return false
+    end
+
+    def to_s
+        return "action_#{self.ruleIndex}:#{self.actionIndex}"
+    end
+end
+# A transition containing a set of values.
+class SetTransition < Transition
+
+    attr_accessor :set
+    def initialize(_target, _set)
+        super(_target)
+        self.serializationType = Transition::SET
+        if _set then
+           @set = _set
+        else
+            @set = IntervalSet.of(Token::INVALID_TYPE)
+        end
+    end
+    def label
+        self.set
+    end
+    def matches(symbol, minVocabSymbol,  maxVocabSymbol)
+        self.set.member? symbol
+    end
+
+    def to_s
+        self.set.to_s
+    end
+end
+
+class NotSetTransition < SetTransition
+
+    def initialize(_target, _set)
+        super(_target, _set)
+        self.serializationType = Transition::NOT_SET
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        symbol >= minVocabSymbol \
+            and symbol <= maxVocabSymbol \
+            and not (self.set.member? symbol)
+    end
+
+    def to_s
+        return '~' + super()
+    end
+end
+
+class WildcardTransition < Transition
+
+    def initialize(_target)
+        super(_target)
+        self.serializationType = Transition::WILDCARD
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        symbol >= minVocabSymbol and symbol <= maxVocabSymbol
+    end
+
+    def to_s
+        return "."
+    end
+end
+
+class PrecedencePredicateTransition < AbstractPredicateTransition
+
+    attr_accessor :precedence 
+    def initialize(_target, precedence)
+        super(_target)
+        self.serializationType = Transition::PRECEDENCE
+        self.precedence = precedence
+        self.isEpsilon = true
+    end
+
+    def matches( symbol, minVocabSymbol,  maxVocabSymbol)
+        return false
+    end
+
+
+    def getPredicate()
+        return PrecedencePredicate.new(self.precedence)
+    end
+
+    def to_s
+        return "#{self.precedence} >= _p"
+    end
+end
+
+Transition.serializationTypes = {
+             EpsilonTransition => Transition::EPSILON,
+             RangeTransition => Transition::RANGE,
+             RuleTransition => Transition::RULE,
+             PredicateTransition => Transition::PREDICATE,
+             AtomTransition => Transition::ATOM,
+             ActionTransition => Transition::ACTION,
+             SetTransition => Transition::SET,
+             NotSetTransition => Transition::NOT_SET,
+             WildcardTransition => Transition::WILDCARD,
+             PrecedencePredicateTransition => Transition::PRECEDENCE
+}