antlr4-runtime 0.1.0

data/lib/antlr4/runtime/dfa.rb

@@ -0,0 +1,97 @@
+require 'antlr4/runtime/dfa_serializer'
+require 'antlr4/runtime/lexer_dfa_serializer'
+
+module Antlr4::Runtime
+
+  class DFA
+    attr_accessor :states
+    attr_accessor :s0
+    attr_reader :decision
+    attr_reader :atn_start_state
+    attr_reader :precedence_dfa
+
+    def initialize(atn_start_state, decision = 0)
+      @atn_start_state = atn_start_state
+      @decision = decision
+      @states = {}
+
+      @precedence_dfa = false
+      if atn_start_state.is_a? StarLoopEntryState
+        if atn_start_state.is_precedence_pecision
+          @precedence_dfa = true
+          precedence_state = DFAState.new(ATNConfigSet.new)
+          precedence_state.edges = []
+          precedence_state.is_accept_state = false
+          precedence_state.requires_full_context = false
+          @s0 = precedence_state
+        end
+      end
+
+    end
+
+    def precedence_dfa?
+      @precedence_dfa
+    end
+
+    def precedence_start_state(precedence)
+      unless @precedence_dfa
+        raise IllegalStateException, 'Only precedence DFAs may contain a precedence start state.'
+      end
+
+      # s0.edges is never nil for a precedence DFA
+      return nil if precedence < 0 || precedence >= @s0.edges.length
+
+      @s0.edges[precedence]
+    end
+
+    def precedence_start_state2(precedence, start_state)
+      unless @precedence_dfa
+        raise IllegalStateException, 'Only precedence DFAs may contain a precedence start state.'
+      end
+
+      return if precedence < 0
+
+      @s0.edges[precedence] = start_state
+    end
+
+    def precedence_dfa(precedence_dfa)
+      if precedence_dfa != @precedence_dfa
+        raise UnsupportedOperationException, 'The precedence_dfa field cannot change after a DFA is constructed.'
+      end
+    end
+
+    def get_states
+      result = @states.keys
+      result.sort! {|i, j| i.state_number - j.state_number}
+
+      result
+    end
+
+    def to_s
+      to_s2(VocabularyImpl.EMPTY_VOCABULARY)
+    end
+
+    def to_s1(token_names)
+      return '' if @s0.nil?
+
+      serializer = DFASerializer.new
+      serializer.init_from_token_names(self, token_names)
+      serializer.to_s
+    end
+
+    def to_s2(vocabulary)
+      return '' if @s0.nil?
+
+      serializer = DFASerializer.new
+      serializer.init_from_vocabulary(self, vocabulary)
+      serializer.to_s
+    end
+
+    def to_lexer_string
+      return '' if @s0.nil?
+
+      serializer = LexerDFASerializer.new(self)
+      serializer.to_s
+    end
+  end
+end

data/lib/antlr4/runtime/dfa_serializer.rb

@@ -0,0 +1,62 @@
+module Antlr4::Runtime
+
+  class DFASerializer
+    def init_from_token_names(dfa, token_names)
+      init_from_vocabulary(dfa, VocabularyImpl.from_token_names(token_names))
+    end
+
+    def init_from_vocabulary(dfa, vocabulary)
+      @dfa = dfa
+      @vocabulary = vocabulary
+    end
+
+    def to_s
+      return nil if @dfa.s0.nil?
+
+      buf = ''
+      states = @dfa.get_states
+      states.each do |s|
+        n = 0
+        n = s.edges.length unless s.edges.nil?
+        i = 0
+        while i < n
+          t = s.edges[i]
+          if !t.nil? && t.state_number != Integer::MAX
+            buf << state_string(s)
+            label = edge_label(i)
+            buf << '-' << label << '->' << state_string(t) << '\n'
+          end
+          i += 1
+        end
+      end
+
+      output = buf
+      return '' if output.empty?
+
+      # return Utils.sortLinesInString(output)
+      output
+    end
+
+    def edge_label(i)
+      @vocabulary.display_name(i - 1)
+    end
+
+    def state_string(s)
+      n = s.state_number
+      base_state_str = (s.is_accept_state ? ':' : '') << 's' << n.to_s << (s.requires_full_context ? '^' : '')
+      if s.is_accept_state
+        if !s.predicates.nil?
+          preds = ''
+          s.predicates.each do |p|
+            preds << p.to_s
+          end
+
+          return base_state_str << '=>' << preds
+        else
+          return base_state_str << '=>' << @vocabulary.symbolic_name(s.prediction)
+        end
+      end
+      base_state_str
+    end
+  end
+end

data/lib/antlr4/runtime/dfa_state.rb

@@ -0,0 +1,109 @@
+require 'antlr4/runtime/atn_config_set'
+
+module Antlr4::Runtime
+  class DFAState
+    attr_accessor :state_number
+
+    attr_accessor :configs
+
+    attr_accessor :edges
+
+    attr_accessor :is_accept_state
+
+    attr_accessor :prediction
+
+    attr_accessor :lexer_action_executor
+
+    attr_accessor :requires_full_context
+
+    attr_accessor :predicates
+
+    def initialize(x = nil)
+      @is_accept_state = false
+      @edges = []
+      @state_number = -1
+
+      if x.nil?
+        @configs = ATNConfigSet.new
+      elsif x.is_a?(ATNConfigSet)
+        @configs = x
+      else
+        @state_number = x
+      end
+    end
+
+    class PredPrediction
+      attr_accessor :pred # never null at least SemanticContext::NONE
+      attr_accessor :alt
+
+      def initiailize(pred, alt)
+        @alt = alt
+        @pred = pred
+      end
+
+      def to_s
+        '(' + @pred.to_s + ', ' + @alt.to_s + ')'
+      end
+    end
+
+    def initialize_state_number(stateNumber)
+      @state_number = stateNumber
+    end
+
+    def initialize_configs(configs)
+      @configs = configs
+    end
+
+    def alt_set
+      alts = Set.new
+      unless @configs.nil?
+        i = 0
+        while i < @configs.length
+          c = @configs[i]
+          alts.add(c.alt)
+          i += 1
+        end
+      end
+      return nil if alts.empty?
+
+      alts
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int(configs.hash)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for DFAState'
+        else
+          puts 'Different hash_code for DFAState'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def equals?(o) # compare set of ATN configurations in this set with other
+      return true if self == o
+      return false unless o.is_a? DFAState
+
+      @configs.eql?(o.configs)
+    end
+
+    def to_s
+      buf = ''
+      buf << @state_number.to_s << ':' << @configs.to_s
+      if @is_accept_state
+        buf << '=>'
+        buf << if !@predicates.nil?
+                 @predicates.to_s
+               else
+                 @prediction.to_s
+               end
+      end
+
+      buf.to_s
+    end
+  end
+end

data/lib/antlr4/runtime/diagnostic_error_listener.rb

@@ -0,0 +1,58 @@
+module Antlr4::Runtime
+  class DiagnosticErrorListener < BaseErrorListener
+    def initialize(exact_only = true)
+      @exact_only = exact_only
+    end
+
+    def report_ambiguity(recognizer, dfa, start_index, stop_index, exact, ambig_alts, configs)
+      return if @exact_only && !exact
+
+      format = "reportAmbiguity d=%s: ambig_alts=%s, input='%s'"
+      decision = decision_description(recognizer, dfa)
+      conflicting_alts = conflicting_alts(ambig_alts, configs)
+      text = recognizer.getTokenStream.text(Interval.of(start_index, stop_index))
+      message = String.format(format, decision, conflicting_alts, text)
+      recognizer.notify_error_listeners(message)
+    end
+
+    def report_attempting_full_context(recognizer, dfa, start_index, stop_index, _conflicting_alts, _configs)
+      format = "reportAttemptingFullContext d=%s, input='%s'"
+      decision = decision_description(recognizer, dfa)
+      text = recognizer.getTokenStream.text(Interval.of(start_index, stop_index))
+      message = String.format(format, decision, text)
+      recognizer.notify_error_listeners(message)
+    end
+
+    def report_context_sensitivity(recognizer, dfa, start_index, stop_index, _prediction, _configs)
+      format = "reportContextSensitivity d=%s, input='%s'"
+      decision = decision_description(recognizer, dfa)
+      text = recognizer.getTokenStream.text(Interval.of(start_index, stop_index))
+      message = String.format(format, decision, text)
+      recognizer.notify_error_listeners(message)
+    end
+
+    def decision_description(recognizer, dfa)
+      decision = dfa.decision
+      rule_index = dfa.atn_start_state.rule_index
+
+      rule_names = recognizer.rule_names
+      return decision.to_s if rule_index < 0 || rule_index >= rule_names.length
+
+      rule_name = rule_names[rule_index]
+      return decision.to_s if rule_name.nil? || rule_name.empty?
+
+      String.format('%d (%s)', decision, rule_name)
+    end
+
+    def conflicting_alts(reported_alts, configs)
+      return reported_alts unless reported_alts.nil?
+
+      result = BitSet.new
+      configs.each do |config|
+        result.set(config.alt)
+      end
+
+      result
+    end
+  end
+end

data/lib/antlr4/runtime/double_key_map.rb

@@ -0,0 +1,49 @@
+module Antlr4::Runtime
+  class DoubleKeyMap
+    def initialize
+      @data = {}
+    end
+
+    def put(k1, k2, v)
+      data2 = @data[k1]
+      prev = nil
+      if data2.nil?
+        data2 = {}
+        @data[k1] = data2
+      else
+        prev = data2[k2]
+      end
+      data2[k2] = v
+      prev
+    end
+
+    def get2(k1, k2)
+      data2 = @data[k1]
+      return nil if data2.nil?
+
+      data2[k2]
+    end
+
+    def get1(k1)
+      @data[k1]
+    end
+
+    def values(k1)
+      data2 = @data[k1]
+      return nil if data2.nil?
+
+      data2.values
+    end
+
+    def key_set0
+      @data.keys
+    end
+
+    def key_set1(k1)
+      data2 = @data[k1]
+      return nil if data2.nil?
+
+      data2.keys
+    end
+  end
+end

data/lib/antlr4/runtime/empty_prediction_context.rb

@@ -0,0 +1,35 @@
+require 'antlr4/runtime/singleton_prediction_context'
+module Antlr4::Runtime
+
+  class EmptyPredictionContext < SingletonPredictionContext
+    def initialize(return_state)
+      super(nil, return_state)
+    end
+
+    EMPTY = EmptyPredictionContext.new(PredictionContextUtils::EMPTY_RETURN_STATE)
+
+    def isEmpty
+      true
+    end
+
+    def size
+      1
+    end
+
+    def parent(_index=nil)
+      nil
+    end
+
+    def return_state(_index=nil)
+      @return_state
+    end
+
+    def equals(o)
+      self == o
+    end
+
+    def to_s
+      '$'
+    end
+  end
+end

data/lib/antlr4/runtime/epsilon_transition.rb

@@ -0,0 +1,27 @@
+module Antlr4::Runtime
+
+  class EpsilonTransition < Transition
+    def initialize(target, outermost_precedence_return = -1)
+      super(target)
+      @outermost_precedence_return = outermost_precedence_return
+    end
+
+    attr_reader :outermost_precedence_return
+
+    def serialization_type
+      EPSILON
+    end
+
+    def epsilon?
+      true
+    end
+
+    def matches(_symbol, _min_vocab_symbol, _max_vocab_symbol)
+      false
+    end
+
+    def to_s
+      'epsilon'
+    end
+  end
+end

data/lib/antlr4/runtime/equality_comparator.rb

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