antlr4ruby 0.1.0

data/lib/antlr4ruby/atn/prediction_mode.rb

@@ -0,0 +1,5 @@
+module Antlr4ruby
+  class PredictionMode
+  end
+
+end

data/lib/antlr4ruby/atn/profiling_atn_simulator.rb

@@ -0,0 +1,5 @@
+module Antlr4ruby
+  class ProfilingATNSimulator < ParserATNSimulator
+  end
+
+end

data/lib/antlr4ruby/atn/state/atn_state.rb

@@ -0,0 +1,109 @@
+# finished
+require 'antlr4ruby/misc/range_set'
+
+
+module Antlr4ruby
+  # @abstract
+  class ATNState
+
+    protected
+    attr_reader :transitions
+
+    public
+
+    INITIAL_NUM_TRANSITIONS = 4
+    INVALID_TYPE = 0
+    BASIC = 1
+    RULE_START = 2
+    BLOCK_START = 3
+    PLUS_BLOCK_START = 4
+    STAR_BLOCK_START = 5
+    TOKEN_START = 6
+    RULE_STOP = 7
+    BLOCK_END = 8
+    STAR_LOOP_BACK = 9
+    STAR_LOOP_ENTRY = 10
+    PLUS_LOOP_BACK = 11
+    LOOP_END = 12
+    INVALID_STATE_NUMBER = -1
+
+    @@serialization_names = %w[INVALID BASIC RULE_START BLOCK_START PLUS_BLOCK_START STAR_BLOCK_START TOKEN_START RULE_STOP BLOCK_END STAR_LOOP_BACK STAR_LOOP_ENTRY PLUS_LOOP_BACK LOOP_END]
+
+    attr_accessor :atn, :state_number, :rule_index, :epsilon_only_transitions, :next_token_within_rule
+
+    def initialize
+      @atn, @state_number, @rule_index, @epsilon_only_transitions, @transitions, @next_token_within_rule =
+        nil, INVALID_STATE_NUMBER, 0, false, [], RangeSet.new
+    end
+
+    def get_state_type
+      raise NotImplementedError.new("#{self.class.name}#get_state_type is abstract method")
+    end
+
+    def get_number_of_transitions
+      transitions.length
+    end
+
+    def add_transition(transition, index = transitions.length)
+      if transitions.empty?
+        @epsilon_only_transitions = transition.is_epsilon?
+      elsif epsilon_only_transitions != transition.is_epsilon?
+        p "ATN state #{state_number} has both epsilon and non-epsilon transitions."
+        @epsilon_only_transitions = false
+      end
+
+      already_present = false
+      transitions.each do |t|
+        if t.target.state_number == transition.target.state_number
+          if t.label && transition.label && t.label.eql?(transition.label)
+            already_present = true
+            break
+          elsif t.is_epsilon? && transition.is_epsilon?
+            already_present = true
+            break
+          end
+        end
+      end
+
+      transitions[index] = transition unless already_present
+    end
+
+    def get_transition(i)
+      transitions[i]
+    end
+
+    def set_transition(i, transition)
+      transitions[i] = transition
+    end
+
+    def remove_transition(i)
+      result = transitions[i]
+      transitions.delete_at(i)
+      result
+    end
+
+    def only_has_epsilon_transitions?
+      @epsilon_only_transitions
+    end
+
+    def set_rule_index(rule_index)
+      @rule_index = rule_index
+    end
+
+
+    def hash
+      @state_number
+    end
+
+    def eql?(other)
+      return false unless other.instance_of?(ATNState)
+      @state_number == other.state_number
+    end
+
+    def to_s
+      state_number.to_s
+    end
+
+
+  end
+end

data/lib/antlr4ruby/atn/state/basic_block_start_state.rb

@@ -0,0 +1,12 @@
+# finished
+
+module Antlr4ruby
+
+  # @final
+  class BasicBlockStartState < BlockStartState
+
+    def get_state_type
+      BLOCK_START
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/basic_state.rb

@@ -0,0 +1,13 @@
+# finished
+
+module Antlr4ruby
+
+  # @final
+  class BasicState < ATNState
+    def get_state_type
+      BASIC
+    end
+
+  end
+
+end

data/lib/antlr4ruby/atn/state/block_end_state.rb

@@ -0,0 +1,13 @@
+# finished
+
+module Antlr4ruby
+
+  # @final
+  class BlockEndState < ATNState
+    attr_accessor :start_state
+
+    def get_state_type
+      BLOCK_END
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/block_start_state.rb

@@ -0,0 +1,14 @@
+# finished
+module Antlr4ruby
+
+  # @abstract
+  class BlockStartState < DecisionState
+    attr_accessor :end_state
+
+    # 似乎应该这样
+    def get_state_type
+      BLOCK_START
+    end
+  end
+
+end

data/lib/antlr4ruby/atn/state/decision_state.rb

@@ -0,0 +1,17 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+
+  # @abstract
+  class DecisionState < ATNState
+    attr_accessor :decision, :non_greedy
+
+    def initialize
+      super
+      @decision = -1
+      @non_greedy = false
+    end
+
+  end
+end

data/lib/antlr4ruby/atn/state/invalid_state.rb

@@ -0,0 +1,12 @@
+# finished
+# frozen_string_literal: true
+
+
+module Antlr4ruby
+  class InvalidState < BasicState
+    def get_state_type
+      INVALID_STATE_NUMBER
+    end
+  end
+end
+

data/lib/antlr4ruby/atn/state/loop_end_state.rb

@@ -0,0 +1,14 @@
+# finished
+
+module Antlr4ruby
+  # @final
+  class LoopEndState < ATNState
+    attr_accessor :loop_back_state
+
+    def get_state_type
+      LOOP_END
+    end
+
+
+  end
+end

data/lib/antlr4ruby/atn/state/plus_block_start_state.rb

@@ -0,0 +1,11 @@
+# finished
+
+module Antlr4ruby
+  class PlusBlockStartState < BlockStartState
+    attr_accessor :loop_back_state
+
+    def get_state_type
+      PLUS_BLOCK_START
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/plus_loopback_state.rb

@@ -0,0 +1,10 @@
+# finished
+module Antlr4ruby
+  # @final
+  class PlusLoopbackState < DecisionState
+
+    def get_state_type
+      PLUS_LOOP_BACK
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/rule_start_state.rb

@@ -0,0 +1,10 @@
+# finished
+module Antlr4ruby
+  class RuleStartState < ATNState
+    attr_accessor :stop_state, :is_left_recursive_rule
+
+    def get_state_type
+      RULE_START
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/rule_stop_state.rb

@@ -0,0 +1,9 @@
+# finished
+module Antlr4ruby
+  class RuleStopState < ATNState
+    def get_state_type
+      RULE_STOP
+    end
+  end
+
+end

data/lib/antlr4ruby/atn/state/simulator_state.rb

@@ -0,0 +1,17 @@
+# finished
+# frozen_string_literal: true
+
+module Antlr4ruby
+  class SimulatorState
+    attr_accessor :outer_context, :s0,
+                  :use_context, :remaining_outer_context
+
+    def initialize(outer_context, s0, use_context, remaining_outer_context)
+      @outer_context, @s0, @use_context, @remaining_outer_context =
+        outer_context, s0, use_context, remaining_outer_context
+    end
+
+
+  end
+end
+

data/lib/antlr4ruby/atn/state/star_block_start_state.rb

@@ -0,0 +1,8 @@
+# finished
+module Antlr4ruby
+  class StarBlockStartState < BlockStartState
+    def get_state_type
+      STAR_BLOCK_START
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/star_loop_entry_state.rb

@@ -0,0 +1,15 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class StarLoopEntryState < DecisionState
+    attr_accessor :is_precedence_decision,
+                  :loop_back_state
+
+    # @override
+    def get_state_type
+      STAR_LOOP_ENTRY
+    end
+  end
+
+end

data/lib/antlr4ruby/atn/state/star_loopback_state.rb

@@ -0,0 +1,10 @@
+# finished
+module Antlr4ruby
+  class StarLoopbackState < ATNState
+
+    # 删除为使用的方法
+    def get_state_type
+      STAR_LOOP_BACK
+    end
+  end
+end

data/lib/antlr4ruby/atn/state/tokens_start_state.rb

@@ -0,0 +1,10 @@
+# finished
+require 'antlr4ruby/atn/state/decision_state'
+
+module Antlr4ruby
+  class TokensStartState < DecisionState
+    def get_state_type
+      TOKEN_START
+    end
+  end
+end

data/lib/antlr4ruby/atn/transition/abstract_predicate_transition.rb

@@ -0,0 +1,11 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  # @abstract
+  class AbstractPredicateTransition < Transition
+    def initialize(target) super(target) end
+  end
+end
+
+

data/lib/antlr4ruby/atn/transition/action_transition.rb

@@ -0,0 +1,36 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  # @final
+  class ActionTransition < Transition
+    attr_reader :rule_index, :action_index, :is_ctx_dependent
+
+    def initialize(target,
+                   rule_index,
+                   action_index = -1,
+                   is_ctx_dependent = false)
+      super(target)
+      @rule_index = rule_index
+      @action_index = action_index
+      @is_ctx_dependent = is_ctx_dependent
+    end
+
+    def get_serialization_type
+      ACTION
+    end
+
+    def is_epsilon?
+      true
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      false
+    end
+
+    def to_s
+      "action_#{rule_index}:#{action_index}"
+    end
+
+  end
+end

data/lib/antlr4ruby/atn/transition/atom_transition.rb

@@ -0,0 +1,29 @@
+# finished
+
+module Antlr4ruby
+  # @final
+  class AtomTransition < Transition
+    attr_reader :atom_label
+
+    def initialize(target, label)
+      super(target)
+      @atom_label = label
+    end
+
+    def get_serialization_type
+      ATOM
+    end
+
+    def label
+      RangeSet.new([atom_label..atom_label])
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      @atom_label == symbol
+    end
+
+    def to_s
+      "#{atom_label}"
+    end
+  end
+end

data/lib/antlr4ruby/atn/transition/code_point_transitions.rb

@@ -0,0 +1,7 @@
+# 从未使用
+
+module Antlr4ruby
+  # @abstract
+  class CodePointTransitions
+  end
+end

data/lib/antlr4ruby/atn/transition/epsilon_transition.rb

@@ -0,0 +1,35 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  # @final
+  class EpsilonTransition < Transition
+
+
+    def initialize(target, outermost_ret = -1)
+      super(target)
+      @outermost_precedence_return = outermost_ret
+    end
+
+    private
+    attr_reader :outermost_precedence_return
+
+    public
+    def get_serialization_type
+      EPSILON
+    end
+
+    def is_epsilon?
+      true
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      false
+    end
+
+    def to_s
+      'epsilon'
+    end
+
+  end
+end

data/lib/antlr4ruby/atn/transition/not_set_transition.rb

@@ -0,0 +1,23 @@
+# finished
+
+module Antlr4ruby
+  # @final
+  class NotSetTransition < SetTransition
+    def initialize(target, range_set)
+      super
+    end
+
+    def get_serialization_type
+      NOT_SET
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      symbol >= min_vocab_symbol && symbol <= max_vocab_symbol && !super(symbol, min_vocab_symbol, max_vocab_symbol)
+    end
+
+    def to_s
+      "~#{super}"
+    end
+  end
+
+end

data/lib/antlr4ruby/atn/transition/precedence_predicate_transition.rb

@@ -0,0 +1,34 @@
+module Antlr4ruby
+  # @final
+  class PrecedencePredicateTransition < AbstractPredicateTransition
+    attr_reader :precedence
+    def initialize(target, precedence)
+      super(target)
+      @precedence = precedence
+    end
+
+    def get_predicate
+      # todo
+    end
+
+    def is_epsilon?
+      true
+    end
+
+    def get_serialization_type
+      PRECEDENCE
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      false
+    end
+
+    def to_s
+      "#{precedence} >= _p"
+    end
+
+
+
+
+  end
+end

data/lib/antlr4ruby/atn/transition/predicate_transition.rb

@@ -0,0 +1,29 @@
+module Antlr4ruby
+  class PredicateTransition < AbstractPredicateTransition
+    attr_reader :rule_index, :pred_index, :is_ctx_dependent
+
+    def initialize(target, rule_index, pred_index, is_ctx_dependent)
+      super(target)
+      @rule_index, @pred_index, @is_ctx_dependent = rule_index, pred_index, is_ctx_dependent
+    end
+
+    def get_serialization_type
+      PREDICATE
+    end
+
+    def is_epsilon?
+      true
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      false
+    end
+
+    # todo get_predicate
+
+    def to_s
+      "pred_#{rule_index}:#{pred_index}"
+    end
+  end
+
+end

data/lib/antlr4ruby/atn/transition/range_transition.rb

@@ -0,0 +1,30 @@
+# finished
+
+module Antlr4ruby
+  class RangeTransition < Transition
+    attr_reader :from, :to
+
+    def initialize(target, from, to)
+      super(target)
+      @from, @to = from, to
+    end
+
+    def get_serialization_type
+      RANGE
+    end
+
+    def label
+      RangeSet.new([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/antlr4ruby/atn/transition/rule_transition.rb

@@ -0,0 +1,29 @@
+# finished
+module Antlr4ruby
+  class RuleTransition < Transition
+    attr_reader :rule_index, :precedence
+    attr_accessor :follow_state
+
+    def initialize(rule_start, rule_index, precedence, follow_state)
+      super(rule_start)
+      @rule_index, @precedence, @follow_state = rule_index, precedence, follow_state
+    end
+
+    def get_serialization_type
+      RULE
+    end
+
+    def is_epsilon?
+      true
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      false
+    end
+
+
+
+
+
+  end
+end

data/lib/antlr4ruby/atn/transition/set_transition.rb

@@ -0,0 +1,31 @@
+# finished
+
+module Antlr4ruby
+  class SetTransition < Transition
+    def initialize(target, range_set)
+      super(target)
+      range_set = RangeSet.new([0..0]) unless range_set
+      @range_set = range_set
+    end
+
+    attr_reader :range_set
+
+    def get_serialization_type
+      SET
+    end
+
+    def label
+      @range_set
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      range_set.include?(symbol)
+    end
+
+    def to_s
+      range_set.to_s
+    end
+
+
+  end
+end