tripper 0.0.3d

data/lib/tripper/model_parsers/has_and_belongs_to_many/HasAndBelongsToManyParserParser.rb

@@ -0,0 +1,1024 @@
+#!/usr/bin/env ruby
+#
+# HasAndBelongsToManyParser.g
+# --
+# Generated using ANTLR version: 3.2.1-SNAPSHOT Jul 31, 2010 19:34:52
+# Ruby runtime library version: 1.8.11
+# Input grammar file: HasAndBelongsToManyParser.g
+# Generated at: 2013-07-28 14:32:00
+# 
+
+# ~~~> start load path setup
+this_directory = File.expand_path( File.dirname( __FILE__ ) )
+$LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory )
+
+antlr_load_failed = proc do
+  load_path = $LOAD_PATH.map { |dir| '  - ' << dir }.join( $/ )
+  raise LoadError, <<-END.strip!
+  
+Failed to load the ANTLR3 runtime library (version 1.8.11):
+
+Ensure the library has been installed on your system and is available
+on the load path. If rubygems is available on your system, this can
+be done with the command:
+  
+  gem install antlr3
+
+Current load path:
+#{ load_path }
+
+  END
+end
+
+defined?( ANTLR3 ) or begin
+  
+  # 1: try to load the ruby antlr3 runtime library from the system path
+  require 'antlr3'
+  
+rescue LoadError
+  
+  # 2: try to load rubygems if it isn't already loaded
+  defined?( Gem ) or begin
+    require 'rubygems'
+  rescue LoadError
+    antlr_load_failed.call
+  end
+  
+  # 3: try to activate the antlr3 gem
+  begin
+    Gem.activate( 'antlr3', '~> 1.8.11' )
+  rescue Gem::LoadError
+    antlr_load_failed.call
+  end
+  
+  require 'antlr3'
+  
+end
+# <~~~ end load path setup
+
+# - - - - - - begin action @parser::header - - - - - -
+# HasAndBelongsToManyParser.g
+
+
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+	@@attribute = nil
+	@@class_name = nil
+	@@foreign_key = nil
+	@@association_foreign_key = nil
+
+# - - - - - - end action @parser::header - - - - - - -
+
+
+module HasAndBelongsToManyParser
+  # TokenData defines all of the token type integer values
+  # as constants, which will be included in all 
+  # ANTLR-generated recognizers.
+  const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new
+
+  module TokenData
+
+    # define the token constants
+    define_tokens( :ACTUALSTRING => 10, :T__19 => 19, :T__16 => 16, :HC => 6, 
+                   :T__15 => 15, :T__18 => 18, :T__17 => 17, :T__12 => 12, 
+                   :T__11 => 11, :T__14 => 14, :T__13 => 13, :ATTRIBUTE => 5, 
+                   :WHITESPACE => 9, :LC => 7, :DIGIT => 8, :COMMENT => 4, 
+                   :EOF => -1 )
+
+    # register the proper human-readable name or literal value
+    # for each token type
+    #
+    # this is necessary because anonymous tokens, which are
+    # created from literal values in the grammar, do not
+    # have descriptive names
+    register_names( "COMMENT", "ATTRIBUTE", "HC", "LC", "DIGIT", "WHITESPACE", 
+                    "ACTUALSTRING", "'has_and_belongs_to_many'", "','", 
+                    "':'", "'class_name'", "'=>'", "'\\''", "'\"'", "'foreign_key'", 
+                    "'association_foreign_key'" )
+    
+  end
+
+
+  class Parser < ANTLR3::Parser
+    @grammar_home = HasAndBelongsToManyParser
+
+    RULE_METHODS = [ :comment, :has_and_belongs_to_many, :class_name, :class_name_old_syntax, 
+                     :class_name_word, :class_name_new_syntax, :foreign_key, 
+                     :foreign_key_old_syntax, :foreign_key_word, :foreign_key_new_syntax, 
+                     :association_foreign_key, :association_foreign_key_old_syntax, 
+                     :association_foreign_key_word, :association_foreign_key_new_syntax, 
+                     :attribute ].freeze
+
+
+    include TokenData
+
+    begin
+      generated_using( "HasAndBelongsToManyParser.g", "3.2.1-SNAPSHOT Jul 31, 2010 19:34:52", "1.8.11" )
+    rescue NoMethodError => error
+      # ignore
+    end
+
+    def initialize( input, options = {} )
+      super( input, options )
+
+
+    end
+
+    attr_accessor :attribute, :class_name, :foreign_key, :association_foreign_key
+
+    # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
+
+    # 
+    # parser rule comment
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 22:1: comment : COMMENT ;
+    # 
+    def comment
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+
+      begin
+        # at line 22:10: COMMENT
+        match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_comment_35 )
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 1 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule has_and_belongs_to_many
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 24:1: has_and_belongs_to_many returns [expr] : ( (c= COMMENT )* | 'has_and_belongs_to_many' attribute ( class_name )? ( foreign_key )? ( association_foreign_key )? ( comment )? ) ;
+    # 
+    def has_and_belongs_to_many
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+      expr = nil
+      c = nil
+
+      begin
+        # at line 24:41: ( (c= COMMENT )* | 'has_and_belongs_to_many' attribute ( class_name )? ( foreign_key )? ( association_foreign_key )? ( comment )? )
+        # at line 24:41: ( (c= COMMENT )* | 'has_and_belongs_to_many' attribute ( class_name )? ( foreign_key )? ( association_foreign_key )? ( comment )? )
+        alt_6 = 2
+        look_6_0 = @input.peek( 1 )
+
+        if ( look_6_0 == EOF || look_6_0 == COMMENT )
+          alt_6 = 1
+        elsif ( look_6_0 == T__11 )
+          alt_6 = 2
+        else
+          raise NoViableAlternative( "", 6, 0 )
+        end
+        case alt_6
+        when 1
+          # at line 24:42: (c= COMMENT )*
+          # at line 24:42: (c= COMMENT )*
+          while true # decision 1
+            alt_1 = 2
+            look_1_0 = @input.peek( 1 )
+
+            if ( look_1_0 == COMMENT )
+              alt_1 = 1
+
+            end
+            case alt_1
+            when 1
+              # at line 24:43: c= COMMENT
+              c = match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_has_and_belongs_to_many_50 )
+
+            else
+              break # out of loop for decision 1
+            end
+          end # loop for decision 1
+
+        when 2
+          # at line 24:57: 'has_and_belongs_to_many' attribute ( class_name )? ( foreign_key )? ( association_foreign_key )? ( comment )?
+          match( T__11, TOKENS_FOLLOWING_T__11_IN_has_and_belongs_to_many_56 )
+          @state.following.push( TOKENS_FOLLOWING_attribute_IN_has_and_belongs_to_many_58 )
+          attribute
+          @state.following.pop
+          # at line 24:93: ( class_name )?
+          alt_2 = 2
+          look_2_0 = @input.peek( 1 )
+
+          if ( look_2_0 == T__12 )
+            look_2_1 = @input.peek( 2 )
+
+            if ( look_2_1 == T__13 )
+              look_2_3 = @input.peek( 3 )
+
+              if ( look_2_3 == T__14 )
+                alt_2 = 1
+              end
+            elsif ( look_2_1 == T__14 )
+              alt_2 = 1
+            end
+          end
+          case alt_2
+          when 1
+            # at line 24:93: class_name
+            @state.following.push( TOKENS_FOLLOWING_class_name_IN_has_and_belongs_to_many_60 )
+            class_name
+            @state.following.pop
+
+          end
+          # at line 24:105: ( foreign_key )?
+          alt_3 = 2
+          look_3_0 = @input.peek( 1 )
+
+          if ( look_3_0 == T__12 )
+            look_3_1 = @input.peek( 2 )
+
+            if ( look_3_1 == T__13 )
+              look_3_3 = @input.peek( 3 )
+
+              if ( look_3_3 == T__18 )
+                alt_3 = 1
+              end
+            elsif ( look_3_1 == T__18 )
+              alt_3 = 1
+            end
+          end
+          case alt_3
+          when 1
+            # at line 24:105: foreign_key
+            @state.following.push( TOKENS_FOLLOWING_foreign_key_IN_has_and_belongs_to_many_63 )
+            foreign_key
+            @state.following.pop
+
+          end
+          # at line 24:118: ( association_foreign_key )?
+          alt_4 = 2
+          look_4_0 = @input.peek( 1 )
+
+          if ( look_4_0 == T__12 )
+            alt_4 = 1
+          end
+          case alt_4
+          when 1
+            # at line 24:118: association_foreign_key
+            @state.following.push( TOKENS_FOLLOWING_association_foreign_key_IN_has_and_belongs_to_many_66 )
+            association_foreign_key
+            @state.following.pop
+
+          end
+          # at line 24:143: ( comment )?
+          alt_5 = 2
+          look_5_0 = @input.peek( 1 )
+
+          if ( look_5_0 == COMMENT )
+            alt_5 = 1
+          end
+          case alt_5
+          when 1
+            # at line 24:143: comment
+            @state.following.push( TOKENS_FOLLOWING_comment_IN_has_and_belongs_to_many_69 )
+            comment
+            @state.following.pop
+
+          end
+
+        end
+        # --> action
+
+        		expr = {attribute: @attribute, class_name: @class_name, foreign_key: @foreign_key, association_foreign_key: @association_foreign_key} unless c
+        	
+        # <-- action
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 2 )
+
+      end
+      
+      return expr
+    end
+
+
+    # 
+    # parser rule class_name
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 30:1: class_name : ',' ( class_name_old_syntax | class_name_new_syntax ) ;
+    # 
+    def class_name
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 3 )
+
+      begin
+        # at line 30:13: ',' ( class_name_old_syntax | class_name_new_syntax )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_class_name_82 )
+        # at line 30:17: ( class_name_old_syntax | class_name_new_syntax )
+        alt_7 = 2
+        look_7_0 = @input.peek( 1 )
+
+        if ( look_7_0 == T__13 )
+          alt_7 = 1
+        elsif ( look_7_0 == T__14 )
+          alt_7 = 2
+        else
+          raise NoViableAlternative( "", 7, 0 )
+        end
+        case alt_7
+        when 1
+          # at line 30:18: class_name_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_class_name_old_syntax_IN_class_name_85 )
+          class_name_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 30:42: class_name_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_class_name_new_syntax_IN_class_name_89 )
+          class_name_new_syntax
+          @state.following.pop
+
+        end
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 3 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule class_name_old_syntax
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 32:1: class_name_old_syntax : ':' 'class_name' '=>' class_name_word ;
+    # 
+    def class_name_old_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 4 )
+
+      begin
+        # at line 32:24: ':' 'class_name' '=>' class_name_word
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_class_name_old_syntax_97 )
+        match( T__14, TOKENS_FOLLOWING_T__14_IN_class_name_old_syntax_99 )
+        match( T__15, TOKENS_FOLLOWING_T__15_IN_class_name_old_syntax_101 )
+        @state.following.push( TOKENS_FOLLOWING_class_name_word_IN_class_name_old_syntax_103 )
+        class_name_word
+        @state.following.pop
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 4 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule class_name_word
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 35:1: class_name_word : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) ) ;
+    # 
+    def class_name_word
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 5 )
+      a = nil
+
+      begin
+        # at line 35:18: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        # at line 35:18: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_8 = 3
+        case look_8 = @input.peek( 1 )
+        when T__16 then alt_8 = 1
+        when T__17 then alt_8 = 2
+        when T__13 then alt_8 = 3
+        else
+          raise NoViableAlternative( "", 8, 0 )
+        end
+        case alt_8
+        when 1
+          # at line 35:19: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 35:19: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 35:20: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_class_name_word_113 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_117 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_class_name_word_119 )
+
+
+        when 2
+          # at line 35:45: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 35:45: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 35:46: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_class_name_word_125 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_129 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_class_name_word_131 )
+
+
+        when 3
+          # at line 35:69: ( ':' a= ATTRIBUTE )
+          # at line 35:69: ( ':' a= ATTRIBUTE )
+          # at line 35:70: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_class_name_word_137 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_141 )
+
+
+        end
+        # --> action
+
+        		@class_name = a.text
+        	
+        # <-- action
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 5 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule class_name_new_syntax
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 41:1: class_name_new_syntax : 'class_name' ':' class_name_word ;
+    # 
+    def class_name_new_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 6 )
+
+      begin
+        # at line 41:24: 'class_name' ':' class_name_word
+        match( T__14, TOKENS_FOLLOWING_T__14_IN_class_name_new_syntax_154 )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_class_name_new_syntax_156 )
+        @state.following.push( TOKENS_FOLLOWING_class_name_word_IN_class_name_new_syntax_158 )
+        class_name_word
+        @state.following.pop
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 6 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule foreign_key
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 43:1: foreign_key : ',' ( foreign_key_old_syntax | foreign_key_new_syntax ) ;
+    # 
+    def foreign_key
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 7 )
+
+      begin
+        # at line 43:14: ',' ( foreign_key_old_syntax | foreign_key_new_syntax )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_foreign_key_165 )
+        # at line 43:18: ( foreign_key_old_syntax | foreign_key_new_syntax )
+        alt_9 = 2
+        look_9_0 = @input.peek( 1 )
+
+        if ( look_9_0 == T__13 )
+          alt_9 = 1
+        elsif ( look_9_0 == T__18 )
+          alt_9 = 2
+        else
+          raise NoViableAlternative( "", 9, 0 )
+        end
+        case alt_9
+        when 1
+          # at line 43:19: foreign_key_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_foreign_key_old_syntax_IN_foreign_key_168 )
+          foreign_key_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 43:44: foreign_key_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_foreign_key_new_syntax_IN_foreign_key_172 )
+          foreign_key_new_syntax
+          @state.following.pop
+
+        end
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 7 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule foreign_key_old_syntax
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 45:1: foreign_key_old_syntax : ':' 'foreign_key' '=>' foreign_key_word ;
+    # 
+    def foreign_key_old_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 8 )
+
+      begin
+        # at line 45:25: ':' 'foreign_key' '=>' foreign_key_word
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_foreign_key_old_syntax_180 )
+        match( T__18, TOKENS_FOLLOWING_T__18_IN_foreign_key_old_syntax_182 )
+        match( T__15, TOKENS_FOLLOWING_T__15_IN_foreign_key_old_syntax_184 )
+        @state.following.push( TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_old_syntax_186 )
+        foreign_key_word
+        @state.following.pop
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 8 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule foreign_key_word
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 48:1: foreign_key_word : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) ) ;
+    # 
+    def foreign_key_word
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 9 )
+      a = nil
+
+      begin
+        # at line 48:19: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        # at line 48:19: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_10 = 3
+        case look_10 = @input.peek( 1 )
+        when T__16 then alt_10 = 1
+        when T__17 then alt_10 = 2
+        when T__13 then alt_10 = 3
+        else
+          raise NoViableAlternative( "", 10, 0 )
+        end
+        case alt_10
+        when 1
+          # at line 48:20: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 48:20: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 48:21: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_foreign_key_word_196 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_200 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_foreign_key_word_202 )
+
+
+        when 2
+          # at line 48:46: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 48:46: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 48:47: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_foreign_key_word_208 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_212 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_foreign_key_word_214 )
+
+
+        when 3
+          # at line 48:70: ( ':' a= ATTRIBUTE )
+          # at line 48:70: ( ':' a= ATTRIBUTE )
+          # at line 48:71: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_foreign_key_word_220 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_224 )
+
+
+        end
+        # --> action
+
+        		@foreign_key = a.text
+        	
+        # <-- action
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 9 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule foreign_key_new_syntax
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 54:1: foreign_key_new_syntax : 'foreign_key' ':' foreign_key_word ;
+    # 
+    def foreign_key_new_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 10 )
+
+      begin
+        # at line 54:25: 'foreign_key' ':' foreign_key_word
+        match( T__18, TOKENS_FOLLOWING_T__18_IN_foreign_key_new_syntax_237 )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_foreign_key_new_syntax_239 )
+        @state.following.push( TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_new_syntax_241 )
+        foreign_key_word
+        @state.following.pop
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 10 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule association_foreign_key
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 57:1: association_foreign_key : ',' ( association_foreign_key_old_syntax | association_foreign_key_new_syntax ) ;
+    # 
+    def association_foreign_key
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 11 )
+
+      begin
+        # at line 57:26: ',' ( association_foreign_key_old_syntax | association_foreign_key_new_syntax )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_association_foreign_key_249 )
+        # at line 57:30: ( association_foreign_key_old_syntax | association_foreign_key_new_syntax )
+        alt_11 = 2
+        look_11_0 = @input.peek( 1 )
+
+        if ( look_11_0 == T__13 )
+          alt_11 = 1
+        elsif ( look_11_0 == T__19 )
+          alt_11 = 2
+        else
+          raise NoViableAlternative( "", 11, 0 )
+        end
+        case alt_11
+        when 1
+          # at line 57:31: association_foreign_key_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_association_foreign_key_old_syntax_IN_association_foreign_key_252 )
+          association_foreign_key_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 57:68: association_foreign_key_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_association_foreign_key_new_syntax_IN_association_foreign_key_256 )
+          association_foreign_key_new_syntax
+          @state.following.pop
+
+        end
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 11 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule association_foreign_key_old_syntax
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 59:1: association_foreign_key_old_syntax : ':' 'association_foreign_key' '=>' association_foreign_key_word ;
+    # 
+    def association_foreign_key_old_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 12 )
+
+      begin
+        # at line 59:37: ':' 'association_foreign_key' '=>' association_foreign_key_word
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_association_foreign_key_old_syntax_264 )
+        match( T__19, TOKENS_FOLLOWING_T__19_IN_association_foreign_key_old_syntax_266 )
+        match( T__15, TOKENS_FOLLOWING_T__15_IN_association_foreign_key_old_syntax_268 )
+        @state.following.push( TOKENS_FOLLOWING_association_foreign_key_word_IN_association_foreign_key_old_syntax_270 )
+        association_foreign_key_word
+        @state.following.pop
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 12 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule association_foreign_key_word
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 62:1: association_foreign_key_word : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) ) ;
+    # 
+    def association_foreign_key_word
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 13 )
+      a = nil
+
+      begin
+        # at line 62:31: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        # at line 62:31: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_12 = 3
+        case look_12 = @input.peek( 1 )
+        when T__16 then alt_12 = 1
+        when T__17 then alt_12 = 2
+        when T__13 then alt_12 = 3
+        else
+          raise NoViableAlternative( "", 12, 0 )
+        end
+        case alt_12
+        when 1
+          # at line 62:32: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 62:32: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 62:33: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_association_foreign_key_word_280 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_association_foreign_key_word_284 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_association_foreign_key_word_286 )
+
+
+        when 2
+          # at line 62:58: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 62:58: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 62:59: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_association_foreign_key_word_292 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_association_foreign_key_word_296 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_association_foreign_key_word_298 )
+
+
+        when 3
+          # at line 62:82: ( ':' a= ATTRIBUTE )
+          # at line 62:82: ( ':' a= ATTRIBUTE )
+          # at line 62:83: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_association_foreign_key_word_304 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_association_foreign_key_word_308 )
+
+
+        end
+        # --> action
+
+        		@association_foreign_key = a.text
+        	
+        # <-- action
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 13 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule association_foreign_key_new_syntax
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 68:1: association_foreign_key_new_syntax : 'association_foreign_key' ':' foreign_key_word ;
+    # 
+    def association_foreign_key_new_syntax
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 14 )
+
+      begin
+        # at line 68:37: 'association_foreign_key' ':' foreign_key_word
+        match( T__19, TOKENS_FOLLOWING_T__19_IN_association_foreign_key_new_syntax_321 )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_association_foreign_key_new_syntax_323 )
+        @state.following.push( TOKENS_FOLLOWING_foreign_key_word_IN_association_foreign_key_new_syntax_325 )
+        foreign_key_word
+        @state.following.pop
+
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 14 )
+
+      end
+      
+      return 
+    end
+
+
+    # 
+    # parser rule attribute
+    # 
+    # (in HasAndBelongsToManyParser.g)
+    # 71:1: attribute : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) );
+    # 
+    def attribute
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 15 )
+      a = nil
+
+      begin
+        # at line 71:10: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_13 = 3
+        case look_13 = @input.peek( 1 )
+        when T__16 then alt_13 = 1
+        when T__17 then alt_13 = 2
+        when T__13 then alt_13 = 3
+        else
+          raise NoViableAlternative( "", 13, 0 )
+        end
+        case alt_13
+        when 1
+          # at line 71:12: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 71:12: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 71:13: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_attribute_334 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_338 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_attribute_340 )
+
+
+        when 2
+          # at line 71:38: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 71:38: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 71:39: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_attribute_346 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_350 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_attribute_352 )
+
+
+        when 3
+          # at line 71:62: ( ':' a= ATTRIBUTE )
+          # at line 71:62: ( ':' a= ATTRIBUTE )
+          # at line 71:63: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_attribute_358 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_362 )
+
+          # --> action
+
+          		@attribute = a.text
+          	
+          # <-- action
+
+        end
+      rescue ANTLR3::Error::RecognitionError => re
+        report_error(re)
+        recover(re)
+
+      ensure
+        # -> uncomment the next line to manually enable rule tracing
+        # trace_out( __method__, 15 )
+
+      end
+      
+      return 
+    end
+
+
+
+    TOKENS_FOLLOWING_COMMENT_IN_comment_35 = Set[ 1 ]
+    TOKENS_FOLLOWING_COMMENT_IN_has_and_belongs_to_many_50 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_T__11_IN_has_and_belongs_to_many_56 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_attribute_IN_has_and_belongs_to_many_58 = Set[ 1, 4, 12 ]
+    TOKENS_FOLLOWING_class_name_IN_has_and_belongs_to_many_60 = Set[ 1, 4, 12 ]
+    TOKENS_FOLLOWING_foreign_key_IN_has_and_belongs_to_many_63 = Set[ 1, 4, 12 ]
+    TOKENS_FOLLOWING_association_foreign_key_IN_has_and_belongs_to_many_66 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_comment_IN_has_and_belongs_to_many_69 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__12_IN_class_name_82 = Set[ 13, 14 ]
+    TOKENS_FOLLOWING_class_name_old_syntax_IN_class_name_85 = Set[ 1 ]
+    TOKENS_FOLLOWING_class_name_new_syntax_IN_class_name_89 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_class_name_old_syntax_97 = Set[ 14 ]
+    TOKENS_FOLLOWING_T__14_IN_class_name_old_syntax_99 = Set[ 15 ]
+    TOKENS_FOLLOWING_T__15_IN_class_name_old_syntax_101 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_class_name_word_IN_class_name_old_syntax_103 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_class_name_word_113 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_117 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_class_name_word_119 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_class_name_word_125 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_129 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_class_name_word_131 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_class_name_word_137 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_141 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__14_IN_class_name_new_syntax_154 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_class_name_new_syntax_156 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_class_name_word_IN_class_name_new_syntax_158 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__12_IN_foreign_key_165 = Set[ 13, 18 ]
+    TOKENS_FOLLOWING_foreign_key_old_syntax_IN_foreign_key_168 = Set[ 1 ]
+    TOKENS_FOLLOWING_foreign_key_new_syntax_IN_foreign_key_172 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_foreign_key_old_syntax_180 = Set[ 18 ]
+    TOKENS_FOLLOWING_T__18_IN_foreign_key_old_syntax_182 = Set[ 15 ]
+    TOKENS_FOLLOWING_T__15_IN_foreign_key_old_syntax_184 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_old_syntax_186 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_foreign_key_word_196 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_200 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_foreign_key_word_202 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_foreign_key_word_208 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_212 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_foreign_key_word_214 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_foreign_key_word_220 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_224 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__18_IN_foreign_key_new_syntax_237 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_foreign_key_new_syntax_239 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_new_syntax_241 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__12_IN_association_foreign_key_249 = Set[ 13, 19 ]
+    TOKENS_FOLLOWING_association_foreign_key_old_syntax_IN_association_foreign_key_252 = Set[ 1 ]
+    TOKENS_FOLLOWING_association_foreign_key_new_syntax_IN_association_foreign_key_256 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_association_foreign_key_old_syntax_264 = Set[ 19 ]
+    TOKENS_FOLLOWING_T__19_IN_association_foreign_key_old_syntax_266 = Set[ 15 ]
+    TOKENS_FOLLOWING_T__15_IN_association_foreign_key_old_syntax_268 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_association_foreign_key_word_IN_association_foreign_key_old_syntax_270 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_association_foreign_key_word_280 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_association_foreign_key_word_284 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_association_foreign_key_word_286 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_association_foreign_key_word_292 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_association_foreign_key_word_296 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_association_foreign_key_word_298 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_association_foreign_key_word_304 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_association_foreign_key_word_308 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__19_IN_association_foreign_key_new_syntax_321 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_association_foreign_key_new_syntax_323 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_foreign_key_word_IN_association_foreign_key_new_syntax_325 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_attribute_334 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_338 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_attribute_340 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_attribute_346 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_350 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_attribute_352 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_attribute_358 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_362 = Set[ 1 ]
+
+  end # class Parser < ANTLR3::Parser
+
+  at_exit { Parser.main( ARGV ) } if __FILE__ == $0
+end
+