antlr4-runtime 0.1.0

data/lib/antlr4/runtime/set_transition.rb

@@ -0,0 +1,29 @@
+module Antlr4::Runtime
+
+  class SetTransition < Transition
+    attr_reader :set
+
+    def initialize(target, set)
+      super(target)
+      set = IntervalSet.of(Token::INVALID_TYPE) if set.nil?
+
+      @set = set
+    end
+
+    def serialization_type
+      SET
+    end
+
+    def label
+      @set
+    end
+
+    def matches(symbol, _min_vocab_symbol, _max_vocab_symbol)
+      @set.contains(symbol)
+    end
+
+    def to_s
+      @set.to_s
+    end
+  end
+end

data/lib/antlr4/runtime/singleton_prediction_context.rb

@@ -0,0 +1,56 @@
+require 'antlr4/runtime/prediction_context'
+require 'antlr4/runtime/prediction_context_utils'
+
+module Antlr4::Runtime
+
+  class SingletonPredictionContext < PredictionContext
+    attr_accessor :parent
+    attr_accessor :return_state
+
+    def initialize(parent, return_state)
+      super(!parent.nil? ? PredictionContextUtils.calculate_hash_code1(parent, return_state) : PredictionContextUtils.calculate_empty_hash_code)
+      @parent = parent
+      @return_state = return_state
+    end
+
+    def get_parent(_i)
+      @parent
+    end
+
+    def size
+      1
+    end
+
+    def empty?
+      @return_state == EMPTY_RETURN_STATE
+    end
+
+    def get_return_state(_index)
+      @return_state
+    end
+
+    def equals(other)
+      if self == other
+        return true
+      elsif !(other.is_a? SingletonPredictionContext)
+        return false
+      end
+
+      if hash != other.hash
+        return false # can't be same if hash is different
+      end
+
+      @return_state == other.return_state && (!@parent.nil? && @parent.eql?(other.parent))
+    end
+
+    def to_s
+      up = !@parent.nil? ? @parent.to_s : ''
+      if up.empty?
+        return '$' if @return_state == EMPTY_RETURN_STATE
+
+        return @return_state.to_s
+      end
+      @return_state.to_s + ' ' + up
+    end
+  end
+end

data/lib/antlr4/runtime/star_block_start_state.rb

@@ -0,0 +1,12 @@
+module Antlr4::Runtime
+
+  class StarBlockStartState < BlockStartState
+    def initialize
+      super
+    end
+
+    def state_type
+      STAR_BLOCK_START
+    end
+  end
+end

data/lib/antlr4/runtime/star_loop_entry_state.rb

@@ -0,0 +1,17 @@
+module Antlr4::Runtime
+
+  class StarLoopEntryState < DecisionState
+    attr_accessor :loopback_state
+    attr_accessor :is_precedence_pecision
+
+    def initialize
+      super
+      @loopback_state = nil
+      @is_precedence_pecision = false
+    end
+
+    def state_type
+      STAR_LOOP_ENTRY
+    end
+  end
+end

data/lib/antlr4/runtime/star_loopback_state.rb

@@ -0,0 +1,16 @@
+module Antlr4::Runtime
+
+  class StarLoopbackState < ATNState
+    def initialize
+      super
+    end
+
+    def loop_entry_state
+      transition(0).target
+    end
+
+    def state_type
+      STAR_LOOP_BACK
+    end
+  end
+end

data/lib/antlr4/runtime/syntax_tree.rb

@@ -0,0 +1,6 @@
+require 'antlr4/runtime/tree'
+
+module Antlr4::Runtime
+  class SyntaxTree < Tree
+  end
+end

data/lib/antlr4/runtime/tag_chunk.rb

@@ -0,0 +1,22 @@
+module Antlr4::Runtime
+
+  class TagChunk < Chunk
+    attr_reader :tag
+    attr_reader :label
+
+    def initialize(label, tag)
+      if tag.nil? || tag.empty?
+        raise IllegalArgumentException, 'tag cannot be nil or empty'
+      end
+
+      @label = label
+      @tag = tag
+    end
+
+    def to_s
+      return @label + ':' + @tag unless @label.nil?
+
+      @tag
+    end
+  end
+end

data/lib/antlr4/runtime/terminal_node.rb

@@ -0,0 +1,5 @@
+module Antlr4::Runtime
+
+  class TerminalNode < ParseTree
+  end
+end

data/lib/antlr4/runtime/terminal_node_impl.rb

@@ -0,0 +1,50 @@
+require 'antlr4/runtime/terminal_node'
+
+module Antlr4::Runtime
+
+  class TerminalNodeImpl < TerminalNode
+    attr_accessor :symbol
+    attr_accessor :parent
+
+    def initialize(symbol)
+      @symbol = symbol
+    end
+
+    def child(_i)
+      nil
+    end
+
+    def payload
+      @symbol
+    end
+
+    def source_interval
+      return Interval.invalid if @symbol.nil?
+
+      token_index = @symbol.token_index
+      Interval.new(token_index, token_index)
+    end
+
+    def child_count
+      0
+    end
+
+    def accept(visitor)
+      visitor.visit_terminal(self)
+    end
+
+    def text
+      @symbol.text
+    end
+
+    def to_string_tree(_parser = nil)
+      to_s
+    end
+
+    def to_s
+      return '<EOF>' if @symbol.type == Token::EOF
+
+      @symbol.text
+    end
+  end
+end

data/lib/antlr4/runtime/text_chunk.rb

@@ -0,0 +1,16 @@
+module Antlr4::Runtime
+
+  class TextChunk < Chunk
+    attr_reader :text
+
+    def initialize(text)
+      raise IllegalArgumentException, 'text cannot be null' if text.nil?
+
+      @text = text
+    end
+
+    def to_s
+      "'" + @text + "'"
+    end
+  end
+end

data/lib/antlr4/runtime/token.rb

@@ -0,0 +1,13 @@
+require 'antlr4/runtime/int_stream'
+module Antlr4::Runtime
+
+  class Token
+    INVALID_TYPE = 0
+    EPSILON = -2
+    MIN_USER_TOKEN_TYPE = 1
+    EOF = IntStream::EOF
+    DEFAULT_CHANNEL = 0
+    HIDDEN_CHANNEL = 1
+    MIN_USER_CHANNEL_VALUE = 2
+  end
+end

data/lib/antlr4/runtime/token_stream.rb

@@ -0,0 +1,13 @@
+module Antlr4::Runtime
+
+  class TokenStream < IntStream
+    def lt(k)
+    end
+
+    def get(index)
+    end
+
+    def token_source
+    end
+  end
+end

data/lib/antlr4/runtime/token_tag_token.rb

@@ -0,0 +1,22 @@
+module Antlr4::Runtime
+  class TokenTagToken < CommonToken
+    attr_reader :token_name
+    attr_reader :label
+
+    def initialize(token_name, type, label = nil)
+      super(type)
+      @token_name = token_name
+      @label = label
+    end
+
+    def text
+      return '<' + @label + ':' + @token_name + '>' unless @label.nil?
+
+      '<' + @token_name + '>'
+    end
+
+    def to_s
+      @token_name + ':' + @type
+    end
+  end
+end

data/lib/antlr4/runtime/tokens_start_state.rb

@@ -0,0 +1,14 @@
+require 'antlr4/runtime/decision_state'
+
+module Antlr4::Runtime
+
+  class TokensStartState < DecisionState
+    def initialize
+      super
+    end
+
+    def state_type
+      TOKEN_START
+    end
+  end
+end

data/lib/antlr4/runtime/transition.rb

@@ -0,0 +1,51 @@
+module Antlr4::Runtime
+  class Transition
+    EPSILON = 1
+    RANGE = 2
+    RULE = 3
+    PREDICATE = 4
+    ATOM = 5
+    ACTION = 6
+    SET = 7
+    NOT_SET = 8
+    WILDCARD = 9
+    PRECEDENCE = 10
+
+    class << self
+
+      @@serialization_names = %w[INVALID EPSILON RANGE RULE PREDICATE ATOM ACTION SET NOT_SET WILDCARD PRECEDENCE]
+
+      @@serialization_types = {}
+
+      @@serialization_types[:EpsilonTransition] = EPSILON
+      @@serialization_types[:RangeTransition] = RANGE
+      @@serialization_types[:RuleTransition] = RULE
+      @@serialization_types[:PredicateTransition] = PREDICATE
+      @@serialization_types[:AtomTransition] = ATOM
+      @@serialization_types[:ActionTransition] = ACTION
+      @@serialization_types[:SetTransition] = SET
+      @@serialization_types[:NotSetTransition] = NOT_SET
+      @@serialization_types[:WildcardTransition] = WILDCARD
+      @@serialization_types[:PrecedencePredicateTransition] = PRECEDENCE
+    end
+
+    attr_accessor :target
+
+    def initialize(target)
+      raise 'target cannot be null.' if target.nil?
+
+      @target = target
+    end
+
+    def epsilon?
+      false
+    end
+
+    def label
+      nil
+    end
+
+    def matches(symbol, min_vocab_symbol, max_vocab_symbol)
+    end
+  end
+end

data/lib/antlr4/runtime/tree.rb

@@ -0,0 +1,4 @@
+module Antlr4::Runtime
+  class Tree
+  end
+end

data/lib/antlr4/runtime/trees.rb

@@ -0,0 +1,195 @@
+module Antlr4::Runtime
+  class Trees
+    def self.to_s_tree_recog(t, recog = nil)
+      rule_names = !recog.nil? ? recog.rule_names : nil
+      rule_names_list = !rule_names.nil? ? rule_names : nil
+      to_s_tree_rulenames(t, rule_names_list)
+    end
+
+    def self.to_s_tree_rulenames(t, rule_names)
+      s = Utils.escape_whitespace(getNodeText(t, rule_names), false)
+      return s if t.child_count == 0
+
+      buf = ''
+      buf << '('
+      s = Utils.escape_whitespace(getNodeText(t, rule_names), false)
+      buf << s
+      buf << ' '
+      i = 0
+      while i < t.child_count
+        buf << ' ' if i > 0
+        buf << to_string_tree(t.child(i), rule_names)
+        i += 1
+      end
+      buf << ')'
+      buf
+    end
+
+    def self.node_text_recog(t, recog)
+      rule_names = !recog.nil? ? recog.rule_names : nil
+      rule_names_list = !rule_names.nil? ? rule_names : nil
+      getNodeText(t, rule_names_list)
+    end
+
+    def self.node_text_rulenames(t, rule_names)
+      unless rule_names.nil?
+        if t.is_a? RuleContext
+          rule_index = t.rule_context.rule_index
+          rule_name = rule_names[rule_index]
+          alt_number = t.alt_number
+          if alt_number != ATN::INVALID_ALT_NUMBER
+            return rule_name + ':' + alt_number
+          end
+
+          return rule_name
+        elsif t.is_a? ErrorNode
+          return t.to_s
+        elsif t.is_a? TerminalNode
+          symbol = t.getSymbol
+          unless symbol.nil?
+            s = symbol.text
+            return s
+          end
+        end
+      end
+      # no recog for rule names
+      payload = t.payload
+      return payload.text if payload.is_a Token
+
+      t.payload.to_s
+    end
+
+    def self.children(t)
+      kids = []
+      i = 0
+      while i < t.child_count
+        kids << t.child(i)
+        i += 1
+      end
+
+      kids
+    end
+
+    def self.ancestors(t)
+      return [] if t.get_parent.nil?
+
+      ancestors = []
+      t = t.get_parent
+      until t.nil?
+        ancestors.unshift(t) # insert at start
+        t = t.get_parent
+      end
+      ancestors
+    end
+
+    def self.ancestor_of?(t, u)
+      return false if t.nil? || u.nil? || t.get_parent.nil?
+
+      p = u.get_parent
+      until p.nil?
+        return true if t == p
+
+        p = p.get_parent
+      end
+      false
+    end
+
+    def self.find_all_token_nodes(t, ttype)
+      find_all_nodes(t, ttype, true)
+    end
+
+    def self.find_all_rule_nodes(t, rule_index)
+      find_all_nodes(t, rule_index, false)
+    end
+
+    def self.find_all_nodes(t, index, find_tokens)
+      nodes = []
+      _find_all_nodes(t, index, find_tokens, nodes)
+      nodes
+    end
+
+    def self._find_all_nodes(t, index, find_tokens, nodes)
+      # check this node (the root) first
+      if find_tokens && t.is_a?(TerminalNode)
+        tnode = t
+        nodes.add(t) if tnode.getSymbol.type == index
+      elsif !find_tokens && t.is_a(ParserRuleContext)
+        ctx = t
+        nodes.push(t) if ctx.rule_index == index
+      end
+      # check children
+      i = 0
+      while i < t.child_count
+        _find_all_nodes(t.child(i), index, find_tokens, nodes)
+        i += 1
+      end
+    end
+
+    def self.descendants(t)
+      nodes = []
+      nodes.push(t)
+
+      n = t.child_count
+      i = 0
+      while i < n
+        nodes.add_all(descendants(t.child(i)))
+        i += 1
+      end
+      nodes
+    end
+
+    def self.root_of_subtree_enclosing_region(t, start_token_index, stop_token_index)
+      n = t.child_count
+      i = 0
+      while i < n
+        ParseTree child = t.child(i)
+        ParserRuleContext r = root_of_subtree_enclosing_region(child, start_token_index, stop_token_index)
+        return r unless r.nil?
+
+        i += 1
+      end
+      if t.is_a? ParserRuleContext
+        r = t
+        if start_token_index >= r.getStart.token_index && # is range fully contained in t?
+            (r.getStop.nil? || stop_token_index <= r.getStop.token_index)
+
+          # note: r.getStop()==nil likely implies that we bailed out of parser and there's nothing to the right
+          return r
+        end
+      end
+      nil
+    end
+
+    def self.strip_children_out_of_range(t, root, start_index, stop_index)
+      return if t.nil?
+
+      i = 0
+      while i < t.child_count
+        child = t.child(i)
+        range = child.source_interval
+        next unless child.is_a? ParserRuleContext && (range.b < start_index || range.a > stop_index)
+
+        if ancestor_of?(child, root) # replace only if subtree doesn't have displayed root
+          abbrev = CommonToken.new(Token::INVALID_TYPE)
+          t.children.set(i, TerminalNodeImpl.new(abbrev))
+        end
+      end
+    end
+
+    def self.find_node_such_that(t, pred)
+      return t if pred.test(t)
+
+      return nil if t.nil?
+
+      n = t.child_count
+      i = 0
+      while i < n
+        u = find_node_such_that(t.child(i), pred)
+        return u unless u.nil?
+
+        i += 1
+      end
+      nil
+    end
+  end
+end