antlr4-runtime 0.1.0

data/lib/antlr4/runtime/atn_simulator.rb

@@ -0,0 +1,69 @@
+require 'antlr4/runtime/dfa_state'
+
+module Antlr4::Runtime
+
+  class ATNSimulator
+    SERIALIZED_VERSION = ATNDeserializer.SERIALIZED_VERSION
+
+    SERIALIZED_UUID = ATNDeserializer.SERIALIZED_Uuid
+
+    attr_accessor :atn
+
+    class << self
+      attr_accessor :error
+      @@error = DFAState.new
+      @@error.initialize_configs(ATNConfigSet.new)
+      @@error.state_number = Integer::MAX
+    end
+
+    def initialize(atn, shared_context_cache)
+      @atn = atn
+      @shared_context_cache = shared_context_cache
+    end
+
+    def clear_dfa
+      raise UnsupportedOperationException, 'This ATN simulator does not support clearing the DFA.'
+    end
+
+    attr_reader :shared_context_cache
+
+    def cached_context(context)
+      return context if @shared_context_cache.nil?
+
+      visited = {}
+      PredictionContextUtils.cached_context(context, @shared_context_cache, visited)
+    end
+
+    def self.deserialize(data)
+      ATNDeserializer.new.deserialize(data)
+    end
+
+    def self.check_condition(condition, message = nil)
+      ATNDeserializer.new.check_condition(condition, message)
+    end
+
+    def self.to_int(c)
+      ATNDeserializer.to_int(c)
+    end
+
+    def self.to_int32(data, offset)
+      ATNDeserializer.to_int32(data, offset)
+    end
+
+    def self.to_long(data, offset)
+      ATNDeserializer.to_long(data, offset)
+    end
+
+    def self.to_uuid(data, offset)
+      ATNDeserializer.to_uuid(data, offset)
+    end
+
+    def edge_factory(atn, type, src, trg, arg1, arg2, arg3, sets)
+      ATNDeserializer.new.edge_factory(atn, type, src, trg, arg1, arg2, arg3, sets)
+    end
+
+    def state_factory(type, rule_index)
+      ATNDeserializer.new.state_factory(type, rule_index)
+    end
+  end
+end

data/lib/antlr4/runtime/atn_state.rb

@@ -0,0 +1,118 @@
+module Antlr4::Runtime
+
+  class ATNState
+    INITIAL_NUM_TRANSITIONS = 4
+    INVALID_TYPE = 0
+    BASIC = 1
+    RULE_START = 2
+    BLOCK_START = 3
+    PLUS_BLOCK_START = 4
+    STAR_BLOCK_START = 5
+    TOKEN_START = 6
+    RULE_STOP = 7
+    BLOCK_END = 8
+    STAR_LOOP_BACK = 9
+    STAR_LOOP_ENTRY = 10
+    PLUS_LOOP_BACK = 11
+    LOOP_END = 12
+
+
+    class << self
+      attr_accessor :invalid_state_number
+      @@serialization_names = %w[INVALID BASIC RULE_START BLOCK_START PLUS_BLOCK_START STAR_BLOCK_START TOKEN_START RULE_STOP BLOCK_END STAR_LOOP_BACK STAR_LOOP_ENTRY PLUS_LOOP_BACK LOOP_END]
+
+      @@invalid_state_number = -1
+    end
+
+    attr_accessor :next_token_within_rule
+    attr_accessor :atn
+    attr_accessor :state_number
+    attr_accessor :rule_index
+
+    def initialize
+      @atn = nil
+      @state_number = @@invalid_state_number
+      @rule_index = 0
+      @epsilon_only_transitions = false
+      @transitions = []
+      @next_token_within_rule = nil
+    end
+
+    def hash
+      @state_number
+    end
+
+    def eql?(other_key)
+      @state_number == other_key.state_number
+    end
+
+    def non_greedy_exit_state?
+      false
+    end
+
+    def to_s
+      @state_number.to_s
+    end
+
+    attr_reader :transitions
+
+    def number_of_transitions
+      @transitions.length
+    end
+
+    def add_transition(e)
+      add_transition_at(@transitions.length, e)
+    end
+
+    def add_transition_at(index, e)
+      if @transitions.empty?
+
+        @epsilon_only_transitions = e.epsilon?
+
+      elsif @epsilon_only_transitions != e.epsilon?
+
+        STDERR.puts format("ATN state %d has both epsilon and non-epsilon transitions.\n", state_number)
+        @epsilon_only_transitions = false
+      end
+      already_present = false
+
+      i = 0
+      while i < @transitions.length
+        t = @transitions[i]
+        if t.target.state_number == e.target.state_number
+
+          if !t.label.nil? && !e.label.nil? && t.label.eql?(e.label)
+            already_present = true
+            break
+          elsif t.epsilon? && e.epsilon?
+            already_present = true
+            break
+          end
+        end
+        i += 1
+      end
+
+      @transitions[index] = e unless already_present
+    end
+
+    def transition(i)
+      @transitions[i]
+    end
+
+    def set_transition(i, e)
+      @transitions[i] = e
+    end
+
+    def remove_transition(index)
+      @transitions.delete_at index
+    end
+
+    def only_has_epsilon_transitions
+      @epsilon_only_transitions
+    end
+
+    def set_rule_index(rule_index)
+      @rule_index = rule_index
+    end
+  end
+end

data/lib/antlr4/runtime/atn_type.rb

@@ -0,0 +1,8 @@
+module Antlr4::Runtime
+  class ATNType
+    LEXER = 0
+    PARSER = 1
+
+    VALUES = [LEXER, PARSER]
+  end
+end

data/lib/antlr4/runtime/atom_transition.rb

@@ -0,0 +1,27 @@
+module Antlr4::Runtime
+
+  class AtomTransition < Transition
+    attr_reader :the_label
+
+    def initialize(target, label)
+      super(target)
+      @the_label = label
+    end
+
+    def serialization_type
+      ATOM
+    end
+
+    def label
+      IntervalSet.of(@the_label)
+    end
+
+    def matches(symbol, _min_vocab_symbol, _max_vocab_symbol)
+      @the_label == symbol
+    end
+
+    def to_s
+      '' + @the_label
+    end
+  end
+end

data/lib/antlr4/runtime/bail_error_strategy.rb

@@ -0,0 +1,31 @@
+require 'antlr4/runtime/parse_cancellation_exception'
+
+module Antlr4::Runtime
+
+  class BailErrorStrategy < DefaultErrorStrategy
+    def recover(recognizer, e)
+      context = recognizer.getContext
+      until context.nil?
+        context = context.get_parent
+        context.exception = e
+      end
+
+      raise ParseCancellationException(e)
+    end
+
+    def recover_in_line(recognizer)
+      e = InputMismatchException.new recognizer
+      context = recognizer.getContext
+      until context.nil?
+        context = context.get_parent
+        context.exception = e
+      end
+
+      raise ParseCancellationException(e)
+    end
+
+    def sync(recognizer)
+      ;
+    end
+  end
+end

data/lib/antlr4/runtime/base_error_listener.rb

@@ -0,0 +1,18 @@
+require 'antlr4/runtime/antlr_error_listener'
+
+module Antlr4::Runtime
+
+  class BaseErrorListener < ANTLRErrorListener
+    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_ilts, _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/antlr4/runtime/basic_block_start_state.rb

@@ -0,0 +1,12 @@
+module Antlr4::Runtime
+
+  class BasicBlockStartState < BlockStartState
+    def initialize
+      super
+    end
+
+    def state_type
+      BLOCK_START
+    end
+  end
+end

data/lib/antlr4/runtime/basic_state.rb

@@ -0,0 +1,11 @@
+module Antlr4::Runtime
+  class BasicState < ATNState
+    def initialize
+      super
+    end
+
+    def state_type
+      BASIC
+    end
+  end
+end

data/lib/antlr4/runtime/bit_set.rb

@@ -0,0 +1,54 @@
+require 'rumourhash/rumourhash'
+
+include RumourHash
+
+module Antlr4::Runtime
+
+  class BitSet
+    MAX_BITS = 128
+
+    attr_reader :bits
+
+    def initialize
+      @bits = 0
+    end
+
+    def set(x)
+      @bits |= (1 << x)
+    end
+
+    def get(x)
+      (@bits & (1 << x)) > 0 ? true : false
+    end
+
+    def cardinality
+      bit_count(@bits)
+    end
+
+    def or(bit_set)
+      @bits |= bit_set.bits
+    end
+
+    def next_set_bit(bit)
+      result = bit
+      i = 0
+      mask = (1 << bit)
+      while i < MAX_BITS
+        if (@bits & mask) > 0
+          return result
+        end
+        result += 1
+        mask <<= 1
+        i += 1
+      end
+      -1
+    end
+
+    def to_s
+      buf = '['
+      buf << @bits.to_s(2)
+      buf << ']'
+      buf
+    end
+  end
+end

data/lib/antlr4/runtime/block_end_state.rb

@@ -0,0 +1,15 @@
+module Antlr4::Runtime
+
+  class BlockEndState < ATNState
+    attr_accessor :start_state
+
+    def initialize
+      super
+      @start_state = nil
+    end
+
+    def state_type
+      BLOCK_END
+    end
+  end
+end

data/lib/antlr4/runtime/block_start_state.rb

@@ -0,0 +1,12 @@
+require 'antlr4/runtime/decision_state'
+
+module Antlr4::Runtime
+  class BlockStartState < DecisionState
+    attr_accessor :end_state
+
+    def initialize
+      super
+      @end_state = nil
+    end
+  end
+end

data/lib/antlr4/runtime/buffered_token_stream.rb

@@ -0,0 +1,335 @@
+require 'antlr4/runtime/writable_token'
+require 'antlr4/runtime/token_stream'
+
+module Antlr4::Runtime
+
+  class BufferedTokenStream < TokenStream
+    def initialize(token_source)
+      raise NilPointerException, 'token_source cannot be nil' if token_source.nil?
+
+      @token_source = token_source
+      @tokens = []
+      @ptr = -1
+      @fetched_eof = false
+    end
+
+    attr_reader :token_source
+
+    def index
+      @ptr
+    end
+
+    def mark
+      0
+    end
+
+    def release(marker)
+      ;
+    end
+
+    def reset
+      seek(0)
+    end
+
+    def seek(index)
+      lazy_init
+      @ptr = adjust_seek_index(index)
+    end
+
+    def size
+      @tokens.length
+    end
+
+    def consume
+      skip_eof_check = false
+      if @ptr >= 0
+        if @fetched_eof
+          # the last token in tokens is EOF. skip check if p indexes any
+          # fetched token except the last.
+          skip_eof_check = @ptr < @tokens.length - 1
+        else # no EOF token in tokens. skip check if p indexes a fetched token.
+          skip_eof_check = @ptr < @tokens.length
+        end
+      else # not yet initialized
+        skip_eof_check = false
+      end
+
+      if !skip_eof_check && la(1) == EOF
+        raise IllegalStateException, 'cannot consume EOF'
+      end
+
+      @ptr = adjust_seek_index(@ptr + 1) if sync(@ptr + 1)
+    end
+
+    def sync(i)
+      n = i - @tokens.length + 1 # how many more elements we need?
+
+      if n > 0
+        fetched = fetch(n)
+        return fetched >= n
+      end
+
+      true
+    end
+
+    def fetch(n)
+      return 0 if @fetched_eof
+
+      i = 0
+      while i < n
+        t = @token_source.next_token
+        t.setTokenIndex(@tokens.length) if t.is_a? WritableToken
+        @tokens << t
+        if t.type == Token::EOF
+          @fetched_eof = true
+          return i + 1
+        end
+        i += 1
+      end
+
+      n
+    end
+
+    def get(i)
+      if i < 0 || i >= @tokens.length
+        raise IndexOutOfBoundsException, 'token index ' + i + ' out of range 0..' + (@tokens.length - 1)
+      end
+
+      @tokens[i]
+    end
+
+    def get_list(start, stop)
+      return nil if start < 0 || stop < 0
+
+      lazy_init
+      subset = []
+      stop = @tokens.length - 1 if stop >= @tokens.length
+      i = start
+      while i <= stop
+        t = @tokens[i]
+        break if t.type == Token::EOF
+
+        subset.add(t)
+        i += 1
+      end
+      subset
+    end
+
+    def la(i)
+      lt(i).type
+    end
+
+    def lb(k)
+      return nil if (@ptr - k) < 0
+
+      @tokens[@ptr - k]
+    end
+
+    def lt(k)
+      lazy_init
+      return nil if k == 0
+
+      return lb(-k) if k < 0
+
+      i = @ptr + k - 1
+      sync(i)
+      if i >= @tokens.length # return EOF token
+        # EOF must be last token
+        return @tokens.get(@tokens.length - 1)
+      end
+
+      #    if ( i>range ) range = i
+      @tokens[i]
+    end
+
+    def adjust_seek_index(i)
+      i
+    end
+
+    def lazy_init
+      setup if @ptr == -1
+    end
+
+    def setup
+      sync(0)
+      @ptr = adjust_seek_index(0)
+    end
+
+    def token_source(tokenSource)
+      @token_source = tokenSource
+      @tokens.clear
+      @ptr = -1
+      @fetched_eof = false
+    end
+
+    attr_reader :tokens
+
+    def tokens1(start, stop, types = nil)
+      lazy_init
+      if start < 0 || stop >= @tokens.length || stop < 0 || start >= @tokens.length
+
+        raise IndexOutOfBoundsException, 'start ' + start + ' or stop ' + stop + ' not in 0..' + (@tokens.length - 1)
+      end
+      return nil if start > stop
+
+      # list = tokens[start:stop]:T t, t.getType() in typesend
+      filtered_tokens = []
+      i = start
+      while i <= stop
+        t = @tokens[i]
+        filtered_tokens.add(t) if types.nil? || types.include?(t.type)
+        i += 1
+      end
+      filtered_tokens = nil if filtered_tokens.empty?
+      filtered_tokens
+    end
+
+    def get_tokens2(start, stop, ttype)
+      s = Set.new
+      s.add(ttype)
+      tokens1(start, stop, s)
+    end
+
+    def next_token_on_channel(i, channel)
+      sync(i)
+      return size - 1 if i >= size
+
+      token = @tokens[i]
+      while token.channel != channel
+        return i if token.type == Token::EOF
+
+        i += 1
+        sync(i)
+        token = @tokens[i]
+      end
+
+      i
+    end
+
+    def previous_token_on_channel(i, channel)
+      sync(i)
+      if i >= size
+        # the EOF token is on every channel
+        return size - 1
+      end
+
+      while i >= 0
+        token = @tokens[i]
+        return i if token.type == Token::EOF || token.channel == channel
+
+        i -= 1
+      end
+
+      i
+    end
+
+    def hidden_tokens_to_right(token_index, channel)
+      lazy_init
+      if token_index < 0 || token_index >= tokens.size
+        raise IndexOutOfBoundsException, token_index + ' not in 0..' + (@tokens.length - 1)
+      end
+
+      next_on_channel = next_token_on_channel(token_index + 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+      from = token_index + 1
+      # if none onchannel to right, next_on_channel=-1 so set to = last token
+      to = next_on_channel == -1 ? size - 1 : next_on_channel
+
+      filter_for_channel(from, to, channel)
+    end
+
+    def hidden_tokens_to_right2(token_index)
+      hidden_tokens_to_right(token_index, -1)
+    end
+
+    def hidden_tokens_to_left(token_index, channel)
+      lazy_init
+      if token_index < 0 || token_index >= tokens.size
+        raise IndexOutOfBoundsException, token_index + ' not in 0..' + (@tokens.length - 1)
+      end
+
+      if token_index == 0
+        # obviously no tokens can appear before the first token
+        return nil
+      end
+
+      prev_on_channel = previous_token_on_channel(token_index - 1, Lexer.DEFAULT_TOKEN_CHANNEL)
+      return nil if prev_on_channel == token_index - 1
+
+      # if none onchannel to left, prev_on_channel=-1 then from=0
+      from = prev_on_channel + 1
+      to = token_index - 1
+
+      filter_for_channel(from, to, channel)
+    end
+
+    def hidden_tokens_to_left1(token_index)
+      hidden_tokens_to_left(token_index, -1)
+    end
+
+    def filter_for_channel(from, to, channel)
+      hidden = []
+      i = from
+      while i <= to
+        t = @tokens[i]
+        if channel == -1
+          hidden.add(t) if t.channel != Lexer.DEFAULT_TOKEN_CHANNEL
+        else
+          hidden.add(t) if t.channel == channel
+        end
+        i += 1
+      end
+      return nil if hidden.empty?
+
+      hidden
+    end
+
+    def source_name
+      @token_source.get_source_name
+    end
+
+    def text
+      text2(Interval.of(0, size - 1))
+    end
+
+    def text2(interval)
+      start = interval.a
+      stop = interval.b
+      return '' if start < 0 || stop < 0
+
+      fill
+      stop = @tokens.length - 1 if stop >= @tokens.length
+
+      buf = ''
+      i = start
+      while i <= stop
+        t = @tokens[i]
+        break if t.type == Token::EOF
+
+        buf << t.text
+        buf << i += 1
+      end
+      buf
+    end
+
+    def text3(ctx)
+      text2(ctx.source_interval)
+    end
+
+    def text4(start, stop)
+      if !start.nil? && !stop.nil?
+        return text2(Interval.of(start.index, stop.index))
+      end
+
+      ''
+    end
+
+    def fill
+      lazy_init
+      block_size = 1000
+      loop do
+        fetched = fetch(block_size)
+        return if fetched < block_size
+      end
+    end
+  end
+end