antlr4-runtime 0.1.0

data/lib/antlr4/runtime/prediction_mode.rb

@@ -0,0 +1,213 @@
+require 'antlr4/runtime/flexible_hash_map'
+require 'antlr4/runtime/bit_set'
+
+module Antlr4::Runtime
+
+  class PredictionMode
+    SLL = 0
+    LL = 1
+    LL_EXACT_AMBIG_DETECTION = 2
+
+    class AltAndContextMap < FlexibleHashMap
+      def initialize
+        super(AltAndContextConfigEqualityComparator.instance)
+      end
+    end
+
+    class AltAndContextConfigEqualityComparator
+      include Singleton
+
+      def hash(o)
+        MurmurHash.hash_int_obj(o.state.state_number, o.context)
+      end
+
+      def equals(a, b)
+        return true if a == b
+        return false if a.nil? || b.nil?
+
+        a.state.state_number == b.state.state_number && a.context.eql?(b.context)
+      end
+    end
+
+    def self.has_sll_conflict_terminating_prediction(mode, configs)
+      return true if all_configs_in_rule_stop_states?(configs)
+
+      # pure SLL mode parsing
+      if mode == PredictionMode::SLL
+        # Don't bother with combining configs from different semantic
+        # contexts if we can fail over to full LL costs more time
+        # since we'll often fail over anyway.
+        if configs.has_semantic_context
+          # dup configs, tossing out semantic predicates
+          dup = ATNConfigSet.new
+          i = 0
+          while i < configs.configs.length
+            cfg = configs.configs[i]
+            c = ATNConfig.new
+            c.atn_config5(cfg, SemanticContext::NONE)
+            dup.add(c)
+
+            i += 1
+          end
+
+          configs = dup
+        end
+        # now we have combined contexts for configs with dissimilar preds
+      end
+
+      # pure SLL or combined SLL+LL mode parsing
+
+      alt_sets = conflicting_alt_subsets(configs)
+      heuristic = has_conflicting_alt_set?(alt_sets) && !has_state_associated_with_one_alt?(configs)
+      heuristic
+    end
+
+    def self.has_config_in_rule_stop_state?(configs)
+      i = 0
+      while i < configs.configs.length
+        return true if configs.configs[i].state.is_a? RuleStopState
+        i += 1
+      end
+
+      false
+    end
+
+    def self.all_configs_in_rule_stop_states?(configs)
+      i = 0
+      while i < configs.configs.length
+        return false unless configs.configs[i].state.is_a? RuleStopState
+        i += 1
+      end
+
+      true
+    end
+
+    def self.resolves_to_just_one_viable_alt?(altsets)
+      single_viable_alt(altsets)
+    end
+
+    def self.all_subsets_conflict?(altsets)
+      !has_non_conflicting_alt_set?(altsets)
+    end
+
+    def self.has_non_conflicting_alt_set?(altsets)
+      i = 0
+      while i < altsets.length
+        alts = altsets[i]
+        return true if alts.cardinality == 1
+        i += 1
+      end
+      false
+    end
+
+    def self.has_conflicting_alt_set?(altsets)
+      i = 0
+      while i < altsets.length
+        alts = altsets[i]
+        return true if alts.cardinality > 1
+        i += 1
+      end
+      false
+    end
+
+    def all_subsets_equal?(altsets)
+      first = nil
+      i = 0
+      while i < altsets.length
+        alt = altsets[i]
+        if i == 0
+          first = altsets[0]
+        else
+          return false unless alt.eql?(first)
+        end
+        i += 1
+      end
+      true
+    end
+
+    def self.unique_alt(altsets)
+      all = get_alts1(altsets)
+      return all.next_set_bit(0) if all.cardinality == 1
+
+      ATN::INVALID_ALT_NUMBER
+    end
+
+    def self.get_alts1(altsets)
+      all = BitSet.new
+      i = 0
+      while i < altsets.length
+        alts = altsets[i]
+        all.or(alts)
+        i += 1
+      end
+      all
+    end
+
+    def get_alts2(configs)
+      alts = BitSet.new
+      i = 0
+      while i < configs.length
+        config = configs[i]
+        alts.set(config.alt)
+        i += 1
+      end
+      alts
+    end
+
+    def self.conflicting_alt_subsets(configs)
+      config_to_alts = AltAndContextMap.new
+      i = 0
+      while i < configs.configs.length
+        c = configs.configs[i]
+        alts = config_to_alts.get(c)
+        if alts.nil?
+          alts = BitSet.new
+          config_to_alts.put(c, alts)
+        end
+        alts.set(c.alt)
+        i += 1
+      end
+      config_to_alts.values
+    end
+
+    def self.state_to_alt_map(configs)
+      m = {}
+      i = 0
+      while i < configs.configs.length
+        c = configs.configs[i]
+        alts = m[c.state]
+        if alts.nil?
+          alts = BitSet.new
+          m[c.state] = alts
+        end
+        alts.set(c.alt)
+        i += 1
+      end
+      m
+    end
+
+    def self.has_state_associated_with_one_alt?(configs)
+      x = state_to_alt_map(configs)
+      i = 0
+      while i < x.values.length
+        alts = x.values[i]
+        return true if alts.cardinality == 1
+        i += 1
+      end
+      false
+    end
+
+    def self.single_viable_alt(altsets)
+      viable_alts = BitSet.new
+      i = 0
+      while i < altsets.length
+        alts = altsets[i]
+        min_alt = alts.next_set_bit(0)
+        viable_alts.set(min_alt)
+        return ATN::INVALID_ALT_NUMBER if viable_alts.cardinality > 1 # more than 1 viable alt
+        i += 1
+      end
+      viable_alts.next_set_bit(0)
+    end
+  end
+end

data/lib/antlr4/runtime/profiling_atn_simulator.rb

@@ -0,0 +1,149 @@
+module Antlr4::Runtime
+  class ProfilingATNSimulator < ParserATNSimulator
+    def initialize(parser)
+      super(parser, parser._interp.atn, parser._interp.decision_to_dfa, parser._interp.shared_context_cache)
+
+      @num_decisions = @atn.decision_to_state.size
+      @_sll_stop_index = 0
+      @_ll_stop_index = 0
+      @current_decision = 0
+      @current_state = nil
+      @conflicting_alt_resolved_by_sll = 0
+
+      @decisions = Array.new(@numDecisions)
+      i = 0
+      while i < @num_decisions
+        @decisions[i] = DecisionInfo.new(i)
+        i += 1
+      end
+    end
+
+    def adaptive_predict(input, decision, outer_ctx)
+      @_sll_stop_index = -1
+      @_ll_stop_index = -1
+      @current_decision = decision
+      start = Time.now # expensive but useful info
+      alt = super.adaptive_predict(input, decision, outer_ctx)
+      stop = Time.now
+      @decisions[decision].timeInPrediction += (stop - start)
+      @decisions[decision].invocations += 1
+
+      _s_ll_k = @_sll_stop_index - @_start_index + 1
+      @decisions[decision].SLL_TotalLook += _s_ll_k
+      @decisions[decision].SLL_MinLook = @decisions[decision].SLL_MinLook == 0 ? _s_ll_k : Math.min(@decisions[decision].SLL_MinLook, _s_ll_k)
+      if _s_ll_k > @decisions[decision].SLL_MaxLook
+        @decisions[decision].SLL_MaxLook = _s_ll_k
+        @decisions[decision].SLL_MaxLookEvent = LookaheadEventInfo.new(decision, nil, alt, input, @_start_index, @_sll_stop_index, false)
+      end
+
+      if @_ll_stop_index >= 0
+        _ll_k = @_ll_stop_index - @_start_index + 1
+        @decisions[decision].LL_TotalLook += _ll_k
+        @decisions[decision].LL_MinLook = @decisions[decision].LL_MinLook == 0 ? _ll_k : Math.min(@decisions[decision].LL_MinLook, _ll_k)
+        if _ll_k > @decisions[decision].LL_MaxLook
+          @decisions[decision].LL_MaxLook = _ll_k
+          @decisions[decision].LL_MaxLookEvent = LookaheadEventInfo.new(decision, nil, alt, input, @_start_index, @_ll_stop_index, true)
+        end
+      end
+
+      alt
+    ensure
+      @current_decision = -1
+    end
+
+    def existing_target_state(prev_d, t) # this method is called after each time the input position advances
+      # during SLL prediction
+      @_sll_stop_index = @_input.index
+
+      existing_tgt_state = super.existing_target_state(prev_d, t)
+      unless existing_tgt_state.nil?
+        @decisions[@current_decision].SLL_DFATransitions += 1 # count only if we transition over a DFA state
+        if existing_tgt_state == @@error
+          @decisions[@current_decision].errors.add(ErrorInfo.new(@current_decision, prev_d.configs, @_input, @_start_index, @_sll_stop_index, false))
+        end
+      end
+
+      @current_state = existing_tgt_state
+      existing_tgt_state
+    end
+
+    def compute_target_state(dfa, prev_d, t)
+      state = super.compute_target_state(dfa, prev_d, t)
+      @current_state = state
+      state
+    end
+
+    def compute_reach_set(closure, t, full_ctx)
+      if full_ctx
+        # this method is called after each time the input position advances
+        # during full context prediction
+        @_ll_stop_index = @_input.index
+      end
+
+      reach_configs = super.compute_reach_set(closure, t, full_ctx)
+      if full_ctx
+        @decisions[@current_decision].LL_ATNTransitions += 1 # count computation even if error
+        if !reach_configs.nil?
+        else # no reach on current lookahead symbol. ERROR.
+          # TODO: does not handle delayed errors per getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule()
+          @decisions[@current_decision].errors.add(ErrorInfo.new(@current_decision, closure, @_input, @_start_index, @_ll_stop_index, true))
+        end
+      else
+        @decisions[@current_decision].SLL_ATNTransitions += 1
+        if !reach_configs.nil?
+        else # no reach on current lookahead symbol. ERROR.
+          @decisions[@current_decision].errors.add(ErrorInfo.new(@current_decision, closure, @_input, @_start_index, @_sll_stop_index, false))
+        end
+      end
+
+      reach_configs
+    end
+
+    def eval_semantic_context(pred, parser_call_stack, alt, full_ctx)
+      result = super.eval_semantic_context(pred, parser_call_stack, alt, full_ctx)
+      unless pred.is_a? SemanticContext.PrecedencePredicate
+        full_context = (@_ll_stop_index >= 0)
+        stop_index = full_context ? @_ll_stop_index : @_sll_stop_index
+        @decisions[@current_decision].predicate_evals.add(PredicateEvalInfo.new(@current_decision, @_input, @_start_index, stop_index, pred, result, alt, full_ctx))
+      end
+
+      result
+    end
+
+    def report_attempting_full_context(dfa, conflicting_alts, configs, start_index, stop_index)
+      if !conflicting_alts.nil?
+        @conflicting_alt_resolved_by_sll = conflicting_alts.next_set_bit(0)
+      else
+        @conflicting_alt_resolved_by_sll = configs.alts.next_set_bit(0)
+      end
+      @decisions[@current_decision].LL_Fallback += 1
+      super.report_attempting_full_context(dfa, conflicting_alts, configs, start_index, stop_index)
+    end
+
+    def report_context_sensitivity(dfa, prediction, configs, start_index, stop_index)
+      if prediction != @conflicting_alt_resolved_by_sll
+        @decisions[@current_decision].context_sensitivities.add(ContextSensitivityInfo.new(@current_decision, configs, @_input, start_index, stop_index))
+      end
+      super.report_context_sensitivity(dfa, prediction, configs, start_index, stop_index)
+    end
+
+    def report_ambiguity(dfa, _d, start_index, stop_index, exact, ambig_alts, configs)
+      prediction = if !ambig_alts.nil?
+                     ambig_alts.next_set_bit(0)
+                   else
+                     configs.alts.next_set_bit(0)
+                   end
+
+      if configs.full_ctx && prediction != @conflicting_alt_resolved_by_sll
+        # Even though this is an ambiguity we are reporting, we can
+        # still detect some context sensitivities.  Both SLL and LL
+        # are showing a conflict, hence an ambiguity, but if they resolve
+        # to different minimum alternatives we have also identified a
+        # context sensitivity.
+        @decisions[@current_decision].context_sensitivities.add(ContextSensitivityInfo.new(@current_decision, configs, @_input, start_index, stop_index))
+      end
+      @decisions[@current_decision].ambiguities.add(AmbiguityInfo.new(@current_decision, configs, ambig_alts, @_input, start_index, stop_index, configs.full_ctx))
+      super.report_ambiguity(dfa, _d, start_index, stop_index, exact, ambig_alts, configs)
+    end
+  end
+end

data/lib/antlr4/runtime/proxy_error_listener.rb

@@ -0,0 +1,33 @@
+module Antlr4::Runtime
+  class ProxyErrorListener
+    def initialize(delegates)
+      raise StandardError, 'delegates is nil' if delegates.nil?
+
+      @delegates = delegates
+    end
+
+    def syntax_error(recognizer, offending_symbol, line, char_position_in_line, msg, e)
+      @delegates.each do |listener|
+        listener.syntax_error(recognizer, offending_symbol, line, char_position_in_line, msg, e)
+      end
+    end
+
+    def report_ambiguity(recognizer, dfa, start_index, stop_index, exact, ambig_alts, configs)
+      @delegates.each do |listener|
+        listener.report_ambiguity(recognizer, dfa, start_index, stop_index, exact, ambig_alts, configs)
+      end
+    end
+
+    def report_attempting_full_context(recognizer, dfa, start_index, stop_index, conflicting_alts, configs)
+      @delegates.each do |listener|
+        listener.report_attempting_full_context(recognizer, dfa, start_index, stop_index, conflicting_alts, configs)
+      end
+    end
+
+    def report_context_sensitivity(recognizer, dfa, start_index, stop_index, prediction, configs)
+      @delegates.each do |listener|
+        listener.report_context_sensitivity(recognizer, dfa, start_index, stop_index, prediction, configs)
+      end
+    end
+  end
+end

data/lib/antlr4/runtime/range_transition.rb

@@ -0,0 +1,29 @@
+module Antlr4::Runtime
+
+  class RangeTransition < Transition
+    attr_reader :from
+    attr_reader :to
+
+    def initialize(target, from, to)
+      super(target)
+      @from = from
+      @to = to
+    end
+
+    def serialization_type
+      RANGE
+    end
+
+    def label
+      IntervalSet.of(@from, @to)
+    end
+
+    def matches(symbol, _min_vocab_symbol, _max_vocab_symbol)
+      symbol >= @from && symbol <= @to
+    end
+
+    def to_s
+      "'" << @from << "'..'" << @to << "'"
+    end
+  end
+end

data/lib/antlr4/runtime/recognition_exception.rb

@@ -0,0 +1,17 @@
+module Antlr4::Runtime
+  class RecognitionException < StandardError
+    attr_accessor :recognizer
+    attr_accessor :context
+    attr_accessor :offending_token
+    attr_accessor :offending_state
+    attr_accessor :input
+
+    def expected_tokens
+      unless @recognizer.nil?
+        return @recognizer._interp.atn.expected_tokens(@offending_state, @context)
+      end
+
+      nil
+    end
+  end
+end

data/lib/antlr4/runtime/recognizer.rb

@@ -0,0 +1,136 @@
+require 'antlr4/runtime/console_error_listener'
+require 'antlr4/runtime/proxy_error_listener'
+
+module Antlr4::Runtime
+
+  class Recognizer
+    EOF = -1
+
+    attr_accessor :_interp
+    attr_accessor :_state_number
+
+    def initialize
+      @token_type_map_cache = []
+      @rule_index_map_cache = []
+      @_listeners = []
+      @_listeners << ConsoleErrorListener.instance
+      @_interp = nil
+      @_state_number = -1
+    end
+
+    def get_vocabulary
+      VocabularyImpl.from_token_names(token_names)
+    end
+
+    def token_names
+      nil
+    end
+
+    def rule_names
+      nil
+    end
+
+    def get_token_type_map
+      vocab = get_vocabulary
+      result = @token_type_map_cache[vocab]
+      if result.nil?
+        result = {}
+        i = 0
+        while i <= getATN.max_token_type
+          literal_name = vocab.literal_name(i)
+          result[literal_name] = i unless literal_name.nil?
+
+          symbolic_name = vocab.symbolic_name(i)
+          result[symbolic_name] = i unless symbolic_name.nil?
+          i += 1
+        end
+
+        result['EOF'] = Token::EOF
+        @token_type_map_cache[vocab] = result
+      end
+
+      result
+    end
+
+    def get_rule_index_map
+      if rule_names.nil?
+        raise UnsupportedOperationException, 'The current recognizer does not provide a list of rule names.'
+      end
+
+      result = @rule_index_map_cache[rule_names]
+      if result.nil?
+        result = Utils.toMap(rule_names)
+        @rule_index_map_cache[rule_names] = result
+      end
+
+      result
+    end
+
+    def get_token_type(token_name)
+      ttype = get_token_type_map[token_name]
+      return ttype unless ttype.nil?
+
+      Token::INVALID_TYPE
+    end
+
+    def get_serialized_atn
+      raise UnsupportedOperationException, 'there is no serialized ATN'
+    end
+
+    def parse_info
+      nil
+    end
+
+    def error_header(e)
+      line = e.getOffendingToken.line
+      charPositionInLine = e.getOffendingToken.char_position_in_line
+      'line ' + line + ':' + charPositionInLine
+    end
+
+    def token_error_display(t)
+      return '<no token>' if t.nil?
+
+      s = t.text
+      if s.nil?
+        s = if t.type == Token::EOF
+              '<EOF>'
+            else
+              '<' + t.type + '>'
+            end
+      end
+      s = s.tr_s!("\n", '\\n')
+      s = s.tr_s!("\r", '\\r')
+      s = s.tr_s!("\t", '\\t')
+      "'" + s + "'"
+    end
+
+    def add_error_listener(listener)
+      raise NullPointerException, 'listener cannot be nil.' if listener.nil?
+
+      @_listeners << listener
+    end
+
+    def remove_error_listener(listener)
+      @_listeners.delete(listener)
+    end
+
+    def remove_error_listeners
+      @_listeners.clear
+    end
+
+    def error_listener_dispatch
+      ProxyErrorListener.new(@_listeners)
+    end
+
+    def sempred(_localctx, _rule_index, _action_index)
+      true
+    end
+
+    def precpred(_localctx, _precedence)
+      true
+    end
+
+    def action(_localctx, _rule_index, _action_index)
+    end
+  end
+end