antlr4ruby 0.1.0

data/lib/antlr4ruby/atn/config/lexer_atn_config.rb

@@ -0,0 +1,47 @@
+module Antlr4ruby
+  class LexerATNConfig < ATNConfig
+    def initialize(state: , alt: nil,
+                   context: nil,
+                   config: nil,
+                   executor: nil )
+      if alt && context
+        # 第一个构造函数
+      elsif config && executor
+        # 第三个构造函数
+      elsif config && context
+        # 第四个构造函数
+      else
+        # 第二个构造函数
+      end
+    end
+
+    private
+    attr_reader :lexer_action_executor, :passed_through_non_greedy_decision
+
+    def self.check_non_greedy_decision(source, target)
+      return source.passed_through_non_greedy_decision ||
+        target.instance_of?(DecisionState) && target.non_greedy
+    end
+
+    public
+    def get_lexer_action_executor
+      @lexer_action_executor
+    end
+
+    def has_passed_through_non_greedy_decision?
+      @passed_through_non_greedy_decision
+    end
+
+    def hash
+      # todo
+    end
+
+    def eql?(other)
+      # todo
+    end
+
+
+
+
+  end
+end

data/lib/antlr4ruby/atn/config/ordered_atn_config_set.rb

@@ -0,0 +1,4 @@
+module Antlr4ruby
+  class OrderedATNConfigSet < ATNConfigSet
+  end
+end

data/lib/antlr4ruby/atn/context/array_prediction_context.rb

@@ -0,0 +1,29 @@
+module Antlr4ruby
+  class ArrayPredictionContext < PredictionContext
+
+    attr_reader :parents, :return_states
+
+    def initialize(context: nil, parents:[], return_states: [])
+      if context
+        parents,  return_states = [context.parent], [context.return_state]
+      end
+      super(calculate_hash_code(parents, return_states))
+      @parents, @return_states = parents, return_states
+    end
+    def is_empty?
+      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
+  end
+end

data/lib/antlr4ruby/atn/context/empty_prediction_context.rb

@@ -0,0 +1,36 @@
+module Antlr4ruby
+  class EmptyPredictionContext < SingletonPredictionContext
+    INSTANCE = EmptyPredictionContext.new
+
+    def initialize
+      super(nil, EMPTY_RETURN_STATE)
+    end
+
+    def is_empty?
+      true
+    end
+
+    def size
+      1
+    end
+
+    def get_parent(index)
+      nil
+    end
+
+    def get_return_state(index)
+      return_state
+    end
+
+    def eql?(other)
+      # todo
+    end
+
+    def to_s
+      '$'
+    end
+
+
+
+  end
+end

data/lib/antlr4ruby/atn/context/prediction_context.rb

@@ -0,0 +1,111 @@
+module Antlr4ruby
+  # @abstract
+  class PredictionContext
+
+    def initialize(cached_hash_code)
+      @cached_hash_code = cached_hash_code
+      @id = @@global_node_count
+      @@global_node_count += 1
+    end
+
+    private
+
+    INITIAL_HASH = 1
+    @@global_node_count = 0
+
+    public
+
+    EMPTY_RETURN_STATE = 2147483647
+    attr_reader :id, :cached_hash_code
+
+    def size
+      raise NotImplementedError.new("#{self.class.name}#size is abstract method")
+    end
+
+    def get_parent(index)
+      raise NotImplementedError.new("#{self.class.name}#get_parent is abstract method")
+    end
+
+    def get_return_state(index)
+      raise NotImplementedError.new("#{self.class.name}#get_return_state is abstract method")
+    end
+
+    def is_empty?
+      # todo
+    end
+
+    def has_empty_path?
+      # todo
+    end
+
+    def hash
+      @cached_hash_code
+    end
+
+    def eql?(other)
+      raise NotImplementedError.new("#{self.class.name}#eql? is abstract method")
+    end
+
+    def to_s(recognizer)
+      super()
+    end
+
+    class << self
+      def from_rule_context(atn, outer_context)
+        # todo
+      end
+
+      def merge(a, b, root_is_wildcard, merge_cache)
+        # todo
+      end
+
+      def merge_singletons(a, b, root_is_wildcard, merge_cache)
+        # todo
+      end
+
+      def merge_root(a, b, root_is_wildcard)
+        # todo
+      end
+
+      def merge_arrays(a, b, root_is_wildcard, merge_cache)
+        # todo
+      end
+
+      def to_dot_string(context)
+        # todo
+      end
+
+      def get_cached_context(context, context_cache, visited)
+        # todo
+      end
+
+      def get_all_context_nodes(context)
+        # todo
+      end
+
+      def get_all_context_nodes_(context, nodes, visited)
+        # todo
+      end
+
+
+      protected
+      def calculate_empty_hash_code
+        # todo
+      end
+
+      def calculate_hash_code(parent: nil, return_state: 0, parents: [], return_states: [])
+        # todo
+      end
+
+      def combine_common_parents(parents)
+        # todo
+      end
+
+
+
+    end
+
+
+  end
+
+end

data/lib/antlr4ruby/atn/context/prediction_context_cache.rb

@@ -0,0 +1,17 @@
+module Antlr4ruby
+  class PredictionContextCache
+    attr_reader :cache
+
+    def add(ctx)
+      # todo
+    end
+
+    def get(ctx)
+      # todo
+    end
+
+    def size
+      cache.length
+    end
+  end
+end

data/lib/antlr4ruby/atn/context/semantic_context.rb

@@ -0,0 +1,74 @@
+module Antlr4ruby
+  # @abstract
+  class SemanticContext
+    def eval(parser, parser_call_stack)
+      raise NotImplementedError "#{self.class.name}#eval is abstract method"
+    end
+
+    def eval_precedence(parser, parser_call_stack)
+      self
+    end
+
+    class Empty < SemanticContext
+      INSTANCE = Empty.new
+      def eval(parser, parser_call_stack)
+        false
+      end
+    end
+    class Predicate < SemanticContext
+      attr_reader :rule_index, :pred_index, :is_ctx_dependent
+
+      def initialize(rule_index, pred_index, is_ctx_dependent)
+        @rule_index, @pred_index, @is_ctx_dependent = rule_index, pred_index, is_ctx_dependent
+      end
+
+      def eval(parser, parser_call_stack)
+        local_ctx = is_ctx_dependent ? parser_call_stack : nil
+        parser.sempred(local_ctx, rule_index, pred_index)
+      end
+
+      def hash
+        # todo
+      end
+
+      def eql?(other)
+        # todo
+      end
+
+      def to_s
+        "{#{rule_index}:#{pred_index}}?"
+      end
+    end
+
+    class PrecedencePredicate < SemanticContext
+      # todo include Comparable
+    end
+
+    class Operator < SemanticContext
+      def get_operands
+        raise NotImplementedError "#{self.class.name}#get_operands is abstract method"
+      end
+    end
+
+    class AND < Operator
+      # todo
+    end
+
+    class OR < Operator
+      # todo
+    end
+
+    def self.and(a, b)
+      # todo
+    end
+
+    def self.or(a, b)
+      # todo
+    end
+
+    private
+    def filter_precedence_predicates(collection)
+      # todo
+    end
+  end
+end

data/lib/antlr4ruby/atn/context/singleton_prediction_context.rb

@@ -0,0 +1,36 @@
+module Antlr4ruby
+  class SingletonPredictionContext < PredictionContext
+    attr_reader :parent, :return_state
+
+    def initialize(parent, return_state)
+      super(parent ? calculate_hash_code(parent, return_state) : calculate_empty_hash_code)
+      @parent, @return_state = parent, return_state
+    end
+
+    def self.create(parent, return_state)
+      return EmptyPredictionContext.INSTANCE if return_state == EMPTY_RETURN_STATE && !parent
+      SingletonPredictionContext.new(parent, return_state)
+    end
+
+    def get_parent(index)
+      parent
+    end
+
+    def get_return_state(index)
+      return_state
+    end
+
+    def size
+      1
+    end
+
+    def to_s
+      # todo
+    end
+
+    def eql?(other)
+      # todo
+    end
+
+  end
+end

data/lib/antlr4ruby/atn/info/accept_state_info.rb

@@ -0,0 +1,26 @@
+# finished
+# frozen_string_literal: true
+
+module Antlr4ruby
+  class AcceptStateInfo
+
+    def initialize(prediction, lexer_action_executor)
+      @prediction, @lexer_action_executor = prediction, lexer_action_executor
+    end
+
+    def get_prediction
+      @prediction
+    end
+
+    def get_lexer_action_executor
+      @lexer_action_executor
+    end
+
+
+    private
+    attr_reader :prediction, :lexer_action_executor
+
+
+  end
+end
+

data/lib/antlr4ruby/atn/info/ambiguity_info.rb

@@ -0,0 +1,13 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class AmbiguityInfo < DecisionEventInfo
+    attr_accessor :ambig_alts
+
+    def initialize(decision, configs, ambig_alts, input, start_index, stop_index, full_ctx)
+      super(decision, configs, input, start_index, stop_index, full_ctx)
+      @ambig_alts = ambig_alts
+    end
+  end
+end

data/lib/antlr4ruby/atn/info/conflict_info.rb

@@ -0,0 +1,39 @@
+# finished
+# frozen_string_literal: true
+
+
+
+module Antlr4ruby
+  class ConflictInfo
+
+    def initialize(conflicted_alts, exact)
+      @conflicted_alts, @exact = conflicted_alts, exact
+    end
+
+    private
+    attr_accessor :conflicted_alts, :exact
+
+    public
+    def get_conflicted_alts
+      @conflicted_alts
+    end
+
+    def is_exact?
+      @exact
+    end
+
+    def eql?(other)
+      return true if self.equal?(other)
+
+      return false unless other.instance_of?(ConflictInfo)
+      @exact == other.exact && conflicted_alts.eql?(other.conflicted_alts)
+    end
+
+    def hash
+      conflicted_alts.hash
+    end
+
+
+  end
+end
+

data/lib/antlr4ruby/atn/info/context_sensitivity_info.rb

@@ -0,0 +1,10 @@
+# finished
+
+
+module Antlr4ruby
+    class ContextSensitivityInfo < DecisionEventInfo
+      def initialize(decision, configs, input, start_index, stop_index)
+        super(decision, configs, input, start_index, stop_index, true)
+      end
+    end
+  end

data/lib/antlr4ruby/atn/info/decision_event_info.rb

@@ -0,0 +1,14 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class DecisionEventInfo
+    attr_reader :decision, :configs, :input, :start_index, :stop_index, :full_ctx
+
+    def initialize(decision, configs, input, start_index, stop_index, full_ctx)
+      @decision, @full_ctx, @stop_index, @input, @start_index, @configs =
+        decision, full_ctx, stop_index, input, start_index, configs
+    end
+
+  end
+end

data/lib/antlr4ruby/atn/info/decision_info.rb

@@ -0,0 +1,25 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class DecisionInfo
+    attr_reader :decision, :context_sensitivities, :errors, :ambiguities, :predicate_evals
+
+
+    attr_accessor  :invocations, :time_in_prediction,
+                :sll_total_look, :sll_min_look, :sll_max_look, :sll_max_look_event,
+                :ll_total_look, :ll_min_look, :ll_max_look, :ll_max_look_event,
+                :sll_atn_transitions, :sll_dfa_transitions, :ll_fallback, :ll_atn_transitions, :ll_dfa_transitions
+
+    def initialize(decision)
+      @decision, @context_sensitivities, @errors, @ambiguities, @predicate_evals  = decision, [], [], [], []
+    end
+
+    def to_s
+      "{decision=#{decision}, context_sensitivities=#{context_sensitivities.length}, errors=#{errors.length}, ambiguities=#{ambiguities.length}, " +
+        "sll_lookahead=#{sll_total_look}, sll_atn_transitions=#{sll_atn_transitions}, sll_dfa_transitions=#{sll_dfa_transitions}, ll_fallback=#{ll_fallback}, " +
+        "ll_lookahead=#{ll_total_look}, ll_atn_transitions=#{ll_atn_transitions}}"
+    end
+
+  end
+end

data/lib/antlr4ruby/atn/info/error_info.rb

@@ -0,0 +1,9 @@
+# finished
+
+module Antlr4ruby
+  class ErrorInfo < DecisionEventInfo
+    def initialize(decision, configs, input, start_index, stop_index, full_ctx)
+      super(decision, configs, input, start_index, stop_index, full_ctx)
+    end
+  end
+end

data/lib/antlr4ruby/atn/info/lookahead_event_info.rb

@@ -0,0 +1,12 @@
+# finished
+module Antlr4ruby
+  class LookaheadEventInfo < DecisionEventInfo
+    attr_accessor :predicted_alt
+
+    def initialize(decision, configs, predicted_alt, input, start_index, stop_index, full_ctx)
+      super(decision, configs, input, start_index, stop_index, full_ctx)
+      @predicted_alt = predicted_alt
+    end
+  end
+
+end

data/lib/antlr4ruby/atn/info/parse_info.rb

@@ -0,0 +1,18 @@
+module Antlr4ruby
+  class ParseInfo
+
+    def initialize(atn_simulator)
+      @atn_simulator = atn_simulator
+    end
+
+    def get_decision_info
+      # atn_simulator.get_decision_info todo
+    end
+
+
+
+
+    protected
+    attr_reader :atn_simulator
+  end
+end

data/lib/antlr4ruby/atn/info/predicate_eval_info.rb

@@ -0,0 +1,5 @@
+module Antlr4ruby
+  class PredicateEvalInfo < DecisionEventInfo
+  end
+
+end

data/lib/antlr4ruby/atn/lexer_atn_simulator.rb

@@ -0,0 +1,150 @@
+module Antlr4ruby
+  class LexerATNSimulator < ATNSimulator
+    MIN_DFA_EDGE = 0
+    MAX_DFA_EDGE = 127
+
+
+    def initialize(recognizer, atn, decision_to_dfa, shared_context_cache)
+      super(atn, shared_context_cache)
+      @decision_to_dfa, @recognizer = decision_to_dfa, recognizer
+    end
+
+
+    @@debug = false
+    @@dfa_debug = false
+
+    def self.debug
+      @@debug
+    end
+    # attr_reader :debug, :dfa_debug
+    attr_accessor :decision_to_dfa
+
+    def match(input, mode)
+      # todo
+    end
+
+    def reset
+      # todo
+    end
+
+    def clear_dfa
+      # todo
+    end
+
+    def get_dfa(mode)
+      # todo
+    end
+
+    def get_text(input)
+      # todo
+    end
+
+    def get_line
+      @line
+    end
+
+    def set_line(line)
+      @line = line
+    end
+
+    def get_char_position_in_line
+      @char_position_in_line
+    end
+
+    def set_char_position_in_line(pos)
+      @char_position_in_line = pos
+    end
+
+    def consume(input)
+      # todo
+    end
+
+    def get_token_name(t)
+      return 'EOF' if t == -1
+      [t].pack("U*")
+    end
+
+
+
+
+
+
+
+    protected
+    def match_atn(input)
+      # todo
+    end
+
+    def exec_atn(input, ds0)
+      # todo
+    end
+
+    def get_existing_target_state(s, t)
+      # todo
+    end
+
+    def compute_target_state(input, s, t)
+      # todo
+    end
+
+    def fail_or_accept(prev_accept, input, reach, t)
+      # todo
+    end
+
+    def get_reachable_config_set(input, closure, reach, t)
+      # todo
+    end
+
+    def accept(input, lexer_action_exec, sstart_index, index, line, char_pos)
+      # todo
+    end
+
+    def get_reachable_target(trans, t)
+      # todo
+    end
+
+    def compute_start_state(input, p)
+      # todo
+    end
+
+    def closure(input, config, configs, current_accept_state, speculative, treat_eor_as_epsilon)
+      # todo
+    end
+
+    def get_epsilon_target(input, config, t, configs, speculative, treat_eof_as_epsilon)
+      # todo
+    end
+
+    def evaluate_predicate(input, rule_index, pred_index, speculative)
+      # todo
+    end
+
+    def capture_sim_state(settings, input, dfa_state)
+      # todo
+    end
+
+    def add_dfa_edge(from, t, q)
+      # todo
+    end
+
+    def add_dfa_state(configs)
+      # todo
+    end
+
+    class SimState
+      protected
+      attr_accessor :index, :line, :char_pos, :dfa_state
+      def reset
+        @index, @line, @char_pos, @dfa_state =
+          -1, 0, -1, nil
+      end
+
+      def initialize
+        reset
+      end
+    end
+    attr_reader :recognizer
+    attr_accessor :start_index, :line, :char_position_in_line, :mode, :prev_accept
+
+  end
+end

data/lib/antlr4ruby/atn/ll1_analyzer.rb

@@ -0,0 +1,4 @@
+module Antlr4ruby
+  class LL1Analyzer
+  end
+end

data/lib/antlr4ruby/atn/parser_atn_simulator.rb

@@ -0,0 +1,4 @@
+module Antlr4ruby
+  class ParserATNSimulator < ATNSimulator
+  end
+end