antlr4ruby 0.1.0

data/lib/antlr4ruby/tree/terminal_node.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+# 已完成
+
+module Antlr4ruby
+
+  class TerminalNode
+    attr_accessor :symbol, :parent
+
+    def initialize(symbol)
+      super()
+      @symbol = symbol
+    end
+
+    # @!override
+    def get_child(i)
+      nil
+    end
+
+    # @!override
+    def get_symbol
+      @symbol
+    end
+
+    def get_parent
+      @parent
+    end
+
+    # @!override
+    def set_parent(parent)
+      @parent = parent
+    end
+
+    # @!override
+    def get_payload
+      @symbol
+    end
+
+    # @!override
+    def get_source_interval
+      unless @symbol
+        return (-1)..(-2)
+      end
+      token_index = self.symbol.get_token_index
+      token_index..token_index
+    end
+
+    # @override
+    def get_child_count
+      0
+    end
+
+    # @override
+    def accept(visitor)
+      visitor.visit_terminal(self)
+    end
+
+    # @override
+    def get_text
+      self.symbol.get_text
+    end
+
+    # @override
+    def to_string_tree(recognizer: nil, rule_names: [])
+      self.to_s
+    end
+
+    # @override
+    def to_s
+      if @symbol.get_type == Token::EOF
+        return '<EOF>'
+      end
+      self.symbol.get_text
+    end
+
+  end
+end
+
+
+

data/lib/antlr4ruby/tree/trees.rb

@@ -0,0 +1,161 @@
+# 已完成
+
+module Antlr4ruby
+
+  class Trees
+
+    class << self
+      def to_string_tree(tree, recognizer: nil, rule_names: [])
+        rule_names = recognizer.get_rule_names if recognizer
+        # todo 转义处理
+        s = get_node_text(tree, rule_names: rule_names)
+        return s if tree.get_child_count <= 0
+        tree.get_child_count.times do |i|
+          child = tree.get_child(i)
+          s += ' ' + to_string_tree(child, rule_names: rule_names) if child
+        end
+        "(#{s})"
+      end
+
+      def get_node_text(tree, recognizer: nil, rule_names: [])
+
+        rule_names = recognizer.get_rule_names if recognizer
+        if tree.instance_of?(RuleContext)
+          rule_index = tree.get_rule_context.get_rule_index
+          return rule_names[rule_index]
+        elsif tree.instance_of?(ErrorNode)
+          return tree.to_s
+        elsif tree.instance_of?(TerminalNode)
+          symbol = tree.get_symbol
+          return symbol.get_text if symbol
+        end
+        tree.get_payload.to_s
+      end
+
+      def get_children(tree)
+        kids = []
+        tree.get_child_count.times do |i|
+          kids.push(tree.get_child(i))
+        end
+        kids
+      end
+
+      def get_ancestors(tree)
+        return [] if tree.get_parent == nil
+        ancestors = []
+        tree = tree.get_parent
+        while tree
+          ancestors.push(tree)
+          tree = tree.get_parent
+        end
+        ancestors
+      end
+
+      def is_ancestor_of?(t, u)
+        return false if t == nil || u == nil || t.get_parent == nil
+        p = u.get_parent
+        while p
+          return true if t.equal?(p)
+          p = p.get_parent
+        end
+        false
+      end
+
+      def find_all_token_nodes(t, token_type)
+        find_all_nodes(t, token_type, true)
+      end
+
+      def find_all_rule_nodes(t, rule_index)
+        find_all_nodes(t, rule_index, false)
+      end
+
+      def find_all_nodes(t, index, find_tokens)
+        nodes = []
+        _find_all_nodes(t, index, find_tokens, nodes)
+        nodes
+      end
+
+      def _find_all_nodes(t, index, find_tokens, nodes)
+        if find_tokens && t.instance_of?(TerminalNode)
+          nodes.push(t) if t.get_symbol.get_type == index
+        elsif !find_tokens && t.instance_of?(ParserRuleContext)
+          nodes.push(t) if t.get_rule_index == index
+        end
+
+        t.get_child_count.times do |i|
+          child = t.get_child(i)
+          _find_all_nodes(child, index, find_tokens, nodes) if child
+        end
+      end
+
+      def get_descendants(t)
+        nodes = [t]
+        n = t.get_child_count
+        n.times do |i|
+          child = t.get_child(i)
+          nodes.push(*get_descendants(child)) if child
+        end
+        nodes
+      end
+
+      def get_root_of_subtree_enclosing_region(t, start_token_index, stop_token_index)
+        n = t.get_child_count
+        n.times do |i|
+          child = t.get_child(i)
+          if child
+            r = get_root_of_subtree_enclosing_region(child, start_token_index, stop_token_index)
+            return r if r
+          end
+
+        end
+        if t.instance_of?(ParserRuleContext)
+          return t if start_token_index >= t.get_start.get_token_index && (t.get_stop == nil || stop_token_index <= t.get_stop.get_token_index)
+        end
+        nil
+      end
+
+      def strip_children_out_of_range(t, root, start_index, stop_index)
+        if t == nil
+          return
+        end
+
+        t.get_child_count.times do |i|
+          child = t.get_child(i, nil )
+          if child and child.instance_of?(ParserRuleContext)
+            range = child.get_source_interval
+            if (range.first < start_index || range.last > stop_index) && is_ancestor_of?(child, root)
+              abbrev = CommonToken.new(type: Token::INVALID_TYPE, text: '...')
+              t.children[i] = TerminalNode.new(abbrev)
+            end
+          end
+
+        end
+      end
+
+      def find_node_such_that(t, pred)
+        if pred.test(t)
+          return t
+        end
+
+        unless t
+          return nil
+        end
+
+        n = t.get_child_count
+        n.times do |i|
+          u = find_node_such_that(t.get_child(i), pred)
+          if u
+            return u
+          end
+        end
+        nil
+
+      end
+
+    end
+
+  end
+
+end
+
+

data/lib/antlr4ruby/unbuffered_char_stream.rb

@@ -0,0 +1,7 @@
+# 似乎用不上
+
+module Antlr4ruby
+  class UnbufferedCharStream
+
+  end
+end

data/lib/antlr4ruby/unbuffered_token_stream.rb

@@ -0,0 +1,8 @@
+# 似乎用不上
+
+
+module Antlr4ruby
+  class UnbufferedTokenStream
+
+  end
+end

data/lib/antlr4ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Antlr4ruby
+  VERSION = "0.1.0"
+end

data/lib/antlr4ruby/vocabulary.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# 已完成
+
+module Antlr4ruby
+
+  class Vocabulary
+    def initialize(literal_names, symbolic_names, display_names = [])
+      super()
+      @literal_names = literal_names || EMPTY_NAMES
+      @symbolic_names = symbolic_names || EMPTY_NAMES
+      @display_names = display_names || EMPTY_NAMES
+      longer = literal_names.length > symbolic_names.length ? literal_names.length : symbolic_names.length
+      @max_token_type = (longer > @display_names.length ? longer : @display_names.length) - 1
+    end
+
+
+    private
+    EMPTY_NAMES = [].freeze
+
+    attr_reader :literal_names, :symbolic_names,
+                :display_names, :max_token_type
+
+    public
+    EMPTY_VOCABULARY = Vocabulary.new(EMPTY_NAMES, EMPTY_NAMES, EMPTY_NAMES)
+
+    def get_literal_name(token_type)
+      @literal_names[token_type]
+    end
+
+    def get_symbolic_name(token_type)
+      return 'EOF' if token_type == Token::EOF
+
+      @symbolic_names[token_type]
+    end
+
+    def get_display_name(token_type)
+      @display_names[token_type] || get_literal_name(token_type) || get_symbolic_name(token_type) || token_type.to_s
+    end
+
+    def get_max_token_type
+      @max_token_type
+    end
+
+
+
+    class << self
+      def from_token_names(token_names)
+        return EMPTY_VOCABULARY if !token_names || (token_names.length <= 0)
+
+        literal_names = token_names.clone
+        symbolic_names = token_names.clone
+        (0..token_names.length).each do |i|
+          token_name = token_names[i]
+          next unless token_name
+
+          unless token_name.empty?
+            case token_name[0]
+            when '\''
+              symbolic_names[i] = nil
+              next
+            when /[A-Z]+/
+              literal_names[i] = nil
+              next
+            end
+          end
+          literal_names[i] = nil
+          symbolic_names[i] = nil
+        end
+        Vocabulary.new(literal_names, symbolic_names, token_names)
+      end
+    end
+  end
+end

data/lib/antlr4ruby.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "antlr4ruby/version"
+
+module Antlr4ruby
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/example/Hello.g4

@@ -0,0 +1,9 @@
+lexer grammar Hello;
+
+fragment Digit: [0-9];
+fragment Letter: [a-zA-Z];
+ID: Letter (Digit | Letter)*;
+NUMBER: Digit + ;
+
+
+

data/lib/example/hello_lexer.rb

@@ -0,0 +1,80 @@
+=begin
+  版本(ANTLR Version): 4.11.1
+  语法(Grammar):       Hello.g4
+=end
+
+
+require 'antlr4ruby/lexer'
+require 'antlr4ruby/vocabulary'
+require 'antlr4ruby/atn/atn_deserializer'
+include Antlr4ruby
+
+# todo LexerATNSimulator Lexer ATN PredictionContextCache DFA
+class HelloLexer < Lexer
+  def initialize(input)
+    super(input)
+    @interpreter = LexerATNSimulator.new(self, @atn, @decision_to_dfa, @shared_context_cache)
+  end
+
+  ID=1, NUMBER=2, WS=3
+  @@channel_names = %w[DEFAULT_TOKEN_CHANNEL HIDDEN]
+
+  @@mode_names = [
+    "DEFAULT_MODE"
+  ]
+
+  @@rule_names = %w[Digit Letter ID NUMBER WS]
+
+  LITERAL_NAMES = []
+  SYMBOLIC_NAMES = [nil, "ID", "NUMBER", "WS"]
+  VOCABULARY = Vocabulary.new(LITERAL_NAMES, SYMBOLIC_NAMES);
+
+  def get_vocabulary
+    VOCABULARY
+  end
+
+
+  def get_grammar_file_name
+    "Hello.g4"
+  end
+
+  def get_rule_names
+    @@rule_names
+  end
+
+  def get_serialized_atn
+    @@serialized_atn
+  end
+
+  def get_channel_names
+    @@channel_names
+  end
+
+  def get_mode_names
+    @@mode_names
+  end
+
+  def get_atn
+    @@atn
+  end
+
+  @@serialized_atn = [4,0,3,32,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,
+                      7,4,1,0,1,0,1,1,1,1,1,2,1,2,1,2,5,2,19,8,2,10,2,12,2,22,9,2,1,3,4,3,25,
+                      8,3,11,3,12,3,26,1,4,1,4,1,4,1,4,0,0,5,1,0,3,0,5,1,7,2,9,3,1,0,3,1,0,48,
+                      57,2,0,65,90,97,122,3,0,9,10,13,13,32,32,32,0,5,1,0,0,0,0,7,1,0,0,0,0,
+                      9,1,0,0,0,1,11,1,0,0,0,3,13,1,0,0,0,5,15,1,0,0,0,7,24,1,0,0,0,9,28,1,0,
+                      0,0,11,12,7,0,0,0,12,2,1,0,0,0,13,14,7,1,0,0,14,4,1,0,0,0,15,20,3,3,1,
+                      0,16,19,3,1,0,0,17,19,3,3,1,0,18,16,1,0,0,0,18,17,1,0,0,0,19,22,1,0,0,
+                      0,20,18,1,0,0,0,20,21,1,0,0,0,21,6,1,0,0,0,22,20,1,0,0,0,23,25,3,1,0,0,
+                      24,23,1,0,0,0,25,26,1,0,0,0,26,24,1,0,0,0,26,27,1,0,0,0,27,8,1,0,0,0,28,
+                      29,7,2,0,0,29,30,1,0,0,0,30,31,6,4,0,0,31,10,1,0,0,0,4,0,18,20,26,1,6,
+                      0,0]
+  @@atn = ATNDeserializer.new.deserialize(@@serialized_atn)
+
+
+  protected
+  @@decision_to_dfa = (0...@@atn.get_number_of_decisions).map { |i| DFA.new(@@atn.get_decision_state(i), i) }
+  @@shared_context_cache = PredictionContextCache.new
+
+end
+

data/lib/example/hello_lexer.rbs

@@ -0,0 +1,37 @@
+class HelloLexer < Antlr4ruby::Lexer
+  Id: Integer
+  ID: Integer
+  LITERAL_NAMES: Array[String]
+  NUMBER: Integer
+  Number: Integer
+
+  SYMBOLIC_NAMES: Array[String]
+
+  VOCABULARY: Antlr4ruby::Vocabulary
+
+  WS: Integer
+
+  @@atn: Antlr4ruby::ATN
+  @@channel_names: Array[String]
+  @@decision_to_dfa: Array[Antlr4ruby::DFA]
+  @@mode_names: Array[String]
+  @@rule_names: Array[String]
+
+  @@serialized_atn: Array[Integer]
+
+  @@shared_context_cache: Antlr4ruby::PredictionContextCache
+
+  def get_atn: -> Antlr4ruby::ATN
+
+  def get_channel_names: -> Array[String]
+
+  def get_grammar_file_name: -> String
+
+  def get_mode_names: -> Array[String]
+
+  def get_rule_names: -> Array[String]
+
+  def get_serialized_atn: -> Array[Integer]
+
+  def get_vocabulary: -> Antlr4ruby::Vocabulary
+end

data/lib/main.rb

@@ -0,0 +1,14 @@
+require 'antlr4ruby/common_token_stream'
+require 'antlr4ruby/char_streams'
+require 'example/hello_lexer'
+
+include Antlr4ruby
+
+stream = CharStreams.from_string('hello world 123456 ____123___     89231 GH')
+lexer = HelloLexer.new(stream)
+tokens = CommonTokenStream.new(lexer)
+tokens.get_number_of_on_channel_tokens.times do |i|
+  p tokens.get(i)
+end
+
+

data/sig/antlr4ruby/antlr_error_listener.rbs

@@ -0,0 +1,23 @@
+# 已完成
+
+module Antlr4ruby
+  interface _ANTLRErrorListener
+    def syntax_error: (
+        Recognizer[untyped, untyped], Object, Integer, Integer, String, RecognitionException
+      ) -> void
+
+    # 后面这些看情况取舍
+    def report_ambiguity: (
+        Parser, DFA, Integer, Integer, bool, BitSet, ATNConfigSet
+      ) -> void
+
+    def report_attempting_full_context: (
+        Parser, DFA, Integer, Integer, BitSet, ATNConfigSet
+      ) -> void
+
+    def report_context_sensitivity: (
+        Parser, DFA, Integer, Integer, Integer, ATNConfigSet
+      ) -> void
+  end
+end
+

data/sig/antlr4ruby/antlr_error_strategy.rbs

@@ -0,0 +1,13 @@
+# 已完成
+
+module Antlr4ruby
+  interface _ANTLRErrorStrategy
+    def reset: (Parser) -> void
+    def recover_in_line:(Parser) -> _Token
+    def recover: (Parser, RecognitionException) -> void
+    def sync: (Parser) -> void
+    def in_error_recovery_mode: (Parser) -> bool
+    def report_match: (Parser) -> void
+    def report_error: (Parser, RecognitionException) -> void
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_action.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  interface _LexerAction
+    def get_action_type: -> Symbol
+
+    def is_position_dependent: -> bool
+
+    def execute: (Lexer) -> void
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_action_executor.rbs

@@ -0,0 +1,22 @@
+module Antlr4ruby
+
+  class LexerActionExecutor
+    def self.append: (LexerActionExecutor, _LexerAction) -> LexerActionExecutor
+
+    attr_reader hash_code: Integer
+
+    def initialize: (Array[_LexerAction]) -> void
+
+    def execute: (Lexer, _CharStream, Integer) -> void
+
+    def fix_offset_before_match: (Integer) -> LexerActionExecutor
+
+    def get_lexer_actions: -> Array[_LexerAction]
+
+    # def execute: () -> void
+
+    private
+
+    attr_reader lexer_actions: Array[_LexerAction]
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_action_type.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class LexerActionType
+    # todo
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_channel_action.rbs

@@ -0,0 +1,15 @@
+module Antlr4ruby
+
+  # @final 实现接口 LexerAction
+  class LexerChannelAction
+    include _LexerAction
+
+    def initialize: (Integer) -> void
+
+    def get_channel: -> Integer
+
+    private
+
+    attr_reader channel: Integer
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_custom_action.rbs

@@ -0,0 +1,17 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerCustomAction
+    include _LexerAction
+
+    attr_reader action_index: Integer
+
+    def get_action_index: -> Integer
+
+    def get_rule_index: -> Integer
+
+    private
+
+    attr_reader rule_index: Integer
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_indexed_custom_action.rbs

@@ -0,0 +1,19 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerIndexedCustomAction
+    include _LexerAction
+
+    def initialize: (Integer, _LexerAction) -> void
+
+    attr_reader action: _LexerAction
+
+    def get_action: -> _LexerAction
+
+    def get_offset: -> Integer
+
+    private
+
+    attr_reader offset: Integer
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_mode_action.rbs

@@ -0,0 +1,16 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerModeAction
+    include _LexerAction
+
+    def initialize: (Integer) -> void
+
+    def get_mode: -> Integer
+
+    private
+
+    attr_reader mode: Integer
+  end
+
+end

data/sig/antlr4ruby/atn/action/lexer_more_action.rbs

@@ -0,0 +1,9 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerMoreAction
+    INSTANCE: LexerMoreAction
+
+    include _LexerAction
+  end
+end

data/sig/antlr4ruby/atn/action/lexer_pop_mode_action.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerPopModeAction
+    INSTANCE: LexerPopModeAction
+
+    include _LexerAction
+  end
+
+end

data/sig/antlr4ruby/atn/action/lexer_push_mode_action.rbs

@@ -0,0 +1,16 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerPushModeAction
+    include _LexerAction
+
+    def initialize: (Integer) -> void
+
+    def get_mode: -> Integer
+
+    private
+
+    attr_reader mode: Integer
+  end
+
+end

data/sig/antlr4ruby/atn/action/lexer_skip_action.rbs

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  # @final LexerAction
+  class LexerSkipAction
+    INSTANCE: LexerSkipAction
+
+    include _LexerAction
+  end
+
+end