antlr4ruby 0.1.0

data/lib/antlr4ruby/atn/transition/transition.rb

@@ -0,0 +1,63 @@
+# finished
+
+module Antlr4ruby
+  # @abstract
+  class Transition
+    EPSILON = 1
+    RANGE = 2
+    RULE = 3
+    PREDICATE = 4
+    ATOM = 5
+    ACTION = 6
+    SET = 7
+    NOT_SET = 8
+    WILDCARD = 9
+    PRECEDENCE = 10
+
+    @@serialization_names = %w[INVALID EPSILON RANGE RULE PREDICATE ATOM ACTION SET NOT_SET WILDCARD PRECEDENCE]
+    @@serialization_types = {
+      EpsilonTransition => EPSILON,
+      RangeTransition => RANGE,
+      RuleTransition => RULE,
+      PredicateTransition => PREDICATE,
+      AtomTransition => ATOM,
+      ActionTransition => ACTION,
+      SetTransition => SET,
+      NotSetTransition => NOT_SET,
+      WildcardTransition => WILDCARD,
+      PrecedencePredicateTransition => PRECEDENCE
+    }
+
+    attr_accessor :target
+
+    def self.serialization_names
+      @@serialization_names
+    end
+
+    def self.serialization_types
+      @@serialization_types
+    end
+
+    def initialize(target)
+      super()
+      raise "target can not be nil." unless target
+      @target = target
+    end
+
+    def get_serialization_type
+      raise NotImplementedError.new("#{self.class.name}#get_serialization_type is abstract method.")
+    end
+
+    def is_epsilon?
+      false
+    end
+
+    def label
+      nil
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      raise NotImplementedError.new("#{self.class.name}#matches is abstract method.")
+    end
+  end
+end

data/lib/antlr4ruby/atn/transition/wildcard_transition.rb

@@ -0,0 +1,21 @@
+# finished
+
+module Antlr4ruby
+  class WildcardTransition < Transition
+    def initialize(target)
+      super(target)
+    end
+
+    def get_serialization_type
+      WILDCARD
+    end
+
+    def matches?(symbol, min_vocab_symbol, max_vocab_symbol)
+      symbol >= min_vocab_symbol && symbol <= max_vocab_symbol
+    end
+
+    def to_s
+      '.'
+    end
+  end
+end

data/lib/antlr4ruby/bail_error_strategy.rb

@@ -0,0 +1,28 @@
+# finished
+
+module Antlr4ruby
+  class BailErrorStrategy < DefaultErrorStrategy
+
+    def recover(recognizer, e)
+      context = recognizer.get_context
+      while context
+        context.exception = e; context = context.get_parent
+      end
+
+      raise ParseCancellationException.new
+    end
+
+    def recover_in_line(recognizer)
+      e = InputMismatchException.new(recognizer, nil, nil)
+      context = recognizer.get_context
+      while context
+        context.exception = e; context = context.get_parent
+      end
+      raise ParseCancellationException.new
+    end
+
+    def sync(recognizer) end
+
+
+  end
+end

data/lib/antlr4ruby/base_error_listener.rb

@@ -0,0 +1,14 @@
+# 已完成
+
+module Antlr4ruby
+  class BaseErrorListener
+    # @override
+    def syntax_error(recognizer, offending_symbol, line, char_position_in_line, msg, e) end
+
+    def 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) end
+
+    def report_context_sensitivity(recognizer,dfa, start_index, stop_index, prediction, configs) end
+  end
+end

data/lib/antlr4ruby/buffered_token_stream.rb

@@ -0,0 +1,115 @@
+# 完成所有函数的声明
+
+module Antlr4ruby
+  class BufferedTokenStream
+
+    def initialize(token_source)
+      @token_source = token_source
+    end
+
+    protected
+
+    attr_accessor :token_source, :tokens, :p, :fetched_eof
+
+    def sync(i)
+      # todo
+    end
+
+    def fetch(n)
+      # todo
+    end
+
+    def lb(k)
+      # todo
+    end
+
+    def adjust_seek_index(i)
+      i;
+    end
+
+    def lazy_init
+      # todo
+    end
+
+    def setup
+      # todo
+    end
+
+    def next_token_on_channel(i, channel)
+      # todo
+    end
+
+    def previous_token_on_channel(i, channel)
+      # todo
+    end
+
+    def filter_for_channel(from, to, channel)
+      # todo
+    end
+
+    public
+
+    def get_token_source
+      @token_source
+    end
+
+    def index
+      @p
+    end
+
+    def mark
+      0
+    end
+
+    def release(marker) end
+
+    def seek(index)
+      # todo
+    end
+
+    def size
+      tokens.length
+    end
+
+    def consume
+      # todo
+    end
+
+    def get_multi(start, stop)
+      # todo
+    end
+
+    def la(i)
+      # todo
+    end
+
+    def lt(k)
+      # todo
+    end
+
+    def get_text(rule_context: nil, interval: nil, start: nil, stop: nil)
+      # todo
+    end
+
+    def fill
+      # todo
+    end
+
+    def set_token_source(token_source)
+      # todo
+    end
+
+    def get_tokens(start, stop, types)
+      # todo 改成关键字参数
+    end
+
+    def get_hidden_tokens_to_right(token_index, channel = -1)
+      # todo
+    end
+
+    def get_hidden_tokens_to_left(token_index, channel = -1)
+      # todo
+    end
+
+  end
+end

data/lib/antlr4ruby/char_streams.rb

@@ -0,0 +1,34 @@
+require_relative 'code_point_char_stream'
+module Antlr4ruby
+  class CharStreams
+    class << self
+      def from_path(path, charset)
+        # from_file(path, charset)
+      end
+
+      def from_file_name(filename, charset)
+        mode = charset ? "rb:#{charset}" : 'r'
+        File.open(filename, mode) do |file|
+          from_file(file)
+        end
+      end
+
+      def from_file(file)
+        input = file.read
+        if input
+          from_string(input)
+        else
+          raise "文件读取异常"
+        end
+      end
+
+      def from_string(input, source_name = IntStream.UNKNOWN_SOURCE_NAME)
+        # 首先将字符串转换为整数数组
+        CodePointCharStream.from_string(input, source_name)
+      end
+
+
+
+    end
+  end
+end

data/lib/antlr4ruby/code_point_buffer.rb

@@ -0,0 +1,31 @@
+# @deprecated
+module Antlr4ruby
+  class CodePointBuffer
+    BYTE = :BYTE
+    CHAR = :CHAR
+    INT = :INT
+
+    def position(new_position)
+      # todo
+    end
+
+    def remaining
+      # todo
+    end
+
+    def get(offset)
+      # todo
+    end
+
+    def get_type
+      # todo
+    end
+
+    def array_offset
+      # todo
+    end
+
+
+
+  end
+end

data/lib/antlr4ruby/code_point_char_stream.rb

@@ -0,0 +1,88 @@
+# finished
+
+module Antlr4ruby
+  # @abstract
+  class CodePointCharStream
+
+    def initialize(data, name = UNKNOWN_SOURCE_NAME)
+      @data, @name, @position = data, name, 0
+    end
+
+    protected
+
+    attr_reader :name, :data
+    attr_accessor :position
+
+    private
+
+    def get_internal_storage
+      @data
+    end
+
+    public
+
+    def self.from_buffer(code_point_buffer, name = UNKNOWN_SOURCE_NAME)
+      # todo
+    end
+
+    def self.from_string(input, name = UNKNOWN_SOURCE_NAME)
+      buffer = input.unpack('U*')
+      # input.each_char do |c|
+      #   buffer.push(c.ord)
+      # end
+      # 这里会有一个警告，但是不好处理
+      CodePointCharStream.new(buffer, name)
+    end
+
+    def consume
+      raise "can not consume eof." if @position == @data.length
+      @position += 1
+    end
+
+    def index
+      @position
+    end
+
+    def size
+      @data.length
+    end
+
+    def mark
+      -1
+    end
+
+    def release(marker) end
+
+    def seek(index)
+      @position = index
+    end
+
+    def la(i)
+      if i < 0
+        offset = position + i
+        offset < 0 ? IntStream.EOF : data[offset]
+      elsif i > 0
+        offset = position + i - 1
+        offset > data.length ? IntStream.EOF : data[offset]
+      else
+        0
+      end
+    end
+
+    def get_text(interval)
+      hold = data[interval]
+      return hold.pack('U*') if hold
+      'error in method get_text'
+    end
+
+    def get_source_name
+      UNKNOWN_SOURCE_NAME if !@name || name.empty?
+      @name
+    end
+
+    def to_s
+      data.pack('U*')
+    end
+
+  end
+end

data/lib/antlr4ruby/common_token.rb

@@ -0,0 +1,113 @@
+# finished
+module Antlr4ruby
+  class CommonToken
+    # 使用关键字参数来定义
+    def initialize(type: nil, source: nil,
+                   channel:nil, start: nil, stop: nil, text: nil )
+      @char_position_in_line = -1
+      @channel = channel || Token::DEFAULT_CHANNEL
+      @index = -1
+      @text = text || ''
+      @type = type || -1
+      @start = start || 0
+      @stop = stop || 0
+
+      if source&.first
+        @line = source.first.get_line
+        @char_position_in_line = source.first.get_char_position_in_line
+      else
+        @source = EMPTY_SOURCE
+      end
+
+    end
+
+    protected
+    EMPTY_SOURCE = Pair.new(nil, nil )
+    attr_accessor :type, :line, :char_position_in_line, :channel, :source, :text,:index,
+                  :start, :stop
+
+    public
+    def to_s(recognizer)
+      channel_str = channel == 0 ? "":", channel=#{channel}"
+      txt = get_text
+      txt = '<no text>' unless txt
+      type_string = type.to_s
+      type_string = recognizer.get_vocabulary.get_display_name(type) if recognizer
+      "[@#{get_token_index}, #{start}:#{stop}='#{txt}',<#{type_string}>, #{line}:#{char_position_in_line}]"
+    end
+
+    def get_type
+      @type
+    end
+
+    def set_line(line)
+      @line = line
+    end
+
+    def get_text
+      return @text if @text
+      input = get_input_stream
+      return "" unless  input
+      n = input.size
+      if start < n && stop < n
+        input.get_text(start..stop)
+      else
+        '<EOF>'
+      end
+    end
+
+    def set_text(text)
+      @text = text
+    end
+
+    def get_line
+      @line
+    end
+
+    def get_char_position_in_line
+      @char_position_in_line
+    end
+
+    def set_char_position_in_line(position)
+      @char_position_in_line = position
+    end
+
+    def get_channel
+      @channel
+    end
+
+    def set_channel(channel) @channel = channel; end
+
+    def set_type(ty) @type = ty; end
+
+    def get_start_index
+      @start
+    end
+
+    def set_start_index(start) @start = start; end
+
+    def get_stop_index
+      @stop
+    end
+
+    def set_stop_index(stop) @stop = stop; end
+
+    def get_token_index
+      @index
+    end
+
+    def set_token_index(index) @index = index; end
+
+    def get_token_source
+      source.first
+    end
+
+    def get_input_stream
+      source.second
+    end
+
+
+
+
+  end
+end

data/lib/antlr4ruby/common_token_factory.rb

@@ -0,0 +1,39 @@
+# finished
+# 已完成
+
+module Antlr4ruby
+  class CommonTokenFactory
+
+    DEFAULT = CommonTokenFactory.new
+
+    def initialize(copy_text = false)
+      @copy_text = copy_text
+    end
+
+    protected
+
+    attr_reader :copy_text
+
+    public
+
+    def create(type:, text:, source: nil,
+               channel: nil, start: nil, stop: nil, line: nil, position: nil)
+      if channel and source and start and stop and line and position
+        t = CommonToken.new(type: type, source: source, channel: channel, start: start, stop: stop)
+        t.set_line(line)
+        t.set_char_position_in_line(position)
+        if text
+          t.set_text(text)
+        elsif copy_text && source.second
+          t.set_text(source.second.get_text(start..stop))
+        end
+        t
+      else
+        CommonToken.new(type: type, text: text)
+      end
+    end
+
+
+
+  end
+end

data/lib/antlr4ruby/common_token_stream.rb

@@ -0,0 +1,62 @@
+# finished
+require 'antlr4ruby/buffered_token_stream'
+
+module Antlr4ruby
+  class CommonTokenStream < BufferedTokenStream
+    def initialize(token_source, channel = Token::DEFAULT_CHANNEL)
+      super(token_source)
+      @channel = channel
+    end
+
+
+
+    protected
+    attr_accessor :channel
+
+    def adjust_seek_index(i)
+      next_token_on_channel(i, @channel)
+    end
+
+    def lb(k)
+      return nil if k==0 || (@p -k) < 0
+
+      i = @p
+      n = 1
+      while n <= k && i > 0
+        i = previous_token_on_channel(i-1, @channel)
+        n += 1
+      end
+      return nil if i < 0
+      tokens[i]
+    end
+
+    public
+    def lt(k)
+      lazy_init
+      return nil if k == 0
+      return lb(-k) if k < 0
+
+      i = @p
+      n = 1
+      while n < k
+        if sync(i + 1)
+          i = next_token_on_channel(i+1, channel)
+        end
+        n += 1
+      end
+
+      tokens[i]
+    end
+    def get_number_of_on_channel_tokens
+      n = 0
+      fill
+      tokens.each do |token|
+        n += 1 if token.get_channel == channel
+        break if token.get_type == Token::EOF
+      end
+      n
+    end
+
+
+  end
+end

data/lib/antlr4ruby/console_error_listener.rb

@@ -0,0 +1,10 @@
+# 已完成
+module Antlr4ruby
+  class ConsoleErrorListener < BaseErrorListener
+    INSTANCE = ConsoleErrorListener.new
+
+    def syntax_error(recognizer, offending_symbol, line, char_position_in_line, msg, e)
+      print "line #{line}:#{char_position_in_line} #{msg}"
+    end
+  end
+end