| #!/usr/bin/env ruby |
| # |
| # GroupFile.g |
| # |
| # Generated using ANTLR version: 3.2.1-SNAPSHOT Jun 18, 2010 05:38:11 |
| # Ruby runtime library version: 1.7.5 |
| # Input grammar file: GroupFile.g |
| # Generated at: 2010-07-03 23:15:35 |
| # |
| |
| # ~~~> 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.7.5): |
| |
| 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.7.5' ) |
| rescue Gem::LoadError |
| antlr_load_failed.call |
| end |
| |
| require 'antlr3' |
| |
| end |
| # <~~~ end load path setup |
| |
| # - - - - - - begin action @parser::header - - - - - - |
| # GroupFile.g |
| |
| |
| module ANTLR3 |
| module Template |
| |
| # - - - - - - end action @parser::header - - - - - - - |
| |
| |
| module GroupFile |
| # 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( :ID => 5, :EOF => -1, :T__19 => 19, :T__16 => 16, :WS => 9, |
| :T__15 => 15, :T__18 => 18, :T__17 => 17, :T__12 => 12, |
| :TEMPLATE => 6, :T__11 => 11, :T__14 => 14, :T__13 => 13, |
| :T__10 => 10, :CONSTANT => 4, :COMMENT => 8, :STRING => 7 ) |
| |
| # 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( "CONSTANT", "ID", "TEMPLATE", "STRING", "COMMENT", "WS", |
| "'group'", "'::'", "';'", "'::='", "'('", "')'", "','", |
| "'*'", "'&'", "'='" ) |
| |
| end |
| |
| |
| class Parser < ANTLR3::Parser |
| @grammar_home = GroupFile |
| |
| RULE_METHODS = [ :group_spec, :group_name, :member, :parameter_declaration, |
| :parameters, :parameter ].freeze |
| |
| |
| include TokenData |
| |
| begin |
| generated_using( "GroupFile.g", "3.2.1-SNAPSHOT Jun 18, 2010 05:38:11", "1.7.5" ) |
| rescue NoMethodError => error |
| # ignore |
| end |
| |
| def initialize( input, options = {} ) |
| super( input, options ) |
| |
| |
| end |
| |
| def fetch_group( namespace, name ) |
| if namespace.const_defined?( name ) |
| group = namespace.const_get( name ) |
| unless group.is_a?( ANTLR3::Template::Group ) |
| |
| end |
| else |
| group = ANTLR3::Template::Group.new |
| namespace.const_set( name, group ) |
| end |
| return( group ) |
| end |
| |
| def unescape( text ) |
| text.gsub( /\\(?:([abefnrstv])|([0-7]{3})|x([0-9a-fA-F]{2})|(.))/ ) do |
| if $1 |
| case $1[ 0 ] |
| when ?a then "\a" |
| when ?b then "\b" |
| when ?e then "\e" |
| when ?f then "\f" |
| when ?n then "\n" |
| when ?r then "\r" |
| when ?s then "\s" |
| when ?t then "\t" |
| when ?v then "\v" |
| end |
| elsif $2 then $2.to_i( 8 ).chr |
| elsif $3 then $3.to_i( 16 ).chr |
| elsif $4 then $4 |
| end |
| end |
| end |
| |
| def extract_template( token ) |
| case token.type |
| when TEMPLATE |
| token.text.gsub( /\A<<<\r?\n?|\r?\n?>>>\Z/, '' ) |
| when STRING |
| unescape( token.text[ 1...-1 ] ) |
| end |
| end |
| |
| def group( namespace = ::Object ) |
| group_spec( namespace ) |
| end |
| |
| # - - - - - - - - - - - - Rules - - - - - - - - - - - - - |
| |
| # |
| # parser rule group_spec |
| # |
| # (in GroupFile.g) |
| # 79:1: group_spec[ namespace ] returns [ group ] : ( group_name[ $namespace ] | ) ( member[ $group ] )* ; |
| # |
| def group_spec( namespace ) |
| # -> uncomment the next line to manually enable rule tracing |
| # trace_in( __method__, 1 ) |
| group = nil |
| group_name1 = nil |
| |
| begin |
| # at line 80:5: ( group_name[ $namespace ] | ) ( member[ $group ] )* |
| # at line 80:5: ( group_name[ $namespace ] | ) |
| alt_1 = 2 |
| look_1_0 = @input.peek( 1 ) |
| |
| if ( look_1_0 == T__10 ) |
| alt_1 = 1 |
| elsif ( look_1_0 == EOF || look_1_0 == ID ) |
| alt_1 = 2 |
| else |
| raise NoViableAlternative( "", 1, 0 ) |
| end |
| case alt_1 |
| when 1 |
| # at line 80:7: group_name[ $namespace ] |
| @state.following.push( TOKENS_FOLLOWING_group_name_IN_group_spec_85 ) |
| group_name1 = group_name( namespace ) |
| @state.following.pop |
| # --> action |
| group = group_name1 |
| # <-- action |
| |
| when 2 |
| # at line 81:7: |
| # --> action |
| group = ANTLR3::Template::Group.new |
| # <-- action |
| |
| end |
| # at line 83:5: ( member[ $group ] )* |
| while true # decision 2 |
| alt_2 = 2 |
| look_2_0 = @input.peek( 1 ) |
| |
| if ( look_2_0 == ID ) |
| alt_2 = 1 |
| |
| end |
| case alt_2 |
| when 1 |
| # at line 83:5: member[ $group ] |
| @state.following.push( TOKENS_FOLLOWING_member_IN_group_spec_108 ) |
| member( group ) |
| @state.following.pop |
| |
| else |
| break # out of loop for decision 2 |
| end |
| end # loop for decision 2 |
| |
| 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 group |
| end |
| |
| |
| # |
| # parser rule group_name |
| # |
| # (in GroupFile.g) |
| # 86:1: group_name[ namespace ] returns [ group ] : 'group' (mod= CONSTANT '::' )* name= CONSTANT ( ';' )? ; |
| # |
| def group_name( namespace ) |
| # -> uncomment the next line to manually enable rule tracing |
| # trace_in( __method__, 2 ) |
| group = nil |
| mod = nil |
| name = nil |
| |
| begin |
| # at line 87:5: 'group' (mod= CONSTANT '::' )* name= CONSTANT ( ';' )? |
| match( T__10, TOKENS_FOLLOWING_T__10_IN_group_name_128 ) |
| # at line 88:5: (mod= CONSTANT '::' )* |
| while true # decision 3 |
| alt_3 = 2 |
| look_3_0 = @input.peek( 1 ) |
| |
| if ( look_3_0 == CONSTANT ) |
| look_3_1 = @input.peek( 2 ) |
| |
| if ( look_3_1 == T__11 ) |
| alt_3 = 1 |
| |
| end |
| |
| end |
| case alt_3 |
| when 1 |
| # at line 89:7: mod= CONSTANT '::' |
| mod = match( CONSTANT, TOKENS_FOLLOWING_CONSTANT_IN_group_name_144 ) |
| match( T__11, TOKENS_FOLLOWING_T__11_IN_group_name_146 ) |
| # --> action |
| namespace = namespace.const_get( mod.text ) |
| # <-- action |
| |
| else |
| break # out of loop for decision 3 |
| end |
| end # loop for decision 3 |
| name = match( CONSTANT, TOKENS_FOLLOWING_CONSTANT_IN_group_name_169 ) |
| # --> action |
| group = fetch_group( namespace, name.text ) |
| # <-- action |
| # at line 93:5: ( ';' )? |
| 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 93:5: ';' |
| match( T__12, TOKENS_FOLLOWING_T__12_IN_group_name_177 ) |
| |
| end |
| |
| 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 group |
| end |
| |
| |
| # |
| # parser rule member |
| # |
| # (in GroupFile.g) |
| # 96:1: member[ group ] : name= ID ( parameter_declaration )? '::=' (aliased= ID | TEMPLATE | STRING ) ; |
| # |
| def member( group ) |
| # -> uncomment the next line to manually enable rule tracing |
| # trace_in( __method__, 3 ) |
| name = nil |
| aliased = nil |
| __TEMPLATE3__ = nil |
| __STRING4__ = nil |
| parameter_declaration2 = nil |
| # - - - - @init action - - - - |
| params = nil |
| |
| begin |
| # at line 98:5: name= ID ( parameter_declaration )? '::=' (aliased= ID | TEMPLATE | STRING ) |
| name = match( ID, TOKENS_FOLLOWING_ID_IN_member_199 ) |
| # at line 98:13: ( parameter_declaration )? |
| alt_5 = 2 |
| look_5_0 = @input.peek( 1 ) |
| |
| if ( look_5_0 == ID || look_5_0 == T__14 || look_5_0.between?( T__17, T__18 ) ) |
| alt_5 = 1 |
| end |
| case alt_5 |
| when 1 |
| # at line 98:15: parameter_declaration |
| @state.following.push( TOKENS_FOLLOWING_parameter_declaration_IN_member_203 ) |
| parameter_declaration2 = parameter_declaration |
| @state.following.pop |
| # --> action |
| params = parameter_declaration2 |
| # <-- action |
| |
| end |
| match( T__13, TOKENS_FOLLOWING_T__13_IN_member_210 ) |
| # at line 99:5: (aliased= ID | TEMPLATE | STRING ) |
| alt_6 = 3 |
| case look_6 = @input.peek( 1 ) |
| when ID then alt_6 = 1 |
| when TEMPLATE then alt_6 = 2 |
| when STRING then alt_6 = 3 |
| else |
| raise NoViableAlternative( "", 6, 0 ) |
| end |
| case alt_6 |
| when 1 |
| # at line 99:7: aliased= ID |
| aliased = match( ID, TOKENS_FOLLOWING_ID_IN_member_220 ) |
| # --> action |
| group.alias_template( name.text, aliased.text ) |
| # <-- action |
| |
| when 2 |
| # at line 100:7: TEMPLATE |
| __TEMPLATE3__ = match( TEMPLATE, TOKENS_FOLLOWING_TEMPLATE_IN_member_230 ) |
| # --> action |
| group.define_template( name.text, extract_template( __TEMPLATE3__ ), params ) |
| # <-- action |
| |
| when 3 |
| # at line 101:7: STRING |
| __STRING4__ = match( STRING, TOKENS_FOLLOWING_STRING_IN_member_242 ) |
| # --> action |
| group.define_template( name.text, extract_template( __STRING4__ ), params ) |
| # <-- 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__, 3 ) |
| |
| end |
| |
| return |
| end |
| |
| |
| # |
| # parser rule parameter_declaration |
| # |
| # (in GroupFile.g) |
| # 105:1: parameter_declaration returns [ list ] : ( '(' ( parameters )? ')' | parameters ); |
| # |
| def parameter_declaration |
| # -> uncomment the next line to manually enable rule tracing |
| # trace_in( __method__, 4 ) |
| list = nil |
| parameters5 = nil |
| parameters6 = nil |
| # - - - - @init action - - - - |
| list = nil |
| |
| begin |
| # at line 107:3: ( '(' ( parameters )? ')' | parameters ) |
| alt_8 = 2 |
| look_8_0 = @input.peek( 1 ) |
| |
| if ( look_8_0 == T__14 ) |
| alt_8 = 1 |
| elsif ( look_8_0 == ID || look_8_0.between?( T__17, T__18 ) ) |
| alt_8 = 2 |
| else |
| raise NoViableAlternative( "", 8, 0 ) |
| end |
| case alt_8 |
| when 1 |
| # at line 107:5: '(' ( parameters )? ')' |
| match( T__14, TOKENS_FOLLOWING_T__14_IN_parameter_declaration_276 ) |
| # at line 107:9: ( parameters )? |
| alt_7 = 2 |
| look_7_0 = @input.peek( 1 ) |
| |
| if ( look_7_0 == ID || look_7_0.between?( T__17, T__18 ) ) |
| alt_7 = 1 |
| end |
| case alt_7 |
| when 1 |
| # at line 107:11: parameters |
| @state.following.push( TOKENS_FOLLOWING_parameters_IN_parameter_declaration_280 ) |
| parameters5 = parameters |
| @state.following.pop |
| # --> action |
| list = parameters5 |
| # <-- action |
| |
| end |
| match( T__15, TOKENS_FOLLOWING_T__15_IN_parameter_declaration_287 ) |
| |
| when 2 |
| # at line 108:5: parameters |
| @state.following.push( TOKENS_FOLLOWING_parameters_IN_parameter_declaration_293 ) |
| parameters6 = parameters |
| @state.following.pop |
| # --> action |
| list = parameters6 |
| # <-- 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__, 4 ) |
| |
| end |
| |
| return list |
| end |
| |
| |
| # |
| # parser rule parameters |
| # |
| # (in GroupFile.g) |
| # 111:1: parameters returns [ list ] : parameter[ $list ] ( ',' parameter[ $list ] )* ; |
| # |
| def parameters |
| # -> uncomment the next line to manually enable rule tracing |
| # trace_in( __method__, 5 ) |
| list = nil |
| # - - - - @init action - - - - |
| list = ANTLR3::Template::ParameterList.new |
| |
| begin |
| # at line 113:5: parameter[ $list ] ( ',' parameter[ $list ] )* |
| @state.following.push( TOKENS_FOLLOWING_parameter_IN_parameters_317 ) |
| parameter( list ) |
| @state.following.pop |
| # at line 113:24: ( ',' parameter[ $list ] )* |
| while true # decision 9 |
| alt_9 = 2 |
| look_9_0 = @input.peek( 1 ) |
| |
| if ( look_9_0 == T__16 ) |
| alt_9 = 1 |
| |
| end |
| case alt_9 |
| when 1 |
| # at line 113:26: ',' parameter[ $list ] |
| match( T__16, TOKENS_FOLLOWING_T__16_IN_parameters_322 ) |
| @state.following.push( TOKENS_FOLLOWING_parameter_IN_parameters_324 ) |
| parameter( list ) |
| @state.following.pop |
| |
| else |
| break # out of loop for decision 9 |
| end |
| end # loop for decision 9 |
| |
| 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 list |
| end |
| |
| |
| # |
| # parser rule parameter |
| # |
| # (in GroupFile.g) |
| # 116:1: parameter[ parameters ] : ( '*' name= ID | '&' name= ID | name= ID ( '=' v= STRING )? ); |
| # |
| def parameter( parameters ) |
| # -> uncomment the next line to manually enable rule tracing |
| # trace_in( __method__, 6 ) |
| name = nil |
| v = nil |
| |
| begin |
| # at line 117:3: ( '*' name= ID | '&' name= ID | name= ID ( '=' v= STRING )? ) |
| alt_11 = 3 |
| case look_11 = @input.peek( 1 ) |
| when T__17 then alt_11 = 1 |
| when T__18 then alt_11 = 2 |
| when ID then alt_11 = 3 |
| else |
| raise NoViableAlternative( "", 11, 0 ) |
| end |
| case alt_11 |
| when 1 |
| # at line 117:5: '*' name= ID |
| match( T__17, TOKENS_FOLLOWING_T__17_IN_parameter_342 ) |
| name = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_346 ) |
| # --> action |
| parameters.splat = name.text |
| # <-- action |
| |
| when 2 |
| # at line 118:5: '&' name= ID |
| match( T__18, TOKENS_FOLLOWING_T__18_IN_parameter_354 ) |
| name = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_358 ) |
| # --> action |
| parameters.block = name.text |
| # <-- action |
| |
| when 3 |
| # at line 119:5: name= ID ( '=' v= STRING )? |
| name = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_368 ) |
| # --> action |
| param = ANTLR3::Template::Parameter.new( name.text ) |
| # <-- action |
| # at line 120:5: ( '=' v= STRING )? |
| alt_10 = 2 |
| look_10_0 = @input.peek( 1 ) |
| |
| if ( look_10_0 == T__19 ) |
| alt_10 = 1 |
| end |
| case alt_10 |
| when 1 |
| # at line 120:7: '=' v= STRING |
| match( T__19, TOKENS_FOLLOWING_T__19_IN_parameter_382 ) |
| v = match( STRING, TOKENS_FOLLOWING_STRING_IN_parameter_386 ) |
| # --> action |
| param.default = v.text |
| # <-- action |
| |
| end |
| # --> action |
| parameters.add( param ) |
| # <-- 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__, 6 ) |
| |
| end |
| |
| return |
| end |
| |
| |
| |
| TOKENS_FOLLOWING_group_name_IN_group_spec_85 = Set[ 1, 5 ] |
| TOKENS_FOLLOWING_member_IN_group_spec_108 = Set[ 1, 5 ] |
| TOKENS_FOLLOWING_T__10_IN_group_name_128 = Set[ 4 ] |
| TOKENS_FOLLOWING_CONSTANT_IN_group_name_144 = Set[ 11 ] |
| TOKENS_FOLLOWING_T__11_IN_group_name_146 = Set[ 4 ] |
| TOKENS_FOLLOWING_CONSTANT_IN_group_name_169 = Set[ 1, 12 ] |
| TOKENS_FOLLOWING_T__12_IN_group_name_177 = Set[ 1 ] |
| TOKENS_FOLLOWING_ID_IN_member_199 = Set[ 5, 13, 14, 17, 18 ] |
| TOKENS_FOLLOWING_parameter_declaration_IN_member_203 = Set[ 13 ] |
| TOKENS_FOLLOWING_T__13_IN_member_210 = Set[ 5, 6, 7 ] |
| TOKENS_FOLLOWING_ID_IN_member_220 = Set[ 1 ] |
| TOKENS_FOLLOWING_TEMPLATE_IN_member_230 = Set[ 1 ] |
| TOKENS_FOLLOWING_STRING_IN_member_242 = Set[ 1 ] |
| TOKENS_FOLLOWING_T__14_IN_parameter_declaration_276 = Set[ 5, 14, 15, 17, 18 ] |
| TOKENS_FOLLOWING_parameters_IN_parameter_declaration_280 = Set[ 15 ] |
| TOKENS_FOLLOWING_T__15_IN_parameter_declaration_287 = Set[ 1 ] |
| TOKENS_FOLLOWING_parameters_IN_parameter_declaration_293 = Set[ 1 ] |
| TOKENS_FOLLOWING_parameter_IN_parameters_317 = Set[ 1, 16 ] |
| TOKENS_FOLLOWING_T__16_IN_parameters_322 = Set[ 5, 14, 17, 18 ] |
| TOKENS_FOLLOWING_parameter_IN_parameters_324 = Set[ 1, 16 ] |
| TOKENS_FOLLOWING_T__17_IN_parameter_342 = Set[ 5 ] |
| TOKENS_FOLLOWING_ID_IN_parameter_346 = Set[ 1 ] |
| TOKENS_FOLLOWING_T__18_IN_parameter_354 = Set[ 5 ] |
| TOKENS_FOLLOWING_ID_IN_parameter_358 = Set[ 1 ] |
| TOKENS_FOLLOWING_ID_IN_parameter_368 = Set[ 1, 19 ] |
| TOKENS_FOLLOWING_T__19_IN_parameter_382 = Set[ 7 ] |
| TOKENS_FOLLOWING_STRING_IN_parameter_386 = Set[ 1 ] |
| |
| end # class Parser < ANTLR3::Parser |
| |
| end |
| # - - - - - - begin action @parser::footer - - - - - - |
| # GroupFile.g |
| |
| |
| end # module Template |
| end # module ANTLR3 |
| |
| # - - - - - - end action @parser::footer - - - - - - - |
| |
| |
| if __FILE__ == $0 and ARGV.first != '--' |
| # - - - - - - begin action @parser::main - - - - - - |
| # GroupFile.g |
| |
| |
| defined?( ANTLR3::Template::GroupFile::Lexer ) or require 'antlr3/template/group-file' |
| ANTLR3::Template::GroupFile::Parser.main( ARGV ) |
| |
| # - - - - - - end action @parser::main - - - - - - - |
| |
| end |
