antlr4ruby 0.1.0

data/lib/antlr4ruby/parser_rule_context.rb

@@ -0,0 +1,161 @@
+# 已完成
+
+module Antlr4ruby
+  class ParserRuleContext < RuleContext
+    EMPTY = ParserRuleContext.new(nil, -1)
+
+    attr_accessor :children,
+                  :start, :stop,
+                  :exception
+
+    def initialize(parent = nil, invoking_state = -1)
+      super(parent, invoking_state)
+    end
+
+    def copy_from(ctx)
+      @parent = ctx.parent
+      @invoking_state = ctx.invoking_state
+
+      @start = ctx.start
+      @stop = ctx.stop
+
+      if ctx.children
+        self.children = []
+        ctx.children.each do |child|
+          if child.instance_of?(ErrorNode)
+            add_child(child)
+          end
+        end
+      end
+    end
+
+    def enter_rule(listener) end
+
+    def exit_rule(listener) end
+
+    def add_child(rule_invocation)
+      if rule_invocation.instance_of?(TerminalNode)
+        rule_invocation.set_parent(self)
+      end
+      add_any_child(rule_invocation)
+    end
+
+    def add_error_node(error_node)
+      error_node.set_parent(self)
+      add_any_child(error_node)
+    end
+
+    def add_any_child(t)
+      unless @children
+        @children = []
+      end
+      @children.push(t)
+      t
+    end
+
+    def remove_last_child
+      if @children
+        @children.pop
+      end
+    end
+
+    # @override
+    def get_parent
+      # 这里会有一个警告，好像没什么办法强制类型转换
+      super
+    end
+
+    # @override
+    def get_child(i, context_type)
+      @children[i] unless context_type
+      arr = []
+      children.each do |child|
+        arr.push(child) if child.instance_of?(context_type)
+      end
+      arr[i]
+    end
+
+    def get_rule_context(context_type, i)
+      get_child(i, context_type)
+    end
+
+    def get_rule_contexts(context_type)
+      result = []
+      return result unless children
+
+      children.each do |child|
+        result.push(child) if child.instance_of?(context_type)
+      end
+      result
+    end
+
+    def get_token(token_type, i)
+      if !@children || i < 0 || i >= @children.length
+        return nil
+      end
+
+      j = -1
+      @children.each do |o|
+        if o.instance_of?(TerminalNode)
+          node = o
+          symbol = node.get_symbol
+          if symbol.get_type == token_type
+            j += 1
+            if j == i
+              return node
+            end
+          end
+        end
+      end
+
+      nil
+    end
+
+    def get_tokens(token_type)
+      unless children
+        return []
+      end
+      tokens = []
+      children.each do |child|
+        if child.instance_of?(TerminalNode)
+          node = child
+          symbol = node.get_symbol
+          if symbol.get_type == token_type
+            tokens.push(node)
+          end
+        end
+      end
+      tokens
+    end
+
+    # @override
+    def get_child_count
+      @children.length || 0
+    end
+
+    # @override
+    def get_source_interval
+      unless @start
+        return (-1)..(-2)
+      end
+      if !@stop || stop.get_token_index < start.get_token_index
+        return start.get_token_index...stop.get_token_index
+      end
+      start.get_token_index..stop.get_token_index
+    end
+
+    def get_start
+      @start
+    end
+
+    def get_stop
+      @stop
+    end
+
+    def to_info_string(recognizer)
+      rules = recognizer.get_rule_invocation_stack(self)
+      rules.reverse!
+      "parser_rule_context#{rules}{start=#{start}, stop=#{stop}}"
+    end
+  end
+end

data/lib/antlr4ruby/proxy_error_listener.rb

@@ -0,0 +1,33 @@
+# 已完成
+
+module Antlr4ruby
+  class ProxyErrorListener
+    def initialize(delegates)
+      super()
+      @delegates = delegates
+    end
+
+    private
+
+    attr_reader :delegates
+
+    public
+    def syntax_error(recognizer, offending_symbol, line, position, msg, e)
+      delegates.each { |listener| listener.syntax_error(recognizer, offending_symbol, line, position, msg, e) }
+    end
+
+    def report_ambiguity(recognizer, dfa, start_index, stop_index, exact, ambig_alts, configs)
+      delegates.each { |listener| listener.report_ambiguity(recognizer, dfa, start_index, stop_index, exact, ambig_alts, configs) }
+    end
+
+    def report_attempting_full_context(recognizer, dfa, start_index,
+                                       stop_index, conflicting_alts, configs)
+      delegates.each { |listener| listener.report_attempting_full_context(recognizer, dfa, start_index, stop_index, conflicting_alts, configs) }
+    end
+
+    def report_context_sensitivity(recognizer, dfa, start_index, stop_index, prediction, configs)
+      delegates.each { |listener| listener.report_context_sensitivity(recognizer, dfa, start_index, stop_index, prediction, configs) }
+    end
+
+  end
+end

data/lib/antlr4ruby/recognizer.rb

@@ -0,0 +1,133 @@
+
+module Antlr4ruby
+  # @abstract
+  class Recognizer
+    EOF = -1
+
+    def initialize
+      super()
+
+      @listeners = [ConsoleErrorListener.INSTANCE]
+      @state_number = -1
+    end
+
+
+    private
+    @@token_type_map_cache = {}
+    @@rule_index_map_cache = {}
+    attr_accessor :listeners, :state_number
+
+    protected
+    attr_accessor :interpreter
+
+    public
+    def get_rule_names
+      # todo 抛出异常
+    end
+
+    def get_token_names
+      # todo 抛出异常
+    end
+
+    def get_vocabulary
+      # todo
+      Vocabulary.from_token_names(get_token_names)
+    end
+
+    def get_token_type_map
+      # todo
+    end
+
+    def get_rule_index_map
+      # todo
+    end
+
+    def get_token_type(token_name)
+      # todo
+    end
+
+    def get_serialized_atn
+      # todo
+    end
+
+    # @abstract
+    def get_grammar_file_name
+      # todo 抛出异常
+    end
+
+    # @abstract
+    def get_atn
+      # todo 抛出异常
+    end
+
+    def get_interpreter
+      @interpreter
+    end
+
+    def get_parse_info
+      nil
+    end
+
+    def set_interpreter(interpreter)
+      @interpreter = interpreter
+    end
+
+    def get_error_header(e)
+      # todo
+    end
+
+    def add_error_listener(listener)
+      listeners.push(listener)
+    end
+
+    def remove_error_listener(listener)
+      listeners.delete(listener)
+    end
+
+    def remove_error_listeners
+      listeners.clear
+    end
+
+    def get_error_listeners
+      listeners
+    end
+
+    def get_error_listener_dispatch
+      ProxyErrorListener.new(get_error_listeners)
+    end
+
+    def sempred(localctx, rule_index, action_index) true; end
+
+    def precpred(localctx, precedence) true; end
+
+    def action(localctx, rule_index, action_index) end
+
+    def get_state
+      @state_number
+    end
+
+    def set_state(atn_state) @state_number = atn_state; end
+
+    # @abstract
+    def get_input_stream
+      # todo 抛出异常
+    end
+
+    # @abstract
+    def set_input_stream(input)
+      # todo 抛出异常
+    end
+
+    # @abstract
+    def get_token_factory
+      # todo 抛出异常
+    end
+
+    # @abstract
+    def set_token_factory(factory)
+      # todo 抛出异常
+    end
+
+
+  end
+end

data/lib/antlr4ruby/rule_context.rb

@@ -0,0 +1,109 @@
+# 已完成
+
+module Antlr4ruby
+  class RuleContext
+    attr_accessor :parent, :invoking_state
+
+    def initialize(parent = nil, invoking_state = -1)
+      super()
+      @parent, @invoking_state = parent, invoking_state
+    end
+
+    def depth
+      n = 0
+      p = self
+      while p
+        p = p.parent
+        n += 1
+      end
+      n
+    end
+
+    def is_empty?
+      @invoking_state == -1
+    end
+
+    # @override
+    def get_source_interval
+      (-1)..(-2)
+    end
+
+    # @override
+    def get_rule_context
+      self
+    end
+
+    # @override
+    def get_parent
+      @parent
+    end
+
+    # @override
+    def get_payload
+      self
+    end
+
+    # @override
+    def get_text
+      return '' if get_child_count == 0
+
+      result = ''
+      get_child_count.times do |i|
+        child = get_child(i)
+        result += child.get_text if child
+      end
+      result
+    end
+
+    def get_rule_index
+      -1
+    end
+
+    def get_alt_number
+      ATN.INVALID_ALT_NUMBER
+    end
+
+    def set_alt_number(alt_number) end
+
+    # @override
+    def set_parent(parent)
+      @parent = parent
+    end
+
+    # @override
+    def get_child(i) nil; end
+
+    # @override
+    def get_child_count
+      0
+    end
+
+    # @override
+    def accept(visitor)
+      visitor.visit_children(self)
+    end
+
+    def to_string_tree(recognizer:nil, rule_names: [])
+      Trees.to_string_tree(self, recognizer:recognizer, rule_names: rule_names)
+    end
+
+    def to_s(recognizer:nil , rule_names:[], stop:nil )
+      # 多余的形式舍弃掉
+      rule_names  = recognizer.get_rule_names if recognizer
+      p = self
+      result = ''
+      while p && !p.equal?(stop)
+        rule_index = p.get_rule_index
+        rule_name = rule_names[rule_index] || rule_index.to_s
+        result += rule_name + ' '
+        p = p.parent
+      end
+      result
+    end
+
+    def enter_rule(listener) end
+
+    def exit_rule(listener) end
+
+  end
+end

data/lib/antlr4ruby/rule_context_with_alt_num.rb

@@ -0,0 +1,22 @@
+# 已完成
+
+module Antlr4ruby
+  class RuleContextWithAltNum < ParserRuleContext
+    attr_accessor :alt_num
+
+    def initialize(parent, invoking_state)
+      super(parent, invoking_state)
+      @alt_num = ATN.INVALID_ALT_NUMBER
+    end
+
+    def get_alt_number
+      @alt_num
+    end
+
+    def set_alt_number(alt_number)
+      @alt_num = alt_number
+    end
+
+
+  end
+end

data/lib/antlr4ruby/runtime_meta_data.rb

@@ -0,0 +1,40 @@
+# 已完成
+
+module Antlr4ruby
+  class RuntimeMetaData
+    VERSION = "4.11.1"
+
+    def self.get_runtime_version
+      VERSION
+    end
+
+    def self.check_version(tool_version, compile_time_version)
+      runtime_version = VERSION
+      conflicts_with_tool = false
+      conflicts_with_compile = false
+
+      if tool_version
+        conflicts_with_tool = !runtime_version.eql?(tool_version) &&
+          !get_major_minor_version(runtime_version).eql?(get_major_minor_version(tool_version))
+      end
+
+      conflicts_with_compile =
+        !runtime_version.eql?(compile_time_version) &&
+          !get_major_minor_version(runtime_version).eql?(get_major_minor_version(compile_time_version))
+
+      if conflicts_with_tool
+        print "ANTLR Tool version #{tool_version} used for code generation does not match the current runtime version #{runtime_version}"
+      end
+
+      if conflicts_with_compile
+        print "ANTLR Runtime version #{compile_time_version} used for parser compilation does not match the current runtime version #{runtime_version}"
+      end
+    end
+
+    def self.get_major_minor_version(version)
+      # 懒得解析了
+      version
+    end
+
+  end
+end

data/lib/antlr4ruby/token.rb

@@ -0,0 +1,10 @@
+module Antlr4ruby
+  module Token
+    INVALID_TYPE = 0; EPSILON = -2; MIN_USER_TOKEN_TYPE = 1
+    EOF = -1 # IntStream.EOF
+    DEFAULT_CHANNEL = 0
+    HIDDEN_CHANNEL = 1
+    MIN_USER_CHANNEL_VALUE = 2
+  end
+end
+

data/lib/antlr4ruby/token_stream_rewriter.rb

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

data/lib/antlr4ruby/tree/abstract_parse_tree_visitor.rb

@@ -0,0 +1,56 @@
+# 已完成
+
+module Antlr4ruby
+
+  # @abstract
+  class AbstractParseTreeVisitor
+    # @override
+    def visit(tree)
+      tree.accept(self)
+    end
+
+    # @override
+    def visit_children(node)
+      result = default_result
+      n = node.get_child_count
+      n.times do |i|
+        unless should_visit_next_child(node, result)
+          break
+        end
+
+        child = node.get_child(i)
+        if child
+          child_result = child.accept(self)
+          result = aggregate_result(result, child_result)
+        end
+      end
+
+      result
+    end
+
+    # @!override
+    def visit_terminal(_node)
+      default_result
+    end
+
+    def visit_error_node(_node)
+      default_result
+    end
+
+    protected
+
+    def default_result
+      nil
+    end
+
+    def aggregate_result(_aggregate, next_result)
+      next_result
+    end
+
+    def should_visit_next_child(_node, _current_result)
+      true
+    end
+  end
+end
+
+

data/lib/antlr4ruby/tree/error_node.rb

@@ -0,0 +1,15 @@
+# 已完成
+
+module Antlr4ruby
+
+  class ErrorNode < TerminalNode
+    def initialize(token)
+      super(token)
+    end
+
+    # @override
+    def accept(visitor)
+      visitor.visit_error_node(self)
+    end
+  end
+end

data/lib/antlr4ruby/tree/iterative_parse_tree_walker.rb

@@ -0,0 +1,10 @@
+module Antlr4ruby
+
+  class IterativeParseTreeWalker < ParseTreeWalker
+    def walk(listener, tree)
+      # todo
+    end
+  end
+end
+
+

data/lib/antlr4ruby/tree/parse_tree_property.rb

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

data/lib/antlr4ruby/tree/parse_tree_walker.rb

@@ -0,0 +1,38 @@
+# 已完成
+
+module Antlr4ruby
+
+  class ParseTreeWalker
+    DEFAULT = ParseTreeWalker.new
+
+    def walk(listener, tree)
+      if tree.instance_of?(ErrorNode)
+        listener.visit_error_node(tree)
+        return
+      elsif tree.instance_of?(TerminalNode)
+        listener.visit_terminal(tree)
+        return
+      end
+      enter_rule(listener, tree)
+      n = tree.get_child_count
+      n.times do |i|
+        walk(listener, tree.get_child(i))
+      end
+      exit_rule(listener, tree)
+    end
+
+    protected
+
+    def enter_rule(listener, rule)
+      ctx = rule.get_rule_context
+      listener.enter_every_rule(ctx)
+      ctx.enter_rule(listener)
+    end
+
+    def exit_rule(listener, rule)
+      ctx = rule.get_rule_context
+      listener.exit_every_rule(ctx)
+      ctx.exit_rule(listener)
+    end
+  end
+end