antlr4ruby 0.1.0

data/lib/antlr4ruby/list_token_source.rb

@@ -0,0 +1,6 @@
+# 暂时先不管
+module Antlr4ruby
+  class ListTokenSource
+
+  end
+end

data/lib/antlr4ruby/misc/bit_set.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Antlr4ruby
+
+  class BitSet
+  end
+end
+
+

data/lib/antlr4ruby/misc/double_key_map.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+
+
+module Antlr4ruby
+  class DoubleKeyMap
+
+    private
+    attr_accessor :data
+
+    public
+    def put(key1, key2, value)
+      data[key1] = {} unless data.has_key?(key1)
+      sub_data = data[key1]
+      prev = sub_data[key2]
+      sub_data[key2] = value
+      prev
+    end
+
+    def get(key1, key2)
+      sub_data = data[key1]
+      return nil unless sub_data
+      sub_data[key2]
+    end
+
+
+  end
+end

data/lib/antlr4ruby/misc/integer_stack.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Antlr4ruby
+
+  class IntegerStack
+  end
+end
+
+

data/lib/antlr4ruby/misc/murmur_hash.rb

@@ -0,0 +1,75 @@
+# finished
+# frozen_string_literal: true
+
+module Antlr4ruby
+  class MurmurHash
+    DEFAULT_SEED = 0
+
+    def initialize
+      raise "不能实例化 #{self.class.name}."
+    end
+
+    class << self
+      def init(seed = DEFAULT_SEED) seed; end
+      def update(hash, value)
+        v = value.hash
+        # 首先判断 hash 是否在 32 位整数所能够表达的范围内, 貌似超出范围也无所谓
+        # raise "hash 值超出范围" if v < -2147483648 || v > 2147483647
+
+        c1 = 0xCC9E2D51
+        c2 = 0x1B873593
+        r1 = 15
+        r2 = 13
+        m = 5
+        n = 0xE6546B64
+        mask = 0xffffffff
+
+        v = (v * c1) & mask # 通过 & 0xffffffff 可以将有符号数转换为无符号
+        v = ((v << r1) | (v >> (32 - r1))) & mask
+        v = (v * c2) & mask
+
+        hash = (hash ^ v) & mask
+        hash = ((hash << r2) | hash >> (32 - r2)) & mask
+
+        # 减去 4294967296 是为了将无符号数再次转换回有符号数
+        hash = ((hash * m + n) & mask)
+        if hash > 2147483647
+          hash - 4294967296
+        else
+          hash
+        end
+      end
+
+      def finish(hash, number_of_words)
+        mask = 0xffffffff
+        hash &= mask; number_of_words &= mask
+
+        hash = (hash ^ (number_of_words << 2)) & mask
+        hash = (hash ^ (hash >> 16)) & mask
+        hash =  (hash * 0x85EBCA6B) & mask
+        hash = (hash ^ (hash >> 13)) & mask
+        hash = (hash * 0xC2B2AE35) & mask
+        hash = (hash ^ (hash >> 16)) & mask
+        if hash > 2147483647
+          hash - 4294967296
+        else
+          hash
+        end
+      end
+
+      def hash(data, seed)
+        hash = init(seed)
+        data.each do |value|
+          hash = update(hash, value)
+        end
+
+        finish(hash, data.length)
+      end
+
+
+
+
+    end
+  end
+
+end

data/lib/antlr4ruby/misc/pair.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Antlr4ruby
+
+  class Pair
+
+    attr_accessor :first, :second
+
+    def initialize(a, b)
+      super()
+      @first, @second = a, b
+    end
+
+    # todo equals hash to_s
+
+  end
+end
+

data/lib/antlr4ruby/misc/range_set.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+# 使用 RangeSet 来代替原来的 IntervalSet
+
+module Antlr4ruby
+  class RangeSet
+    attr_accessor :data
+
+    def initialize(data = [])
+      @data = data
+    end
+
+    def clear
+      data.clear
+    end
+
+    def add(range)
+      i = 0
+      result = []
+      while i < data.length
+        a = data[i]
+        if a.min > range.max + 1
+          break
+        elsif a.max < range.min - 1
+          result << a; i += 1; next
+        else
+          # 直接将 a 合并到 range 里面
+          start = a.min < range.min ? a.min : range.min
+          stop = a.max > range.max ? a.max : range.max
+          range = start..stop; i += 1
+        end
+      end
+
+      result << range
+      while i < data.length
+        result << data[i]; i += 1
+      end
+
+
+      @data = result
+    end
+
+    def + (other)
+      # other_data = other.data.reverse
+      # range = other_data.pop
+      # i = 0
+      # result = []
+      # while range && i < data.length
+      #   a = data[i]
+      #   if a.min > range.max + 1
+      #     new_range = other_data.pop
+      #     result << range; range = other_data.pop
+      #   elsif a.max < range.min - 1
+      #     result << a; i += 1
+      #   else
+      #     # 直接将 a 合并到 range 里面
+      #     start = a.min < range.min ? a.min : range.min
+      #     stop = a.max > range.max ? a.max : range.max
+      #     range = start..stop; i += 1
+      #   end
+      #
+      # end
+      #
+      # result << range if range
+      # while i < data.length
+      #   result << data[i]; i += 1
+      # end
+      #
+      # while other_data.length > 0
+      #   result << other_data.pop
+      # end
+      # RangeSet.new(result)
+      #
+      result = self.clone
+      other.data.each { |item| result.add(item) }
+      result
+    end
+
+    def | (other)
+      self + other
+    end
+
+    def & (other)
+      result = []
+      i, j = 0, 0
+
+      while i < data.length && j < other.data.length
+        while j < other.data.length && data[i].min > other.data[j].max
+          j += 1
+        end
+        break if j >= other.data.length
+        while i < data.length && other.data[j].min > data[i].max
+          i += 1
+        end
+        break if i >= data.length
+
+
+        a, b = data[i], other.data[j]
+        if a.cover?(b)
+          result << b; j += 1
+        elsif b.cover?(a)
+          result << a; i += 1
+        elsif a.include?(b.min)
+          result << (b.min..a.max); i += 1
+        elsif b.include?(a.min)
+          result << (a.min..b.max); j += 1
+
+        end
+      end
+
+      RangeSet.new(result)
+      # other.data.each do |a|
+      #   data.each do |b|
+      #     next if a.min > b.max || a.max < b.min
+      #     if a.cover?(b)
+      #       result.push(b)
+      #     elsif b.cover?(a)
+      #       result.push(a)
+      #     else
+      #       start = a.min > b.min ? a.min : b.min
+      #       stop = a.max < b.max ? a.max : b.max
+      #       result.push(start..stop)
+      #     end
+      #   end
+      # end
+      # RangeSet.new(result)
+    end
+
+    def add_all(ranges)
+      other_data = ranges.instance_of?(RangeSet) ? ranges.data : ranges
+      other_data.each do |item|
+        add(item)
+      end
+    end
+
+    def delete(range)
+      result = []
+      data.each do |item|
+        next if range.cover?(item)
+        result.push(item.min...range.min) if item.include?(range.min) && range.min > item.min
+        result.push(range.max + 1..item.max) if item.include?(range.max) && range.max < item.max
+        result.push(item) if item.max < range.min || item.min > range.max
+      end
+
+      @data = result
+    end
+
+    def delete_all(ranges)
+      other_data = ranges.instance_of?(RangeSet) ? ranges.data : ranges
+      other_data.each do |item|
+        delete(item)
+      end
+    end
+
+    def - (other)
+      result = self.clone
+      other.data.each { |item| result.delete(item) }
+      result
+    end
+
+    def complement(total)
+      total - self
+    end
+
+    def nil?
+      data.empty?
+    end
+
+    def empty?
+      data.empty?
+    end
+
+    def include?(n)
+      data.each { |item| return true if item.include?(n) }
+      false
+    end
+
+    def cover?(range)
+      data.each do |item|
+        return true if item.cover?(range)
+      end
+      false
+    end
+
+    def start
+      nil if empty?
+      data.sort! do |a, b|
+        a.min == b.min ? a.max <=> b.max : a.min <=> b.min
+      end
+
+      data[0].min
+    end
+
+    def stop
+      nil if empty?
+      data.sort! do |a, b|
+        a.min == b.min ? a.max <=> b.max : a.min <=> b.min
+      end
+      data[-1].max
+    end
+
+    def to_a
+      @data
+    end
+
+    def to_set
+      data.to_set
+    end
+
+    def eql?(other)
+      return false if !other || data.length != other.data.length
+      data.length.times do |i|
+        return false unless data[i].eql?(other.data[i])
+      end
+      true
+    end
+
+    def == (other)
+      self.eql?(other)
+    end
+
+  end
+end
+

data/lib/antlr4ruby/parser.rb

@@ -0,0 +1,225 @@
+
+module Antlr4ruby
+  class Parser < Recognizer
+    def initialize(input)
+      super()
+      set_input_stream(input)
+    end
+
+    private
+    attr_accessor :bypass_alt_atn_cache
+
+    protected
+    attr_accessor :err_handler, :input, :ctx,
+                  :build_parse_trees, :parse_listeners, :syntax_errors, :matched_eof
+    attr_reader :precedence_stack
+
+    def trigger_enter_rule_event
+      # todo
+    end
+
+    def trigger_exit_rule_event
+      # todo
+    end
+
+    public
+    def reset
+      # todo
+    end
+
+    def match(token_type)
+      # todo
+    end
+
+    def match_wildcard
+      # todo
+    end
+
+    def set_build_parse_tree(build_parse_trees)
+      @build_parse_trees = build_parse_trees
+    end
+
+    def get_build_parse_tree
+      @build_parse_trees
+    end
+
+    # 不要 set_trim_parse_tree get_trim_parse_tree
+
+    def get_parse_listeners
+      # todo
+    end
+
+    def add_parse_listener(listener)
+      # todo
+    end
+
+    def remove_parse_listener(listener)
+      # todo
+    end
+
+    def remove_parse_listeners
+      listeners.clear
+    end
+
+    def get_syntax_error_count
+      @syntax_errors
+    end
+
+    def get_token_factory
+      input.get_token_source.get_token_factory
+    end
+
+    def set_token_factory(factory)
+      input.get_token_source.set_token_factory(factory)
+    end
+
+    def get_atn_with_bypass_alts
+      # todo
+    end
+
+    # compile_parse_tree_pattern 不要
+
+    def get_error_handler
+      @err_handler
+    end
+
+    def set_error_handler(handler)
+      @err_handler = handler
+    end
+
+    def get_token_stream
+      @input
+    end
+
+    def get_input_stream
+      get_token_stream
+    end
+
+    def set_token_stream(input)
+      @input = nil
+      reset
+      @input = input
+    end
+
+    def set_input_stream(input)
+      set_token_stream(input)
+    end
+
+    def get_current_token
+      input.lt(1)
+    end
+
+    def notify_error_listeners(msg, token, e)
+      unless  token
+        token = get_current_token
+      end
+      # todo
+    end
+
+    def consume
+      # todo
+    end
+
+    def create_terminal_node(parent, token)
+      # todo
+    end
+
+    def add_contex_to_parse_tree
+      # todo
+    end
+
+    def enter_rule(localctx, state, rule_index)
+      # todo
+    end
+
+    # 不要 enterOuterAlt
+
+    def get_precedence
+      # todo
+    end
+
+    def enter_recursion_rule(localctx, state, rule_index, precedence)
+      # todo
+    end
+
+    def push_new_recursion_context(localctx, state, rule_index)
+      # todo
+    end
+
+    def unroll_recursion_contexts(parent)
+      # todo
+    end
+
+    def get_invoking_context(rule_index)
+      # todo
+    end
+
+    def get_context
+      @ctx
+    end
+
+    def set_context(ctx)
+      @ctx = ctx
+    end
+
+    def precpred(localctx, precedence)
+      # todo
+      # precedence >= @precedence_stack.peek()
+    end
+
+    # 不要 in_context
+
+    def is_expected_token(symbol)
+      # todo
+    end
+
+    def is_matched_eof?
+      @matched_eof
+    end
+
+    def get_expected_tokens
+      # todo
+    end
+
+    def get_expected_tokens_within_current_rule
+      # todo
+    end
+
+    def get_rule_index(rule_name)
+      # todo
+    end
+
+    def get_rule_context
+      @ctx
+    end
+
+    def get_rule_invocation_stack(rule_context)
+      # rule_context = rule_context || ctx
+      # todo
+    end
+
+    def get_dfa_strings
+      # todo
+    end
+
+    def dump_dfa
+      # todo
+    end
+
+    def get_source_name
+      input.get_source_name
+    end
+
+    def get_parse_info
+      # todo
+    end
+
+    def set_profile(profile)
+      # todo
+    end
+
+
+
+
+  end
+end

data/lib/antlr4ruby/parser_interpreter.rb

@@ -0,0 +1,25 @@
+
+module Antlr4ruby
+  class ParserInterpreter < Parser
+    def initialize(grammar_file_name, vocabulary, rule_names, atn, input)
+      super(input)
+      @grammar_file_name, @atn, @rule_names, @vocabulary, = grammar_file_name, atn, rule_names, vocabulary
+      # number_of_decisions = todo
+    end
+
+    protected
+    attr_reader :grammar_file_name, :atn, :decision_to_dfa, :shared_context_cache,
+                :rule_names, :parent_context_stack
+
+    attr_accessor :override_decision, :override_decision_input_index, :override_decision_alt,
+                  :override_decision_reached, :override_decision_root, :root_context
+    private
+    attr_reader :vocabulary
+
+    public
+    # def reset
+    #
+    # end
+
+  end
+end