• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1#!/usr/bin/env ruby
2#
3# GroupFile.g
4#
5# Generated using ANTLR version: 3.2.1-SNAPSHOT Jun 18, 2010 05:38:11
6# Ruby runtime library version: 1.7.5
7# Input grammar file: GroupFile.g
8# Generated at: 2010-07-03 23:15:35
9#
10
11# ~~~> start load path setup
12this_directory = File.expand_path( File.dirname( __FILE__ ) )
13$LOAD_PATH.unshift( this_directory ) unless $LOAD_PATH.include?( this_directory )
14
15antlr_load_failed = proc do
16  load_path = $LOAD_PATH.map { |dir| '  - ' << dir }.join( $/ )
17  raise LoadError, <<-END.strip!
18
19Failed to load the ANTLR3 runtime library (version 1.7.5):
20
21Ensure the library has been installed on your system and is available
22on the load path. If rubygems is available on your system, this can
23be done with the command:
24
25  gem install antlr3
26
27Current load path:
28#{ load_path }
29
30  END
31end
32
33defined?( ANTLR3 ) or begin
34
35  # 1: try to load the ruby antlr3 runtime library from the system path
36  require 'antlr3'
37
38rescue LoadError
39
40  # 2: try to load rubygems if it isn't already loaded
41  defined?( Gem ) or begin
42    require 'rubygems'
43  rescue LoadError
44    antlr_load_failed.call
45  end
46
47  # 3: try to activate the antlr3 gem
48  begin
49    Gem.activate( 'antlr3', '~> 1.7.5' )
50  rescue Gem::LoadError
51    antlr_load_failed.call
52  end
53
54  require 'antlr3'
55
56end
57# <~~~ end load path setup
58
59# - - - - - - begin action @parser::header - - - - - -
60# GroupFile.g
61
62
63module ANTLR3
64module Template
65
66# - - - - - - end action @parser::header - - - - - - -
67
68
69module GroupFile
70  # TokenData defines all of the token type integer values
71  # as constants, which will be included in all
72  # ANTLR-generated recognizers.
73  const_defined?( :TokenData ) or TokenData = ANTLR3::TokenScheme.new
74
75  module TokenData
76
77    # define the token constants
78    define_tokens( :ID => 5, :EOF => -1, :T__19 => 19, :T__16 => 16, :WS => 9,
79                   :T__15 => 15, :T__18 => 18, :T__17 => 17, :T__12 => 12,
80                   :TEMPLATE => 6, :T__11 => 11, :T__14 => 14, :T__13 => 13,
81                   :T__10 => 10, :CONSTANT => 4, :COMMENT => 8, :STRING => 7 )
82
83    # register the proper human-readable name or literal value
84    # for each token type
85    #
86    # this is necessary because anonymous tokens, which are
87    # created from literal values in the grammar, do not
88    # have descriptive names
89    register_names( "CONSTANT", "ID", "TEMPLATE", "STRING", "COMMENT", "WS",
90                    "'group'", "'::'", "';'", "'::='", "'('", "')'", "','",
91                    "'*'", "'&'", "'='" )
92
93  end
94
95
96  class Parser < ANTLR3::Parser
97    @grammar_home = GroupFile
98
99    RULE_METHODS = [ :group_spec, :group_name, :member, :parameter_declaration,
100                     :parameters, :parameter ].freeze
101
102
103    include TokenData
104
105    begin
106      generated_using( "GroupFile.g", "3.2.1-SNAPSHOT Jun 18, 2010 05:38:11", "1.7.5" )
107    rescue NoMethodError => error
108      # ignore
109    end
110
111    def initialize( input, options = {} )
112      super( input, options )
113
114
115    end
116
117      def fetch_group( namespace, name )
118        if namespace.const_defined?( name )
119          group = namespace.const_get( name )
120          unless group.is_a?( ANTLR3::Template::Group )
121
122          end
123        else
124          group = ANTLR3::Template::Group.new
125          namespace.const_set( name, group )
126        end
127        return( group )
128      end
129
130      def unescape( text )
131        text.gsub( /\\(?:([abefnrstv])|([0-7]{3})|x([0-9a-fA-F]{2})|(.))/ ) do
132          if $1
133            case $1[ 0 ]
134            when ?a then "\a"
135            when ?b then "\b"
136            when ?e then "\e"
137            when ?f then "\f"
138            when ?n then "\n"
139            when ?r then "\r"
140            when ?s then "\s"
141            when ?t then "\t"
142            when ?v then "\v"
143            end
144          elsif $2 then $2.to_i( 8 ).chr
145          elsif $3 then $3.to_i( 16 ).chr
146          elsif $4 then $4
147          end
148        end
149      end
150
151      def extract_template( token )
152        case token.type
153        when TEMPLATE
154          token.text.gsub( /\A<<<\r?\n?|\r?\n?>>>\Z/, '' )
155        when STRING
156          unescape( token.text[ 1...-1 ] )
157        end
158      end
159
160      def group( namespace = ::Object )
161        group_spec( namespace )
162      end
163
164    # - - - - - - - - - - - - Rules - - - - - - - - - - - - -
165
166    #
167    # parser rule group_spec
168    #
169    # (in GroupFile.g)
170    # 79:1: group_spec[ namespace ] returns [ group ] : ( group_name[ $namespace ] | ) ( member[ $group ] )* ;
171    #
172    def group_spec( namespace )
173      # -> uncomment the next line to manually enable rule tracing
174      # trace_in( __method__, 1 )
175      group = nil
176      group_name1 = nil
177
178      begin
179        # at line 80:5: ( group_name[ $namespace ] | ) ( member[ $group ] )*
180        # at line 80:5: ( group_name[ $namespace ] | )
181        alt_1 = 2
182        look_1_0 = @input.peek( 1 )
183
184        if ( look_1_0 == T__10 )
185          alt_1 = 1
186        elsif ( look_1_0 == EOF || look_1_0 == ID )
187          alt_1 = 2
188        else
189          raise NoViableAlternative( "", 1, 0 )
190        end
191        case alt_1
192        when 1
193          # at line 80:7: group_name[ $namespace ]
194          @state.following.push( TOKENS_FOLLOWING_group_name_IN_group_spec_85 )
195          group_name1 = group_name( namespace )
196          @state.following.pop
197          # --> action
198           group = group_name1
199          # <-- action
200
201        when 2
202          # at line 81:7:
203          # --> action
204           group = ANTLR3::Template::Group.new
205          # <-- action
206
207        end
208        # at line 83:5: ( member[ $group ] )*
209        while true # decision 2
210          alt_2 = 2
211          look_2_0 = @input.peek( 1 )
212
213          if ( look_2_0 == ID )
214            alt_2 = 1
215
216          end
217          case alt_2
218          when 1
219            # at line 83:5: member[ $group ]
220            @state.following.push( TOKENS_FOLLOWING_member_IN_group_spec_108 )
221            member( group )
222            @state.following.pop
223
224          else
225            break # out of loop for decision 2
226          end
227        end # loop for decision 2
228
229      rescue ANTLR3::Error::RecognitionError => re
230        report_error( re )
231        recover( re )
232
233      ensure
234        # -> uncomment the next line to manually enable rule tracing
235        # trace_out( __method__, 1 )
236
237      end
238
239      return group
240    end
241
242
243    #
244    # parser rule group_name
245    #
246    # (in GroupFile.g)
247    # 86:1: group_name[ namespace ] returns [ group ] : 'group' (mod= CONSTANT '::' )* name= CONSTANT ( ';' )? ;
248    #
249    def group_name( namespace )
250      # -> uncomment the next line to manually enable rule tracing
251      # trace_in( __method__, 2 )
252      group = nil
253      mod = nil
254      name = nil
255
256      begin
257        # at line 87:5: 'group' (mod= CONSTANT '::' )* name= CONSTANT ( ';' )?
258        match( T__10, TOKENS_FOLLOWING_T__10_IN_group_name_128 )
259        # at line 88:5: (mod= CONSTANT '::' )*
260        while true # decision 3
261          alt_3 = 2
262          look_3_0 = @input.peek( 1 )
263
264          if ( look_3_0 == CONSTANT )
265            look_3_1 = @input.peek( 2 )
266
267            if ( look_3_1 == T__11 )
268              alt_3 = 1
269
270            end
271
272          end
273          case alt_3
274          when 1
275            # at line 89:7: mod= CONSTANT '::'
276            mod = match( CONSTANT, TOKENS_FOLLOWING_CONSTANT_IN_group_name_144 )
277            match( T__11, TOKENS_FOLLOWING_T__11_IN_group_name_146 )
278            # --> action
279             namespace = namespace.const_get( mod.text )
280            # <-- action
281
282          else
283            break # out of loop for decision 3
284          end
285        end # loop for decision 3
286        name = match( CONSTANT, TOKENS_FOLLOWING_CONSTANT_IN_group_name_169 )
287        # --> action
288         group = fetch_group( namespace, name.text )
289        # <-- action
290        # at line 93:5: ( ';' )?
291        alt_4 = 2
292        look_4_0 = @input.peek( 1 )
293
294        if ( look_4_0 == T__12 )
295          alt_4 = 1
296        end
297        case alt_4
298        when 1
299          # at line 93:5: ';'
300          match( T__12, TOKENS_FOLLOWING_T__12_IN_group_name_177 )
301
302        end
303
304      rescue ANTLR3::Error::RecognitionError => re
305        report_error( re )
306        recover( re )
307
308      ensure
309        # -> uncomment the next line to manually enable rule tracing
310        # trace_out( __method__, 2 )
311
312      end
313
314      return group
315    end
316
317
318    #
319    # parser rule member
320    #
321    # (in GroupFile.g)
322    # 96:1: member[ group ] : name= ID ( parameter_declaration )? '::=' (aliased= ID | TEMPLATE | STRING ) ;
323    #
324    def member( group )
325      # -> uncomment the next line to manually enable rule tracing
326      # trace_in( __method__, 3 )
327      name = nil
328      aliased = nil
329      __TEMPLATE3__ = nil
330      __STRING4__ = nil
331      parameter_declaration2 = nil
332      # - - - - @init action - - - -
333       params = nil
334
335      begin
336        # at line 98:5: name= ID ( parameter_declaration )? '::=' (aliased= ID | TEMPLATE | STRING )
337        name = match( ID, TOKENS_FOLLOWING_ID_IN_member_199 )
338        # at line 98:13: ( parameter_declaration )?
339        alt_5 = 2
340        look_5_0 = @input.peek( 1 )
341
342        if ( look_5_0 == ID || look_5_0 == T__14 || look_5_0.between?( T__17, T__18 ) )
343          alt_5 = 1
344        end
345        case alt_5
346        when 1
347          # at line 98:15: parameter_declaration
348          @state.following.push( TOKENS_FOLLOWING_parameter_declaration_IN_member_203 )
349          parameter_declaration2 = parameter_declaration
350          @state.following.pop
351          # --> action
352           params = parameter_declaration2
353          # <-- action
354
355        end
356        match( T__13, TOKENS_FOLLOWING_T__13_IN_member_210 )
357        # at line 99:5: (aliased= ID | TEMPLATE | STRING )
358        alt_6 = 3
359        case look_6 = @input.peek( 1 )
360        when ID then alt_6 = 1
361        when TEMPLATE then alt_6 = 2
362        when STRING then alt_6 = 3
363        else
364          raise NoViableAlternative( "", 6, 0 )
365        end
366        case alt_6
367        when 1
368          # at line 99:7: aliased= ID
369          aliased = match( ID, TOKENS_FOLLOWING_ID_IN_member_220 )
370          # --> action
371           group.alias_template( name.text, aliased.text )
372          # <-- action
373
374        when 2
375          # at line 100:7: TEMPLATE
376          __TEMPLATE3__ = match( TEMPLATE, TOKENS_FOLLOWING_TEMPLATE_IN_member_230 )
377          # --> action
378           group.define_template( name.text, extract_template( __TEMPLATE3__ ), params )
379          # <-- action
380
381        when 3
382          # at line 101:7: STRING
383          __STRING4__ = match( STRING, TOKENS_FOLLOWING_STRING_IN_member_242 )
384          # --> action
385           group.define_template( name.text, extract_template( __STRING4__ ), params )
386          # <-- action
387
388        end
389
390      rescue ANTLR3::Error::RecognitionError => re
391        report_error( re )
392        recover( re )
393
394      ensure
395        # -> uncomment the next line to manually enable rule tracing
396        # trace_out( __method__, 3 )
397
398      end
399
400      return
401    end
402
403
404    #
405    # parser rule parameter_declaration
406    #
407    # (in GroupFile.g)
408    # 105:1: parameter_declaration returns [ list ] : ( '(' ( parameters )? ')' | parameters );
409    #
410    def parameter_declaration
411      # -> uncomment the next line to manually enable rule tracing
412      # trace_in( __method__, 4 )
413      list = nil
414      parameters5 = nil
415      parameters6 = nil
416      # - - - - @init action - - - -
417       list = nil
418
419      begin
420        # at line 107:3: ( '(' ( parameters )? ')' | parameters )
421        alt_8 = 2
422        look_8_0 = @input.peek( 1 )
423
424        if ( look_8_0 == T__14 )
425          alt_8 = 1
426        elsif ( look_8_0 == ID || look_8_0.between?( T__17, T__18 ) )
427          alt_8 = 2
428        else
429          raise NoViableAlternative( "", 8, 0 )
430        end
431        case alt_8
432        when 1
433          # at line 107:5: '(' ( parameters )? ')'
434          match( T__14, TOKENS_FOLLOWING_T__14_IN_parameter_declaration_276 )
435          # at line 107:9: ( parameters )?
436          alt_7 = 2
437          look_7_0 = @input.peek( 1 )
438
439          if ( look_7_0 == ID || look_7_0.between?( T__17, T__18 ) )
440            alt_7 = 1
441          end
442          case alt_7
443          when 1
444            # at line 107:11: parameters
445            @state.following.push( TOKENS_FOLLOWING_parameters_IN_parameter_declaration_280 )
446            parameters5 = parameters
447            @state.following.pop
448            # --> action
449             list = parameters5
450            # <-- action
451
452          end
453          match( T__15, TOKENS_FOLLOWING_T__15_IN_parameter_declaration_287 )
454
455        when 2
456          # at line 108:5: parameters
457          @state.following.push( TOKENS_FOLLOWING_parameters_IN_parameter_declaration_293 )
458          parameters6 = parameters
459          @state.following.pop
460          # --> action
461           list = parameters6
462          # <-- action
463
464        end
465      rescue ANTLR3::Error::RecognitionError => re
466        report_error( re )
467        recover( re )
468
469      ensure
470        # -> uncomment the next line to manually enable rule tracing
471        # trace_out( __method__, 4 )
472
473      end
474
475      return list
476    end
477
478
479    #
480    # parser rule parameters
481    #
482    # (in GroupFile.g)
483    # 111:1: parameters returns [ list ] : parameter[ $list ] ( ',' parameter[ $list ] )* ;
484    #
485    def parameters
486      # -> uncomment the next line to manually enable rule tracing
487      # trace_in( __method__, 5 )
488      list = nil
489      # - - - - @init action - - - -
490       list = ANTLR3::Template::ParameterList.new
491
492      begin
493        # at line 113:5: parameter[ $list ] ( ',' parameter[ $list ] )*
494        @state.following.push( TOKENS_FOLLOWING_parameter_IN_parameters_317 )
495        parameter( list )
496        @state.following.pop
497        # at line 113:24: ( ',' parameter[ $list ] )*
498        while true # decision 9
499          alt_9 = 2
500          look_9_0 = @input.peek( 1 )
501
502          if ( look_9_0 == T__16 )
503            alt_9 = 1
504
505          end
506          case alt_9
507          when 1
508            # at line 113:26: ',' parameter[ $list ]
509            match( T__16, TOKENS_FOLLOWING_T__16_IN_parameters_322 )
510            @state.following.push( TOKENS_FOLLOWING_parameter_IN_parameters_324 )
511            parameter( list )
512            @state.following.pop
513
514          else
515            break # out of loop for decision 9
516          end
517        end # loop for decision 9
518
519      rescue ANTLR3::Error::RecognitionError => re
520        report_error( re )
521        recover( re )
522
523      ensure
524        # -> uncomment the next line to manually enable rule tracing
525        # trace_out( __method__, 5 )
526
527      end
528
529      return list
530    end
531
532
533    #
534    # parser rule parameter
535    #
536    # (in GroupFile.g)
537    # 116:1: parameter[ parameters ] : ( '*' name= ID | '&' name= ID | name= ID ( '=' v= STRING )? );
538    #
539    def parameter( parameters )
540      # -> uncomment the next line to manually enable rule tracing
541      # trace_in( __method__, 6 )
542      name = nil
543      v = nil
544
545      begin
546        # at line 117:3: ( '*' name= ID | '&' name= ID | name= ID ( '=' v= STRING )? )
547        alt_11 = 3
548        case look_11 = @input.peek( 1 )
549        when T__17 then alt_11 = 1
550        when T__18 then alt_11 = 2
551        when ID then alt_11 = 3
552        else
553          raise NoViableAlternative( "", 11, 0 )
554        end
555        case alt_11
556        when 1
557          # at line 117:5: '*' name= ID
558          match( T__17, TOKENS_FOLLOWING_T__17_IN_parameter_342 )
559          name = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_346 )
560          # --> action
561           parameters.splat = name.text
562          # <-- action
563
564        when 2
565          # at line 118:5: '&' name= ID
566          match( T__18, TOKENS_FOLLOWING_T__18_IN_parameter_354 )
567          name = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_358 )
568          # --> action
569           parameters.block = name.text
570          # <-- action
571
572        when 3
573          # at line 119:5: name= ID ( '=' v= STRING )?
574          name = match( ID, TOKENS_FOLLOWING_ID_IN_parameter_368 )
575          # --> action
576           param = ANTLR3::Template::Parameter.new( name.text )
577          # <-- action
578          # at line 120:5: ( '=' v= STRING )?
579          alt_10 = 2
580          look_10_0 = @input.peek( 1 )
581
582          if ( look_10_0 == T__19 )
583            alt_10 = 1
584          end
585          case alt_10
586          when 1
587            # at line 120:7: '=' v= STRING
588            match( T__19, TOKENS_FOLLOWING_T__19_IN_parameter_382 )
589            v = match( STRING, TOKENS_FOLLOWING_STRING_IN_parameter_386 )
590            # --> action
591             param.default = v.text
592            # <-- action
593
594          end
595          # --> action
596           parameters.add( param )
597          # <-- action
598
599        end
600      rescue ANTLR3::Error::RecognitionError => re
601        report_error( re )
602        recover( re )
603
604      ensure
605        # -> uncomment the next line to manually enable rule tracing
606        # trace_out( __method__, 6 )
607
608      end
609
610      return
611    end
612
613
614
615    TOKENS_FOLLOWING_group_name_IN_group_spec_85 = Set[ 1, 5 ]
616    TOKENS_FOLLOWING_member_IN_group_spec_108 = Set[ 1, 5 ]
617    TOKENS_FOLLOWING_T__10_IN_group_name_128 = Set[ 4 ]
618    TOKENS_FOLLOWING_CONSTANT_IN_group_name_144 = Set[ 11 ]
619    TOKENS_FOLLOWING_T__11_IN_group_name_146 = Set[ 4 ]
620    TOKENS_FOLLOWING_CONSTANT_IN_group_name_169 = Set[ 1, 12 ]
621    TOKENS_FOLLOWING_T__12_IN_group_name_177 = Set[ 1 ]
622    TOKENS_FOLLOWING_ID_IN_member_199 = Set[ 5, 13, 14, 17, 18 ]
623    TOKENS_FOLLOWING_parameter_declaration_IN_member_203 = Set[ 13 ]
624    TOKENS_FOLLOWING_T__13_IN_member_210 = Set[ 5, 6, 7 ]
625    TOKENS_FOLLOWING_ID_IN_member_220 = Set[ 1 ]
626    TOKENS_FOLLOWING_TEMPLATE_IN_member_230 = Set[ 1 ]
627    TOKENS_FOLLOWING_STRING_IN_member_242 = Set[ 1 ]
628    TOKENS_FOLLOWING_T__14_IN_parameter_declaration_276 = Set[ 5, 14, 15, 17, 18 ]
629    TOKENS_FOLLOWING_parameters_IN_parameter_declaration_280 = Set[ 15 ]
630    TOKENS_FOLLOWING_T__15_IN_parameter_declaration_287 = Set[ 1 ]
631    TOKENS_FOLLOWING_parameters_IN_parameter_declaration_293 = Set[ 1 ]
632    TOKENS_FOLLOWING_parameter_IN_parameters_317 = Set[ 1, 16 ]
633    TOKENS_FOLLOWING_T__16_IN_parameters_322 = Set[ 5, 14, 17, 18 ]
634    TOKENS_FOLLOWING_parameter_IN_parameters_324 = Set[ 1, 16 ]
635    TOKENS_FOLLOWING_T__17_IN_parameter_342 = Set[ 5 ]
636    TOKENS_FOLLOWING_ID_IN_parameter_346 = Set[ 1 ]
637    TOKENS_FOLLOWING_T__18_IN_parameter_354 = Set[ 5 ]
638    TOKENS_FOLLOWING_ID_IN_parameter_358 = Set[ 1 ]
639    TOKENS_FOLLOWING_ID_IN_parameter_368 = Set[ 1, 19 ]
640    TOKENS_FOLLOWING_T__19_IN_parameter_382 = Set[ 7 ]
641    TOKENS_FOLLOWING_STRING_IN_parameter_386 = Set[ 1 ]
642
643  end # class Parser < ANTLR3::Parser
644
645end
646# - - - - - - begin action @parser::footer - - - - - -
647# GroupFile.g
648
649
650end # module Template
651end # module ANTLR3
652
653# - - - - - - end action @parser::footer - - - - - - -
654
655
656if __FILE__ == $0 and ARGV.first != '--'
657  # - - - - - - begin action @parser::main - - - - - -
658  # GroupFile.g
659
660
661    defined?( ANTLR3::Template::GroupFile::Lexer ) or require 'antlr3/template/group-file'
662    ANTLR3::Template::GroupFile::Parser.main( ARGV )
663
664  # - - - - - - end action @parser::main - - - - - - -
665
666end
667