antlr4ruby 0.1.0

data/lib/antlr4ruby/default_error_strategy.rb

@@ -0,0 +1,108 @@
+
+module Antlr4ruby
+  class DefaultErrorStrategy
+    protected
+    attr_accessor :error_recovery_mode, :last_error_index, :last_error_states,
+                  :next_tokens_context, :next_tokens_state
+
+    def begin_error_condition(recognizer)
+      # todo
+    end
+
+    def end_error_condition(recognizer)
+      # todo
+    end
+
+    def report_no_viable_alternative(recognizer, e)
+      # todo
+    end
+
+    def report_input_mismatch(recognizer, e)
+      # todo
+    end
+
+    def report_failed_predicate(recognizer, e)
+      # todo
+    end
+
+    def report_unwanted_token(recognizer)
+      # todo
+    end
+
+    def report_missing_token(recognizer)
+      # todo
+    end
+
+    def single_token_insertion(recognizer)
+      # todo
+    end
+
+    def single_token_deletion(recognizer)
+      # todo
+    end
+
+    def get_missing_symbol(recognizer)
+      # todo
+    end
+
+    def get_expected_tokens(recognizer)
+      # todo
+    end
+
+    def get_token_error_display(token)
+      # todo
+    end
+
+    def get_symbol_text(symbol)
+      # todo
+    end
+
+    def get_symbol_type(symbol)
+      # todo
+    end
+
+    def escape_ws_and_quote(s)
+      # todo
+    end
+
+    def get_error_recovery_set(recognizer)
+      # todo
+    end
+
+    def consume_until(recognizer, set)
+      # todo
+    end
+
+
+    public
+    # 重载函数
+    def reset(recognizer)
+      # todo
+    end
+
+    def in_error_recovery_mode(recognizer)
+      # todo
+    end
+
+    def report_match(recognizer)
+      # todo
+    end
+    def report_error(recognizer, e)
+      # todo
+    end
+
+    def recover(recognizer, e)
+      # todo
+    end
+
+    def sync(recognizer)
+      # todo
+    end
+
+    def recover_in_line(recognizer)
+      # todo
+    end
+
+
+  end
+end

data/lib/antlr4ruby/dfa/dfa.rb

@@ -0,0 +1,67 @@
+module Antlr4ruby
+  class DFA
+    attr_accessor :states,
+                  :s0,
+                  :decision,
+                  :atn_start_state
+
+    def initialize(atn_start_state, decision = 0)
+      super()
+      @atn_start_state = atn_start_state
+      @decision = decision
+
+      precedence_dfa = false
+      if @atn_start_state.instance_of?(StarLoopEntryState)
+        if @atn_start_state.is_precedence_decision
+          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
+
+      @precedence_dfa = precedence_dfa
+
+    end
+
+    def is_precedence_dfa
+      @precedence_dfa
+    end
+
+    def get_precedence_start_state(precedence)
+      unless is_precedence_dfa
+        # todo 抛出一个异常
+      end
+
+      s0.edges[precedence]
+    end
+
+    def set_precedence_start_state(precedence, start_state)
+      unless is_precedence_dfa
+        # todo 抛出一个异常
+      end
+
+      if precedence < 0
+        return
+      end
+
+      if precedence >= s0.edges.length
+        # todo 再检查一下 Arrays.copyOf 是什么意思
+        s0.edges = Array.slice(0, precedence + 1)
+      end
+      s0.edges[precedence] = start_state
+    end
+
+    def get_states
+      # todo
+    end
+
+    def to_lexer_string
+      # todo
+    end
+  end
+end
+

data/lib/antlr4ruby/dfa/dfa_serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Antlr4ruby
+  # 来一条注释
+
+  # 注释
+  class DFASerializer
+
+    def initialize(dfa, vocabulary)
+      super()
+      @dfa = dfa
+      @vocabulary = vocabulary
+    end
+
+    def get_edge_label(index)
+      @vocabulary.display_name(index - 1)
+    end
+
+    def get_state_string(state)
+      # todo
+    end
+
+    # @override
+    def to_s
+      # todo
+    end
+  end
+end

data/lib/antlr4ruby/dfa/dfa_state.rb

@@ -0,0 +1,80 @@
+module Antlr4ruby
+
+  class DFAState
+    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
+
+    attr_accessor :state_number,
+                  :configs,
+                  :edges,
+                  :is_accept_state,
+                  :prediction,
+                  :lexer_action_executor,
+                  :requires_full_context,
+                  :predicates
+
+    class PredPrediction
+      def initialize(pred, alt)
+        @alt = alt
+        @pred = pred
+      end
+
+      def to_s
+        # todo
+      end
+    end
+
+    def initialize(configs)
+      @configs = ATNConfigSet.new
+      @state_number = -1
+      @edges = []
+      @is_accept_state = false
+      @prediction = 0
+      @predicates = []
+
+      if configs
+        if configs.instance_of?(Integer)
+          @state_number = configs
+        elsif configs.instance_of?(ATNConfigSet)
+          @configs = configs
+        end
+      end
+    end
+
+    def get_alt_set
+      alts = Set.new
+      if @configs
+        # todo
+      end
+      if alts.empty?
+        return nil
+      end
+      alts
+    end
+
+    def hash
+      # todo
+    end
+
+    def eql?(other)
+      # todo
+    end
+
+    def to_s
+      # todo
+    end
+  end
+end

data/lib/antlr4ruby/dfa/lexer_dfa_serializer.rb

@@ -0,0 +1,12 @@
+module Antlr4ruby
+  class LexerDFASerializer < DFASerializer
+    def initialize(dfa)
+      super(dfa, Vocabulary::EMPTY_VOCABULARY)
+    end
+
+    # @override
+    def get_edge_label(index)
+      # todo
+    end
+  end
+end

data/lib/antlr4ruby/diagnostic_error_listener.rb

@@ -0,0 +1,18 @@
+
+module Antlr4ruby
+  class DiagnosticErrorListener < BaseErrorListener
+
+    def initialize(exact_only = true) @exact_only = exact_only; end
+
+
+    protected
+    attr_reader :exact_only
+    def get_decision_description(recognizer, dfa)
+      # todo
+    end
+
+    def get_conflicting_alts(reported_alts, configs)
+      # todo
+    end
+  end
+end

data/lib/antlr4ruby/exception/failed_predicate_exception.rb

@@ -0,0 +1,27 @@
+# finished
+module Antlr4ruby
+  class FailedPredicateException < RecognitionException
+
+    def initialize(recognizer, predicate, message)
+      super(recognizer, recognizer.get_input_stream, recognizer.ctx, message || "failed predicate: #{predicate}")
+    end
+
+    private
+    attr_reader :rule_index, :predicate_index, :predicate
+
+
+    public
+    def get_rule_index
+      @rule_index
+    end
+
+    def get_pred_index
+      @predicate_index
+    end
+
+    def get_predicate
+      @predicate
+    end
+
+  end
+end

data/lib/antlr4ruby/exception/input_mismatch_exception.rb

@@ -0,0 +1,16 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class InputMismatchException < RecognitionException
+
+    def initialize(recognizer, state, ctx)
+      ctx = recognizer.ctx unless ctx
+      super(recognizer, recognizer.get_input_stream, ctx)
+      set_offending_state(state) if state
+      set_offending_token(recognizer.get_current_token)
+    end
+
+
+  end
+end

data/lib/antlr4ruby/exception/lexer_no_viable_alt_exception.rb

@@ -0,0 +1,36 @@
+# finished
+# 已完成
+module Antlr4ruby
+  class LexerNoViableAltException < RecognitionException
+    def initialize(lexer, input, start_index, dead_end_configs)
+      super(lexer, input, nil )
+      @start_index, @dead_end_configs = start_index, dead_end_configs
+    end
+
+    private
+    attr_reader :start_index, :dead_end_configs
+
+    public
+    def get_dead_end_configs
+      @dead_end_configs
+    end
+
+    def get_start_index
+      @start_index
+    end
+
+    def get_input_stream
+      super
+    end
+
+    def to_s
+      symbol = ''
+      if start_index >= 0 && start_index < get_input_stream.size
+        symbol = get_input_stream.get_text(start_index..start_index)
+      end
+      "#{self.class.name}(#{symbol})"
+    end
+
+
+  end
+end

data/lib/antlr4ruby/exception/no_viable_alt_exception.rb

@@ -0,0 +1,29 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class NoViableAltException < RecognitionException
+
+    def initialize(recognizer, input, start,
+                   offsending, dead_end_configs, ctx)
+      ctx = ctx || recognizer.ctx
+      input = input || recognizer.get_input_stream
+      super(recognizer, input, ctx)
+      set_offending_token(offsending || recognizer.get_current_token)
+      @start_token = start || recognizer.get_current_token
+      @dead_end_configs = dead_end_configs
+    end
+
+    private
+    attr_reader :dead_end_configs, :start_token
+
+    public
+    def get_start_token
+      @start_token
+    end
+
+    def get_dead_end_configs
+      @dead_end_configs
+    end
+  end
+end

data/lib/antlr4ruby/exception/parse_cancellation_exception.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Antlr4ruby
+  class ParseCancellationException < RuntimeError
+    def initialize(msg = "ParseCancellationException")
+      super
+    end
+  end
+end
+

data/lib/antlr4ruby/exception/recognition_exception.rb

@@ -0,0 +1,55 @@
+# finished
+
+module Antlr4ruby
+  class RecognitionException < RuntimeError
+
+    def initialize(recognizer, input, ctx, msg="RecognitionException")
+      super(msg)
+      @recognizer, @input, @ctx = recognizer, input, ctx
+      if recognizer
+        @offending_state = recognizer.get_state
+      else
+        @offending_state = -1
+      end
+    end
+
+    private
+    attr_reader :recognizer, :ctx, :input
+    attr_accessor :offending_token, :offending_state
+
+    public
+    def get_offending_state
+      @offending_state
+    end
+
+    def set_offending_state(offending_state)
+      @offending_state = offending_state
+    end
+
+    def get_expected_tokens
+      return RangeSet.new unless recognizer
+      recognizer.get_atn.get_expected_tokens(offending_state, ctx)
+    end
+
+    def get_ctx
+      @ctx
+    end
+
+    def get_input_stream
+      @input
+    end
+
+    def get_offending_token
+      @offending_token
+    end
+
+    def set_offending_token(token)
+      @offending_token = token
+    end
+
+    def get_recognizer
+      @recognizer
+    end
+
+  end
+end

data/lib/antlr4ruby/int_stream.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+
+module Antlr4ruby
+  module IntStream
+    EOF = -1
+    UNKNOWN_SOURCE_NAME = '<unknown>'
+  end
+end
+
+

data/lib/antlr4ruby/interpreter_rule_context.rb

@@ -0,0 +1,19 @@
+# 已完成
+
+module Antlr4ruby
+  class InterpreterRuleContext < ParserRuleContext
+
+    def initialize(parent = nil, invoking_state = -1, rule_index = -1)
+      super(parent, invoking_state)
+      @rule_index = rule_index
+    end
+
+    def get_rule_index
+      @rule_index
+    end
+
+    protected
+    attr_accessor :rule_index
+
+  end
+end

data/lib/antlr4ruby/lexer.rb

@@ -0,0 +1,180 @@
+require 'antlr4ruby/recognizer'
+require 'antlr4ruby/token'
+
+
+module Antlr4ruby
+  # @abstract
+  class Lexer < Recognizer
+    DEFAULT_MODE = 0
+    MORE = -2
+    SKIP = -3
+    DEFAULT_TOKEN_CHANNEL = Token::DEFAULT_CHANNEL
+    HIDDEN = Token::HIDDEN_CHANNEL
+    MIN_CHAR_VALUE = 0x0000
+    MAX_CHAR_VALUE = 0x10ffff
+
+
+    attr_accessor :input, :token, :token_start_char_index,
+                  :token_start_line, :hit_eof, :channel,
+                  :type, :mode_stack, :mode, :text
+
+    def initialize(input)
+      super()
+      @token_start_char_index = -1
+      @mode = Lexer.DEFAULT_MODE
+      @mode_stack = IntegerStack.new
+      if input
+        @input = input
+        @token_factory_source_pair = Pair.new(self, input)
+      end
+    end
+
+
+    protected
+    attr_accessor :token_factory_source_pair, :factory
+
+    public
+    def reset
+      # todo
+    end
+
+    def skip
+      @type = SKIP
+    end
+
+    def more
+      @type = more
+    end
+
+    # 不能定义 mode 函数，会覆盖掉 attr_accessor
+    # def mode(m)
+    #   @mode = m
+    # end
+
+    def pop_mode
+      # todo
+    end
+
+    def push_mode(m)
+      p "push_mode #{m}" if LexerATNSimulator.debug
+      # todo
+    end
+
+    def emit(token)
+      # todo
+    end
+
+    def emit_eof
+      # todo
+    end
+
+    def set_line(line)
+      # todo
+    end
+
+    def set_char_position_in_line(position)
+      # todo
+    end
+
+    def get_char_index
+      # todo
+    end
+
+    def get_text
+      # todo
+    end
+
+    def set_text(text)
+      @text = text
+    end
+
+    def get_token
+      @token
+    end
+
+    def set_token(token)
+      @token = token
+    end
+
+    def set_type(token_type)
+      @type = token_type
+    end
+
+    def get_type
+      @type
+    end
+
+    def set_channel(channel)
+      @channel = channel
+    end
+
+    def get_channel
+      @channel
+    end
+
+    def get_channel_names
+      []
+    end
+
+    def get_mode_names
+      []
+    end
+
+    def get_all_tokens
+      # todo
+    end
+
+    def recover(e)
+      # todo
+    end
+
+    def notify_listeners(e)
+      # todo
+    end
+
+    def get_error_display(s)
+      # todo
+    end
+
+    def get_char_error_display(c)
+      # todo
+    end
+
+
+    def next_token
+      # todo
+    end
+
+    def set_token_factory(factory)
+      # todo
+    end
+
+    def get_token_factory
+      # todo
+    end
+
+    def set_input_stream(input)
+      # todo
+    end
+
+    def get_source_name
+      # todo
+    end
+
+    def get_input_stream
+      # todo
+    end
+
+    def get_line
+      # todo
+    end
+
+    def get_char_position_in_line
+      # todo
+    end
+
+
+
+
+  end
+end

data/lib/antlr4ruby/lexer_interpreter.rb

@@ -0,0 +1,5 @@
+
+module Antlr4ruby
+  class LexerInterpreter < Lexer
+  end
+end