antlr4-runtime 0.1.0

data/ext/rumourhash/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "rumourhash"

data/ext/rumourhash/rumourhash.c

@@ -0,0 +1,59 @@
+#include <ruby.h>
+
+#define c1 0xCC9E2D51
+#define c2 0x1B873593
+#define r1 15
+#define r2 13
+#define m 5
+#define n 0xE6546B64
+
+static VALUE rumour_hash_update_int(VALUE self, VALUE hashv, VALUE valuev) {
+    long hash = NUM2LONG(hashv);
+    long value = NUM2LONG(valuev);
+
+    long k = value;
+    k *= c1;
+    k = (k << r1) | (k >> (32 - r1));
+    k *= c2;
+
+    hash = hash ^ k;
+    hash = (hash << r2) | (hash >> (32 - r2));
+    hash *= m + n;
+
+    return LONG2NUM(hash);
+}
+
+static VALUE rumour_hash_finish(VALUE self, VALUE hashv, VALUE n_wordsv) {
+    long hash = NUM2LONG(hashv);
+    long n_words = NUM2LONG(n_wordsv);
+
+    hash = hash ^ (n_words * 4);
+    hash = hash ^ (hash >> 16);
+    hash *= 0x85EBCA6B;
+    hash = hash ^ (hash >> 13);
+    hash *= 0xC2B2AE35;
+    hash ^= (hash >> 16);
+
+    return LONG2NUM(hash);
+}
+
+static VALUE bit_count(VALUE self, VALUE v) {
+    long num = NUM2LONG(v);
+    int count = 0;
+
+    while (num)
+    {
+      num &= (num-1) ;
+      count++;
+    }
+
+    return INT2NUM(count);
+}
+
+void Init_rumourhash() {
+  VALUE mod = rb_define_module("RumourHash");
+  rb_define_method(mod, "rumour_hash_update_int", rumour_hash_update_int, 2);
+  rb_define_method(mod, "rumour_hash_finish", rumour_hash_finish, 2);
+  rb_define_method(mod, "bit_count", bit_count, 1);
+}
+

data/lib/antlr4/runtime.rb

@@ -0,0 +1,37 @@
+require 'set'
+require 'singleton'
+require 'ostruct'
+require 'weakref'
+
+require "rumourhash/rumourhash"
+
+module Antlr4
+  module Runtime
+  end
+end
+
+module RumourHash
+
+end
+
+module BitCount
+
+end
+
+require 'antlr4/runtime/interval'
+require 'antlr4/runtime/char_streams'
+require 'antlr4/runtime/common_token_stream'
+require 'antlr4/runtime/prediction_context_cache'
+require 'antlr4/runtime/vocabulary_impl'
+require 'antlr4/runtime/dfa'
+require 'antlr4/runtime/atn_deserializer'
+require 'antlr4/runtime/lexer_atn_simulator'
+require 'antlr4/runtime/parser_atn_simulator'
+require 'antlr4/runtime/parser_rule_context'
+require 'antlr4/runtime/lexer'
+require 'antlr4/runtime/parser'
+require 'antlr4/runtime/parse_tree_listener'
+require 'antlr4/runtime/parse_tree_visitor'
+require 'antlr4/runtime/abstract_parse_tree_visitor'
+require 'antlr4/runtime/recognition_exception'
+require 'antlr4/runtime/utils'

data/lib/antlr4/runtime/abstract_parse_tree_visitor.rb

@@ -0,0 +1,43 @@
+module Antlr4::Runtime
+  class AbstractParseTreeVisitor
+    def visit(tree)
+      tree.accept(self)
+    end
+
+    def visit_children(node)
+      result = default_result
+      n = node.child_count
+      i = 0
+      while i < n
+        break unless should_visit_next_child(node, result)
+
+        c = node.child_at(i)
+        child_result = c.accept(self)
+        result = aggregate_result(result, child_result)
+        i += 1
+      end
+
+      result
+    end
+
+    def visit_terminal(_node)
+      default_result
+    end
+
+    def visit_error_node(_node)
+      default_result
+    end
+
+    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/antlr4/runtime/abstract_predicate_transition.rb

@@ -0,0 +1,11 @@
+require 'antlr4/runtime/transition'
+
+module Antlr4::Runtime
+
+  class AbstractPredicateTransition < Transition
+    def initialize(target)
+      super(target)
+    end
+  end
+
+end

data/lib/antlr4/runtime/action_transition.rb

@@ -0,0 +1,29 @@
+module Antlr4::Runtime
+
+  class ActionTransition < Transition
+    attr_reader :action_index
+
+    def initialize(target, rule_index, action_index, is_ctx_dependent)
+      super(target)
+      @rule_index = rule_index
+      @action_index = action_index
+      @is_ctx_dependent = is_ctx_dependent
+    end
+
+    def serialization_type
+      ACTION
+    end
+
+    def epsilon?
+      true
+    end
+
+    def matches(_symbol, _min_vocab_symbol, _max_vocab_symbol)
+      false
+    end
+
+    def to_s
+      'action_' + @rule_index + ':' + @action_index
+    end
+  end
+end

data/lib/antlr4/runtime/ambiguity_info.rb

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

data/lib/antlr4/runtime/antlr_error_listener.rb

@@ -0,0 +1,15 @@
+module Antlr4::Runtime
+  class 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_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/antlr4/runtime/antlr_error_strategy.rb

@@ -0,0 +1,24 @@
+module Antlr4::Runtime
+  class ANTLRErrorStrategy
+    def reset(_recognizer)
+    end
+
+    def recover_in_line(_recognizer)
+    end
+
+    def recover(_recognizer, _e)
+    end
+
+    def sync(_recognizer)
+    end
+
+    def in_error_recovery_mode(_recognizer)
+    end
+
+    def report_match(_recognizer)
+    end
+
+    def report_error(_recognizer, _e)
+    end
+  end
+end

data/lib/antlr4/runtime/antlr_file_stream.rb

@@ -0,0 +1,17 @@
+module Antlr4::Runtime
+  class ANTLRFileStream < ANTLRInputStream
+    def initialize(file_name, encoding)
+      @file_name = file_name
+      load(file_name, encoding)
+    end
+
+    def load(file_name, encoding)
+      data = Utils.read_file(file_name, encoding)
+      @n_items = data.length
+    end
+
+    def source_name
+      @file_name
+    end
+  end
+end

data/lib/antlr4/runtime/antlr_input_stream.rb

@@ -0,0 +1,6 @@
+module Antlr4::Runtime
+  class ANTLRInputStream < CharStream
+    READ_BUFFER_SIZE = 1024
+    INITIAL_BUFFER_SIZE = 1024
+  end
+end

data/lib/antlr4/runtime/array_2d_hash_set.rb

@@ -0,0 +1,471 @@
+require 'antlr4/runtime/object_equality_comparator'
+require 'antlr4/runtime/murmur_hash'
+
+module Antlr4::Runtime
+
+  class Array2DHashSet
+    INITIAL_CAPACITY = 16 # must be power of 2
+    INITIAL_BUCKET_CAPACITY = 8
+    LOAD_FACTOR = 0.75
+
+    def initialize(comparator = nil, initial_capacity = INITIAL_CAPACITY, initial_bucket_capacity = INITIAL_BUCKET_CAPACITY)
+      comparator.nil? ? @comparator = ObjectEqualityComparator.instance : @comparator = comparator
+
+      @n_elements = 0
+      @initial_bucket_capacity = initial_bucket_capacity
+      @threshold = (initial_bucket_capacity * LOAD_FACTOR).floor # when to expand
+      @current_prime = 1 # jump by 4 primes each expand or whatever
+      @buckets = create_buckets(initial_capacity)
+    end
+
+    def get_or_add(o)
+      expand if @n_elements > @threshold
+      get_or_add_impl(o)
+    end
+
+    def get_or_add_impl(o)
+      b = get_bucket(o)
+      bucket = @buckets[b]
+
+      if bucket.nil?
+        bucket = create_bucket(@initial_bucket_capacity)
+        bucket[0] = o
+        @buckets[b] = bucket
+        @n_elements += 1
+        return o
+      end
+
+      # LOOK FOR IT IN BUCKET
+      i = 0
+      while i < bucket.length
+        existing = bucket[i]
+        if existing.nil? # empty slot not there, add.
+          bucket[i] = o
+          @n_elements += 1
+          return o
+        end
+        if @comparator.equals(existing, o)
+          return existing # found existing, quit
+        end
+
+        i += 1
+      end
+
+      # FULL BUCKET, add to end
+      @buckets[b] = bucket
+      bucket << o # add to end
+      @n_elements += 1
+      o
+    end
+
+    def get(o)
+      return o if o.nil?
+
+      b = get_bucket(o)
+      bucket = @buckets[b]
+      if bucket.nil?
+        return nil # no bucket
+      end
+
+      i = 0
+      while i < bucket.length
+        e = bucket[i]
+        if e.nil?
+          return nil # empty slot not there
+        end
+        return e if @comparator.equals(e, o)
+        i += 1
+      end
+      nil
+    end
+
+    def get_bucket(o)
+      hash = @comparator.hash(o)
+      hash & (@buckets.length - 1) # assumes len is power of 2
+    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
+          o = bucket[j]
+          break if o.nil?
+
+          objs << o
+          j += 1
+        end
+        i += 1
+      end
+
+      hash_code = MurmurHash.hash_objs(objs)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for Array2DHashSet'
+        else
+          puts 'Different hash_code for Array2DHashSet'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def equals(o)
+      return true if o == self
+      return false unless o.is_a? Array2DHashSet
+
+      other = o
+      return false if other.size != size
+
+      contains_all(other)
+    end
+
+    def add(t)
+      existing = get_or_add(t)
+      existing == t
+    end
+
+    def size
+      @n_elements
+    end
+
+    def empty?
+      @n_elements == 0
+    end
+
+    def contains(o)
+      contains_fast(o)
+    end
+
+    def contains_fast(obj)
+      return false if obj.nil?
+
+      !get(obj).nil?
+    end
+
+    def iterator
+      a = to_a
+      a.sort(@comparator) unless @comparator.nil?
+      SetIterator.new(a, self)
+    end
+
+    def to_a
+      a = create_bucket(size)
+      i = 0
+      j = 0
+      while j < @buckets.length
+        bucket = @buckets[j]
+        if bucket.nil?
+          j += 1
+          next
+        end
+
+        k = 0
+        while k < bucket.length
+          o = bucket[k]
+          break if o.nil?
+
+          a[i] = o
+          i += 1
+          k += 1
+        end
+        j += 1
+      end
+      a
+    end
+
+    def remove(o)
+      remove_fast(o)
+    end
+
+    def remove_fast(obj)
+      return false if obj.nil?
+
+      b = get_bucket(obj)
+      bucket = @buckets[b]
+      if bucket.nil?
+        # no bucket
+        return false
+      end
+
+      i = 0
+      while i < bucket.length
+        e = bucket[i]
+        if e.nil?
+          # empty slot not there
+          return false
+        end
+
+        if @comparator.eql?(e, obj) # found it
+          bucket[i] = nil
+          return true
+        end
+        i += 1
+      end
+
+      false
+    end
+
+    def contains_all(collection)
+      if collection.is_a? Array2DHashSet
+        s = collection
+        i = 0
+        while i < s.buckets.length
+          bucket = s.buckets[i]
+          if bucket.nil?
+            i += 1
+            next
+          end
+
+          j = 0
+          while j < bucket.length
+            o = bucket[j]
+            break if o.nil?
+            return false unless contains_fast(o)
+            j += 1
+          end
+          i += 1
+        end
+      else
+        i = 0
+        while i < collection.length
+          o = collection[i]
+          return false unless contains_fast(o)
+          i += 1
+        end
+      end
+      true
+    end
+
+    def add_all(c)
+      changed = false
+      i = 0
+      while i < c.length
+        o = c[i]
+        existing = get_or_add(o)
+        changed = true if existing != o
+        i += 1
+      end
+      changed
+    end
+
+    def retain_all(c)
+      newsize = 0
+      k = 0
+      while k < @buckets.length
+        bucket = @buckets[k]
+        if bucket.nil?
+          k += 1
+          next
+        end
+
+        i = 0
+        j = 0
+        while i < bucket.length
+          break if bucket[i].nil?
+
+          if c.contains(bucket[i])
+            # keep
+            bucket[j] = bucket[i] if i != j
+
+            j += 1
+            newsize += 1
+          end
+
+          i += 1
+        end
+
+        newsize += j
+
+        while j < i
+          bucket[j] = nil
+          j += 1
+        end
+        k += 1
+      end
+
+      changed = newsize != @n_elements
+      @n_elements = newsize
+      changed
+    end
+
+    def remove_all(c)
+      changed = false
+      i = 0
+      while i < c.length
+        o = c[i]
+        changed |= remove_fast(o)
+        i += 1
+      end
+
+      changed
+    end
+
+    def clear
+      @buckets = create_buckets(INITIAL_CAPACITY)
+      @n_elements = 0
+      @threshold = (INITIAL_CAPACITY * LOAD_FACTOR).floor
+    end
+
+    def to_s
+      return '{}' if size == 0
+
+      buf = ''
+      buf << '{'
+      first = true
+      i = 0
+      while i < @buckets.length
+        bucket = @buckets[i]
+        if bucket.nil?
+          i += 1
+          next
+        end
+
+        j = 0
+        while j < bucket.length
+          o = bucket[j]
+          break if o.nil?
+
+          if first
+            first = false
+          else
+            buf << ', '
+            buf << o.to_s
+          end
+          j += 1
+        end
+        i += 1
+      end
+      buf << '}'
+      buf
+    end
+
+    def to_table_string
+      buf = ''
+      i = 0
+      while i < @buckets.length
+        bucket = @buckets[i]
+        if bucket.nil?
+          buf << "null\n"
+        else
+          buf << '['
+          first = true
+          j = 0
+          while j < bucket.length
+            o = bucket[j]
+            if first
+              first = false
+            else
+              buf << ' '
+            end
+            buf << if o.nil?
+                     '_'
+                   else
+                     o.to_s
+                   end
+            j += 1
+          end
+          buf << "]\n"
+        end
+        i += 1
+      end
+      buf
+    end
+
+    def create_buckets(capacity)
+      Array.new(capacity)
+    end
+
+    def create_bucket(capacity)
+      Array.new(capacity)
+    end
+
+    class SetIterator
+      def initialize(data, parent)
+        @data = data
+        @parent = parent
+        @next_index = 0
+        @removed = true
+      end
+
+      def has_next
+        @next_index < @data.length
+      end
+
+      def next
+        raise StandardError unless has_next
+
+        @removed = false
+        result = @data[@next_index]
+        @next_index += 1
+        result
+      end
+
+      def remove
+        raise IllegalStateException if @removed
+
+        parent.remove(@data[@next_index - 1])
+        @removed = true
+      end
+    end
+
+    def expand
+      old = @buckets
+      @current_prime += 4
+      new_capacity = @buckets.length * 2
+      new_table = create_buckets(new_capacity)
+      new_bucket_lengths = Array.new(new_table.length, 0)
+      @buckets = new_table
+      @threshold = (new_capacity * LOAD_FACTOR).floor
+
+      old_size = size
+      j = 0
+      while j < old.length
+        bucket = old[j]
+        if bucket.nil?
+          j += 1
+          next
+        end
+
+        k = 0
+        while k < bucket.length
+          o = bucket[k]
+          break if o.nil?
+
+          b = get_bucket(o)
+          bucket_length = new_bucket_lengths[b]
+          if bucket_length == 0
+            new_bucket = create_bucket(@initial_bucket_capacity)
+            new_table[b] = new_bucket
+          else
+            new_bucket = new_table[b]
+            if bucket_length == new_bucket.length
+              tmp = Array.new(new_bucket.length * 2)
+              i = 0
+              while i < new_bucket.length
+                tmp[i] = new_bucket[i]
+                i += 1
+              end
+              new_bucket = tmp
+              new_table[b] = new_bucket
+            end
+          end
+
+          new_bucket[bucket_length] = o
+          new_bucket_lengths[b] += 1
+          k += 1
+        end
+        j += 1
+      end
+
+      raise StandardError, '@nElements != oldSize' if @n_elements != old_size
+    end
+  end
+end