antlr4-runtime 0.1.0

data/lib/antlr4/runtime/lexer_channel_action.rb

@@ -0,0 +1,51 @@
+module Antlr4::Runtime
+
+  class LexerChannelAction < LexerAction
+    attr_reader :channel
+
+    def initialize(channel)
+      @channel = channel
+    end
+
+    def action_type
+      LexerActionType::CHANNEL
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer.setChannel(@channel)
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int_int(action_type.ordinal, channel)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerChannelAction'
+        else
+          puts 'Different hash_code for LexerChannelAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      if other == self
+        return true
+      else
+        return false unless other.is_a? LexerChannelAction
+      end
+
+      @channel == other.channel
+    end
+
+    def to_s
+      'channel(' << @channel.to_s << ')'
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_custom_action.rb

@@ -0,0 +1,49 @@
+module Antlr4::Runtime
+
+  class LexerCustomAction < LexerAction
+    attr_reader :ruleIndex
+    attr_reader :action_index
+
+    def initialize(rule_index, action_index)
+      @rule_index = rule_index
+      @action_index = action_index
+    end
+
+    def action_type
+      LexerActionType::CUSTOM
+    end
+
+    def position_dependent?
+      true
+    end
+
+    def execute(lexer)
+      lexer.action(nil, @rule_index, @action_index)
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_ints([action_type, rule_index, action_index])
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerCustomAction'
+        else
+          puts 'Different hash_code for LexerCustomAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      if other == self
+        return true
+      else
+        return false unless other.is_a? LexerCustomAction
+      end
+
+      @rule_index == other.rule_index && @action_index == other.action_index
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_dfa_serializer.rb

@@ -0,0 +1,12 @@
+module Antlr4::Runtime
+
+  class LexerDFASerializer < DFASerializer
+    def initialize(dfa)
+      init_from_vocabulary(dfa, VocabularyImpl::EMPTY_VOCABULARY)
+    end
+
+    def edge_label(i)
+      "'" << i.to_s << "'"
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_indexed_custom_action.rb

@@ -0,0 +1,49 @@
+module Antlr4::Runtime
+
+  class LexerIndexedCustomAction < LexerAction
+    attr_reader :action
+    attr_reader :offset
+
+    def initialize(offset, action)
+      @offset = offset
+      @action = action
+    end
+
+    def action_type
+      @action.action_type
+    end
+
+    def position_dependent?
+      true
+    end
+
+    def execute(lexer) # assume the input stream position was properly set by the calling code
+      @action.execute(lexer)
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int_obj(offset, action)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerIndexedCustomAction'
+        else
+          puts 'Different hash_code for LexerIndexedCustomAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      if other == self
+        return true
+      else
+        return false unless other.is_a? LexerIndexedCustomAction
+      end
+
+      @offset == other.offset && @action == other.action
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_mode_action.rb

@@ -0,0 +1,51 @@
+module Antlr4::Runtime
+
+  class LexerModeAction < LexerAction
+    attr_reader :mode
+
+    def initialize(mode)
+      @mode = mode
+    end
+
+    def action_type
+      LexerActionType::MODE
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer.mode(@mode)
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int_int(action_type, mode)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerModeAction'
+        else
+          puts 'Different hash_code for LexerModeAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      if other == self
+        return true
+      else
+        return false unless other.is_a? LexerModeAction
+      end
+
+      @mode == other.mode
+    end
+
+    def to_s
+      'mode(' << @mode << ')'
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_more_action.rb

@@ -0,0 +1,41 @@
+module Antlr4::Runtime
+
+  class LexerMoreAction < LexerAction
+    include Singleton
+
+    def action_type
+      LexerActionType::MORE
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer.more
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int(action_type)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerMoreAction'
+        else
+          puts 'Different hash_code for LexerMoreAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      other == self
+    end
+
+    def to_s
+      'more'
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_no_viable_alt_exception.rb

@@ -0,0 +1,4 @@
+module Antlr4::Runtime
+  class LexerNoViableAltException < StandardError
+  end
+end

data/lib/antlr4/runtime/lexer_pop_mode_action.rb

@@ -0,0 +1,41 @@
+module Antlr4::Runtime
+
+  class LexerPopModeAction < LexerAction
+    include Singleton
+
+    def action_type
+      LexerActionType::POP_MODE
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer.pop_mode
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int(action_type)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerPopModeAction'
+        else
+          puts 'Different hash_code for LexerPopModeAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def equals(other)
+      other == self
+    end
+
+    def to_s
+      'popMode'
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_push_mode_action.rb

@@ -0,0 +1,51 @@
+module Antlr4::Runtime
+
+  class LexerPushModeAction < LexerAction
+    attr_reader :mode
+
+    def initialize(mode)
+      @mode = mode
+    end
+
+    def action_type
+      LexerActionType::PUSH_MODE
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer.push_mode(@mode)
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int_int(action_type, mode)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerPushModeAction'
+        else
+          puts 'Different hash_code for LexerPushModeAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      if other == self
+        return true
+      else
+        return false unless other.is_a? LexerPushModeAction
+      end
+
+      @mode == other.mode
+    end
+
+    def to_s
+      'pushMode(' << @mode << ')'
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_skip_action.rb

@@ -0,0 +1,43 @@
+require 'antlr4/runtime/lexer_action'
+
+module Antlr4::Runtime
+
+  class LexerSkipAction < LexerAction
+    include Singleton
+
+    def action_type
+      LexerActionType::SKIP
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer.skip
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int(action_type)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerSkipAction'
+        else
+          puts 'Different hash_code for LexerSkipAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      other == self
+    end
+
+    def to_s
+      'skip'
+    end
+  end
+end

data/lib/antlr4/runtime/lexer_type_action.rb

@@ -0,0 +1,51 @@
+module Antlr4::Runtime
+
+  class LexerTypeAction < LexerAction
+    attr_reader :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def action_type
+      LexerActionType::TYPE
+    end
+
+    def position_dependent?
+      false
+    end
+
+    def execute(lexer)
+      lexer._type = @type
+    end
+
+    def hash
+      return @_hash unless @_hash.nil?
+
+      hash_code = MurmurHash.hash_int_int(action_type, @type)
+
+      if !@_hash.nil?
+        if hash_code == @_hash
+          puts 'Same hash_code for LexerTypeAction'
+        else
+          puts 'Different hash_code for LexerTypeAction'
+        end
+      end
+      @_hash = hash_code
+    end
+
+    def eql?(other)
+      if other == self
+        return true
+      else
+        return false unless other.is_a? LexerTypeAction
+      end
+
+      @type == other.type
+    end
+
+    def to_s
+      'type(' << @type << ')'
+    end
+  end
+end