antlr4-runtime 0.1.0

data/lib/antlr4/runtime/array_prediction_context.rb

@@ -0,0 +1,76 @@
+module Antlr4::Runtime
+
+  class ArrayPredictionContext < PredictionContext
+    attr_accessor :parents
+    attr_accessor :return_states
+
+    def initialize(parents, return_states = nil)
+      if parents.is_a? SingletonPredictionContext
+        return_states = [parents.return_state]
+        parents = [parents.parent]
+      end
+
+      super(PredictionContextUtils.calculate_hash_code2(parents, return_states))
+      @parents = parents
+      @return_states = return_states
+    end
+
+    def empty? # since EMPTY_RETURN_STATE can only appear in the last position, we
+      # don't need to verify that size==1
+      @return_states[0] == EMPTY_RETURN_STATE
+    end
+
+    def size
+      @return_states.length
+    end
+
+    def get_parent(index)
+      @parents[index]
+    end
+
+    def get_return_state(index)
+      @return_states[index]
+    end
+
+    def equals(o)
+      if self == o
+        return true
+      elsif !(o.is_a? ArrayPredictionContext)
+        return false
+      end
+
+      if hash != o.hash
+        return false # can't be same if hash is different
+      end
+
+      (@return_states.eql? o.return_states) && (@parents.eql? o.parents)
+    end
+
+    def to_s
+      return '[]' if empty?
+
+      buf = ''
+      buf << '['
+      i = 0
+      while i < @return_states.length
+        buf << ', ' if i > 0
+        if return_states[i] == EMPTY_RETURN_STATE
+          buf << '$'
+          i += 1
+          next
+        end
+        buf << @return_states[i]
+        if !@parents[i].nil?
+          buf << ' '
+          buf << @parents[i].to_s
+        else
+          buf << 'nil'
+        end
+        i += 1
+      end
+
+      buf << ']'
+      buf.to_s
+    end
+  end
+end

data/lib/antlr4/runtime/atn.rb

@@ -0,0 +1,100 @@
+require 'antlr4/runtime/ll1_analyzer'
+
+module Antlr4::Runtime
+
+  class IllegalArgumentException < RuntimeError
+  end
+
+  class ATN
+    INVALID_ALT_NUMBER = 0
+
+    attr_accessor :states
+    attr_accessor :grammar_type
+    attr_accessor :rule_to_token_type
+    attr_accessor :rule_to_start_state
+    attr_accessor :rule_to_stop_state
+    attr_accessor :mode_name_to_start_state
+    attr_accessor :mode_to_start_state
+    attr_accessor :decision_to_state
+    attr_accessor :_a
+    attr_accessor :max_token_type
+
+    def initialize(grammar_type, max_token_type)
+      @states = []
+      @decision_to_state = []
+      @rule_to_start_state = []
+      @rule_to_stop_state = []
+      @mode_name_to_start_state = {}
+      @grammar_type = grammar_type
+      @max_token_type = max_token_type
+      @rule_to_token_type = []
+      @_a = []
+      @mode_to_start_state = []
+    end
+
+    def next_tokens_ctx(s, ctx)
+      LL1Analyzer.new(self).look(s, nil, ctx)
+    end
+
+    def next_tokens(s)
+      return s.next_token_within_rule unless s.next_token_within_rule.nil?
+
+      s.next_token_within_rule = next_tokens_ctx(s, nil)
+      s.next_token_within_rule.readonly(true)
+      s.next_token_within_rule
+    end
+
+    def add_state(state)
+      unless state.nil?
+        state.atn = self
+        state.state_number = @states.length
+      end
+
+      @states << state
+    end
+
+    def remove_state(state)
+      @states[state.state_number] = nil
+    end
+
+    def define_decision_state(s)
+      @decision_to_state << s
+      s.decision = @decision_to_state.length - 1
+    end
+
+    def decision_state(decision)
+      @decision_to_state[decision] unless @decision_to_state.empty?
+    end
+
+    def number_of_decisions
+      @decision_to_state.length
+    end
+
+    def expected_tokens(state_number, context)
+      if state_number < 0 || state_number >= @states.length
+        raise IllegalArgumentException, 'Invalid state number.'
+      end
+
+      ctx = context
+      s = @states[state_number]
+      following = next_tokens(s)
+      return following unless following.contains(Token::EPSILON)
+
+      expected = IntervalSet.new
+      expected.add_all(following)
+      expected.remove(Token::EPSILON)
+      while !ctx.nil? && ctx.invoking_state >= 0 && following.contains(Token::EPSILON)
+        invoking_state = @states[ctx.invoking_state]
+        rt = invoking_state.transition(0)
+        following = next_tokens(rt.follow_state)
+        expected.add_all(following)
+        expected.remove(Token::EPSILON)
+        ctx = ctx.parent
+      end
+
+      expected << Token::EOF if following.contains(Token::EPSILON)
+
+      expected
+    end
+  end
+end

data/lib/antlr4/runtime/atn_config.rb

@@ -0,0 +1,140 @@
+module Antlr4::Runtime
+  class ATNConfig
+    SUPPRESS_PRECEDENCE_FILTER = 0x40000000
+
+    attr_accessor :state
+    attr_accessor :alt
+    attr_accessor :context
+    attr_accessor :target
+    attr_accessor :reaches_into_outer_context
+    attr_accessor :semantic_context
+
+    def initialize
+      @reaches_into_outer_context = 0
+      @alt = 0
+    end
+
+    def bucket_hash
+      return @_bucket_hash unless @_bucket_hash.nil?
+
+      if !@_bucket_hash.nil?
+        if hash_code == @_bucket_hash
+          puts 'Same hash_code for ATNConfig.bucket_hash'
+        else
+          puts 'Different hash_code for ATNConfig.bucket_hash'
+        end
+      end
+      @_bucket_hash = MurmurHash.hash_int_int(@state.state_number, @alt)
+    end
+
+    def atn_config_copy(old)
+      @state = old.state
+      @alt = old.alt
+      @context = old.context
+      @semantic_context = old.semantic_context
+      @reaches_into_outer_context = old.reaches_into_outer_context
+    end
+
+    def atn_config1(state, alt, context)
+      atn_config2(state, alt, context, SemanticContext::NONE)
+    end
+
+    def atn_config2(state, alt, context, semantic_context)
+      @state = state
+      @alt = alt
+      @context = context
+      @semantic_context = semantic_context
+    end
+
+    def atn_config3(c, state)
+      atn_config7(c, state, c.context, c.semantic_context)
+    end
+
+    def atn_config4(c, state, semantic_context)
+      atn_config7(c, state, c.context, semantic_context)
+    end
+
+    def atn_config5(c, semantic_context)
+      atn_config7(c, c.state, c.context, semantic_context)
+    end
+
+    def atn_config6(c, state, context)
+      atn_config7(c, state, context, c.semantic_context)
+    end
+
+    def atn_config7(c, state, context, semantic_context)
+      @state = state
+      @alt = c.alt
+      @context = context
+      @semantic_context = semantic_context
+      @reaches_into_outer_context = c.reaches_into_outer_context
+    end
+
+    def outer_context_depth
+      (@reaches_into_outer_context & ~SUPPRESS_PRECEDENCE_FILTER)
+    end
+
+    def precedence_filter_suppressed?
+      (@reaches_into_outer_context & SUPPRESS_PRECEDENCE_FILTER) != 0
+    end
+
+    def precedence_filter_suppressed(value)
+      if value
+        @reaches_into_outer_context |= 0x40000000
+      else
+        @reaches_into_outer_context &= ~SUPPRESS_PRECEDENCE_FILTER
+      end
+    end
+
+    def to_s
+      to_s2(nil, true)
+    end
+
+    def to_s2(_recog = nil, show_alt = false)
+      buf = ''
+      buf << '('
+      buf << @state.to_s
+      if show_alt
+        buf << ','
+        buf << @alt.to_s
+      end
+      unless @context.nil?
+        buf << ',['
+        buf << @context.to_s
+        buf << ']'
+      end
+      if !@semantic_context.nil? && @semantic_context != SemanticContext::NONE
+        buf << ','
+        buf << @semantic_context.to_s
+      end
+      buf << ',up=' << outer_context_depth.to_s if outer_context_depth > 0
+      buf << ')'
+      buf
+    end
+
+    def eql?(other)
+      if self == other
+        return true
+      elsif other.nil?
+        return false
+      end
+
+      @state.state_number == other.state.state_number && @alt == other.alt && (@context == other.context || (!@context.nil? && @context.<=>(other.context))) && @semantic_context.<=>(other.semantic_context) && precedence_filter_suppressed? == other.precedence_filter_suppressed?
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int_int_obj_obj(@state.state_number,@alt,@context,@semantic_context)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for ATNConfig'
+        else
+          puts 'Different hash_code for ATNConfig'
+        end
+      end
+      @_hash = hash_code
+    end
+  end
+end

data/lib/antlr4/runtime/atn_config_set.rb

@@ -0,0 +1,150 @@
+require 'antlr4/runtime/array_2d_hash_set'
+require 'antlr4/runtime/atn'
+
+module Antlr4::Runtime
+
+  class ATNConfigSet
+    attr_accessor :has_semantic_context
+    attr_accessor :readonly
+    attr_accessor :configs
+    attr_accessor :unique_alt
+    attr_accessor :dips_into_outer_context
+    attr_accessor :full_ctx
+    attr_accessor :conflictingAlts
+
+    def initialize(full_ctx = true)
+      @full_ctx = full_ctx
+      @has_semantic_context = false
+      @readonly = false
+      @config_lookup = ConfigHashSet.new
+      @configs = []
+      @dips_into_outer_context = false
+      @unique_alt = ATN::INVALID_ALT_NUMBER
+    end
+
+    def alts
+      alts = BitSet.new
+      i = 0
+      while i < @configs.length
+        config = @configs[i]
+        alts.set(config.alt)
+        i += 1
+      end
+      alts
+    end
+
+    def add(config, merge_cache = nil)
+      raise IllegalStateException, 'This set is readonly' if @readonly
+
+      if config.semantic_context != SemanticContext::NONE
+        @has_semantic_context = true
+      end
+
+      @dips_into_outer_context = true if config.outer_context_depth > 0
+
+      existing = @config_lookup.get_or_add config
+      if existing == config
+        @cached_hash_code = -1
+        @configs << config
+        return true
+      end
+
+      root_is_wildcard = !@full_ctx
+
+      merged = PredictionContextUtils.merge(existing.context, config.context, root_is_wildcard, merge_cache)
+
+      existing.reaches_into_outer_context = [existing.reaches_into_outer_context, config.reaches_into_outer_context].max
+
+      if config.precedence_filter_suppressed?
+        existing.precedence_filter_suppressed(true)
+      end
+
+      existing.context = merged
+      true
+    end
+
+    def find_first_rule_stop_state
+      result = nil
+
+      i = 0
+      while i < @configs.length
+        config = @configs[i]
+        if config.state.is_a? RuleStopState
+          result = config
+          break
+        end
+        i += 1
+      end
+      result
+    end
+
+    def empty?
+      @config_lookup.empty?
+    end
+
+    def to_s
+      buf = ''
+      buf << '<'
+      i = 0
+      while i < @configs.length
+        c = @configs[i]
+        buf << c.to_s << ' '
+        i += 1
+      end
+      buf << '>'
+
+      if @has_semantic_context
+        buf << ',hasSemanticContext=' << @has_semantic_context.to_s
+      end
+      buf << ',uniqueAlt=' << @unique_alt if @unique_alt != ATN::INVALID_ALT_NUMBER
+      unless @conflictingAlts.nil?
+        buf << ',conflictingAlts=' << @conflictingAlts.to_s
+      end
+      buf << ',dipsIntoOuterContext' if @dips_into_outer_context
+      buf
+    end
+
+    class AbstractConfigHashSet < Array2DHashSet
+      def initialize(comparator)
+        super(comparator, 64, 64)
+      end
+    end
+
+    class ConfigHashSet < AbstractConfigHashSet
+      def initialize
+        super(ConfigEqualityComparator.instance)
+      end
+    end
+
+    def optimize_configs(interpreter)
+      raise IllegalStateException, 'This set is readonly' if @readonly
+      return if @config_lookup.empty?
+
+      i = 0
+      while i < @configs.length
+        config = @configs[i]
+        config.context = interpreter.cached_context(config.context)
+        i += 1
+      end
+    end
+
+    class ConfigEqualityComparator
+      include Singleton
+
+      def hash(o)
+        o.bucket_hash
+      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.alt == b.alt && a.semantic_context.eql?(b.semantic_context)
+      end
+    end
+
+    def size
+      @configs.length
+    end
+  end
+end