antlr4ruby 0.1.0

data/sig/antlr4ruby/exception/lexer_no_viable_alt_exception.rbs

@@ -0,0 +1,15 @@
+
+module Antlr4ruby
+  class LexerNoViableAltException < RecognitionException
+    attr_reader start_index: Integer
+    attr_reader dead_end_configs: ATNConfigSet
+
+    def initialize: (Lexer, _CharStream, Integer, ATNConfigSet) -> void
+
+    def get_dead_end_configs: -> ATNConfigSet
+
+    def get_start_index: -> Integer
+
+    def get_input_stream: -> _CharStream
+  end
+end

data/sig/antlr4ruby/exception/no_viable_alt_exception.rbs

@@ -0,0 +1,14 @@
+
+module Antlr4ruby
+  class NoViableAltException < RecognitionException
+    attr_reader start_token: _Token
+    attr_reader dead_end_configs: ATNConfigSet?
+
+    def initialize: (Parser, _TokenStream?, _Token?, _Token?, ATNConfigSet?, ParserRuleContext?) -> void
+
+    def get_dead_end_configs: -> ATNConfigSet?
+
+    def get_start_token: -> _Token
+
+  end
+end

data/sig/antlr4ruby/exception/recognition_exception.rbs

@@ -0,0 +1,30 @@
+
+module Antlr4ruby
+  # todo 继承运行时异常
+  class RecognitionException
+    attr_reader ctx: RuleContext
+
+    attr_reader input: _IntStream
+    attr_accessor offending_state: Integer
+    attr_accessor offending_token: _Token
+    attr_reader recognizer: Recognizer[untyped, untyped]
+
+    def initialize: (Recognizer[untyped, untyped], _IntStream, ParserRuleContext?, String) -> void
+
+    def get_ctx: -> RuleContext
+
+    def get_expected_tokens: -> RangeSet[Integer]
+
+    def get_input_stream: -> _IntStream
+
+    def get_offending_state: -> Integer
+
+    def get_offending_token: -> _Token
+
+    def get_recognizer: -> Recognizer[untyped, untyped]
+
+    def set_offending_state: (Integer) -> void
+
+    def set_offending_token: (_Token) -> void
+  end
+end

data/sig/antlr4ruby/int_stream.rbs

@@ -0,0 +1,19 @@
+
+module Antlr4ruby
+  module IntStream
+    EOF: Integer
+    UNKNOWN_SOURCE_NAME: String
+  end
+
+  interface _IntStream
+    def consume: -> void
+    def la: (Integer) -> Integer
+    def mark: -> Integer
+    def release: (Integer) -> void
+    def index: -> Integer
+    def seek: (Integer) -> void
+    def size: -> Integer
+
+    def get_source_name: -> String
+  end
+end

data/sig/antlr4ruby/interpreter_rule_context.rbs

@@ -0,0 +1,6 @@
+
+module Antlr4ruby
+  class InterpreterRuleContext < ParserRuleContext
+    attr_accessor rule_index: Integer
+  end
+end

data/sig/antlr4ruby/lexer.rbs

@@ -0,0 +1,88 @@
+
+module Antlr4ruby
+  # @abstract
+  class Lexer < Recognizer[Integer, LexerATNSimulator]
+    include _TokenSource
+
+
+    DEFAULT_MODE: Integer
+    DEFAULT_TOKEN_CHANNEL: Integer
+    HIDDEN: Integer
+    MAX_CHAR_VALUE: Integer
+    MIN_CHAR_VALUE: Integer
+    MORE: Integer
+
+    SKIP: Integer
+
+
+
+    @token_factory_source_pair: Pair[_TokenSource, _CharStream]
+
+    attr_accessor channel: Integer
+    attr_accessor factory: _TokenFactory[untyped]
+    attr_accessor hit_eof: bool
+    attr_accessor input: _CharStream
+    attr_accessor mode: Integer
+    attr_accessor mode_stack: IntegerStack
+    attr_accessor text: String
+    attr_accessor token: _Token
+
+    attr_accessor token_factory_source_pair: Pair[_TokenSource, _CharStream]
+    attr_accessor token_start_char_index: Integer
+
+    attr_accessor token_start_line: Integer
+    attr_accessor type: Integer
+
+    def initialize: (_CharStream?) -> void
+
+    def emit: (_Token?) -> _Token?
+
+    def emit_eof: -> _Token
+
+    def get_all_tokens: -> Array[_Token]
+
+    def get_channel: -> Integer
+
+    def get_channel_names: -> Array[String]
+
+    def get_char_error_display: (Integer) -> String
+
+    def get_char_index: -> Integer
+
+    def get_error_display: (String | Integer) -> String
+
+    def get_mode_names: -> Array[String]
+
+    def get_text: -> String
+
+    def get_token: -> _Token
+
+    def get_type: -> Integer
+
+    def more: -> void
+
+    def notify_listeners: (LexerNoViableAltException) -> void
+
+    def pop_mode: -> Integer
+
+    def push_mode: (Integer) -> void
+
+    def recover: (LexerNoViableAltException | RecognitionException) -> void
+
+    def reset: -> void
+
+    def set_channel: (Integer) -> void
+
+    def set_char_position_in_line: (Integer) -> void
+
+    def set_line: (Integer) -> void
+
+    def set_text: (String) -> void
+
+    def set_token: (_Token) -> void
+
+    def set_type: (Integer) -> void
+
+    def skip: -> void
+  end
+end

data/sig/antlr4ruby/lexer_interpreter.rbs

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

data/sig/antlr4ruby/list_token_source.rbs

@@ -0,0 +1,6 @@
+
+module Antlr4ruby
+  class ListTokenSource
+    include _TokenSource
+  end
+end

data/sig/antlr4ruby/misc/bit_set.rbs

@@ -0,0 +1,6 @@
+module Antlr4ruby
+
+  class BitSet
+  end
+end
+

data/sig/antlr4ruby/misc/double_key_map.rbs

@@ -0,0 +1,11 @@
+module Antlr4ruby
+  class DoubleKeyMap[Key1, Key2, Value]
+    def get: (Key1, Key2) -> Value?
+
+    def put: (Key1, Key2) -> Value?
+
+    private
+
+    attr_accessor data: Hash[Key1, Hash[Key2, Value]]
+  end
+end

data/sig/antlr4ruby/misc/equality_comparator.rbs

@@ -0,0 +1,7 @@
+
+
+module Antlr4ruby
+  interface _EqualityComparator
+
+  end
+end

data/sig/antlr4ruby/misc/int_set.rbs

@@ -0,0 +1,29 @@
+module Antlr4ruby
+
+  interface _IntSet
+    def add: (Integer) -> void
+
+    def add_all: (_IntSet) -> _IntSet
+
+    def and: (_IntSet) -> _IntSet
+
+    def complement: (_IntSet) -> _IntSet
+
+    def or: (_IntSet) -> _IntSet
+
+    def substract: (_IntSet) -> _IntSet
+
+    def size: -> Integer
+
+    # def nil?: -> bool
+
+    def contains: (Integer) -> bool
+
+    def remove: (Integer) -> void
+
+    def to_list: -> Array[Integer]
+
+  end
+end
+
+

data/sig/antlr4ruby/misc/integer_stack.rbs

@@ -0,0 +1,9 @@
+module Antlr4ruby
+
+  class IntegerStack
+
+  end
+end
+
+
+

data/sig/antlr4ruby/misc/murmur_hash.rbs

@@ -0,0 +1,13 @@
+module Antlr4ruby
+  class MurmurHash
+    DEFAULT_SEED: Integer
+
+    def self.finish: (Integer, Integer) -> Integer
+
+    def self.init: (Integer) -> Integer
+
+    def self.update: (Integer, Object) -> Integer
+
+    def self.hash: (Array[untyped], Integer) -> untyped
+  end
+end

data/sig/antlr4ruby/misc/pair.rbs

@@ -0,0 +1,15 @@
+module Antlr4ruby
+
+  class Pair[A, B]
+
+    attr_accessor first: A
+    attr_accessor second: B
+
+    @first: A
+    @second: B
+
+    def initialize: (A, B) -> void
+
+  end
+end
+

data/sig/antlr4ruby/misc/predicate.rbs

@@ -0,0 +1,7 @@
+module Antlr4ruby
+
+  interface _Predicate[T]
+    def test: (T) -> bool
+  end
+end
+

data/sig/antlr4ruby/misc/range_set.rbs

@@ -0,0 +1,49 @@
+module Antlr4ruby
+  class RangeSet[T]
+    attr_accessor data: Array[Range[T]]
+
+    def &: (RangeSet[T]) -> RangeSet[T]
+
+    def +: (RangeSet[T]) -> RangeSet[T]
+
+    def -: (RangeSet[T]) -> RangeSet[T]
+
+    def add: (Range[T]) -> void
+
+    def add_all: (Enumerable[Range[T]] | RangeSet[T]) -> void
+
+    def clear: -> void
+
+    def complement: (RangeSet[T]) -> RangeSet[T]
+
+    def cover?: (Range[T]) -> bool
+
+    def delete: (Range[T]) -> void
+
+    def delete_all: (Enumerable[Range[T]] | RangeSet[T]) -> void
+
+    def empty?: -> bool
+
+    def include?: (Integer) -> bool
+
+    def merge: (RangeSet[T]) -> void
+
+    def start: -> Integer?
+
+    def stop: -> Integer?
+
+    def to_a: -> Array[Range[T]]
+
+    def to_set: -> Set[Range[T]]
+
+    def |: (RangeSet[T]) -> RangeSet[T]
+
+    def ~: -> RangeSet[T]
+
+    def initialize: (Array[Range[T]]) -> void
+
+    def eql?: (RangeSet[T]?) -> bool
+
+    def == :(RangeSet[T]) -> bool
+  end
+end

data/sig/antlr4ruby/parser.rbs

@@ -0,0 +1,109 @@
+
+module Antlr4ruby
+  class Parser < Recognizer[_Token, ParserATNSimulator]
+
+    class TraceListener
+      include _ParseTreeListener
+    end
+
+    class TrimToSizeListener
+      include _ParseTreeListener
+    end
+
+    attr_accessor build_parse_trees: bool
+    attr_accessor ctx: ParserRuleContext
+    attr_accessor err_handler: _ANTLRErrorStrategy
+    attr_accessor input: _TokenStream?
+    attr_accessor matched_eof: bool
+    attr_accessor parse_listeners: Array[_ParseTreeListener]
+    attr_reader precedence_stack: IntegerStack
+
+    attr_accessor syntax_errors: Integer
+
+    def add_contex_to_parse_tree: -> void
+
+    def add_parse_listener: (_ParseTreeListener) -> void
+
+    def consume: -> _Token
+
+    def create_terminal_node: (ParserRuleContext, _Token) -> _TerminalNode
+
+    def dump_dfa: -> void
+
+    def enter_recursion_rule: (ParserRuleContext, Integer, Integer, Integer) -> void
+
+    def enter_rule: (ParserRuleContext?, Integer?, Integer?) -> void
+
+    def get_atn_with_bypass_alts: -> ATN
+
+    def get_build_parse_tree: -> bool
+
+    def get_context: -> ParserRuleContext
+
+    def get_current_token: -> _Token
+
+    def get_dfa_strings: -> Array[String]
+
+    def get_error_handler: -> _ANTLRErrorStrategy
+
+    def get_expected_tokens: -> IntervalSet
+
+    def get_expected_tokens_within_current_rule: -> IntervalSet
+
+    def get_invoking_context: (Integer) -> ParserRuleContext
+
+    def get_parse_listeners: -> Array[_ParseTreeListener]
+
+    def get_precedence: -> Integer
+
+    def get_rule_context: -> ParserRuleContext
+
+    def get_rule_index: (String) -> Integer
+
+    def get_rule_invocation_stack: (RuleContext?) -> Array[String]
+
+    def get_source_name: -> String
+
+    def get_syntax_error_count: -> Integer
+
+    def get_token_stream: -> _TokenStream
+
+    def is_expected_token: (Integer) -> bool
+
+    def is_matched_eof?: -> bool
+
+    def match: (Integer) -> _Token
+
+    def match_wildcard: -> _Token
+
+    def notify_error_listeners: (String, _Token?, RecognitionException?) -> void
+
+    def push_new_recursion_context: (ParserRuleContext, Integer, Integer) -> void
+
+    def remove_parse_listener: (_ParseTreeListener) -> void
+
+    def remove_parse_listeners: -> void
+
+    def reset: -> void
+
+    def set_build_parse_tree: (bool) -> void
+
+    def set_context: (ParserRuleContext) -> void
+
+    def set_error_handler: (_ANTLRErrorStrategy) -> void
+
+    def set_profile: (bool) -> void
+
+    def set_token_stream: (_TokenStream) -> void
+
+    def trigger_enter_rule_event: -> void
+
+    def trigger_exit_rule_event: -> void
+
+    def unroll_recursion_contexts: (ParserRuleContext) -> void
+
+    private
+
+    attr_accessor bypass_alt_atn_cache: ATN
+  end
+end

data/sig/antlr4ruby/parser_interpreter.rbs

@@ -0,0 +1,24 @@
+
+module Antlr4ruby
+  class ParserInterpreter < Parser
+    attr_reader atn: ATN
+    attr_reader decision_to_dfa: Array[DFA]
+    attr_reader grammar_file_name: String
+
+    attr_accessor override_decision: Integer
+    attr_accessor override_decision_alt: Integer
+    attr_accessor override_decision_input_index: Integer
+    attr_accessor override_decision_reached: bool
+    attr_accessor override_decision_root: InterpreterRuleContext?
+    # attr_accessor override_decision_root: InterpreterRuleContext
+    attr_reader parent_context_stack: Vocabulary
+    attr_accessor root_context: InterpreterRuleContext
+    attr_reader rule_names: Array[String]
+    attr_reader shared_context_cache: PredictionContextCache
+
+    attr_reader vocabulary: Vocabulary
+
+    def initialize: (String, Vocabulary, Array[String], ATN, _TokenStream) -> void
+
+  end
+end

data/sig/antlr4ruby/parser_rule_context.rbs

@@ -0,0 +1,53 @@
+
+module Antlr4ruby
+  class ParserRuleContext < RuleContext
+    EMPTY: ParserRuleContext
+
+    @children: Array[_ParseTree]
+    @start: _Token
+    @stop: _Token
+    @exception: RecognitionException
+
+    attr_accessor children: Array[_ParseTree]
+
+    attr_accessor exception: RecognitionException
+    attr_accessor start: _Token
+
+    attr_accessor stop: _Token
+
+    def initialize: (ParserRuleContext?, Integer) -> void
+
+    def add_any_child: (untyped) -> _ParseTree
+
+    def add_child: (RuleContext | TerminalNode) -> (RuleContext | TerminalNode)
+
+    def add_error_node: (ErrorNode) -> ErrorNode
+
+    def copy_from: (ParserRuleContext) -> void
+
+    # def enter_rule: (_ParseTreeListener) -> void
+
+    # def exit_rule: (_ParseTreeListener) -> void
+
+    def get_start: -> _Token
+
+    def get_stop: -> _Token
+
+    def get_token: (Integer, Integer) -> TerminalNode?
+
+    def get_tokens: (Integer) -> Array[TerminalNode]
+
+    def remove_last_child: -> void
+
+    def to_info_string: (Parser) -> String
+
+    def get_parent: -> ParserRuleContext
+
+    def get_child: (Integer, Class?) -> _ParseTree?
+
+    def get_rule_context: (Class, Integer) -> RuleContext?
+
+    def get_rule_contexts: (Class) -> Array[RuleContext]
+
+  end
+end

data/sig/antlr4ruby/proxy_error_listener.rbs

@@ -0,0 +1,10 @@
+
+module Antlr4ruby
+  class ProxyErrorListener
+    include _ANTLRErrorListener
+
+    attr_reader delegates: Array[_ANTLRErrorListener]
+
+    def initialize: (Array[_ANTLRErrorListener]) -> void
+  end
+end

data/sig/antlr4ruby/recognizer.rbs

@@ -0,0 +1,76 @@
+
+module Antlr4ruby
+  # @abstract
+  class Recognizer[Symbol, ATNInterpreter]
+    EOF: Integer
+
+    @@token_type_map_cache: Hash[Vocabulary, Hash[String, Integer]]
+    @@rule_index_map_cache: Hash[Array[String], Hash[String, Integer]]
+    @listeners: Array[_ANTLRErrorListener]
+
+    attr_accessor interpreter: ATNInterpreter
+
+    attr_accessor state_number: Integer
+
+    def action: (RuleContext?, Integer, Integer) -> void
+
+    def add_error_listener: (_ANTLRErrorListener) -> void
+
+    def get_atn: -> ATN
+
+    def get_error_header: (RecognitionException) -> String
+
+    def get_error_listener_dispatch: -> _ANTLRErrorListener
+
+    def get_error_listeners: -> Array[_ANTLRErrorListener]
+
+    def get_grammar_file_name: -> String
+
+    def get_input_stream: -> _IntStream
+
+    def get_interpreter: -> ATNInterpreter
+
+    def get_parse_info: -> ParseInfo?
+
+    def get_rule_index_map: -> Hash[String, Integer]
+
+    def get_rule_names: -> Array[String]
+
+    def get_serialized_atn: -> String
+
+    def get_state: -> Integer
+
+    def get_token_factory: -> _TokenFactory[untyped]
+
+    def get_token_names: -> Array[String]
+
+    def get_token_type: -> Integer
+
+    def get_token_type_map: -> Hash[String, Integer]
+
+    def get_vocabulary: -> Vocabulary
+
+    def precpred: (RuleContext, Integer) -> bool
+
+    def remove_error_listener: (_ANTLRErrorListener) -> void
+
+    def remove_error_listeners: -> void
+
+    def sempred: (RuleContext, Integer, Integer) -> bool
+
+    def set_input_stream: (_IntStream) -> void
+
+    def set_interpreter: (ATNInterpreter) -> void
+
+    def set_state: (Integer) -> void
+
+    def set_token_factory: (_TokenFactory[untyped]) -> void
+
+    private
+
+    attr_accessor listeners:  Array[_ANTLRErrorListener]
+    
+    
+
+  end
+end

data/sig/antlr4ruby/rule_context.rbs

@@ -0,0 +1,31 @@
+
+module Antlr4ruby
+  class RuleContext
+    include _RuleNode
+    @parent: RuleContext?
+    @invoking_state: Integer
+
+    attr_accessor invoking_state: Integer
+    attr_accessor parent: RuleContext
+
+    def initialize: (RuleContext?, Integer) -> void
+
+    def depth: -> Integer
+
+    def enter_rule: (_ParseTreeListener) -> void
+
+    def exit_rule: (_ParseTreeListener) -> void
+
+    def get_alt_number: -> Integer
+
+    def get_rule_index: -> Integer
+
+    def is_empty?: -> bool
+
+    def set_alt_number: (Integer) -> void
+
+    def to_s: (recognizer: Recognizer[untyped, untyped]?, rule_names: Array[String], stop: RuleContext?) -> String
+
+    # def get_rule_context: (Class, Integer?) -> RuleContext?
+  end
+end

data/sig/antlr4ruby/rule_context_with_alt_num.rbs

@@ -0,0 +1,8 @@
+
+module Antlr4ruby
+  class RuleContextWithAltNum < ParserRuleContext
+    attr_accessor alt_num: Integer
+
+    # def rule_context_with_alt_num: -> void
+  end
+end

data/sig/antlr4ruby/runtime_meta_data.rbs

@@ -0,0 +1,12 @@
+
+module Antlr4ruby
+  class RuntimeMetaData
+    VERSION: String
+
+    def self.check_version: (String, String) -> void
+
+    def self.get_major_minor_version: (String) -> String
+
+    def self.get_runtime_version: -> String
+  end
+end