antlr4-runtime 0.1.0

data/lib/antlr4/runtime/error_info.rb

@@ -0,0 +1,7 @@
+module Antlr4::Runtime
+  class ErrorInfo < DecisionEventInfo
+    def initialize(decision, configs, input, start_index, stop_index, full_ctx)
+      super(decision, configs, input, start_index, stop_index, full_ctx)
+    end
+  end
+end

data/lib/antlr4/runtime/error_node.rb

@@ -0,0 +1,5 @@
+module Antlr4::Runtime
+
+  class ErrorNode < TerminalNode
+  end
+end

data/lib/antlr4/runtime/error_node_impl.rb

@@ -0,0 +1,12 @@
+module Antlr4::Runtime
+
+  class ErrorNodeImpl < TerminalNodeImpl
+    def initialize(token)
+      super(token)
+    end
+
+    def accept(visitor)
+      visitor.visit_error_node(self)
+    end
+  end
+end

data/lib/antlr4/runtime/failed_predicate_exception.rb

@@ -0,0 +1,33 @@
+module Antlr4::Runtime
+
+  class FailedPredicateException < RecognitionException
+    attr_reader :predicate
+    attr_reader :predicate_index
+    attr_reader :rule_index
+
+    def initialize(recognizer, predicate = nil, message = nil)
+      super(format_message(predicate, message))
+      @recognizer = recognizer
+      @input = recognizer.input_stream
+      @context = recognizer._ctx
+
+      s = recognizer._interp.atn.states.get(recognizer.getState)
+
+      trans = s.transition(0)
+      if trans.is_a? PredicateTransition
+        @rule_index = trans.rule_index
+        @predicate_index = trans.pred_index
+      else
+        @rule_index = 0
+        @predicate_index = 0
+      end
+
+      @predicate = predicate
+      @offending_token = recognizer.current_token
+    end
+
+    def format_message(predicate, message)
+      message.nil? ? message : "failed predicate: {" + predicate + "}?"
+    end
+  end
+end

data/lib/antlr4/runtime/flexible_hash_map.rb

@@ -0,0 +1,232 @@
+module Antlr4::Runtime
+  class FlexibleHashMap
+    INITIAL_CAPACITY = 16 # must be power of 2
+    INITIAL_BUCKET_CAPACITY = 8
+    LOAD_FACTOR = 0.75
+
+    class Entry
+      attr_accessor :key
+      attr_accessor :value
+
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+
+      def to_s
+        @key.to_s << ':' << @value.to_s
+      end
+    end
+
+    def initialize(comparator = nil, initial_capacity = nil, initial_bucket_capacity = nil)
+      comparator = ObjectEqualityComparator.INSTANCE if comparator.nil?
+
+      initial_capacity = INITIAL_CAPACITY if initial_capacity.nil?
+      initial_bucket_capacity = INITIAL_BUCKET_CAPACITY if initial_bucket_capacity.nil?
+
+      @n_items = 0
+      @threshold = initial_capacity * LOAD_FACTOR # when to expand
+      @current_prime = 1 # jump by 4 primes each expand or whatever
+      @initial_bucket_capacity = initial_bucket_capacity
+      @comparator = comparator
+      @buckets = create_entry_list_array(initial_bucket_capacity)
+    end
+
+    def create_entry_list_array(length)
+      Array.new(length)
+    end
+
+    def bucket(key)
+      hash = @comparator.hash(key)
+      hash & (@buckets.length - 1) # assumes len is power of 2
+    end
+
+    def get(key)
+      typed_key = key
+      return nil if key.nil?
+
+      b = bucket(typed_key)
+      bucket = @buckets[b]
+      if bucket.nil?
+        return nil # no bucket
+      end
+
+      i = 0
+      while i < bucket.length
+        e = bucket[i]
+        return e.value if @comparator.equals(e.key, typed_key)
+        i += 1
+      end
+      nil
+    end
+
+    def put(key, value)
+      return nil if key.nil?
+
+      expand if @n_items > @threshold
+      b = bucket(key)
+      bucket = @buckets[b]
+      bucket = @buckets[b] = [] if bucket.nil?
+      i = 0
+      while i < bucket.length
+        e = bucket[i]
+        unless @comparator.equals(e.key, key)
+          i += 1
+          next
+        end
+
+        prev = e.value
+        e.value = value
+        @n_items += 1
+        return prev
+      end
+      # not there
+      bucket << Entry.new(key, value)
+      @n_items += 1
+      nil
+    end
+
+    def values
+      a = []
+      i = 0
+      while i < @buckets.length
+        bucket = @buckets[i]
+        if bucket.nil?
+          i += 1
+          next
+        end
+
+        j = 0
+        while j < bucket.length
+          e = bucket[j]
+          a << e.value
+          j += 1
+        end
+        i += 1
+      end
+      a
+    end
+
+    def contains_key(key)
+      !get(key).nil?
+    end
+
+    def hash
+      objs = []
+      i = 0
+      while i < @buckets.length
+        bucket = @buckets[i]
+        if bucket.nil?
+          i += 1
+          next
+        end
+
+        j = 0
+        while j < bucket.length
+          e = bucket[j]
+          break if e.nil?
+
+          objs << e.key
+          j += 1
+        end
+        i += 1
+      end
+
+      hash_code = MurmurHash.hash_objs(objs)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for FlexibleHashMap'
+        else
+          puts 'Different hash_code for FlexibleHashMap'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def expand
+      old = @buckets
+      @current_prime += 4
+      new_capacity = @buckets.length * 2
+      new_table = create_entry_list_array(new_capacity)
+      @buckets = new_table
+      @threshold = new_capacity * LOAD_FACTOR
+
+      old_size = size
+      i = 0
+      while i < old.length
+        bucket = old[i]
+        if bucket.nil?
+          i += 1
+          next
+        end
+
+        j = 0
+        while j < bucket.length
+          e = bucket[j]
+          break if e.nil?
+
+          put(e.key, e.value)
+          j += 1
+        end
+        i += 1
+      end
+      @n_items = old_size
+    end
+
+    def size
+      @n_items
+    end
+
+    def empty?
+      @n_items == 0
+    end
+
+    def clear
+      @buckets = create_entry_list_array(INITIAL_CAPACITY)
+      @n_items = 0
+    end
+
+    def to_s
+      return 'end' if size == 0
+
+      buf = ''
+      buf << ''
+      first = true
+      @buckets.each do |bucket|
+        next if bucket.nil?
+
+        bucket.each do |e|
+          break if e.nil?
+
+          if first
+            first = false
+          else
+            buf << ', '
+          end
+          buf << e.to_s
+        end
+      end
+      buf << 'end'
+      buf.to_s
+    end
+
+    def to_table_string
+      buf = ''
+      @buckets.each do |bucket|
+        if bucket.nil?
+          buf << "nil\n"
+          next
+        end
+        buf << '['
+        first = true
+        bucket.each do |e|
+          first ? first = false : buf << ' '
+          buf << (e.nil? ? '_' : e.to_s)
+        end
+        buf << "]\n"
+      end
+      buf.to_s
+    end
+  end
+end

data/lib/antlr4/runtime/input_mismatch_exception.rb

@@ -0,0 +1,20 @@
+require 'antlr4/runtime/recognition_exception'
+
+module Antlr4::Runtime
+
+  class InputMismatchException < RecognitionException
+    def self.create(recog, state = nil)
+      result = InputMismatchException.new
+
+      result.offending_state = -1
+      result.context = recog._ctx
+      result.input = recog._input
+      result.recognizer = recog
+      result.offending_state = recog._state_number unless recog.nil?
+
+      result.offending_token = recog.current_token unless recog.nil?
+      result.offending_state = state unless state.nil?
+      result
+    end
+  end
+end

data/lib/antlr4/runtime/int_stream.rb

@@ -0,0 +1,31 @@
+module Antlr4::Runtime
+  class IntStream
+    EOF = -1
+
+    UNKNOWN_SOURCE_NAME = '<unknown>'.freeze
+
+    def consume
+    end
+
+    def la(i)
+    end
+
+    def mark
+    end
+
+    def release(marker)
+    end
+
+    def index
+    end
+
+    def seek(index)
+    end
+
+    def size
+    end
+
+    def source_name
+    end
+  end
+end

data/lib/antlr4/runtime/integer.rb

@@ -0,0 +1,14 @@
+module Antlr4::Runtime
+  class Integer
+    N_BYTES = [42].pack('i').size
+    N_BITS = N_BYTES * 16
+    MAX = 2 ** (N_BITS - 2) - 1
+    MIN = -MAX - 1
+
+    def self.signum(x)
+      return 0 if x.zero?
+      return -1 if x < 0
+      1
+    end
+  end
+end

data/lib/antlr4/runtime/interval.rb

@@ -0,0 +1,111 @@
+module Antlr4::Runtime
+  class Interval
+    INTERVAL_POOL_MAX_VALUE = 1000
+
+
+    attr_accessor :a
+    attr_accessor :b
+
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+
+    class << self
+      attr_accessor :creates
+      attr_accessor :misses
+      attr_accessor :hits
+      attr_accessor :outOfRange
+      attr_accessor :invalid
+
+      @@cache = []
+      @@creates = 0
+      @@misses = 0
+      @@hits = 0
+      @@outOfRange = 0
+      @@invalid = Interval.new(-1, -2)
+    end
+
+    def self.of(a, b)
+      return Interval.new(a, b) if a != b || a < 0 || a > INTERVAL_POOL_MAX_VALUE
+
+      @@cache[a] = Interval.new(a, a) if @@cache[a].nil?
+      @@cache[a]
+    end
+
+    def length
+      return 0 if @b < @a
+
+      @b - @a + 1
+    end
+
+    def ==(o)
+      return false if o.nil? || !(o.is_a? Interval)
+
+      @a == o.a && @b == o.b
+    end
+
+    def hash
+      hash = 23
+      hash = hash * 31 + @a
+      hash * 31 + @b
+    end
+
+    def starts_before_disjoint(other)
+      @a < other.a && @b < other.a
+    end
+
+    def starts_before_non_disjoint(other)
+      @a <= other.a && @b >= other.a
+    end
+
+    def startsAfter(other)
+      @a > other.a
+    end
+
+    def startsAfterDisjoint(other)
+      @a > other.b
+    end
+
+    def startsAfterNonDisjoint(other)
+      @a > other.a && @a <= other.b
+    end
+
+    def disjoint(other)
+      starts_before_disjoint(other) || startsAfterDisjoint(other)
+    end
+
+    def adjacent(other)
+      @a == other.b + 1 || @b == other.a - 1
+    end
+
+    def properlyContains(other)
+      other.a >= @a && other.b <= @b
+    end
+
+    def union(other)
+      Interval.of([a, other.a].min, [b, other.b].max)
+    end
+
+    def intersection(other)
+      Interval.of([a, other.a].max, [b, other.b].min)
+    end
+
+    def difference_not_properly_contained(other)
+      diff = null
+      if other.starts_before_non_disjoint(this)
+
+        diff = Interval.of([@a, other.b + 1].max, @b)
+
+      elsif other.startsAfterNonDisjoint(this)
+
+        diff = Interval.of(@a, other.a - 1)
+      end
+      diff
+    end
+
+    def to_s
+      @a.to_s + '..' + @b.to_s
+    end
+  end
+end