• 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 @lexer::header - - - - - -
60# GroupFile.g
61
62
63module ANTLR3
64module Template
65
66# - - - - - - end action @lexer::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, :WS => 9, :T__16 => 16,
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  end
84
85
86  class Lexer < ANTLR3::Lexer
87    @grammar_home = GroupFile
88    include TokenData
89
90
91    begin
92      generated_using( "GroupFile.g", "3.2.1-SNAPSHOT Jun 18, 2010 05:38:11", "1.7.5" )
93    rescue NoMethodError => error
94      # ignore
95    end
96
97    RULE_NAMES   = [ "T__10", "T__11", "T__12", "T__13", "T__14", "T__15",
98                     "T__16", "T__17", "T__18", "T__19", "CONSTANT", "ID",
99                     "TEMPLATE", "STRING", "COMMENT", "WS" ].freeze
100    RULE_METHODS = [ :t__10!, :t__11!, :t__12!, :t__13!, :t__14!, :t__15!,
101                     :t__16!, :t__17!, :t__18!, :t__19!, :constant!, :id!,
102                     :template!, :string!, :comment!, :ws! ].freeze
103
104
105    def initialize( input=nil, options = {} )
106      super( input, options )
107
108    end
109
110
111    # - - - - - - - - - - - lexer rules - - - - - - - - - - - -
112    # lexer rule t__10! (T__10)
113    # (in GroupFile.g)
114    def t__10!
115      # -> uncomment the next line to manually enable rule tracing
116      # trace_in( __method__, 1 )
117
118      type = T__10
119      channel = ANTLR3::DEFAULT_CHANNEL
120
121
122      # - - - - main rule block - - - -
123      # at line 16:9: 'group'
124      match( "group" )
125
126
127      @state.type = type
128      @state.channel = channel
129
130    ensure
131      # -> uncomment the next line to manually enable rule tracing
132      # trace_out( __method__, 1 )
133
134    end
135
136    # lexer rule t__11! (T__11)
137    # (in GroupFile.g)
138    def t__11!
139      # -> uncomment the next line to manually enable rule tracing
140      # trace_in( __method__, 2 )
141
142      type = T__11
143      channel = ANTLR3::DEFAULT_CHANNEL
144
145
146      # - - - - main rule block - - - -
147      # at line 17:9: '::'
148      match( "::" )
149
150
151      @state.type = type
152      @state.channel = channel
153
154    ensure
155      # -> uncomment the next line to manually enable rule tracing
156      # trace_out( __method__, 2 )
157
158    end
159
160    # lexer rule t__12! (T__12)
161    # (in GroupFile.g)
162    def t__12!
163      # -> uncomment the next line to manually enable rule tracing
164      # trace_in( __method__, 3 )
165
166      type = T__12
167      channel = ANTLR3::DEFAULT_CHANNEL
168
169
170      # - - - - main rule block - - - -
171      # at line 18:9: ';'
172      match( 0x3b )
173
174
175      @state.type = type
176      @state.channel = channel
177
178    ensure
179      # -> uncomment the next line to manually enable rule tracing
180      # trace_out( __method__, 3 )
181
182    end
183
184    # lexer rule t__13! (T__13)
185    # (in GroupFile.g)
186    def t__13!
187      # -> uncomment the next line to manually enable rule tracing
188      # trace_in( __method__, 4 )
189
190      type = T__13
191      channel = ANTLR3::DEFAULT_CHANNEL
192
193
194      # - - - - main rule block - - - -
195      # at line 19:9: '::='
196      match( "::=" )
197
198
199      @state.type = type
200      @state.channel = channel
201
202    ensure
203      # -> uncomment the next line to manually enable rule tracing
204      # trace_out( __method__, 4 )
205
206    end
207
208    # lexer rule t__14! (T__14)
209    # (in GroupFile.g)
210    def t__14!
211      # -> uncomment the next line to manually enable rule tracing
212      # trace_in( __method__, 5 )
213
214      type = T__14
215      channel = ANTLR3::DEFAULT_CHANNEL
216
217
218      # - - - - main rule block - - - -
219      # at line 20:9: '('
220      match( 0x28 )
221
222
223      @state.type = type
224      @state.channel = channel
225
226    ensure
227      # -> uncomment the next line to manually enable rule tracing
228      # trace_out( __method__, 5 )
229
230    end
231
232    # lexer rule t__15! (T__15)
233    # (in GroupFile.g)
234    def t__15!
235      # -> uncomment the next line to manually enable rule tracing
236      # trace_in( __method__, 6 )
237
238      type = T__15
239      channel = ANTLR3::DEFAULT_CHANNEL
240
241
242      # - - - - main rule block - - - -
243      # at line 21:9: ')'
244      match( 0x29 )
245
246
247      @state.type = type
248      @state.channel = channel
249
250    ensure
251      # -> uncomment the next line to manually enable rule tracing
252      # trace_out( __method__, 6 )
253
254    end
255
256    # lexer rule t__16! (T__16)
257    # (in GroupFile.g)
258    def t__16!
259      # -> uncomment the next line to manually enable rule tracing
260      # trace_in( __method__, 7 )
261
262      type = T__16
263      channel = ANTLR3::DEFAULT_CHANNEL
264
265
266      # - - - - main rule block - - - -
267      # at line 22:9: ','
268      match( 0x2c )
269
270
271      @state.type = type
272      @state.channel = channel
273
274    ensure
275      # -> uncomment the next line to manually enable rule tracing
276      # trace_out( __method__, 7 )
277
278    end
279
280    # lexer rule t__17! (T__17)
281    # (in GroupFile.g)
282    def t__17!
283      # -> uncomment the next line to manually enable rule tracing
284      # trace_in( __method__, 8 )
285
286      type = T__17
287      channel = ANTLR3::DEFAULT_CHANNEL
288
289
290      # - - - - main rule block - - - -
291      # at line 23:9: '*'
292      match( 0x2a )
293
294
295      @state.type = type
296      @state.channel = channel
297
298    ensure
299      # -> uncomment the next line to manually enable rule tracing
300      # trace_out( __method__, 8 )
301
302    end
303
304    # lexer rule t__18! (T__18)
305    # (in GroupFile.g)
306    def t__18!
307      # -> uncomment the next line to manually enable rule tracing
308      # trace_in( __method__, 9 )
309
310      type = T__18
311      channel = ANTLR3::DEFAULT_CHANNEL
312
313
314      # - - - - main rule block - - - -
315      # at line 24:9: '&'
316      match( 0x26 )
317
318
319      @state.type = type
320      @state.channel = channel
321
322    ensure
323      # -> uncomment the next line to manually enable rule tracing
324      # trace_out( __method__, 9 )
325
326    end
327
328    # lexer rule t__19! (T__19)
329    # (in GroupFile.g)
330    def t__19!
331      # -> uncomment the next line to manually enable rule tracing
332      # trace_in( __method__, 10 )
333
334      type = T__19
335      channel = ANTLR3::DEFAULT_CHANNEL
336
337
338      # - - - - main rule block - - - -
339      # at line 25:9: '='
340      match( 0x3d )
341
342
343      @state.type = type
344      @state.channel = channel
345
346    ensure
347      # -> uncomment the next line to manually enable rule tracing
348      # trace_out( __method__, 10 )
349
350    end
351
352    # lexer rule constant! (CONSTANT)
353    # (in GroupFile.g)
354    def constant!
355      # -> uncomment the next line to manually enable rule tracing
356      # trace_in( __method__, 11 )
357
358      type = CONSTANT
359      channel = ANTLR3::DEFAULT_CHANNEL
360
361
362      # - - - - main rule block - - - -
363      # at line 125:5: 'A' .. 'Z' ( 'a' .. 'z' | '_' | 'A' .. 'Z' | '0' .. '9' )*
364      match_range( 0x41, 0x5a )
365      # at line 125:14: ( 'a' .. 'z' | '_' | 'A' .. 'Z' | '0' .. '9' )*
366      while true # decision 1
367        alt_1 = 2
368        look_1_0 = @input.peek( 1 )
369
370        if ( look_1_0.between?( 0x30, 0x39 ) || look_1_0.between?( 0x41, 0x5a ) || look_1_0 == 0x5f || look_1_0.between?( 0x61, 0x7a ) )
371          alt_1 = 1
372
373        end
374        case alt_1
375        when 1
376          # at line
377          if @input.peek( 1 ).between?( 0x30, 0x39 ) || @input.peek( 1 ).between?( 0x41, 0x5a ) || @input.peek( 1 ) == 0x5f || @input.peek( 1 ).between?( 0x61, 0x7a )
378            @input.consume
379          else
380            mse = MismatchedSet( nil )
381            recover mse
382            raise mse
383          end
384
385
386
387        else
388          break # out of loop for decision 1
389        end
390      end # loop for decision 1
391
392
393      @state.type = type
394      @state.channel = channel
395
396    ensure
397      # -> uncomment the next line to manually enable rule tracing
398      # trace_out( __method__, 11 )
399
400    end
401
402    # lexer rule id! (ID)
403    # (in GroupFile.g)
404    def id!
405      # -> uncomment the next line to manually enable rule tracing
406      # trace_in( __method__, 12 )
407
408      type = ID
409      channel = ANTLR3::DEFAULT_CHANNEL
410
411
412      # - - - - main rule block - - - -
413      # at line 129:5: ( 'a' .. 'z' | '_' ) ( 'a' .. 'z' | '_' | 'A' .. 'Z' | '0' .. '9' )*
414      if @input.peek( 1 ) == 0x5f || @input.peek( 1 ).between?( 0x61, 0x7a )
415        @input.consume
416      else
417        mse = MismatchedSet( nil )
418        recover mse
419        raise mse
420      end
421
422
423      # at line 130:5: ( 'a' .. 'z' | '_' | 'A' .. 'Z' | '0' .. '9' )*
424      while true # decision 2
425        alt_2 = 2
426        look_2_0 = @input.peek( 1 )
427
428        if ( look_2_0.between?( 0x30, 0x39 ) || look_2_0.between?( 0x41, 0x5a ) || look_2_0 == 0x5f || look_2_0.between?( 0x61, 0x7a ) )
429          alt_2 = 1
430
431        end
432        case alt_2
433        when 1
434          # at line
435          if @input.peek( 1 ).between?( 0x30, 0x39 ) || @input.peek( 1 ).between?( 0x41, 0x5a ) || @input.peek( 1 ) == 0x5f || @input.peek( 1 ).between?( 0x61, 0x7a )
436            @input.consume
437          else
438            mse = MismatchedSet( nil )
439            recover mse
440            raise mse
441          end
442
443
444
445        else
446          break # out of loop for decision 2
447        end
448      end # loop for decision 2
449
450
451      @state.type = type
452      @state.channel = channel
453
454    ensure
455      # -> uncomment the next line to manually enable rule tracing
456      # trace_out( __method__, 12 )
457
458    end
459
460    # lexer rule template! (TEMPLATE)
461    # (in GroupFile.g)
462    def template!
463      # -> uncomment the next line to manually enable rule tracing
464      # trace_in( __method__, 13 )
465
466      type = TEMPLATE
467      channel = ANTLR3::DEFAULT_CHANNEL
468
469
470      # - - - - main rule block - - - -
471      # at line 134:5: '<<<' ( options {greedy=false; } : '\\\\' . | . )* '>>>'
472      match( "<<<" )
473      # at line 135:5: ( options {greedy=false; } : '\\\\' . | . )*
474      while true # decision 3
475        alt_3 = 3
476        look_3_0 = @input.peek( 1 )
477
478        if ( look_3_0 == 0x3e )
479          look_3_1 = @input.peek( 2 )
480
481          if ( look_3_1 == 0x3e )
482            look_3_4 = @input.peek( 3 )
483
484            if ( look_3_4 == 0x3e )
485              alt_3 = 3
486            elsif ( look_3_4.between?( 0x0, 0x3d ) || look_3_4.between?( 0x3f, 0xffff ) )
487              alt_3 = 2
488
489            end
490          elsif ( look_3_1.between?( 0x0, 0x3d ) || look_3_1.between?( 0x3f, 0xffff ) )
491            alt_3 = 2
492
493          end
494        elsif ( look_3_0 == 0x5c )
495          look_3_2 = @input.peek( 2 )
496
497          if ( look_3_2 == 0x3e )
498            alt_3 = 1
499          elsif ( look_3_2 == 0x5c )
500            alt_3 = 1
501          elsif ( look_3_2.between?( 0x0, 0x3d ) || look_3_2.between?( 0x3f, 0x5b ) || look_3_2.between?( 0x5d, 0xffff ) )
502            alt_3 = 1
503
504          end
505        elsif ( look_3_0.between?( 0x0, 0x3d ) || look_3_0.between?( 0x3f, 0x5b ) || look_3_0.between?( 0x5d, 0xffff ) )
506          alt_3 = 2
507
508        end
509        case alt_3
510        when 1
511          # at line 135:35: '\\\\' .
512          match( 0x5c )
513          match_any
514
515        when 2
516          # at line 135:44: .
517          match_any
518
519        else
520          break # out of loop for decision 3
521        end
522      end # loop for decision 3
523      match( ">>>" )
524
525
526      @state.type = type
527      @state.channel = channel
528
529    ensure
530      # -> uncomment the next line to manually enable rule tracing
531      # trace_out( __method__, 13 )
532
533    end
534
535    # lexer rule string! (STRING)
536    # (in GroupFile.g)
537    def string!
538      # -> uncomment the next line to manually enable rule tracing
539      # trace_in( __method__, 14 )
540
541      type = STRING
542      channel = ANTLR3::DEFAULT_CHANNEL
543
544
545      # - - - - main rule block - - - -
546      # at line 140:3: ( '\"' (~ ( '\\\\' | '\"' ) | '\\\\' . )* '\"' | '\\'' (~ ( '\\\\' | '\\'' ) | '\\\\' . )* '\\'' )
547      alt_6 = 2
548      look_6_0 = @input.peek( 1 )
549
550      if ( look_6_0 == 0x22 )
551        alt_6 = 1
552      elsif ( look_6_0 == 0x27 )
553        alt_6 = 2
554      else
555        raise NoViableAlternative( "", 6, 0 )
556      end
557      case alt_6
558      when 1
559        # at line 140:5: '\"' (~ ( '\\\\' | '\"' ) | '\\\\' . )* '\"'
560        match( 0x22 )
561        # at line 140:10: (~ ( '\\\\' | '\"' ) | '\\\\' . )*
562        while true # decision 4
563          alt_4 = 3
564          look_4_0 = @input.peek( 1 )
565
566          if ( look_4_0.between?( 0x0, 0x21 ) || look_4_0.between?( 0x23, 0x5b ) || look_4_0.between?( 0x5d, 0xffff ) )
567            alt_4 = 1
568          elsif ( look_4_0 == 0x5c )
569            alt_4 = 2
570
571          end
572          case alt_4
573          when 1
574            # at line 140:12: ~ ( '\\\\' | '\"' )
575            if @input.peek( 1 ).between?( 0x0, 0x21 ) || @input.peek( 1 ).between?( 0x23, 0x5b ) || @input.peek( 1 ).between?( 0x5d, 0xff )
576              @input.consume
577            else
578              mse = MismatchedSet( nil )
579              recover mse
580              raise mse
581            end
582
583
584
585          when 2
586            # at line 140:31: '\\\\' .
587            match( 0x5c )
588            match_any
589
590          else
591            break # out of loop for decision 4
592          end
593        end # loop for decision 4
594        match( 0x22 )
595
596      when 2
597        # at line 141:5: '\\'' (~ ( '\\\\' | '\\'' ) | '\\\\' . )* '\\''
598        match( 0x27 )
599        # at line 141:10: (~ ( '\\\\' | '\\'' ) | '\\\\' . )*
600        while true # decision 5
601          alt_5 = 3
602          look_5_0 = @input.peek( 1 )
603
604          if ( look_5_0.between?( 0x0, 0x26 ) || look_5_0.between?( 0x28, 0x5b ) || look_5_0.between?( 0x5d, 0xffff ) )
605            alt_5 = 1
606          elsif ( look_5_0 == 0x5c )
607            alt_5 = 2
608
609          end
610          case alt_5
611          when 1
612            # at line 141:12: ~ ( '\\\\' | '\\'' )
613            if @input.peek( 1 ).between?( 0x0, 0x26 ) || @input.peek( 1 ).between?( 0x28, 0x5b ) || @input.peek( 1 ).between?( 0x5d, 0xff )
614              @input.consume
615            else
616              mse = MismatchedSet( nil )
617              recover mse
618              raise mse
619            end
620
621
622
623          when 2
624            # at line 141:31: '\\\\' .
625            match( 0x5c )
626            match_any
627
628          else
629            break # out of loop for decision 5
630          end
631        end # loop for decision 5
632        match( 0x27 )
633
634      end
635
636      @state.type = type
637      @state.channel = channel
638
639    ensure
640      # -> uncomment the next line to manually enable rule tracing
641      # trace_out( __method__, 14 )
642
643    end
644
645    # lexer rule comment! (COMMENT)
646    # (in GroupFile.g)
647    def comment!
648      # -> uncomment the next line to manually enable rule tracing
649      # trace_in( __method__, 15 )
650
651      type = COMMENT
652      channel = ANTLR3::DEFAULT_CHANNEL
653
654
655      # - - - - main rule block - - - -
656      # at line 146:3: ( ( '#' | '//' ) (~ '\\n' )* | '/*' ( . )* '*/' )
657      alt_10 = 2
658      look_10_0 = @input.peek( 1 )
659
660      if ( look_10_0 == 0x23 )
661        alt_10 = 1
662      elsif ( look_10_0 == 0x2f )
663        look_10_2 = @input.peek( 2 )
664
665        if ( look_10_2 == 0x2f )
666          alt_10 = 1
667        elsif ( look_10_2 == 0x2a )
668          alt_10 = 2
669        else
670          raise NoViableAlternative( "", 10, 2 )
671        end
672      else
673        raise NoViableAlternative( "", 10, 0 )
674      end
675      case alt_10
676      when 1
677        # at line 146:5: ( '#' | '//' ) (~ '\\n' )*
678        # at line 146:5: ( '#' | '//' )
679        alt_7 = 2
680        look_7_0 = @input.peek( 1 )
681
682        if ( look_7_0 == 0x23 )
683          alt_7 = 1
684        elsif ( look_7_0 == 0x2f )
685          alt_7 = 2
686        else
687          raise NoViableAlternative( "", 7, 0 )
688        end
689        case alt_7
690        when 1
691          # at line 146:7: '#'
692          match( 0x23 )
693
694        when 2
695          # at line 146:13: '//'
696          match( "//" )
697
698        end
699        # at line 146:20: (~ '\\n' )*
700        while true # decision 8
701          alt_8 = 2
702          look_8_0 = @input.peek( 1 )
703
704          if ( look_8_0.between?( 0x0, 0x9 ) || look_8_0.between?( 0xb, 0xffff ) )
705            alt_8 = 1
706
707          end
708          case alt_8
709          when 1
710            # at line 146:20: ~ '\\n'
711            if @input.peek( 1 ).between?( 0x0, 0x9 ) || @input.peek( 1 ).between?( 0xb, 0xff )
712              @input.consume
713            else
714              mse = MismatchedSet( nil )
715              recover mse
716              raise mse
717            end
718
719
720
721          else
722            break # out of loop for decision 8
723          end
724        end # loop for decision 8
725
726      when 2
727        # at line 147:5: '/*' ( . )* '*/'
728        match( "/*" )
729        # at line 147:10: ( . )*
730        while true # decision 9
731          alt_9 = 2
732          look_9_0 = @input.peek( 1 )
733
734          if ( look_9_0 == 0x2a )
735            look_9_1 = @input.peek( 2 )
736
737            if ( look_9_1 == 0x2f )
738              alt_9 = 2
739            elsif ( look_9_1.between?( 0x0, 0x2e ) || look_9_1.between?( 0x30, 0xffff ) )
740              alt_9 = 1
741
742            end
743          elsif ( look_9_0.between?( 0x0, 0x29 ) || look_9_0.between?( 0x2b, 0xffff ) )
744            alt_9 = 1
745
746          end
747          case alt_9
748          when 1
749            # at line 147:10: .
750            match_any
751
752          else
753            break # out of loop for decision 9
754          end
755        end # loop for decision 9
756        match( "*/" )
757
758      end
759
760      @state.type = type
761      @state.channel = channel
762    # --> action
763     skip
764    # <-- action
765    ensure
766      # -> uncomment the next line to manually enable rule tracing
767      # trace_out( __method__, 15 )
768
769    end
770
771    # lexer rule ws! (WS)
772    # (in GroupFile.g)
773    def ws!
774      # -> uncomment the next line to manually enable rule tracing
775      # trace_in( __method__, 16 )
776
777      type = WS
778      channel = ANTLR3::DEFAULT_CHANNEL
779
780
781      # - - - - main rule block - - - -
782      # at line 151:5: ( ' ' | '\\t' | '\\n' | '\\r' | '\\f' )+
783      # at file 151:5: ( ' ' | '\\t' | '\\n' | '\\r' | '\\f' )+
784      match_count_11 = 0
785      while true
786        alt_11 = 2
787        look_11_0 = @input.peek( 1 )
788
789        if ( look_11_0.between?( 0x9, 0xa ) || look_11_0.between?( 0xc, 0xd ) || look_11_0 == 0x20 )
790          alt_11 = 1
791
792        end
793        case alt_11
794        when 1
795          # at line
796          if @input.peek( 1 ).between?( 0x9, 0xa ) || @input.peek( 1 ).between?( 0xc, 0xd ) || @input.peek( 1 ) == 0x20
797            @input.consume
798          else
799            mse = MismatchedSet( nil )
800            recover mse
801            raise mse
802          end
803
804
805
806        else
807          match_count_11 > 0 and break
808          eee = EarlyExit( 11 )
809
810
811          raise eee
812        end
813        match_count_11 += 1
814      end
815
816      # --> action
817       skip
818      # <-- action
819
820
821      @state.type = type
822      @state.channel = channel
823
824    ensure
825      # -> uncomment the next line to manually enable rule tracing
826      # trace_out( __method__, 16 )
827
828    end
829
830    # main rule used to study the input at the current position,
831    # and choose the proper lexer rule to call in order to
832    # fetch the next token
833    #
834    # usually, you don't make direct calls to this method,
835    # but instead use the next_token method, which will
836    # build and emit the actual next token
837    def token!
838      # at line 1:8: ( T__10 | T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | CONSTANT | ID | TEMPLATE | STRING | COMMENT | WS )
839      alt_12 = 16
840      alt_12 = @dfa12.predict( @input )
841      case alt_12
842      when 1
843        # at line 1:10: T__10
844        t__10!
845
846      when 2
847        # at line 1:16: T__11
848        t__11!
849
850      when 3
851        # at line 1:22: T__12
852        t__12!
853
854      when 4
855        # at line 1:28: T__13
856        t__13!
857
858      when 5
859        # at line 1:34: T__14
860        t__14!
861
862      when 6
863        # at line 1:40: T__15
864        t__15!
865
866      when 7
867        # at line 1:46: T__16
868        t__16!
869
870      when 8
871        # at line 1:52: T__17
872        t__17!
873
874      when 9
875        # at line 1:58: T__18
876        t__18!
877
878      when 10
879        # at line 1:64: T__19
880        t__19!
881
882      when 11
883        # at line 1:70: CONSTANT
884        constant!
885
886      when 12
887        # at line 1:79: ID
888        id!
889
890      when 13
891        # at line 1:82: TEMPLATE
892        template!
893
894      when 14
895        # at line 1:91: STRING
896        string!
897
898      when 15
899        # at line 1:98: COMMENT
900        comment!
901
902      when 16
903        # at line 1:106: WS
904        ws!
905
906      end
907    end
908
909
910    # - - - - - - - - - - DFA definitions - - - - - - - - - - -
911    class DFA12 < ANTLR3::DFA
912      EOT = unpack( 1, -1, 1, 11, 14, -1, 1, 11, 1, 20, 1, 11, 2, -1, 1,
913                    11, 1, 23, 1, -1 )
914      EOF = unpack( 24, -1 )
915      MIN = unpack( 1, 9, 1, 114, 1, 58, 13, -1, 1, 111, 1, 61, 1, 117,
916                    2, -1, 1, 112, 1, 48, 1, -1 )
917      MAX = unpack( 1, 122, 1, 114, 1, 58, 13, -1, 1, 111, 1, 61, 1, 117,
918                    2, -1, 1, 112, 1, 122, 1, -1 )
919      ACCEPT = unpack( 3, -1, 1, 3, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10,
920                       1, 11, 1, 12, 1, 13, 1, 14, 1, 15, 1, 16, 3, -1,
921                       1, 4, 1, 2, 2, -1, 1, 1 )
922      SPECIAL = unpack( 24, -1 )
923      TRANSITION = [
924        unpack( 2, 15, 1, -1, 2, 15, 18, -1, 1, 15, 1, -1, 1, 13, 1, 14,
925                2, -1, 1, 8, 1, 13, 1, 4, 1, 5, 1, 7, 1, -1, 1, 6, 2, -1,
926                1, 14, 10, -1, 1, 2, 1, 3, 1, 12, 1, 9, 3, -1, 26, 10, 4,
927                -1, 1, 11, 1, -1, 6, 11, 1, 1, 19, 11 ),
928        unpack( 1, 16 ),
929        unpack( 1, 17 ),
930        unpack(  ),
931        unpack(  ),
932        unpack(  ),
933        unpack(  ),
934        unpack(  ),
935        unpack(  ),
936        unpack(  ),
937        unpack(  ),
938        unpack(  ),
939        unpack(  ),
940        unpack(  ),
941        unpack(  ),
942        unpack(  ),
943        unpack( 1, 18 ),
944        unpack( 1, 19 ),
945        unpack( 1, 21 ),
946        unpack(  ),
947        unpack(  ),
948        unpack( 1, 22 ),
949        unpack( 10, 11, 7, -1, 26, 11, 4, -1, 1, 11, 1, -1, 26, 11 ),
950        unpack(  )
951      ].freeze
952
953      ( 0 ... MIN.length ).zip( MIN, MAX ) do | i, a, z |
954        if a > 0 and z < 0
955          MAX[ i ] %= 0x10000
956        end
957      end
958
959      @decision = 12
960
961
962      def description
963        <<-'__dfa_description__'.strip!
964          1:1: Tokens : ( T__10 | T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | CONSTANT | ID | TEMPLATE | STRING | COMMENT | WS );
965        __dfa_description__
966      end
967    end
968
969
970    private
971
972    def initialize_dfas
973      super rescue nil
974      @dfa12 = DFA12.new( self, 12 )
975
976    end
977  end # class Lexer < ANTLR3::Lexer
978
979  at_exit { Lexer.main( ARGV ) } if __FILE__ == $0
980end
981# - - - - - - begin action @lexer::footer - - - - - -
982# GroupFile.g
983
984
985end # module Template
986end # module ANTLR3
987
988# - - - - - - end action @lexer::footer - - - - - - -
989