tripper 0.0.3d

data/lib/tripper/model_parsers/has_many/HasManyParserParser.rb

@@ -0,0 +1,788 @@
+#!/usr/bin/env ruby
+#
+# HasManyParser.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: HasManyParser.g
+# Generated at: 2013-07-28 14:21:15
+# 
+
+# ~~~> 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 - - - - - -
+# HasManyParser.g
+
+
+	def strip_quotes str
+		return str[1,(str.length)-2]
+	end
+
+	@@attribute = nil
+	@@class_name = nil
+	@@foreign_key = nil
+
+# - - - - - - end action @parser::header - - - - - - -
+
+
+module HasManyParser
+  # 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__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_many'", "','", "':'", "'class_name'", 
+                    "'=>'", "'\\''", "'\"'", "'foreign_key'" )
+    
+  end
+
+
+  class Parser < ANTLR3::Parser
+    @grammar_home = HasManyParser
+
+    RULE_METHODS = [ :comment, :has_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, 
+                     :attribute ].freeze
+
+
+    include TokenData
+
+    begin
+      generated_using( "HasManyParser.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
+
+    # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
+
+    # 
+    # parser rule comment
+    # 
+    # (in HasManyParser.g)
+    # 21:1: comment : COMMENT ;
+    # 
+    def comment
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 1 )
+
+      begin
+        # at line 21: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_many
+    # 
+    # (in HasManyParser.g)
+    # 23:1: has_many returns [expr] : ( (c= COMMENT )* | 'has_many' attribute ( class_name )? ( foreign_key )? ( comment )? ) ;
+    # 
+    def has_many
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 2 )
+      expr = nil
+      c = nil
+
+      begin
+        # at line 23:26: ( (c= COMMENT )* | 'has_many' attribute ( class_name )? ( foreign_key )? ( comment )? )
+        # at line 23:26: ( (c= COMMENT )* | 'has_many' attribute ( class_name )? ( foreign_key )? ( comment )? )
+        alt_5 = 2
+        look_5_0 = @input.peek( 1 )
+
+        if ( look_5_0 == EOF || look_5_0 == COMMENT )
+          alt_5 = 1
+        elsif ( look_5_0 == T__11 )
+          alt_5 = 2
+        else
+          raise NoViableAlternative( "", 5, 0 )
+        end
+        case alt_5
+        when 1
+          # at line 23:27: (c= COMMENT )*
+          # at line 23:27: (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 23:28: c= COMMENT
+              c = match( COMMENT, TOKENS_FOLLOWING_COMMENT_IN_has_many_50 )
+
+            else
+              break # out of loop for decision 1
+            end
+          end # loop for decision 1
+
+        when 2
+          # at line 23:42: 'has_many' attribute ( class_name )? ( foreign_key )? ( comment )?
+          match( T__11, TOKENS_FOLLOWING_T__11_IN_has_many_56 )
+          @state.following.push( TOKENS_FOLLOWING_attribute_IN_has_many_58 )
+          attribute
+          @state.following.pop
+          # at line 23:63: ( 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 23:63: class_name
+            @state.following.push( TOKENS_FOLLOWING_class_name_IN_has_many_60 )
+            class_name
+            @state.following.pop
+
+          end
+          # at line 23:75: ( foreign_key )?
+          alt_3 = 2
+          look_3_0 = @input.peek( 1 )
+
+          if ( look_3_0 == T__12 )
+            alt_3 = 1
+          end
+          case alt_3
+          when 1
+            # at line 23:75: foreign_key
+            @state.following.push( TOKENS_FOLLOWING_foreign_key_IN_has_many_63 )
+            foreign_key
+            @state.following.pop
+
+          end
+          # at line 23:88: ( comment )?
+          alt_4 = 2
+          look_4_0 = @input.peek( 1 )
+
+          if ( look_4_0 == COMMENT )
+            alt_4 = 1
+          end
+          case alt_4
+          when 1
+            # at line 23:88: comment
+            @state.following.push( TOKENS_FOLLOWING_comment_IN_has_many_66 )
+            comment
+            @state.following.pop
+
+          end
+
+        end
+        # --> action
+
+        		expr = {attribute: @attribute, class_name: @class_name, foreign_key: @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 HasManyParser.g)
+    # 29: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 29:13: ',' ( class_name_old_syntax | class_name_new_syntax )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_class_name_79 )
+        # at line 29:17: ( class_name_old_syntax | class_name_new_syntax )
+        alt_6 = 2
+        look_6_0 = @input.peek( 1 )
+
+        if ( look_6_0 == T__13 )
+          alt_6 = 1
+        elsif ( look_6_0 == T__14 )
+          alt_6 = 2
+        else
+          raise NoViableAlternative( "", 6, 0 )
+        end
+        case alt_6
+        when 1
+          # at line 29:18: class_name_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_class_name_old_syntax_IN_class_name_82 )
+          class_name_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 29:42: class_name_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_class_name_new_syntax_IN_class_name_86 )
+          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 HasManyParser.g)
+    # 31: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 31:24: ':' 'class_name' '=>' class_name_word
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_class_name_old_syntax_94 )
+        match( T__14, TOKENS_FOLLOWING_T__14_IN_class_name_old_syntax_96 )
+        match( T__15, TOKENS_FOLLOWING_T__15_IN_class_name_old_syntax_98 )
+        @state.following.push( TOKENS_FOLLOWING_class_name_word_IN_class_name_old_syntax_100 )
+        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 HasManyParser.g)
+    # 34: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 34:18: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        # at line 34:18: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_7 = 3
+        case look_7 = @input.peek( 1 )
+        when T__16 then alt_7 = 1
+        when T__17 then alt_7 = 2
+        when T__13 then alt_7 = 3
+        else
+          raise NoViableAlternative( "", 7, 0 )
+        end
+        case alt_7
+        when 1
+          # at line 34:19: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 34:19: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 34:20: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_class_name_word_110 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_114 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_class_name_word_116 )
+
+
+        when 2
+          # at line 34:45: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 34:45: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 34:46: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_class_name_word_122 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_126 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_class_name_word_128 )
+
+
+        when 3
+          # at line 34:69: ( ':' a= ATTRIBUTE )
+          # at line 34:69: ( ':' a= ATTRIBUTE )
+          # at line 34:70: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_class_name_word_134 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_138 )
+
+
+        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 HasManyParser.g)
+    # 40: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 40:24: 'class_name' ':' class_name_word
+        match( T__14, TOKENS_FOLLOWING_T__14_IN_class_name_new_syntax_151 )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_class_name_new_syntax_153 )
+        @state.following.push( TOKENS_FOLLOWING_class_name_word_IN_class_name_new_syntax_155 )
+        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 HasManyParser.g)
+    # 42: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 42:14: ',' ( foreign_key_old_syntax | foreign_key_new_syntax )
+        match( T__12, TOKENS_FOLLOWING_T__12_IN_foreign_key_162 )
+        # at line 42:18: ( foreign_key_old_syntax | foreign_key_new_syntax )
+        alt_8 = 2
+        look_8_0 = @input.peek( 1 )
+
+        if ( look_8_0 == T__13 )
+          alt_8 = 1
+        elsif ( look_8_0 == T__18 )
+          alt_8 = 2
+        else
+          raise NoViableAlternative( "", 8, 0 )
+        end
+        case alt_8
+        when 1
+          # at line 42:19: foreign_key_old_syntax
+          @state.following.push( TOKENS_FOLLOWING_foreign_key_old_syntax_IN_foreign_key_165 )
+          foreign_key_old_syntax
+          @state.following.pop
+
+        when 2
+          # at line 42:44: foreign_key_new_syntax
+          @state.following.push( TOKENS_FOLLOWING_foreign_key_new_syntax_IN_foreign_key_169 )
+          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 HasManyParser.g)
+    # 44: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 44:25: ':' 'foreign_key' '=>' foreign_key_word
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_foreign_key_old_syntax_177 )
+        match( T__18, TOKENS_FOLLOWING_T__18_IN_foreign_key_old_syntax_179 )
+        match( T__15, TOKENS_FOLLOWING_T__15_IN_foreign_key_old_syntax_181 )
+        @state.following.push( TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_old_syntax_183 )
+        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 HasManyParser.g)
+    # 47: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 47:19: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        # at line 47:19: ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) )
+        alt_9 = 3
+        case look_9 = @input.peek( 1 )
+        when T__16 then alt_9 = 1
+        when T__17 then alt_9 = 2
+        when T__13 then alt_9 = 3
+        else
+          raise NoViableAlternative( "", 9, 0 )
+        end
+        case alt_9
+        when 1
+          # at line 47:20: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 47:20: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 47:21: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_foreign_key_word_193 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_197 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_foreign_key_word_199 )
+
+
+        when 2
+          # at line 47:46: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 47:46: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 47:47: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_foreign_key_word_205 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_209 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_foreign_key_word_211 )
+
+
+        when 3
+          # at line 47:70: ( ':' a= ATTRIBUTE )
+          # at line 47:70: ( ':' a= ATTRIBUTE )
+          # at line 47:71: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_foreign_key_word_217 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_221 )
+
+
+        end
+        # --> action
+
+        		puts "hello..."
+        		@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 HasManyParser.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_234 )
+        match( T__13, TOKENS_FOLLOWING_T__13_IN_foreign_key_new_syntax_236 )
+        @state.following.push( TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_new_syntax_238 )
+        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 attribute
+    # 
+    # (in HasManyParser.g)
+    # 57:1: attribute : ( ( '\\'' a= ATTRIBUTE '\\'' ) | ( '\"' a= ATTRIBUTE '\"' ) | ( ':' a= ATTRIBUTE ) );
+    # 
+    def attribute
+      # -> uncomment the next line to manually enable rule tracing
+      # trace_in( __method__, 11 )
+      a = nil
+
+      begin
+        # at line 57:10: ( ( '\\'' 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 57:12: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 57:12: ( '\\'' a= ATTRIBUTE '\\'' )
+          # at line 57:13: '\\'' a= ATTRIBUTE '\\''
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_attribute_247 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_251 )
+          match( T__16, TOKENS_FOLLOWING_T__16_IN_attribute_253 )
+
+
+        when 2
+          # at line 57:38: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 57:38: ( '\"' a= ATTRIBUTE '\"' )
+          # at line 57:39: '\"' a= ATTRIBUTE '\"'
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_attribute_259 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_263 )
+          match( T__17, TOKENS_FOLLOWING_T__17_IN_attribute_265 )
+
+
+        when 3
+          # at line 57:62: ( ':' a= ATTRIBUTE )
+          # at line 57:62: ( ':' a= ATTRIBUTE )
+          # at line 57:63: ':' a= ATTRIBUTE
+          match( T__13, TOKENS_FOLLOWING_T__13_IN_attribute_271 )
+          a = match( ATTRIBUTE, TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_275 )
+
+          # --> 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__, 11 )
+
+      end
+      
+      return 
+    end
+
+
+
+    TOKENS_FOLLOWING_COMMENT_IN_comment_35 = Set[ 1 ]
+    TOKENS_FOLLOWING_COMMENT_IN_has_many_50 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_T__11_IN_has_many_56 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_attribute_IN_has_many_58 = Set[ 1, 4, 12 ]
+    TOKENS_FOLLOWING_class_name_IN_has_many_60 = Set[ 1, 4, 12 ]
+    TOKENS_FOLLOWING_foreign_key_IN_has_many_63 = Set[ 1, 4 ]
+    TOKENS_FOLLOWING_comment_IN_has_many_66 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__12_IN_class_name_79 = Set[ 13, 14 ]
+    TOKENS_FOLLOWING_class_name_old_syntax_IN_class_name_82 = Set[ 1 ]
+    TOKENS_FOLLOWING_class_name_new_syntax_IN_class_name_86 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_class_name_old_syntax_94 = Set[ 14 ]
+    TOKENS_FOLLOWING_T__14_IN_class_name_old_syntax_96 = Set[ 15 ]
+    TOKENS_FOLLOWING_T__15_IN_class_name_old_syntax_98 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_class_name_word_IN_class_name_old_syntax_100 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_class_name_word_110 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_114 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_class_name_word_116 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_class_name_word_122 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_126 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_class_name_word_128 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_class_name_word_134 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_class_name_word_138 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__14_IN_class_name_new_syntax_151 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_class_name_new_syntax_153 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_class_name_word_IN_class_name_new_syntax_155 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__12_IN_foreign_key_162 = Set[ 13, 18 ]
+    TOKENS_FOLLOWING_foreign_key_old_syntax_IN_foreign_key_165 = Set[ 1 ]
+    TOKENS_FOLLOWING_foreign_key_new_syntax_IN_foreign_key_169 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_foreign_key_old_syntax_177 = Set[ 18 ]
+    TOKENS_FOLLOWING_T__18_IN_foreign_key_old_syntax_179 = Set[ 15 ]
+    TOKENS_FOLLOWING_T__15_IN_foreign_key_old_syntax_181 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_old_syntax_183 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_foreign_key_word_193 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_197 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_foreign_key_word_199 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_foreign_key_word_205 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_209 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_foreign_key_word_211 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_foreign_key_word_217 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_foreign_key_word_221 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__18_IN_foreign_key_new_syntax_234 = Set[ 13 ]
+    TOKENS_FOLLOWING_T__13_IN_foreign_key_new_syntax_236 = Set[ 13, 16, 17 ]
+    TOKENS_FOLLOWING_foreign_key_word_IN_foreign_key_new_syntax_238 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__16_IN_attribute_247 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_251 = Set[ 16 ]
+    TOKENS_FOLLOWING_T__16_IN_attribute_253 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__17_IN_attribute_259 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_263 = Set[ 17 ]
+    TOKENS_FOLLOWING_T__17_IN_attribute_265 = Set[ 1 ]
+    TOKENS_FOLLOWING_T__13_IN_attribute_271 = Set[ 5 ]
+    TOKENS_FOLLOWING_ATTRIBUTE_IN_attribute_275 = Set[ 1 ]
+
+  end # class Parser < ANTLR3::Parser
+
+  at_exit { Parser.main( ARGV ) } if __FILE__ == $0
+end
+