GC: ActionLexer - org.antlr.stringtemplate.language.ActionLexer (.java)

Maven-Central
/
com.ning.billing /.....bundles-analytics
/
0.2.1

0.5.13
0.5.0
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.3.6
0.3.5
0.3.4
0.3.3
0.3.2
0.3.1
0.3.0
0.2.2
0.2.1
0.2.0
/
org.antlr.stringtemplate.language.ActionLexer
Find Usages
Diff
Raw
Download
HTML Widget
Stack Overflow Questions
1
   // $ANTLR 2.7.7 (20060906): "action.g" -> "ActionLexer.java"$
2
   
3
   /*
4
    [The "BSD licence"]
5
    Copyright (c) 2003-2004 Terence Parr
6
    All rights reserved.
7
   
8
    Redistribution and use in source and binary forms, with or without
9
    modification, are permitted provided that the following conditions
10
   are met:
11
   1. Redistributions of source code must retain the above copyright
12
      notice, this list of conditions and the following disclaimer.
13
   2. Redistributions in binary form must reproduce the above copyright
14
      notice, this list of conditions and the following disclaimer in the
15
      documentation and/or other materials provided with the distribution.
16
   3. The name of the author may not be used to endorse or promote products
17
      derived from this software without specific prior written permission.
18
  
19
   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20
   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21
   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22
   IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23
   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24
   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28
   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
  */
30
  package org.antlr.stringtemplate.language;
31
  import org.antlr.stringtemplate.*;
32
  import java.util.*;
33
  
34
  import java.io.InputStream;
35
  import antlr.TokenStreamException;
36
  import antlr.TokenStreamIOException;
37
  import antlr.TokenStreamRecognitionException;
38
  import antlr.CharStreamException;
39
  import antlr.CharStreamIOException;
40
  import antlr.ANTLRException;
41
  import java.io.Reader;
42
  import java.util.Hashtable;
43
  import antlr.CharScanner;
44
  import antlr.InputBuffer;
45
  import antlr.ByteBuffer;
46
  import antlr.CharBuffer;
47
  import antlr.Token;
48
  import antlr.CommonToken;
49
  import antlr.RecognitionException;
50
  import antlr.NoViableAltForCharException;
51
  import antlr.MismatchedCharException;
52
  import antlr.TokenStream;
53
  import antlr.ANTLRHashString;
54
  import antlr.LexerSharedInputState;
55
  import antlr.collections.impl.BitSet;
56
  import antlr.SemanticException;
57
  
58
  public class ActionLexer extends antlr.CharScanner implements ActionParserTokenTypes, TokenStream
59
   {
60
  public ActionLexer(InputStream in) {
61
  	this(new ByteBuffer(in));
62
  }
63
  public ActionLexer(Reader in) {
64
  	this(new CharBuffer(in));
65
  }
66
  public ActionLexer(InputBuffer ib) {
67
  	this(new LexerSharedInputState(ib));
68
  }
69
  public ActionLexer(LexerSharedInputState state) {
70
  	super(state);
71
  	caseSensitiveLiterals = true;
72
  	setCaseSensitive(true);
73
  	literals = new Hashtable();
74
  	literals.put(new ANTLRHashString("super", this), new Integer(32));
75
  	literals.put(new ANTLRHashString("if", this), new Integer(8));
76
  	literals.put(new ANTLRHashString("first", this), new Integer(26));
77
  	literals.put(new ANTLRHashString("last", this), new Integer(28));
78
  	literals.put(new ANTLRHashString("rest", this), new Integer(27));
79
  	literals.put(new ANTLRHashString("trunc", this), new Integer(31));
80
  	literals.put(new ANTLRHashString("strip", this), new Integer(30));
81
  	literals.put(new ANTLRHashString("length", this), new Integer(29));
82
  	literals.put(new ANTLRHashString("elseif", this), new Integer(18));
83
  }
84
  
85
  public Token nextToken() throws TokenStreamException {
86
  	Token theRetToken=null;
87
  tryAgain:
88
  	for (;;) {
89
  		Token _token = null;
90
  		int _ttype = Token.INVALID_TYPE;
91
  		resetText();
92
  		try {   // for char stream error handling
93
  			try {   // for lexical error handling
94
  				switch ( LA(1)) {
95
  				case 'A':  case 'B':  case 'C':  case 'D':
96
  				case 'E':  case 'F':  case 'G':  case 'H':
97
  				case 'I':  case 'J':  case 'K':  case 'L':
98
  				case 'M':  case 'N':  case 'O':  case 'P':
99
  				case 'Q':  case 'R':  case 'S':  case 'T':
100
 				case 'U':  case 'V':  case 'W':  case 'X':
101
 				case 'Y':  case 'Z':  case '_':  case 'a':
102
 				case 'b':  case 'c':  case 'd':  case 'e':
103
 				case 'f':  case 'g':  case 'h':  case 'i':
104
 				case 'j':  case 'k':  case 'l':  case 'm':
105
 				case 'n':  case 'o':  case 'p':  case 'q':
106
 				case 'r':  case 's':  case 't':  case 'u':
107
 				case 'v':  case 'w':  case 'x':  case 'y':
108
 				case 'z':
109
 				{
110
 					mID(true);
111
 					theRetToken=_returnToken;
112
 					break;
113
 				}
114
 				case '0':  case '1':  case '2':  case '3':
115
 				case '4':  case '5':  case '6':  case '7':
116
 				case '8':  case '9':
117
 				{
118
 					mINT(true);
119
 					theRetToken=_returnToken;
120
 					break;
121
 				}
122
 				case '"':
123
 				{
124
 					mSTRING(true);
125
 					theRetToken=_returnToken;
126
 					break;
127
 				}
128
 				case '{':
129
 				{
130
 					mANONYMOUS_TEMPLATE(true);
131
 					theRetToken=_returnToken;
132
 					break;
133
 				}
134
 				case '[':
135
 				{
136
 					mLBRACK(true);
137
 					theRetToken=_returnToken;
138
 					break;
139
 				}
140
 				case ']':
141
 				{
142
 					mRBRACK(true);
143
 					theRetToken=_returnToken;
144
 					break;
145
 				}
146
 				case '(':
147
 				{
148
 					mLPAREN(true);
149
 					theRetToken=_returnToken;
150
 					break;
151
 				}
152
 				case ')':
153
 				{
154
 					mRPAREN(true);
155
 					theRetToken=_returnToken;
156
 					break;
157
 				}
158
 				case ',':
159
 				{
160
 					mCOMMA(true);
161
 					theRetToken=_returnToken;
162
 					break;
163
 				}
164
 				case '=':
165
 				{
166
 					mASSIGN(true);
167
 					theRetToken=_returnToken;
168
 					break;
169
 				}
170
 				case ':':
171
 				{
172
 					mCOLON(true);
173
 					theRetToken=_returnToken;
174
 					break;
175
 				}
176
 				case '+':
177
 				{
178
 					mPLUS(true);
179
 					theRetToken=_returnToken;
180
 					break;
181
 				}
182
 				case ';':
183
 				{
184
 					mSEMI(true);
185
 					theRetToken=_returnToken;
186
 					break;
187
 				}
188
 				case '!':
189
 				{
190
 					mNOT(true);
191
 					theRetToken=_returnToken;
192
 					break;
193
 				}
194
 				case '\t':  case '\n':  case '\r':  case ' ':
195
 				{
196
 					mWS(true);
197
 					theRetToken=_returnToken;
198
 					break;
199
 				}
200
 				default:
201
 					if ((LA(1)=='.') && (LA(2)=='.')) {
202
 						mDOTDOTDOT(true);
203
 						theRetToken=_returnToken;
204
 					}
205
 					else if ((LA(1)=='.') && (true)) {
206
 						mDOT(true);
207
 						theRetToken=_returnToken;
208
 					}
209
 				else {
210
 					if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
211
 				else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
212
 				}
213
 				}
214
 				if ( _returnToken==null ) continue tryAgain; // found SKIP token
215
 				_ttype = _returnToken.getType();
216
 				_returnToken.setType(_ttype);
217
 				return _returnToken;
218
 			}
219
 			catch (RecognitionException e) {
220
 				throw new TokenStreamRecognitionException(e);
221
 			}
222
 		}
223
 		catch (CharStreamException cse) {
224
 			if ( cse instanceof CharStreamIOException ) {
225
 				throw new TokenStreamIOException(((CharStreamIOException)cse).io);
226
 			}
227
 			else {
228
 				throw new TokenStreamException(cse.getMessage());
229
 			}
230
 		}
231
 	}
232
 }
233
 
234
 	public final void mID(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
235
 		int _ttype; Token _token=null; int _begin=text.length();
236
 		_ttype = ID;
237
 		int _saveIndex;
238
 		
239
 		{
240
 		switch ( LA(1)) {
241
 		case 'a':  case 'b':  case 'c':  case 'd':
242
 		case 'e':  case 'f':  case 'g':  case 'h':
243
 		case 'i':  case 'j':  case 'k':  case 'l':
244
 		case 'm':  case 'n':  case 'o':  case 'p':
245
 		case 'q':  case 'r':  case 's':  case 't':
246
 		case 'u':  case 'v':  case 'w':  case 'x':
247
 		case 'y':  case 'z':
248
 		{
249
 			matchRange('a','z');
250
 			break;
251
 		}
252
 		case 'A':  case 'B':  case 'C':  case 'D':
253
 		case 'E':  case 'F':  case 'G':  case 'H':
254
 		case 'I':  case 'J':  case 'K':  case 'L':
255
 		case 'M':  case 'N':  case 'O':  case 'P':
256
 		case 'Q':  case 'R':  case 'S':  case 'T':
257
 		case 'U':  case 'V':  case 'W':  case 'X':
258
 		case 'Y':  case 'Z':
259
 		{
260
 			matchRange('A','Z');
261
 			break;
262
 		}
263
 		case '_':
264
 		{
265
 			match('_');
266
 			break;
267
 		}
268
 		default:
269
 		{
270
 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
271
 		}
272
 		}
273
 		}
274
 		{
275
 		_loop60:
276
 		do {
277
 			switch ( LA(1)) {
278
 			case 'a':  case 'b':  case 'c':  case 'd':
279
 			case 'e':  case 'f':  case 'g':  case 'h':
280
 			case 'i':  case 'j':  case 'k':  case 'l':
281
 			case 'm':  case 'n':  case 'o':  case 'p':
282
 			case 'q':  case 'r':  case 's':  case 't':
283
 			case 'u':  case 'v':  case 'w':  case 'x':
284
 			case 'y':  case 'z':
285
 			{
286
 				matchRange('a','z');
287
 				break;
288
 			}
289
 			case 'A':  case 'B':  case 'C':  case 'D':
290
 			case 'E':  case 'F':  case 'G':  case 'H':
291
 			case 'I':  case 'J':  case 'K':  case 'L':
292
 			case 'M':  case 'N':  case 'O':  case 'P':
293
 			case 'Q':  case 'R':  case 'S':  case 'T':
294
 			case 'U':  case 'V':  case 'W':  case 'X':
295
 			case 'Y':  case 'Z':
296
 			{
297
 				matchRange('A','Z');
298
 				break;
299
 			}
300
 			case '0':  case '1':  case '2':  case '3':
301
 			case '4':  case '5':  case '6':  case '7':
302
 			case '8':  case '9':
303
 			{
304
 				matchRange('0','9');
305
 				break;
306
 			}
307
 			case '_':
308
 			{
309
 				match('_');
310
 				break;
311
 			}
312
 			case '/':
313
 			{
314
 				match('/');
315
 				break;
316
 			}
317
 			default:
318
 			{
319
 				break _loop60;
320
 			}
321
 			}
322
 		} while (true);
323
 		}
324
 		_ttype = testLiteralsTable(_ttype);
325
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
326
 			_token = makeToken(_ttype);
327
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
328
 		}
329
 		_returnToken = _token;
330
 	}
331
 	
332
 	public final void mINT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
333
 		int _ttype; Token _token=null; int _begin=text.length();
334
 		_ttype = INT;
335
 		int _saveIndex;
336
 		
337
 		{
338
 		int _cnt63=0;
339
 		_loop63:
340
 		do {
341
 			if (((LA(1) >= '0' && LA(1) <= '9'))) {
342
 				matchRange('0','9');
343
 			}
344
 			else {
345
 				if ( _cnt63>=1 ) { break _loop63; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
346
 			}
347
 			
348
 			_cnt63++;
349
 		} while (true);
350
 		}
351
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
352
 			_token = makeToken(_ttype);
353
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
354
 		}
355
 		_returnToken = _token;
356
 	}
357
 	
358
 	public final void mSTRING(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
359
 		int _ttype; Token _token=null; int _begin=text.length();
360
 		_ttype = STRING;
361
 		int _saveIndex;
362
 		
363
 		_saveIndex=text.length();
364
 		match('"');
365
 		text.setLength(_saveIndex);
366
 		{
367
 		_loop66:
368
 		do {
369
 			if ((LA(1)=='\\')) {
370
 				mESC_CHAR(false,true);
371
 			}
372
 			else if ((_tokenSet_0.member(LA(1)))) {
373
 				matchNot('"');
374
 			}
375
 			else {
376
 				break _loop66;
377
 			}
378
 			
379
 		} while (true);
380
 		}
381
 		_saveIndex=text.length();
382
 		match('"');
383
 		text.setLength(_saveIndex);
384
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
385
 			_token = makeToken(_ttype);
386
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
387
 		}
388
 		_returnToken = _token;
389
 	}
	
Match escape sequences, optionally translating them for strings, but not
  for templates.  Do \} only when in {...} templates.
393
 
394
 	protected final void mESC_CHAR(boolean _createToken,
395
 		boolean doEscape
396
 	) throws RecognitionException, CharStreamException, TokenStreamException {
397
 		int _ttype; Token _token=null; int _begin=text.length();
398
 		_ttype = ESC_CHAR;
399
 		int _saveIndex;
400
 		char  c = '\0';
401
 		
402
 		match('\\');
403
 		{
404
 		if ((LA(1)=='n') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
405
 			match('n');
406
 			if ( inputState.guessing==0 ) {
407
 				if (doEscape) { text.setLength(_begin); text.append("\n"); }
408
 			}
409
 		}
410
 		else if ((LA(1)=='r') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
411
 			match('r');
412
 			if ( inputState.guessing==0 ) {
413
 				if (doEscape) { text.setLength(_begin); text.append("\r"); }
414
 			}
415
 		}
416
 		else if ((LA(1)=='t') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
417
 			match('t');
418
 			if ( inputState.guessing==0 ) {
419
 				if (doEscape) { text.setLength(_begin); text.append("\t"); }
420
 			}
421
 		}
422
 		else if ((LA(1)=='b') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
423
 			match('b');
424
 			if ( inputState.guessing==0 ) {
425
 				if (doEscape) { text.setLength(_begin); text.append("\b"); }
426
 			}
427
 		}
428
 		else if ((LA(1)=='f') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
429
 			match('f');
430
 			if ( inputState.guessing==0 ) {
431
 				if (doEscape) { text.setLength(_begin); text.append("\f"); }
432
 			}
433
 		}
434
 		else if (((LA(1) >= '\u0003' && LA(1) <= '\ufffe')) && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
435
 			c = LA(1);
436
 			matchNot(EOF_CHAR);
437
 			if ( inputState.guessing==0 ) {
438
 				if (doEscape) {text.setLength(_begin); text.append(String.valueOf(c));}
439
 			}
440
 		}
441
 		else {
442
 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
443
 		}
444
 		
445
 		}
446
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
447
 			_token = makeToken(_ttype);
448
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
449
 		}
450
 		_returnToken = _token;
451
 	}
452
 	
453
 	public final void mANONYMOUS_TEMPLATE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
454
 		int _ttype; Token _token=null; int _begin=text.length();
455
 		_ttype = ANONYMOUS_TEMPLATE;
456
 		int _saveIndex;
457
 		
458
 		List args=null;
459
 		StringTemplateToken t = null;
460
 		
461
 		
462
 		_saveIndex=text.length();
463
 		match('{');
464
 		text.setLength(_saveIndex);
465
 		{
466
 		boolean synPredMatched70 = false;
467
 		if (((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))))) {
468
 			int _m70 = mark();
469
 			synPredMatched70 = true;
470
 			inputState.guessing++;
471
 			try {
472
 				{
473
 				mTEMPLATE_ARGS(false);
474
 				}
475
 			}
476
 			catch (RecognitionException pe) {
477
 				synPredMatched70 = false;
478
 			}
479
 			rewind(_m70);
480
 inputState.guessing--;
481
 		}
482
 		if ( synPredMatched70 ) {
483
 			args=mTEMPLATE_ARGS(false);
484
 			{
485
 			if ((_tokenSet_3.member(LA(1))) && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
486
 				_saveIndex=text.length();
487
 				mWS_CHAR(false);
488
 				text.setLength(_saveIndex);
489
 			}
490
 			else if (((LA(1) >= '\u0003' && LA(1) <= '\ufffe')) && (true)) {
491
 			}
492
 			else {
493
 				throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
494
 			}
495
 			
496
 			}
497
 			if ( inputState.guessing==0 ) {
498
 				
499
 					          // create a special token to track args
500
 					          t = new StringTemplateToken(ANONYMOUS_TEMPLATE,new String(text.getBuffer(),_begin,text.length()-_begin),args);
501
 					          _token = t;
502
 					
503
 			}
504
 		}
505
 		else if (((LA(1) >= '\u0003' && LA(1) <= '\ufffe')) && (true)) {
506
 		}
507
 		else {
508
 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
509
 		}
510
 		
511
 		}
512
 		{
513
 		_loop73:
514
 		do {
515
 			if ((LA(1)=='\\') && (LA(2)=='{')) {
516
 				_saveIndex=text.length();
517
 				match('\\');
518
 				text.setLength(_saveIndex);
519
 				match('{');
520
 			}
521
 			else if ((LA(1)=='\\') && (LA(2)=='}')) {
522
 				_saveIndex=text.length();
523
 				match('\\');
524
 				text.setLength(_saveIndex);
525
 				match('}');
526
 			}
527
 			else if ((LA(1)=='\\') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
528
 				mESC_CHAR(false,false);
529
 			}
530
 			else if ((LA(1)=='{')) {
531
 				mNESTED_ANONYMOUS_TEMPLATE(false);
532
 			}
533
 			else if ((_tokenSet_4.member(LA(1)))) {
534
 				matchNot('}');
535
 			}
536
 			else {
537
 				break _loop73;
538
 			}
539
 			
540
 		} while (true);
541
 		}
542
 		if ( inputState.guessing==0 ) {
543
 			
544
 				        if ( t!=null ) {
545
 				        	t.setText(new String(text.getBuffer(),_begin,text.length()-_begin));
546
 				        }
547
 				
548
 		}
549
 		_saveIndex=text.length();
550
 		match('}');
551
 		text.setLength(_saveIndex);
552
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
553
 			_token = makeToken(_ttype);
554
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
555
 		}
556
 		_returnToken = _token;
557
 	}
558
 	
559
 	protected final List  mTEMPLATE_ARGS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
560
 		List args=new ArrayList();
561
 		int _ttype; Token _token=null; int _begin=text.length();
562
 		_ttype = TEMPLATE_ARGS;
563
 		int _saveIndex;
564
 		Token a=null;
565
 		Token a2=null;
566
 		
567
 		{
568
 		switch ( LA(1)) {
569
 		case '\t':  case '\n':  case '\r':  case ' ':
570
 		{
571
 			_saveIndex=text.length();
572
 			mWS_CHAR(false);
573
 			text.setLength(_saveIndex);
574
 			break;
575
 		}
576
 		case 'A':  case 'B':  case 'C':  case 'D':
577
 		case 'E':  case 'F':  case 'G':  case 'H':
578
 		case 'I':  case 'J':  case 'K':  case 'L':
579
 		case 'M':  case 'N':  case 'O':  case 'P':
580
 		case 'Q':  case 'R':  case 'S':  case 'T':
581
 		case 'U':  case 'V':  case 'W':  case 'X':
582
 		case 'Y':  case 'Z':  case '_':  case 'a':
583
 		case 'b':  case 'c':  case 'd':  case 'e':
584
 		case 'f':  case 'g':  case 'h':  case 'i':
585
 		case 'j':  case 'k':  case 'l':  case 'm':
586
 		case 'n':  case 'o':  case 'p':  case 'q':
587
 		case 'r':  case 's':  case 't':  case 'u':
588
 		case 'v':  case 'w':  case 'x':  case 'y':
589
 		case 'z':
590
 		{
591
 			break;
592
 		}
593
 		default:
594
 		{
595
 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
596
 		}
597
 		}
598
 		}
599
 		_saveIndex=text.length();
600
 		mID(true);
601
 		text.setLength(_saveIndex);
602
 		a=_returnToken;
603
 		if ( inputState.guessing==0 ) {
604
 			args.add(a.getText());
605
 		}
606
 		{
607
 		_loop79:
608
 		do {
609
 			if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
610
 				{
611
 				switch ( LA(1)) {
612
 				case '\t':  case '\n':  case '\r':  case ' ':
613
 				{
614
 					_saveIndex=text.length();
615
 					mWS_CHAR(false);
616
 					text.setLength(_saveIndex);
617
 					break;
618
 				}
619
 				case ',':
620
 				{
621
 					break;
622
 				}
623
 				default:
624
 				{
625
 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
626
 				}
627
 				}
628
 				}
629
 				_saveIndex=text.length();
630
 				match(',');
631
 				text.setLength(_saveIndex);
632
 				{
633
 				switch ( LA(1)) {
634
 				case '\t':  case '\n':  case '\r':  case ' ':
635
 				{
636
 					_saveIndex=text.length();
637
 					mWS_CHAR(false);
638
 					text.setLength(_saveIndex);
639
 					break;
640
 				}
641
 				case 'A':  case 'B':  case 'C':  case 'D':
642
 				case 'E':  case 'F':  case 'G':  case 'H':
643
 				case 'I':  case 'J':  case 'K':  case 'L':
644
 				case 'M':  case 'N':  case 'O':  case 'P':
645
 				case 'Q':  case 'R':  case 'S':  case 'T':
646
 				case 'U':  case 'V':  case 'W':  case 'X':
647
 				case 'Y':  case 'Z':  case '_':  case 'a':
648
 				case 'b':  case 'c':  case 'd':  case 'e':
649
 				case 'f':  case 'g':  case 'h':  case 'i':
650
 				case 'j':  case 'k':  case 'l':  case 'm':
651
 				case 'n':  case 'o':  case 'p':  case 'q':
652
 				case 'r':  case 's':  case 't':  case 'u':
653
 				case 'v':  case 'w':  case 'x':  case 'y':
654
 				case 'z':
655
 				{
656
 					break;
657
 				}
658
 				default:
659
 				{
660
 					throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
661
 				}
662
 				}
663
 				}
664
 				_saveIndex=text.length();
665
 				mID(true);
666
 				text.setLength(_saveIndex);
667
 				a2=_returnToken;
668
 				if ( inputState.guessing==0 ) {
669
 					args.add(a2.getText());
670
 				}
671
 			}
672
 			else {
673
 				break _loop79;
674
 			}
675
 			
676
 		} while (true);
677
 		}
678
 		{
679
 		switch ( LA(1)) {
680
 		case '\t':  case '\n':  case '\r':  case ' ':
681
 		{
682
 			_saveIndex=text.length();
683
 			mWS_CHAR(false);
684
 			text.setLength(_saveIndex);
685
 			break;
686
 		}
687
 		case '|':
688
 		{
689
 			break;
690
 		}
691
 		default:
692
 		{
693
 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
694
 		}
695
 		}
696
 		}
697
 		_saveIndex=text.length();
698
 		match('|');
699
 		text.setLength(_saveIndex);
700
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
701
 			_token = makeToken(_ttype);
702
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
703
 		}
704
 		_returnToken = _token;
705
 		return args;
706
 	}
707
 	
708
 	protected final void mWS_CHAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
709
 		int _ttype; Token _token=null; int _begin=text.length();
710
 		_ttype = WS_CHAR;
711
 		int _saveIndex;
712
 		
713
 		switch ( LA(1)) {
714
 		case ' ':
715
 		{
716
 			match(' ');
717
 			break;
718
 		}
719
 		case '\t':
720
 		{
721
 			match('\t');
722
 			break;
723
 		}
724
 		case '\r':
725
 		{
726
 			match('\r');
727
 			break;
728
 		}
729
 		case '\n':
730
 		{
731
 			match('\n');
732
 			if ( inputState.guessing==0 ) {
733
 				newline();
734
 			}
735
 			break;
736
 		}
737
 		default:
738
 		{
739
 			throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
740
 		}
741
 		}
742
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
743
 			_token = makeToken(_ttype);
744
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
745
 		}
746
 		_returnToken = _token;
747
 	}
748
 	
749
 	protected final void mNESTED_ANONYMOUS_TEMPLATE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
750
 		int _ttype; Token _token=null; int _begin=text.length();
751
 		_ttype = NESTED_ANONYMOUS_TEMPLATE;
752
 		int _saveIndex;
753
 		
754
 		match('{');
755
 		{
756
 		_loop83:
757
 		do {
758
 			if ((LA(1)=='\\') && (LA(2)=='{')) {
759
 				_saveIndex=text.length();
760
 				match('\\');
761
 				text.setLength(_saveIndex);
762
 				match('{');
763
 			}
764
 			else if ((LA(1)=='\\') && (LA(2)=='}')) {
765
 				_saveIndex=text.length();
766
 				match('\\');
767
 				text.setLength(_saveIndex);
768
 				match('}');
769
 			}
770
 			else if ((LA(1)=='\\') && ((LA(2) >= '\u0003' && LA(2) <= '\ufffe'))) {
771
 				mESC_CHAR(false,false);
772
 			}
773
 			else if ((LA(1)=='{')) {
774
 				mNESTED_ANONYMOUS_TEMPLATE(false);
775
 			}
776
 			else if ((_tokenSet_4.member(LA(1)))) {
777
 				matchNot('}');
778
 			}
779
 			else {
780
 				break _loop83;
781
 			}
782
 			
783
 		} while (true);
784
 		}
785
 		match('}');
786
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
787
 			_token = makeToken(_ttype);
788
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
789
 		}
790
 		_returnToken = _token;
791
 	}
792
 	
793
 	public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
794
 		int _ttype; Token _token=null; int _begin=text.length();
795
 		_ttype = LBRACK;
796
 		int _saveIndex;
797
 		
798
 		match('[');
799
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
800
 			_token = makeToken(_ttype);
801
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
802
 		}
803
 		_returnToken = _token;
804
 	}
805
 	
806
 	public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
807
 		int _ttype; Token _token=null; int _begin=text.length();
808
 		_ttype = RBRACK;
809
 		int _saveIndex;
810
 		
811
 		match(']');
812
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
813
 			_token = makeToken(_ttype);
814
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
815
 		}
816
 		_returnToken = _token;
817
 	}
818
 	
819
 	public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
820
 		int _ttype; Token _token=null; int _begin=text.length();
821
 		_ttype = LPAREN;
822
 		int _saveIndex;
823
 		
824
 		match('(');
825
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
826
 			_token = makeToken(_ttype);
827
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
828
 		}
829
 		_returnToken = _token;
830
 	}
831
 	
832
 	public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
833
 		int _ttype; Token _token=null; int _begin=text.length();
834
 		_ttype = RPAREN;
835
 		int _saveIndex;
836
 		
837
 		match(')');
838
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
839
 			_token = makeToken(_ttype);
840
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
841
 		}
842
 		_returnToken = _token;
843
 	}
844
 	
845
 	public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
846
 		int _ttype; Token _token=null; int _begin=text.length();
847
 		_ttype = COMMA;
848
 		int _saveIndex;
849
 		
850
 		match(',');
851
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
852
 			_token = makeToken(_ttype);
853
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
854
 		}
855
 		_returnToken = _token;
856
 	}
857
 	
858
 	public final void mDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
859
 		int _ttype; Token _token=null; int _begin=text.length();
860
 		_ttype = DOT;
861
 		int _saveIndex;
862
 		
863
 		match('.');
864
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
865
 			_token = makeToken(_ttype);
866
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
867
 		}
868
 		_returnToken = _token;
869
 	}
870
 	
871
 	public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
872
 		int _ttype; Token _token=null; int _begin=text.length();
873
 		_ttype = ASSIGN;
874
 		int _saveIndex;
875
 		
876
 		match('=');
877
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
878
 			_token = makeToken(_ttype);
879
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
880
 		}
881
 		_returnToken = _token;
882
 	}
883
 	
884
 	public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
885
 		int _ttype; Token _token=null; int _begin=text.length();
886
 		_ttype = COLON;
887
 		int _saveIndex;
888
 		
889
 		match(':');
890
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
891
 			_token = makeToken(_ttype);
892
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
893
 		}
894
 		_returnToken = _token;
895
 	}
896
 	
897
 	public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
898
 		int _ttype; Token _token=null; int _begin=text.length();
899
 		_ttype = PLUS;
900
 		int _saveIndex;
901
 		
902
 		match('+');
903
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
904
 			_token = makeToken(_ttype);
905
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
906
 		}
907
 		_returnToken = _token;
908
 	}
909
 	
910
 	public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
911
 		int _ttype; Token _token=null; int _begin=text.length();
912
 		_ttype = SEMI;
913
 		int _saveIndex;
914
 		
915
 		match(';');
916
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
917
 			_token = makeToken(_ttype);
918
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
919
 		}
920
 		_returnToken = _token;
921
 	}
922
 	
923
 	public final void mNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
924
 		int _ttype; Token _token=null; int _begin=text.length();
925
 		_ttype = NOT;
926
 		int _saveIndex;
927
 		
928
 		match('!');
929
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
930
 			_token = makeToken(_ttype);
931
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
932
 		}
933
 		_returnToken = _token;
934
 	}
935
 	
936
 	public final void mDOTDOTDOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
937
 		int _ttype; Token _token=null; int _begin=text.length();
938
 		_ttype = DOTDOTDOT;
939
 		int _saveIndex;
940
 		
941
 		match("...");
942
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
943
 			_token = makeToken(_ttype);
944
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
945
 		}
946
 		_returnToken = _token;
947
 	}
948
 	
949
 	public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
950
 		int _ttype; Token _token=null; int _begin=text.length();
951
 		_ttype = WS;
952
 		int _saveIndex;
953
 		
954
 		{
955
 		int _cnt100=0;
956
 		_loop100:
957
 		do {
958
 			switch ( LA(1)) {
959
 			case ' ':
960
 			{
961
 				match(' ');
962
 				break;
963
 			}
964
 			case '\t':
965
 			{
966
 				match('\t');
967
 				break;
968
 			}
969
 			case '\r':
970
 			{
971
 				match('\r');
972
 				break;
973
 			}
974
 			case '\n':
975
 			{
976
 				match('\n');
977
 				if ( inputState.guessing==0 ) {
978
 					newline();
979
 				}
980
 				break;
981
 			}
982
 			default:
983
 			{
984
 				if ( _cnt100>=1 ) { break _loop100; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
985
 			}
986
 			}
987
 			_cnt100++;
988
 		} while (true);
989
 		}
990
 		if ( inputState.guessing==0 ) {
991
 			_ttype = Token.SKIP;
992
 		}
993
 		if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
994
 			_token = makeToken(_ttype);
995
 			_token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
996
 		}
997
 		_returnToken = _token;
998
 	}
999
 	
1000
	
1001
	private static final long[] mk_tokenSet_0() {
1002
		long[] data = new long[2048];
1003
		data[0]=-17179869192L;
1004
		data[1]=-268435457L;
1005
		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
1006
		data[1023]=9223372036854775807L;
1007
		return data;
1008
	}
1009
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1010
	private static final long[] mk_tokenSet_1() {
1011
		long[] data = new long[1025];
1012
		data[0]=4294977024L;
1013
		data[1]=576460745995190270L;
1014
		return data;
1015
	}
1016
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1017
	private static final long[] mk_tokenSet_2() {
1018
		long[] data = new long[1025];
1019
		data[0]=288107235144377856L;
1020
		data[1]=1729382250602037246L;
1021
		return data;
1022
	}
1023
	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1024
	private static final long[] mk_tokenSet_3() {
1025
		long[] data = new long[1025];
1026
		data[0]=4294977024L;
1027
		return data;
1028
	}
1029
	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1030
	private static final long[] mk_tokenSet_4() {
1031
		long[] data = new long[2048];
1032
		data[0]=-8L;
1033
		data[1]=-2882303761785552897L;
1034
		for (int i = 2; i<=1022; i++) { data[i]=-1L; }
1035
		data[1023]=9223372036854775807L;
1036
		return data;
1037
	}
1038
	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1039
	private static final long[] mk_tokenSet_5() {
1040
		long[] data = new long[1025];
1041
		data[0]=17596481021440L;
1042
		return data;
1043
	}
1044
	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
1045
	private static final long[] mk_tokenSet_6() {
1046
		long[] data = new long[1025];
1047
		data[0]=17596481021440L;
1048
		data[1]=576460745995190270L;
1049
		return data;
1050
	}
1051
	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
1052
	
1053
	}