View Javadoc

1   // $ANTLR 3.1.1 F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g 2009-05-22 10:39:44
2   
3   //--------------------------------------
4   // UTGB Project
5   //
6   // BEDLexer.java
7   // Since: May 8, 2009
8   //
9   //--------------------------------------
10  package org.utgenome.format.bed;
11  
12  
13  import org.antlr.runtime.*;
14  import java.util.Stack;
15  import java.util.List;
16  import java.util.ArrayList;
17  
18  public class BEDLexer extends Lexer {
19      public static final int StringChars=19;
20      public static final int Double=22;
21      public static final int Frac=16;
22      public static final int QName=24;
23      public static final int Eq=8;
24      public static final int Exp=17;
25      public static final int UnicodeChar=12;
26      public static final int Digit=10;
27      public static final int EOF=-1;
28      public static final int Attribute=7;
29      public static final int HexDigit=11;
30      public static final int Int=15;
31      public static final int Value=6;
32      public static final int Description=4;
33      public static final int Number=23;
34      public static final int Name=5;
35      public static final int Dot=9;
36      public static final int StringChar=14;
37      public static final int WhiteSpace=18;
38      public static final int String=20;
39      public static final int EscapeSequence=13;
40      public static final int Integer=21;
41  
42      // delegates
43      // delegators
44  
45      public BEDLexer() {;} 
46      public BEDLexer(CharStream input) {
47          this(input, new RecognizerSharedState());
48      }
49      public BEDLexer(CharStream input, RecognizerSharedState state) {
50          super(input,state);
51  
52      }
53      public String getGrammarFileName() { return "F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g"; }
54  
55      // $ANTLR start "Eq"
56      public final void mEq() throws RecognitionException {
57          try {
58              int _type = Eq;
59              int _channel = DEFAULT_TOKEN_CHANNEL;
60              // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:68:3: ( '=' )
61              // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:68:5: '='
62              {
63              match('='); 
64  
65              }
66  
67              state.type = _type;
68              state.channel = _channel;
69          }
70          finally {
71          }
72      }
73      // $ANTLR end "Eq"
74  
75      // $ANTLR start "Dot"
76      public final void mDot() throws RecognitionException {
77          try {
78              int _type = Dot;
79              int _channel = DEFAULT_TOKEN_CHANNEL;
80              // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:69:4: ( '.' )
81              // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:69:6: '.'
82              {
83              match('.'); 
84  
85              }
86  
87              state.type = _type;
88              state.channel = _channel;
89          }
90          finally {
91          }
92      }
93      // $ANTLR end "Dot"
94  
95      // $ANTLR start "Digit"
96      public final void mDigit() throws RecognitionException {
97          try {
98              // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:71:15: ( '0' .. '9' )
99              // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:71:17: '0' .. '9'
100             {
101             matchRange('0','9'); 
102 
103             }
104 
105         }
106         finally {
107         }
108     }
109     // $ANTLR end "Digit"
110 
111     // $ANTLR start "HexDigit"
112     public final void mHexDigit() throws RecognitionException {
113         try {
114             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:72:18: ( ( '0' .. '9' | 'A' .. 'F' | 'a' .. 'f' ) )
115             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:72:20: ( '0' .. '9' | 'A' .. 'F' | 'a' .. 'f' )
116             {
117             if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) {
118                 input.consume();
119 
120             }
121             else {
122                 MismatchedSetException mse = new MismatchedSetException(null,input);
123                 recover(mse);
124                 throw mse;}
125 
126 
127             }
128 
129         }
130         finally {
131         }
132     }
133     // $ANTLR end "HexDigit"
134 
135     // $ANTLR start "UnicodeChar"
136     public final void mUnicodeChar() throws RecognitionException {
137         try {
138             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:73:21: (~ ( '\"' | '\\\\' ) )
139             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:73:23: ~ ( '\"' | '\\\\' )
140             {
141             if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
142                 input.consume();
143 
144             }
145             else {
146                 MismatchedSetException mse = new MismatchedSetException(null,input);
147                 recover(mse);
148                 throw mse;}
149 
150 
151             }
152 
153         }
154         finally {
155         }
156     }
157     // $ANTLR end "UnicodeChar"
158 
159     // $ANTLR start "StringChar"
160     public final void mStringChar() throws RecognitionException {
161         try {
162             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:74:21: ( UnicodeChar | EscapeSequence )
163             int alt1=2;
164             int LA1_0 = input.LA(1);
165 
166             if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) {
167                 alt1=1;
168             }
169             else if ( (LA1_0=='\\') ) {
170                 alt1=2;
171             }
172             else {
173                 NoViableAltException nvae =
174                     new NoViableAltException("", 1, 0, input);
175 
176                 throw nvae;
177             }
178             switch (alt1) {
179                 case 1 :
180                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:74:24: UnicodeChar
181                     {
182                     mUnicodeChar(); 
183 
184                     }
185                     break;
186                 case 2 :
187                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:74:38: EscapeSequence
188                     {
189                     mEscapeSequence(); 
190 
191                     }
192                     break;
193 
194             }
195         }
196         finally {
197         }
198     }
199     // $ANTLR end "StringChar"
200 
201     // $ANTLR start "EscapeSequence"
202     public final void mEscapeSequence() throws RecognitionException {
203         try {
204             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:3: ( '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit ) )
205             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:5: '\\\\' ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
206             {
207             match('\\'); 
208             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:10: ( '\\\"' | '\\\\' | '/' | 'b' | 'f' | 'n' | 'r' | 't' | 'u' HexDigit HexDigit HexDigit HexDigit )
209             int alt2=9;
210             switch ( input.LA(1) ) {
211             case '\"':
212                 {
213                 alt2=1;
214                 }
215                 break;
216             case '\\':
217                 {
218                 alt2=2;
219                 }
220                 break;
221             case '/':
222                 {
223                 alt2=3;
224                 }
225                 break;
226             case 'b':
227                 {
228                 alt2=4;
229                 }
230                 break;
231             case 'f':
232                 {
233                 alt2=5;
234                 }
235                 break;
236             case 'n':
237                 {
238                 alt2=6;
239                 }
240                 break;
241             case 'r':
242                 {
243                 alt2=7;
244                 }
245                 break;
246             case 't':
247                 {
248                 alt2=8;
249                 }
250                 break;
251             case 'u':
252                 {
253                 alt2=9;
254                 }
255                 break;
256             default:
257                 NoViableAltException nvae =
258                     new NoViableAltException("", 2, 0, input);
259 
260                 throw nvae;
261             }
262 
263             switch (alt2) {
264                 case 1 :
265                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:11: '\\\"'
266                     {
267                     match('\"'); 
268 
269                     }
270                     break;
271                 case 2 :
272                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:18: '\\\\'
273                     {
274                     match('\\'); 
275 
276                     }
277                     break;
278                 case 3 :
279                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:25: '/'
280                     {
281                     match('/'); 
282 
283                     }
284                     break;
285                 case 4 :
286                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:31: 'b'
287                     {
288                     match('b'); 
289 
290                     }
291                     break;
292                 case 5 :
293                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:37: 'f'
294                     {
295                     match('f'); 
296 
297                     }
298                     break;
299                 case 6 :
300                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:43: 'n'
301                     {
302                     match('n'); 
303 
304                     }
305                     break;
306                 case 7 :
307                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:49: 'r'
308                     {
309                     match('r'); 
310 
311                     }
312                     break;
313                 case 8 :
314                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:55: 't'
315                     {
316                     match('t'); 
317 
318                     }
319                     break;
320                 case 9 :
321                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:77:61: 'u' HexDigit HexDigit HexDigit HexDigit
322                     {
323                     match('u'); 
324                     mHexDigit(); 
325                     mHexDigit(); 
326                     mHexDigit(); 
327                     mHexDigit(); 
328 
329                     }
330                     break;
331 
332             }
333 
334 
335             }
336 
337         }
338         finally {
339         }
340     }
341     // $ANTLR end "EscapeSequence"
342 
343     // $ANTLR start "Int"
344     public final void mInt() throws RecognitionException {
345         try {
346             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:13: ( ( '-' )? ( '0' | '1' .. '9' ( Digit )* ) )
347             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:15: ( '-' )? ( '0' | '1' .. '9' ( Digit )* )
348             {
349             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:15: ( '-' )?
350             int alt3=2;
351             int LA3_0 = input.LA(1);
352 
353             if ( (LA3_0=='-') ) {
354                 alt3=1;
355             }
356             switch (alt3) {
357                 case 1 :
358                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:15: '-'
359                     {
360                     match('-'); 
361 
362                     }
363                     break;
364 
365             }
366 
367             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:20: ( '0' | '1' .. '9' ( Digit )* )
368             int alt5=2;
369             int LA5_0 = input.LA(1);
370 
371             if ( (LA5_0=='0') ) {
372                 alt5=1;
373             }
374             else if ( ((LA5_0>='1' && LA5_0<='9')) ) {
375                 alt5=2;
376             }
377             else {
378                 NoViableAltException nvae =
379                     new NoViableAltException("", 5, 0, input);
380 
381                 throw nvae;
382             }
383             switch (alt5) {
384                 case 1 :
385                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:21: '0'
386                     {
387                     match('0'); 
388 
389                     }
390                     break;
391                 case 2 :
392                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:27: '1' .. '9' ( Digit )*
393                     {
394                     matchRange('1','9'); 
395                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:36: ( Digit )*
396                     loop4:
397                     do {
398                         int alt4=2;
399                         int LA4_0 = input.LA(1);
400 
401                         if ( ((LA4_0>='0' && LA4_0<='9')) ) {
402                             alt4=1;
403                         }
404 
405 
406                         switch (alt4) {
407                     	case 1 :
408                     	    // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:80:36: Digit
409                     	    {
410                     	    mDigit(); 
411 
412                     	    }
413                     	    break;
414 
415                     	default :
416                     	    break loop4;
417                         }
418                     } while (true);
419 
420 
421                     }
422                     break;
423 
424             }
425 
426 
427             }
428 
429         }
430         finally {
431         }
432     }
433     // $ANTLR end "Int"
434 
435     // $ANTLR start "Frac"
436     public final void mFrac() throws RecognitionException {
437         try {
438             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:81:14: ( Dot ( Digit )+ )
439             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:81:16: Dot ( Digit )+
440             {
441             mDot(); 
442             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:81:20: ( Digit )+
443             int cnt6=0;
444             loop6:
445             do {
446                 int alt6=2;
447                 int LA6_0 = input.LA(1);
448 
449                 if ( ((LA6_0>='0' && LA6_0<='9')) ) {
450                     alt6=1;
451                 }
452 
453 
454                 switch (alt6) {
455             	case 1 :
456             	    // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:81:20: Digit
457             	    {
458             	    mDigit(); 
459 
460             	    }
461             	    break;
462 
463             	default :
464             	    if ( cnt6 >= 1 ) break loop6;
465                         EarlyExitException eee =
466                             new EarlyExitException(6, input);
467                         throw eee;
468                 }
469                 cnt6++;
470             } while (true);
471 
472 
473             }
474 
475         }
476         finally {
477         }
478     }
479     // $ANTLR end "Frac"
480 
481     // $ANTLR start "Exp"
482     public final void mExp() throws RecognitionException {
483         try {
484             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:82:13: ( ( 'e' | 'E' ) ( '+' | '-' )? ( Digit )+ )
485             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:82:15: ( 'e' | 'E' ) ( '+' | '-' )? ( Digit )+
486             {
487             if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
488                 input.consume();
489 
490             }
491             else {
492                 MismatchedSetException mse = new MismatchedSetException(null,input);
493                 recover(mse);
494                 throw mse;}
495 
496             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:82:27: ( '+' | '-' )?
497             int alt7=2;
498             int LA7_0 = input.LA(1);
499 
500             if ( (LA7_0=='+'||LA7_0=='-') ) {
501                 alt7=1;
502             }
503             switch (alt7) {
504                 case 1 :
505                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:
506                     {
507                     if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
508                         input.consume();
509 
510                     }
511                     else {
512                         MismatchedSetException mse = new MismatchedSetException(null,input);
513                         recover(mse);
514                         throw mse;}
515 
516 
517                     }
518                     break;
519 
520             }
521 
522             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:82:40: ( Digit )+
523             int cnt8=0;
524             loop8:
525             do {
526                 int alt8=2;
527                 int LA8_0 = input.LA(1);
528 
529                 if ( ((LA8_0>='0' && LA8_0<='9')) ) {
530                     alt8=1;
531                 }
532 
533 
534                 switch (alt8) {
535             	case 1 :
536             	    // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:82:40: Digit
537             	    {
538             	    mDigit(); 
539 
540             	    }
541             	    break;
542 
543             	default :
544             	    if ( cnt8 >= 1 ) break loop8;
545                         EarlyExitException eee =
546                             new EarlyExitException(8, input);
547                         throw eee;
548                 }
549                 cnt8++;
550             } while (true);
551 
552 
553             }
554 
555         }
556         finally {
557         }
558     }
559     // $ANTLR end "Exp"
560 
561     // $ANTLR start "WhiteSpace"
562     public final void mWhiteSpace() throws RecognitionException {
563         try {
564             int _type = WhiteSpace;
565             int _channel = DEFAULT_TOKEN_CHANNEL;
566             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:84:11: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
567             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:84:13: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
568             {
569             if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||(input.LA(1)>='\f' && input.LA(1)<='\r')||input.LA(1)==' ' ) {
570                 input.consume();
571 
572             }
573             else {
574                 MismatchedSetException mse = new MismatchedSetException(null,input);
575                 recover(mse);
576                 throw mse;}
577 
578              _channel=HIDDEN; 
579 
580             }
581 
582             state.type = _type;
583             state.channel = _channel;
584         }
585         finally {
586         }
587     }
588     // $ANTLR end "WhiteSpace"
589 
590     // $ANTLR start "StringChars"
591     public final void mStringChars() throws RecognitionException {
592         try {
593             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:87:12: ( ( StringChar )* )
594             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:87:14: ( StringChar )*
595             {
596             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:87:14: ( StringChar )*
597             loop9:
598             do {
599                 int alt9=2;
600                 int LA9_0 = input.LA(1);
601 
602                 if ( ((LA9_0>='\u0000' && LA9_0<='!')||(LA9_0>='#' && LA9_0<='\uFFFF')) ) {
603                     alt9=1;
604                 }
605 
606 
607                 switch (alt9) {
608             	case 1 :
609             	    // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:87:14: StringChar
610             	    {
611             	    mStringChar(); 
612 
613             	    }
614             	    break;
615 
616             	default :
617             	    break loop9;
618                 }
619             } while (true);
620 
621 
622             }
623 
624         }
625         finally {
626         }
627     }
628     // $ANTLR end "StringChars"
629 
630     // $ANTLR start "String"
631     public final void mString() throws RecognitionException {
632         try {
633             int _type = String;
634             int _channel = DEFAULT_TOKEN_CHANNEL;
635             Token StringChars1=null;
636 
637             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:89:7: ( '\"' StringChars '\"' )
638             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:89:9: '\"' StringChars '\"'
639             {
640             match('\"'); 
641             int StringChars1Start284 = getCharIndex();
642             mStringChars(); 
643             StringChars1 = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, StringChars1Start284, getCharIndex()-1);
644             match('\"'); 
645              setText("\"" + (StringChars1!=null?StringChars1.getText():null) + "\""); 
646 
647             }
648 
649             state.type = _type;
650             state.channel = _channel;
651         }
652         finally {
653         }
654     }
655     // $ANTLR end "String"
656 
657     // $ANTLR start "Integer"
658     public final void mInteger() throws RecognitionException {
659         try {
660             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:91:17: ( Int )
661             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:91:19: Int
662             {
663             mInt(); 
664 
665             }
666 
667         }
668         finally {
669         }
670     }
671     // $ANTLR end "Integer"
672 
673     // $ANTLR start "Double"
674     public final void mDouble() throws RecognitionException {
675         try {
676             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:16: ( Int ( Frac ( Exp )? | Exp ) )
677             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:19: Int ( Frac ( Exp )? | Exp )
678             {
679             mInt(); 
680             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:23: ( Frac ( Exp )? | Exp )
681             int alt11=2;
682             int LA11_0 = input.LA(1);
683 
684             if ( (LA11_0=='.') ) {
685                 alt11=1;
686             }
687             else if ( (LA11_0=='E'||LA11_0=='e') ) {
688                 alt11=2;
689             }
690             else {
691                 NoViableAltException nvae =
692                     new NoViableAltException("", 11, 0, input);
693 
694                 throw nvae;
695             }
696             switch (alt11) {
697                 case 1 :
698                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:24: Frac ( Exp )?
699                     {
700                     mFrac(); 
701                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:29: ( Exp )?
702                     int alt10=2;
703                     int LA10_0 = input.LA(1);
704 
705                     if ( (LA10_0=='E'||LA10_0=='e') ) {
706                         alt10=1;
707                     }
708                     switch (alt10) {
709                         case 1 :
710                             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:29: Exp
711                             {
712                             mExp(); 
713 
714                             }
715                             break;
716 
717                     }
718 
719 
720                     }
721                     break;
722                 case 2 :
723                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:92:36: Exp
724                     {
725                     mExp(); 
726 
727                     }
728                     break;
729 
730             }
731 
732 
733             }
734 
735         }
736         finally {
737         }
738     }
739     // $ANTLR end "Double"
740 
741     // $ANTLR start "Number"
742     public final void mNumber() throws RecognitionException {
743         try {
744             int _type = Number;
745             int _channel = DEFAULT_TOKEN_CHANNEL;
746             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:94:7: ( Integer | Double )
747             int alt12=2;
748             alt12 = dfa12.predict(input);
749             switch (alt12) {
750                 case 1 :
751                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:94:9: Integer
752                     {
753                     mInteger(); 
754 
755                     }
756                     break;
757                 case 2 :
758                     // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:94:19: Double
759                     {
760                     mDouble(); 
761 
762                     }
763                     break;
764 
765             }
766             state.type = _type;
767             state.channel = _channel;
768         }
769         finally {
770         }
771     }
772     // $ANTLR end "Number"
773 
774     // $ANTLR start "QName"
775     public final void mQName() throws RecognitionException {
776         try {
777             int _type = QName;
778             int _channel = DEFAULT_TOKEN_CHANNEL;
779             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:96:6: ( ( 'A' .. 'Z' | 'a' .. 'z' | Digit | ':' | ',' | '-' )+ )
780             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:96:8: ( 'A' .. 'Z' | 'a' .. 'z' | Digit | ':' | ',' | '-' )+
781             {
782             // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:96:8: ( 'A' .. 'Z' | 'a' .. 'z' | Digit | ':' | ',' | '-' )+
783             int cnt13=0;
784             loop13:
785             do {
786                 int alt13=2;
787                 int LA13_0 = input.LA(1);
788 
789                 if ( ((LA13_0>=',' && LA13_0<='-')||(LA13_0>='0' && LA13_0<=':')||(LA13_0>='A' && LA13_0<='Z')||(LA13_0>='a' && LA13_0<='z')) ) {
790                     alt13=1;
791                 }
792 
793 
794                 switch (alt13) {
795             	case 1 :
796             	    // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:
797             	    {
798             	    if ( (input.LA(1)>=',' && input.LA(1)<='-')||(input.LA(1)>='0' && input.LA(1)<=':')||(input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z') ) {
799             	        input.consume();
800 
801             	    }
802             	    else {
803             	        MismatchedSetException mse = new MismatchedSetException(null,input);
804             	        recover(mse);
805             	        throw mse;}
806 
807 
808             	    }
809             	    break;
810 
811             	default :
812             	    if ( cnt13 >= 1 ) break loop13;
813                         EarlyExitException eee =
814                             new EarlyExitException(13, input);
815                         throw eee;
816                 }
817                 cnt13++;
818             } while (true);
819 
820 
821             }
822 
823             state.type = _type;
824             state.channel = _channel;
825         }
826         finally {
827         }
828     }
829     // $ANTLR end "QName"
830 
831     public void mTokens() throws RecognitionException {
832         // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:8: ( Eq | Dot | WhiteSpace | String | Number | QName )
833         int alt14=6;
834         alt14 = dfa14.predict(input);
835         switch (alt14) {
836             case 1 :
837                 // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:10: Eq
838                 {
839                 mEq(); 
840 
841                 }
842                 break;
843             case 2 :
844                 // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:13: Dot
845                 {
846                 mDot(); 
847 
848                 }
849                 break;
850             case 3 :
851                 // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:17: WhiteSpace
852                 {
853                 mWhiteSpace(); 
854 
855                 }
856                 break;
857             case 4 :
858                 // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:28: String
859                 {
860                 mString(); 
861 
862                 }
863                 break;
864             case 5 :
865                 // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:35: Number
866                 {
867                 mNumber(); 
868 
869                 }
870                 break;
871             case 6 :
872                 // F:\\workspace\\utgb\\utgb-core\\src\\main\\java\\org\\utgenome\\format\\bed\\BED.g:1:42: QName
873                 {
874                 mQName(); 
875 
876                 }
877                 break;
878 
879         }
880 
881     }
882 
883 
884     protected DFA12 dfa12 = new DFA12(this);
885     protected DFA14 dfa14 = new DFA14(this);
886     static final String DFA12_eotS =
887         "\2\uffff\2\4\2\uffff\1\4";
888     static final String DFA12_eofS =
889         "\7\uffff";
890     static final String DFA12_minS =
891         "\1\55\1\60\2\56\2\uffff\1\56";
892     static final String DFA12_maxS =
893         "\2\71\2\145\2\uffff\1\145";
894     static final String DFA12_acceptS =
895         "\4\uffff\1\1\1\2\1\uffff";
896     static final String DFA12_specialS =
897         "\7\uffff}>";
898     static final String[] DFA12_transitionS = {
899             "\1\1\2\uffff\1\2\11\3",
900             "\1\2\11\3",
901             "\1\5\26\uffff\1\5\37\uffff\1\5",
902             "\1\5\1\uffff\12\6\13\uffff\1\5\37\uffff\1\5",
903             "",
904             "",
905             "\1\5\1\uffff\12\6\13\uffff\1\5\37\uffff\1\5"
906     };
907 
908     static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
909     static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
910     static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
911     static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
912     static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
913     static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
914     static final short[][] DFA12_transition;
915 
916     static {
917         int numStates = DFA12_transitionS.length;
918         DFA12_transition = new short[numStates][];
919         for (int i=0; i<numStates; i++) {
920             DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
921         }
922     }
923 
924     class DFA12 extends DFA {
925 
926         public DFA12(BaseRecognizer recognizer) {
927             this.recognizer = recognizer;
928             this.decisionNumber = 12;
929             this.eot = DFA12_eot;
930             this.eof = DFA12_eof;
931             this.min = DFA12_min;
932             this.max = DFA12_max;
933             this.accept = DFA12_accept;
934             this.special = DFA12_special;
935             this.transition = DFA12_transition;
936         }
937         public String getDescription() {
938             return "94:1: Number : ( Integer | Double );";
939         }
940     }
941     static final String DFA14_eotS =
942         "\5\uffff\1\10\2\11\2\uffff\1\10\1\11\1\10\1\11";
943     static final String DFA14_eofS =
944         "\16\uffff";
945     static final String DFA14_minS =
946         "\1\11\4\uffff\1\60\2\54\2\uffff\1\53\1\54\1\60\1\54";
947     static final String DFA14_maxS =
948         "\1\172\4\uffff\1\71\2\172\2\uffff\1\71\1\172\1\71\1\172";
949     static final String DFA14_acceptS =
950         "\1\uffff\1\1\1\2\1\3\1\4\3\uffff\1\6\1\5\4\uffff";
951     static final String DFA14_specialS =
952         "\16\uffff}>";
953     static final String[] DFA14_transitionS = {
954             "\2\3\1\uffff\2\3\22\uffff\1\3\1\uffff\1\4\11\uffff\1\10\1\5"+
955             "\1\2\1\uffff\1\6\11\7\1\10\2\uffff\1\1\3\uffff\32\10\6\uffff"+
956             "\32\10",
957             "",
958             "",
959             "",
960             "",
961             "\1\6\11\7",
962             "\2\10\2\uffff\13\10\6\uffff\4\10\1\12\25\10\6\uffff\4\10\1"+
963             "\12\25\10",
964             "\2\10\2\uffff\12\13\1\10\6\uffff\4\10\1\12\25\10\6\uffff\4"+
965             "\10\1\12\25\10",
966             "",
967             "",
968             "\1\11\1\uffff\1\14\2\uffff\12\15",
969             "\2\10\2\uffff\12\13\1\10\6\uffff\4\10\1\12\25\10\6\uffff\4"+
970             "\10\1\12\25\10",
971             "\12\15",
972             "\2\10\2\uffff\12\15\1\10\6\uffff\32\10\6\uffff\32\10"
973     };
974 
975     static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS);
976     static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS);
977     static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS);
978     static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS);
979     static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS);
980     static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS);
981     static final short[][] DFA14_transition;
982 
983     static {
984         int numStates = DFA14_transitionS.length;
985         DFA14_transition = new short[numStates][];
986         for (int i=0; i<numStates; i++) {
987             DFA14_transition[i] = DFA.unpackEncodedString(DFA14_transitionS[i]);
988         }
989     }
990 
991     class DFA14 extends DFA {
992 
993         public DFA14(BaseRecognizer recognizer) {
994             this.recognizer = recognizer;
995             this.decisionNumber = 14;
996             this.eot = DFA14_eot;
997             this.eof = DFA14_eof;
998             this.min = DFA14_min;
999             this.max = DFA14_max;
1000             this.accept = DFA14_accept;
1001             this.special = DFA14_special;
1002             this.transition = DFA14_transition;
1003         }
1004         public String getDescription() {
1005             return "1:1: Tokens : ( Eq | Dot | WhiteSpace | String | Number | QName );";
1006         }
1007     }
1008  
1009 
1010 }