antlr4-runtime 0.1.0

data/lib/antlr4/runtime/rule_context.rb

@@ -0,0 +1,131 @@
+require 'antlr4/runtime/rule_node'
+
+module Antlr4::Runtime
+
+  class RuleContext < RuleNode
+    attr_accessor :parent
+    attr_accessor :invoking_state
+
+    def initialize(parent = nil, invoking_state = nil)
+      @invoking_state = -1
+      @parent = parent
+      @invoking_state = invoking_state
+    end
+
+    def depth
+      n = 0
+      p = self
+      until p.nil?
+        p = p.parent
+        n += 1
+      end
+      n
+    end
+
+    def empty?
+      @invoking_state == -1
+    end
+
+    # satisfy the ParseTree / SyntaxTree interface
+
+    def source_interval
+      Interval.invalid
+    end
+
+    def rule_context
+      self
+    end
+
+    def payload
+      self
+    end
+
+    def set_alt_number(_num)
+    end
+
+    def text
+      return '' if child_count == 0
+
+      builder = ''
+      i = 0
+      while i < child_count
+        builder << child_at(i).text
+        i += 1
+      end
+
+      builder.to_s
+    end
+
+    def rule_index
+      -1
+    end
+
+    def alt_number
+      ATN::INVALID_ALT_NUMBER
+    end
+
+    def child(_i)
+      nil
+    end
+
+    def child_count
+      0
+    end
+
+    def accept(visitor)
+      visitor.visit_children(self)
+    end
+
+    def to_string_tree_recog(recog)
+      Trees.to_sTree(self, recog)
+    end
+
+    def to_string_tree_rulenames(rule_names)
+      Trees.to_sTree(self, rule_names)
+    end
+
+    def to_string_tree
+      to_string_tree_rulenames(nil)
+    end
+
+    def to_s
+      to_s_recog_ctx(nil, nil)
+    end
+
+    def to_s_recog(recog)
+      to_s_recog_ctx(recog, ParserRuleContext::EMPTY)
+    end
+
+    def to_s_list(rule_names)
+      to_s_list_ctx(rule_names, nil)
+    end
+
+    def to_s_recog_ctx(recog, stop)
+      rule_names = !recog.nil? ? recog.rule_names : nil
+      rule_names_list = !rule_names.nil? ? rule_names : nil
+      to_s_list_ctx(rule_names_list, stop)
+    end
+
+    def to_s_list_ctx(rule_names, stop)
+      buf = ''
+      p = self
+      buf << '['
+      while !p.nil? && p != stop
+        if rule_names.nil?
+          buf << p.invoking_state unless p.empty?
+        else
+          rule_index = p.rule_index
+          rule_name = rule_index >= 0 && rule_index < rule_names.size ? rule_names[rule_index] : rule_index
+          buf << rule_name.to_s
+        end
+
+        buf << ' ' if !p.parent.nil? && (!rule_names.nil? || !p.parent.empty?)
+
+        p = p.parent
+      end
+
+      buf << ']'
+      buf
+    end
+  end
+end

data/lib/antlr4/runtime/rule_context_with_alt_num.rb

@@ -0,0 +1,11 @@
+module Antlr4::Runtime
+
+  class RuleContextWithAltNum < ParserRuleContext
+    attr_accessor :alt_num
+
+    def initialize(parent = nil, invoking_state_number = nil)
+      super(parent, invoking_state_number)
+      @alt_num = ATN::INVALID_ALT_NUMBER
+    end
+  end
+end

data/lib/antlr4/runtime/rule_node.rb

@@ -0,0 +1,8 @@
+require 'antlr4/runtime/parse_tree'
+
+module Antlr4::Runtime
+  class RuleNode < ParseTree
+    def rule_context
+    end
+  end
+end

data/lib/antlr4/runtime/rule_start_state.rb

@@ -0,0 +1,17 @@
+module Antlr4::Runtime
+
+  class RuleStartState < ATNState
+    attr_accessor :stop_state
+    attr_accessor :is_left_recursive_rule
+
+    def initialize
+      super
+      @is_left_recursive_rule = false
+      @stop_state = nil
+    end
+
+    def state_type
+      RULE_START
+    end
+  end
+end

data/lib/antlr4/runtime/rule_stop_state.rb

@@ -0,0 +1,12 @@
+module Antlr4::Runtime
+
+  class RuleStopState < ATNState
+    def initialize
+      super
+    end
+
+    def state_type
+      RULE_STOP
+    end
+  end
+end

data/lib/antlr4/runtime/rule_tag_token.rb

@@ -0,0 +1,64 @@
+module Antlr4::Runtime
+
+  class RuleTagToken < Token
+    attr_reader :rule_name
+    attr_reader :bypass_token_type
+    attr_reader :label
+
+    def initialize(rule_name, bypass_token_type, label = nil)
+      if rule_name.nil? || rule_name.empty?
+        raise IllegalArgumentException, 'rule_name cannot be nil or empty.'
+      end
+
+      @rule_name = rule_name
+      @bypass_token_type = bypass_token_type
+      @label = label
+    end
+
+    def channel
+      DEFAULT_CHANNEL
+    end
+
+    def text
+      return '<' + @label + ':' + @rule_name + '>' unless @label.nil?
+
+      '<' + @rule_name + '>'
+    end
+
+    def type
+      @bypass_token_type
+    end
+
+    def line
+      0
+    end
+
+    def char_position_in_line
+      -1
+    end
+
+    def token_index
+      -1
+    end
+
+    def start_index
+      -1
+    end
+
+    def stop_index
+      -1
+    end
+
+    def token_source
+      nil
+    end
+
+    def input_stream
+      nil
+    end
+
+    def to_s
+      @rule_name + ':' + @bypass_token_type
+    end
+  end
+end

data/lib/antlr4/runtime/rule_transition.rb

@@ -0,0 +1,29 @@
+module Antlr4::Runtime
+
+  class RuleTransition < Transition
+    attr_reader :rule_index # no Rule object at runtime
+
+    attr_reader :precedence
+
+    attr_reader :follow_state
+
+    def initialize(rule_start, rule_index, precedence, follow_state)
+      super(rule_start)
+      @rule_index = rule_index
+      @precedence = precedence
+      @follow_state = follow_state
+    end
+
+    def serialization_type
+      RULE
+    end
+
+    def epsilon?
+      true
+    end
+
+    def matches(_symbol, _min_vocab_symbol, _max_vocab_symbol)
+      false
+    end
+  end
+end

data/lib/antlr4/runtime/semantic_context.rb

@@ -0,0 +1,313 @@
+module Antlr4::Runtime
+  class SemanticContext
+    def eval(parser, parser_call_stack)
+    end
+
+    def eval_precedence(_parser, _parser_call_stack)
+      self
+    end
+
+    class Predicate < SemanticContext
+      attr_accessor :rule_index
+      attr_accessor :pred_index
+      attr_accessor :is_ctx_dependent # e.g., $i ref in pred
+
+      def initialize(rule_index = -1, pred_index = -1, is_ctx_dependent = false)
+        @rule_index = rule_index
+        @pred_index = pred_index
+        @is_ctx_dependent = is_ctx_dependent
+      end
+
+      def eval(parser, parser_call_stack)
+        localctx = @is_ctx_dependent ? parser_call_stack : nil
+        parser.sempred(localctx, @rule_index, @pred_index)
+      end
+
+      def hash
+        return @_hash unless @_hash.nil?
+
+        hash_code = MurmurHash.hash_ints([@rule_index, @pred_index, @is_ctx_dependent ? 1 : 0])
+
+        if !@_hash.nil?
+          if hash_code == @_hash
+            puts 'Same hash_code for SemanticContext'
+          else
+            puts 'Different hash_code for SemanticContext'
+          end
+        end
+        @_hash = hash_code
+      end
+
+      def eql?(other)
+        return false unless other.is_a? Predicate
+        return true if self == other
+
+        @rule_index == other.rule_index && @pred_index == other.pred_index && @is_ctx_dependent == other.is_ctx_dependent
+      end
+
+      def to_s
+        '' + @rule_index + ':' + @pred_index + 'end?'
+      end
+    end
+
+    class PrecedencePredicate < SemanticContext
+      attr_accessor :precedence
+
+      def initialize(precedence = 0)
+        @precedence = precedence
+      end
+
+      def eval(parser, parser_call_stack)
+        parser.precpred(parser_call_stack, @precedence)
+      end
+
+      def eval_precedence(parser, parser_call_stack)
+        SemanticContext::NONE if parser.precpred(parser_call_stack, @precedence)
+      end
+
+      def compare_to(o)
+        @precedence - o.precedence
+      end
+
+      def hash
+        hash_code = 1
+        31 * hash_code + @precedence
+      end
+
+      def eql?(other)
+        return false unless other.is_a? PrecedencePredicate
+
+        return true if self == other
+
+        @precedence == other.precedence
+      end
+
+      # precedence >= _precedenceStack.peek()
+      def to_s
+        '' + @precedence + '>=precend?'
+      end
+    end
+
+    class Operator < SemanticContext
+      def operands
+      end
+    end
+
+    class AND < Operator
+      attr_accessor :opnds
+
+      def initialize(a, b)
+        operands = Set.new
+        if a.is_a? AND
+          operands.add_all(a.opnds)
+        else
+          operands.add(a)
+        end
+        if b.is_a? AND
+          operands.add_all(b.opnds)
+        else
+          operands.add(b)
+        end
+        precedence_predicates = filter_precedence_predicates(operands)
+        unless precedence_predicates.empty?
+          # interested in the transition with the lowest precedence
+          reduced = precedence_predicates.min
+          operands.add(reduced)
+        end
+
+        @opnds = operands.to_a
+      end
+
+      def eql?(other)
+        return true if self == other
+        return false unless other.is_a? AND
+
+        @opnds.eql?(other.opnds)
+      end
+
+      def hash
+        hash_code = MurmurHash.hash(@opnds, AND.hash)
+        if !@_hash2.nil?
+          if hash_code == @_hash2
+            puts 'Same hash_code for SemanticContext_2'
+          else
+            puts 'Different hash_code for SemanticContext_2'
+          end
+        end
+        @_hash2 = hash_code
+      end
+
+      def eval(parser, parser_call_stack)
+        i = 0
+        while i < @opnds.length
+          opnd = @opnds[i]
+          return false unless opnd.eval(parser, parser_call_stack)
+          i += 1
+        end
+        true
+      end
+
+      def eval_precedence(parser, parser_call_stack)
+        differs = false
+        operands = []
+        i = 0
+        while i < @opnds.length
+          context = @opnds[i]
+          evaluated = context.eval_precedence(parser, parser_call_stack)
+          differs |= (evaluated != context)
+          if evaluated == null
+            # The AND context is false if any element is false
+            return nil
+          elsif evaluated != NONE
+            # Reduce the result by skipping true elements
+            operands.add(evaluated)
+          end
+          i += 1
+        end
+
+        return self unless differs
+
+        if operands.empty?
+          # all elements were true, so the AND context is true
+          return NONE
+        end
+
+        result = operands[0]
+        i = 1
+        while i < operands.length
+          result = SemanticContext.and(result, operands.get(i))
+          i += 1
+        end
+
+        result
+      end
+
+      def to_s
+        @opnds.join('&&')
+      end
+    end
+
+    class OR < Operator
+      attr_accessor :opnds
+
+      def initialize(a, b)
+        operands = Set.new
+        if a.is_a? OR
+          operands.add_all(a.opnds)
+        else
+          operands.add(a)
+        end
+        if b.is_a? OR
+          operands.add_all(b.opnds)
+        else
+          operands.add(b)
+        end
+
+        precedence_predicates = filter_precedence_predicates(operands)
+        unless precedence_predicates.empty?
+          # interested in the transition with the highest precedence
+          reduced = precedence_predicates.max
+          operands.add(reduced)
+        end
+
+        @opnds = operands.to_s
+      end
+
+      def eql?(other)
+        return true if self == other
+        return false unless other.is_a? OR
+
+        @opnds.eql?(other.opnds)
+      end
+
+      def hash
+        hash_code = MurmurHash.hash(@opnds, OR.hash)
+        if !@_hash3.nil?
+          if hash_code == @_hash3
+            puts 'Same hash_code for SemanticContext_2'
+          else
+            puts 'Different hash_code for SemanticContext_2'
+          end
+        end
+        @_hash3 = hash_code
+      end
+
+      def eval(parser, parser_call_stack)
+        i = 0
+        while i < @opnds.length
+          opnd = @opnds[i]
+          return true if opnd.eval(parser, parser_call_stack)
+          i += 1
+        end
+        false
+      end
+
+      def eval_precedence(parser, parser_call_stack)
+        differs = false
+        operands = []
+        i = 0
+        while i < @opnds.length
+          context = @opnds[i]
+          evaluated = context.eval_precedence(parser, parser_call_stack)
+          differs |= (evaluated != context)
+          if evaluated == NONE
+            # The OR context is true if any element is true
+            return NONE
+          elsif evaluated != null
+            # Reduce the result by skipping false elements
+            operands.add(evaluated)
+          end
+          i += 1
+        end
+        return self unless differs
+
+        if operands.empty?
+          # all elements were false, so the OR context is false
+          return nil
+        end
+
+        result = operands[0]
+        i = 1
+        while i < operands.size
+          result = SemanticContext.or(result, operands.get(i))
+          i += 1
+        end
+
+        result
+      end
+
+      def to_s
+        @opnds.join('||')
+      end
+    end
+
+    def self.and(a, b)
+      return b if a.nil? || a == NONE
+      return a if b.nil? || b == NONE
+
+      result = AND.new(a, b)
+      return result.opnds[0] if result.opnds.length == 1
+
+      result
+    end
+
+    def self.or(a, b)
+      return b if a.nil?
+      return a if b.nil?
+      return NONE if a == NONE || b == NONE
+
+      OR result = OR.new(a, b)
+      return result.opnds[0] if result.opnds.length == 1
+
+      result
+    end
+
+    def self.filter_precedence_predicates(collection)
+      result = collection.select {|item| item.is_a? PrecedencePredicate}
+      collection.reject! {|item| (item.is_a? PrecedencePredicate)}
+      result
+    end
+
+    NONE = Predicate.new
+  end
+end