667 lines
19 KiB
Ruby
667 lines
19 KiB
Ruby
#!/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
|