View | Details | Raw Unified | Return to bug 42565
Collapse All | Expand All

(-)ELParserTokenManager.java (-1393 / +1387 lines)
Lines 1-1403 Link Here
1
/* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
1
/* Generated By:JJTree&JavaCC: Do not edit this line. ELParserTokenManager.java */
2
package org.apache.el.parser;
2
package org.apache.el.parser;
3
import java.io.StringReader;
4
import javax.el.ELException;
3
5
4
public class ELParserTokenManager implements ELParserConstants {
6
public class ELParserTokenManager implements ELParserConstants
5
	public java.io.PrintStream debugStream = System.out;
7
{
8
  public  java.io.PrintStream debugStream = System.out;
9
  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
10
private final int jjStopStringLiteralDfa_1(int pos, long active0)
11
{
12
   switch (pos)
13
   {
14
      case 0:
15
         if ((active0 & 0x141d555401c000L) != 0L)
16
         {
17
            jjmatchedKind = 53;
18
            return 42;
19
         }
20
         if ((active0 & 0x40000L) != 0L)
21
            return 1;
22
         return -1;
23
      case 1:
24
         if ((active0 & 0x1419400001c000L) != 0L)
25
         {
26
            jjmatchedKind = 53;
27
            jjmatchedPos = 1;
28
            return 42;
29
         }
30
         if ((active0 & 0x41554000000L) != 0L)
31
            return 42;
32
         return -1;
33
      case 2:
34
         if ((active0 & 0x18000001c000L) != 0L)
35
         {
36
            jjmatchedKind = 53;
37
            jjmatchedPos = 2;
38
            return 42;
39
         }
40
         if ((active0 & 0x14014000000000L) != 0L)
41
            return 42;
42
         return -1;
43
      case 3:
44
         if ((active0 & 0x180000008000L) != 0L)
45
         {
46
            jjmatchedKind = 53;
47
            jjmatchedPos = 3;
48
            return 42;
49
         }
50
         if ((active0 & 0x14000L) != 0L)
51
            return 42;
52
         return -1;
53
      case 4:
54
         if ((active0 & 0x100000000000L) != 0L)
55
         {
56
            jjmatchedKind = 53;
57
            jjmatchedPos = 4;
58
            return 42;
59
         }
60
         if ((active0 & 0x80000008000L) != 0L)
61
            return 42;
62
         return -1;
63
      case 5:
64
         if ((active0 & 0x100000000000L) != 0L)
65
         {
66
            jjmatchedKind = 53;
67
            jjmatchedPos = 5;
68
            return 42;
69
         }
70
         return -1;
71
      case 6:
72
         if ((active0 & 0x100000000000L) != 0L)
73
         {
74
            jjmatchedKind = 53;
75
            jjmatchedPos = 6;
76
            return 42;
77
         }
78
         return -1;
79
      case 7:
80
         if ((active0 & 0x100000000000L) != 0L)
81
         {
82
            jjmatchedKind = 53;
83
            jjmatchedPos = 7;
84
            return 42;
85
         }
86
         return -1;
87
      case 8:
88
         if ((active0 & 0x100000000000L) != 0L)
89
         {
90
            jjmatchedKind = 53;
91
            jjmatchedPos = 8;
92
            return 42;
93
         }
94
         return -1;
95
      default :
96
         return -1;
97
   }
98
}
99
private final int jjStartNfa_1(int pos, long active0)
100
{
101
   return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
102
}
103
private final int jjStopAtPos(int pos, int kind)
104
{
105
   jjmatchedKind = kind;
106
   jjmatchedPos = pos;
107
   return pos + 1;
108
}
109
private final int jjStartNfaWithStates_1(int pos, int kind, int state)
110
{
111
   jjmatchedKind = kind;
112
   jjmatchedPos = pos;
113
   try { curChar = input_stream.readChar(); }
114
   catch(java.io.IOException e) { return pos + 1; }
115
   return jjMoveNfa_1(state, pos + 1);
116
}
117
private final int jjMoveStringLiteralDfa0_1()
118
{
119
   switch(curChar)
120
   {
121
      case 33:
122
         jjmatchedKind = 37;
123
         return jjMoveStringLiteralDfa1_1(0x800000000L);
124
      case 37:
125
         return jjStopAtPos(0, 51);
126
      case 38:
127
         return jjMoveStringLiteralDfa1_1(0x8000000000L);
128
      case 40:
129
         return jjStopAtPos(0, 19);
130
      case 41:
131
         return jjStopAtPos(0, 20);
132
      case 42:
133
         return jjStopAtPos(0, 45);
134
      case 43:
135
         return jjStopAtPos(0, 46);
136
      case 44:
137
         return jjStopAtPos(0, 24);
138
      case 45:
139
         return jjStopAtPos(0, 47);
140
      case 46:
141
         return jjStartNfaWithStates_1(0, 18, 1);
142
      case 47:
143
         return jjStopAtPos(0, 49);
144
      case 58:
145
         return jjStopAtPos(0, 23);
146
      case 60:
147
         jjmatchedKind = 27;
148
         return jjMoveStringLiteralDfa1_1(0x80000000L);
149
      case 61:
150
         return jjMoveStringLiteralDfa1_1(0x200000000L);
151
      case 62:
152
         jjmatchedKind = 25;
153
         return jjMoveStringLiteralDfa1_1(0x20000000L);
154
      case 63:
155
         return jjStopAtPos(0, 48);
156
      case 91:
157
         return jjStopAtPos(0, 21);
158
      case 93:
159
         return jjStopAtPos(0, 22);
160
      case 97:
161
         return jjMoveStringLiteralDfa1_1(0x10000000000L);
162
      case 100:
163
         return jjMoveStringLiteralDfa1_1(0x4000000000000L);
164
      case 101:
165
         return jjMoveStringLiteralDfa1_1(0x80400000000L);
166
      case 102:
167
         return jjMoveStringLiteralDfa1_1(0x8000L);
168
      case 103:
169
         return jjMoveStringLiteralDfa1_1(0x44000000L);
170
      case 105:
171
         return jjMoveStringLiteralDfa1_1(0x100000000000L);
172
      case 108:
173
         return jjMoveStringLiteralDfa1_1(0x110000000L);
174
      case 109:
175
         return jjMoveStringLiteralDfa1_1(0x10000000000000L);
176
      case 110:
177
         return jjMoveStringLiteralDfa1_1(0x5000010000L);
178
      case 111:
179
         return jjMoveStringLiteralDfa1_1(0x40000000000L);
180
      case 116:
181
         return jjMoveStringLiteralDfa1_1(0x4000L);
182
      case 124:
183
         return jjMoveStringLiteralDfa1_1(0x20000000000L);
184
      case 125:
185
         return jjStopAtPos(0, 17);
186
      default :
187
         return jjMoveNfa_1(0, 0);
188
   }
189
}
190
private final int jjMoveStringLiteralDfa1_1(long active0)
191
{
192
   try { curChar = input_stream.readChar(); }
193
   catch(java.io.IOException e) {
194
      jjStopStringLiteralDfa_1(0, active0);
195
      return 1;
196
   }
197
   switch(curChar)
198
   {
199
      case 38:
200
         if ((active0 & 0x8000000000L) != 0L)
201
            return jjStopAtPos(1, 39);
202
         break;
203
      case 61:
204
         if ((active0 & 0x20000000L) != 0L)
205
            return jjStopAtPos(1, 29);
206
         else if ((active0 & 0x80000000L) != 0L)
207
            return jjStopAtPos(1, 31);
208
         else if ((active0 & 0x200000000L) != 0L)
209
            return jjStopAtPos(1, 33);
210
         else if ((active0 & 0x800000000L) != 0L)
211
            return jjStopAtPos(1, 35);
212
         break;
213
      case 97:
214
         return jjMoveStringLiteralDfa2_1(active0, 0x8000L);
215
      case 101:
216
         if ((active0 & 0x40000000L) != 0L)
217
            return jjStartNfaWithStates_1(1, 30, 42);
218
         else if ((active0 & 0x100000000L) != 0L)
219
            return jjStartNfaWithStates_1(1, 32, 42);
220
         else if ((active0 & 0x1000000000L) != 0L)
221
            return jjStartNfaWithStates_1(1, 36, 42);
222
         break;
223
      case 105:
224
         return jjMoveStringLiteralDfa2_1(active0, 0x4000000000000L);
225
      case 109:
226
         return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L);
227
      case 110:
228
         return jjMoveStringLiteralDfa2_1(active0, 0x110000000000L);
229
      case 111:
230
         return jjMoveStringLiteralDfa2_1(active0, 0x10004000000000L);
231
      case 113:
232
         if ((active0 & 0x400000000L) != 0L)
233
            return jjStartNfaWithStates_1(1, 34, 42);
234
         break;
235
      case 114:
236
         if ((active0 & 0x40000000000L) != 0L)
237
            return jjStartNfaWithStates_1(1, 42, 42);
238
         return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
239
      case 116:
240
         if ((active0 & 0x4000000L) != 0L)
241
            return jjStartNfaWithStates_1(1, 26, 42);
242
         else if ((active0 & 0x10000000L) != 0L)
243
            return jjStartNfaWithStates_1(1, 28, 42);
244
         break;
245
      case 117:
246
         return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
247
      case 124:
248
         if ((active0 & 0x20000000000L) != 0L)
249
            return jjStopAtPos(1, 41);
250
         break;
251
      default :
252
         break;
253
   }
254
   return jjStartNfa_1(0, active0);
255
}
256
private final int jjMoveStringLiteralDfa2_1(long old0, long active0)
257
{
258
   if (((active0 &= old0)) == 0L)
259
      return jjStartNfa_1(0, old0); 
260
   try { curChar = input_stream.readChar(); }
261
   catch(java.io.IOException e) {
262
      jjStopStringLiteralDfa_1(1, active0);
263
      return 2;
264
   }
265
   switch(curChar)
266
   {
267
      case 100:
268
         if ((active0 & 0x10000000000L) != 0L)
269
            return jjStartNfaWithStates_1(2, 40, 42);
270
         else if ((active0 & 0x10000000000000L) != 0L)
271
            return jjStartNfaWithStates_1(2, 52, 42);
272
         break;
273
      case 108:
274
         return jjMoveStringLiteralDfa3_1(active0, 0x18000L);
275
      case 112:
276
         return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L);
277
      case 115:
278
         return jjMoveStringLiteralDfa3_1(active0, 0x100000000000L);
279
      case 116:
280
         if ((active0 & 0x4000000000L) != 0L)
281
            return jjStartNfaWithStates_1(2, 38, 42);
282
         break;
283
      case 117:
284
         return jjMoveStringLiteralDfa3_1(active0, 0x4000L);
285
      case 118:
286
         if ((active0 & 0x4000000000000L) != 0L)
287
            return jjStartNfaWithStates_1(2, 50, 42);
288
         break;
289
      default :
290
         break;
291
   }
292
   return jjStartNfa_1(1, active0);
293
}
294
private final int jjMoveStringLiteralDfa3_1(long old0, long active0)
295
{
296
   if (((active0 &= old0)) == 0L)
297
      return jjStartNfa_1(1, old0); 
298
   try { curChar = input_stream.readChar(); }
299
   catch(java.io.IOException e) {
300
      jjStopStringLiteralDfa_1(2, active0);
301
      return 3;
302
   }
303
   switch(curChar)
304
   {
305
      case 101:
306
         if ((active0 & 0x4000L) != 0L)
307
            return jjStartNfaWithStates_1(3, 14, 42);
308
         break;
309
      case 108:
310
         if ((active0 & 0x10000L) != 0L)
311
            return jjStartNfaWithStates_1(3, 16, 42);
312
         break;
313
      case 115:
314
         return jjMoveStringLiteralDfa4_1(active0, 0x8000L);
315
      case 116:
316
         return jjMoveStringLiteralDfa4_1(active0, 0x180000000000L);
317
      default :
318
         break;
319
   }
320
   return jjStartNfa_1(2, active0);
321
}
322
private final int jjMoveStringLiteralDfa4_1(long old0, long active0)
323
{
324
   if (((active0 &= old0)) == 0L)
325
      return jjStartNfa_1(2, old0); 
326
   try { curChar = input_stream.readChar(); }
327
   catch(java.io.IOException e) {
328
      jjStopStringLiteralDfa_1(3, active0);
329
      return 4;
330
   }
331
   switch(curChar)
332
   {
333
      case 97:
334
         return jjMoveStringLiteralDfa5_1(active0, 0x100000000000L);
335
      case 101:
336
         if ((active0 & 0x8000L) != 0L)
337
            return jjStartNfaWithStates_1(4, 15, 42);
338
         break;
339
      case 121:
340
         if ((active0 & 0x80000000000L) != 0L)
341
            return jjStartNfaWithStates_1(4, 43, 42);
342
         break;
343
      default :
344
         break;
345
   }
346
   return jjStartNfa_1(3, active0);
347
}
348
private final int jjMoveStringLiteralDfa5_1(long old0, long active0)
349
{
350
   if (((active0 &= old0)) == 0L)
351
      return jjStartNfa_1(3, old0); 
352
   try { curChar = input_stream.readChar(); }
353
   catch(java.io.IOException e) {
354
      jjStopStringLiteralDfa_1(4, active0);
355
      return 5;
356
   }
357
   switch(curChar)
358
   {
359
      case 110:
360
         return jjMoveStringLiteralDfa6_1(active0, 0x100000000000L);
361
      default :
362
         break;
363
   }
364
   return jjStartNfa_1(4, active0);
365
}
366
private final int jjMoveStringLiteralDfa6_1(long old0, long active0)
367
{
368
   if (((active0 &= old0)) == 0L)
369
      return jjStartNfa_1(4, old0); 
370
   try { curChar = input_stream.readChar(); }
371
   catch(java.io.IOException e) {
372
      jjStopStringLiteralDfa_1(5, active0);
373
      return 6;
374
   }
375
   switch(curChar)
376
   {
377
      case 99:
378
         return jjMoveStringLiteralDfa7_1(active0, 0x100000000000L);
379
      default :
380
         break;
381
   }
382
   return jjStartNfa_1(5, active0);
383
}
384
private final int jjMoveStringLiteralDfa7_1(long old0, long active0)
385
{
386
   if (((active0 &= old0)) == 0L)
387
      return jjStartNfa_1(5, old0); 
388
   try { curChar = input_stream.readChar(); }
389
   catch(java.io.IOException e) {
390
      jjStopStringLiteralDfa_1(6, active0);
391
      return 7;
392
   }
393
   switch(curChar)
394
   {
395
      case 101:
396
         return jjMoveStringLiteralDfa8_1(active0, 0x100000000000L);
397
      default :
398
         break;
399
   }
400
   return jjStartNfa_1(6, active0);
401
}
402
private final int jjMoveStringLiteralDfa8_1(long old0, long active0)
403
{
404
   if (((active0 &= old0)) == 0L)
405
      return jjStartNfa_1(6, old0); 
406
   try { curChar = input_stream.readChar(); }
407
   catch(java.io.IOException e) {
408
      jjStopStringLiteralDfa_1(7, active0);
409
      return 8;
410
   }
411
   switch(curChar)
412
   {
413
      case 111:
414
         return jjMoveStringLiteralDfa9_1(active0, 0x100000000000L);
415
      default :
416
         break;
417
   }
418
   return jjStartNfa_1(7, active0);
419
}
420
private final int jjMoveStringLiteralDfa9_1(long old0, long active0)
421
{
422
   if (((active0 &= old0)) == 0L)
423
      return jjStartNfa_1(7, old0); 
424
   try { curChar = input_stream.readChar(); }
425
   catch(java.io.IOException e) {
426
      jjStopStringLiteralDfa_1(8, active0);
427
      return 9;
428
   }
429
   switch(curChar)
430
   {
431
      case 102:
432
         if ((active0 & 0x100000000000L) != 0L)
433
            return jjStartNfaWithStates_1(9, 44, 42);
434
         break;
435
      default :
436
         break;
437
   }
438
   return jjStartNfa_1(8, active0);
439
}
440
private final void jjCheckNAdd(int state)
441
{
442
   if (jjrounds[state] != jjround)
443
   {
444
      jjstateSet[jjnewStateCnt++] = state;
445
      jjrounds[state] = jjround;
446
   }
447
}
448
private final void jjAddStates(int start, int end)
449
{
450
   do {
451
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
452
   } while (start++ != end);
453
}
454
private final void jjCheckNAddTwoStates(int state1, int state2)
455
{
456
   jjCheckNAdd(state1);
457
   jjCheckNAdd(state2);
458
}
459
private final void jjCheckNAddStates(int start, int end)
460
{
461
   do {
462
      jjCheckNAdd(jjnextStates[start]);
463
   } while (start++ != end);
464
}
465
private final void jjCheckNAddStates(int start)
466
{
467
   jjCheckNAdd(jjnextStates[start]);
468
   jjCheckNAdd(jjnextStates[start + 1]);
469
}
470
static final long[] jjbitVec0 = {
471
   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
472
};
473
static final long[] jjbitVec2 = {
474
   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
475
};
476
static final long[] jjbitVec3 = {
477
   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
478
};
479
static final long[] jjbitVec4 = {
480
   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
481
};
482
static final long[] jjbitVec5 = {
483
   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
484
};
485
static final long[] jjbitVec6 = {
486
   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
487
};
488
static final long[] jjbitVec7 = {
489
   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
490
};
491
static final long[] jjbitVec8 = {
492
   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
493
};
494
private final int jjMoveNfa_1(int startState, int curPos)
495
{
496
   int[] nextStates;
497
   int startsAt = 0;
498
   jjnewStateCnt = 42;
499
   int i = 1;
500
   jjstateSet[0] = startState;
501
   int j, kind = 0x7fffffff;
502
   for (;;)
503
   {
504
      if (++jjround == 0x7fffffff)
505
         ReInitRounds();
506
      if (curChar < 64)
507
      {
508
         long l = 1L << curChar;
509
         MatchLoop: do
510
         {
511
            switch(jjstateSet[--i])
512
            {
513
               case 0:
514
                  if ((0x3ff000000000000L & l) != 0L)
515
                  {
516
                     if (kind > 9)
517
                        kind = 9;
518
                     jjCheckNAddStates(0, 4);
519
                  }
520
                  else if ((0x1800000000L & l) != 0L)
521
                  {
522
                     if (kind > 53)
523
                        kind = 53;
524
                     jjCheckNAddStates(5, 11);
525
                  }
526
                  else if (curChar == 39)
527
                     jjCheckNAddStates(12, 16);
528
                  else if (curChar == 34)
529
                     jjCheckNAddStates(17, 21);
530
                  else if (curChar == 46)
531
                     jjCheckNAdd(1);
532
                  break;
533
               case 42:
534
                  if ((0x3ff601000000000L & l) != 0L)
535
                     jjCheckNAddTwoStates(36, 37);
536
                  else if (curChar == 40)
537
                  {
538
                     if (kind > 56)
539
                        kind = 56;
540
                  }
541
                  else if (curChar == 58)
542
                     jjstateSet[jjnewStateCnt++] = 38;
543
                  if ((0x3ff001000000000L & l) != 0L)
544
                  {
545
                     if (kind > 57)
546
                        kind = 57;
547
                     jjCheckNAdd(41);
548
                  }
549
                  if ((0x3ff001000000000L & l) != 0L)
550
                     jjCheckNAddTwoStates(39, 40);
551
                  if ((0x3ff001000000000L & l) != 0L)
552
                     jjCheckNAddStates(22, 24);
553
                  if ((0x3ff001000000000L & l) != 0L)
554
                  {
555
                     if (kind > 53)
556
                        kind = 53;
557
                     jjCheckNAdd(34);
558
                  }
559
                  break;
560
               case 1:
561
                  if ((0x3ff000000000000L & l) == 0L)
562
                     break;
563
                  if (kind > 10)
564
                     kind = 10;
565
                  jjCheckNAddTwoStates(1, 2);
566
                  break;
567
               case 3:
568
                  if ((0x280000000000L & l) != 0L)
569
                     jjCheckNAdd(4);
570
                  break;
571
               case 4:
572
                  if ((0x3ff000000000000L & l) == 0L)
573
                     break;
574
                  if (kind > 10)
575
                     kind = 10;
576
                  jjCheckNAdd(4);
577
                  break;
578
               case 5:
579
                  if ((0x3ff000000000000L & l) == 0L)
580
                     break;
581
                  if (kind > 9)
582
                     kind = 9;
583
                  jjCheckNAddStates(0, 4);
584
                  break;
585
               case 6:
586
                  if ((0x3ff000000000000L & l) == 0L)
587
                     break;
588
                  if (kind > 9)
589
                     kind = 9;
590
                  jjCheckNAdd(6);
591
                  break;
592
               case 7:
593
                  if ((0x3ff000000000000L & l) != 0L)
594
                     jjCheckNAddTwoStates(7, 8);
595
                  break;
596
               case 8:
597
                  if (curChar != 46)
598
                     break;
599
                  if (kind > 10)
600
                     kind = 10;
601
                  jjCheckNAddTwoStates(9, 10);
602
                  break;
603
               case 9:
604
                  if ((0x3ff000000000000L & l) == 0L)
605
                     break;
606
                  if (kind > 10)
607
                     kind = 10;
608
                  jjCheckNAddTwoStates(9, 10);
609
                  break;
610
               case 11:
611
                  if ((0x280000000000L & l) != 0L)
612
                     jjCheckNAdd(12);
613
                  break;
614
               case 12:
615
                  if ((0x3ff000000000000L & l) == 0L)
616
                     break;
617
                  if (kind > 10)
618
                     kind = 10;
619
                  jjCheckNAdd(12);
620
                  break;
621
               case 13:
622
                  if ((0x3ff000000000000L & l) != 0L)
623
                     jjCheckNAddTwoStates(13, 14);
624
                  break;
625
               case 15:
626
                  if ((0x280000000000L & l) != 0L)
627
                     jjCheckNAdd(16);
628
                  break;
629
               case 16:
630
                  if ((0x3ff000000000000L & l) == 0L)
631
                     break;
632
                  if (kind > 10)
633
                     kind = 10;
634
                  jjCheckNAdd(16);
635
                  break;
636
               case 17:
637
                  if (curChar == 34)
638
                     jjCheckNAddStates(17, 21);
639
                  break;
640
               case 18:
641
                  if ((0xfffffffbffffffffL & l) != 0L)
642
                     jjCheckNAddStates(25, 27);
643
                  break;
644
               case 20:
645
                  if (curChar == 34)
646
                     jjCheckNAddStates(25, 27);
647
                  break;
648
               case 21:
649
                  if (curChar == 34 && kind > 12)
650
                     kind = 12;
651
                  break;
652
               case 22:
653
                  if ((0xfffffffbffffffffL & l) != 0L)
654
                     jjCheckNAddTwoStates(22, 23);
655
                  break;
656
               case 24:
657
                  if ((0xfffffffbffffffffL & l) != 0L && kind > 13)
658
                     kind = 13;
659
                  break;
660
               case 25:
661
                  if (curChar == 39)
662
                     jjCheckNAddStates(12, 16);
663
                  break;
664
               case 26:
665
                  if ((0xffffff7fffffffffL & l) != 0L)
666
                     jjCheckNAddStates(28, 30);
667
                  break;
668
               case 28:
669
                  if (curChar == 39)
670
                     jjCheckNAddStates(28, 30);
671
                  break;
672
               case 29:
673
                  if (curChar == 39 && kind > 12)
674
                     kind = 12;
675
                  break;
676
               case 30:
677
                  if ((0xffffff7fffffffffL & l) != 0L)
678
                     jjCheckNAddTwoStates(30, 31);
679
                  break;
680
               case 32:
681
                  if ((0xffffff7fffffffffL & l) != 0L && kind > 13)
682
                     kind = 13;
683
                  break;
684
               case 33:
685
                  if ((0x1800000000L & l) == 0L)
686
                     break;
687
                  if (kind > 53)
688
                     kind = 53;
689
                  jjCheckNAddStates(5, 11);
690
                  break;
691
               case 34:
692
                  if ((0x3ff001000000000L & l) == 0L)
693
                     break;
694
                  if (kind > 53)
695
                     kind = 53;
696
                  jjCheckNAdd(34);
697
                  break;
698
               case 35:
699
                  if ((0x3ff001000000000L & l) != 0L)
700
                     jjCheckNAddStates(22, 24);
701
                  break;
702
               case 36:
703
                  if ((0x3ff601000000000L & l) != 0L)
704
                     jjCheckNAddTwoStates(36, 37);
705
                  break;
706
               case 37:
707
                  if (curChar == 58)
708
                     jjstateSet[jjnewStateCnt++] = 38;
709
                  break;
710
               case 38:
711
                  if ((0x1800000000L & l) != 0L)
712
                     jjCheckNAddTwoStates(39, 40);
713
                  break;
714
               case 39:
715
                  if ((0x3ff001000000000L & l) != 0L)
716
                     jjCheckNAddTwoStates(39, 40);
717
                  break;
718
               case 40:
719
                  if (curChar == 40 && kind > 56)
720
                     kind = 56;
721
                  break;
722
               case 41:
723
                  if ((0x3ff001000000000L & l) == 0L)
724
                     break;
725
                  if (kind > 57)
726
                     kind = 57;
727
                  jjCheckNAdd(41);
728
                  break;
729
               default : break;
730
            }
731
         } while(i != startsAt);
732
      }
733
      else if (curChar < 128)
734
      {
735
         long l = 1L << (curChar & 077);
736
         MatchLoop: do
737
         {
738
            switch(jjstateSet[--i])
739
            {
740
               case 0:
741
                  if ((0x7fffffe87fffffeL & l) == 0L)
742
                     break;
743
                  if (kind > 53)
744
                     kind = 53;
745
                  jjCheckNAddStates(5, 11);
746
                  break;
747
               case 42:
748
                  if ((0x7fffffe87fffffeL & l) != 0L)
749
                  {
750
                     if (kind > 57)
751
                        kind = 57;
752
                     jjCheckNAdd(41);
753
                  }
754
                  if ((0x7fffffe87fffffeL & l) != 0L)
755
                     jjCheckNAddTwoStates(39, 40);
756
                  if ((0x7fffffe87fffffeL & l) != 0L)
757
                     jjCheckNAddTwoStates(36, 37);
758
                  if ((0x7fffffe87fffffeL & l) != 0L)
759
                     jjCheckNAddStates(22, 24);
760
                  if ((0x7fffffe87fffffeL & l) != 0L)
761
                  {
762
                     if (kind > 53)
763
                        kind = 53;
764
                     jjCheckNAdd(34);
765
                  }
766
                  break;
767
               case 2:
768
                  if ((0x2000000020L & l) != 0L)
769
                     jjAddStates(31, 32);
770
                  break;
771
               case 10:
772
                  if ((0x2000000020L & l) != 0L)
773
                     jjAddStates(33, 34);
774
                  break;
775
               case 14:
776
                  if ((0x2000000020L & l) != 0L)
777
                     jjAddStates(35, 36);
778
                  break;
779
               case 18:
780
                  if ((0xffffffffefffffffL & l) != 0L)
781
                     jjCheckNAddStates(25, 27);
782
                  break;
783
               case 19:
784
                  if (curChar == 92)
785
                     jjstateSet[jjnewStateCnt++] = 20;
786
                  break;
787
               case 20:
788
                  if (curChar == 92)
789
                     jjCheckNAddStates(25, 27);
790
                  break;
791
               case 22:
792
                  if ((0xffffffffefffffffL & l) != 0L)
793
                     jjAddStates(37, 38);
794
                  break;
795
               case 23:
796
                  if (curChar == 92)
797
                     jjstateSet[jjnewStateCnt++] = 24;
798
                  break;
799
               case 24:
800
               case 32:
801
                  if ((0xffffffffefffffffL & l) != 0L && kind > 13)
802
                     kind = 13;
803
                  break;
804
               case 26:
805
                  if ((0xffffffffefffffffL & l) != 0L)
806
                     jjCheckNAddStates(28, 30);
807
                  break;
808
               case 27:
809
                  if (curChar == 92)
810
                     jjstateSet[jjnewStateCnt++] = 28;
811
                  break;
812
               case 28:
813
                  if (curChar == 92)
814
                     jjCheckNAddStates(28, 30);
815
                  break;
816
               case 30:
817
                  if ((0xffffffffefffffffL & l) != 0L)
818
                     jjAddStates(39, 40);
819
                  break;
820
               case 31:
821
                  if (curChar == 92)
822
                     jjstateSet[jjnewStateCnt++] = 32;
823
                  break;
824
               case 34:
825
                  if ((0x7fffffe87fffffeL & l) == 0L)
826
                     break;
827
                  if (kind > 53)
828
                     kind = 53;
829
                  jjCheckNAdd(34);
830
                  break;
831
               case 35:
832
                  if ((0x7fffffe87fffffeL & l) != 0L)
833
                     jjCheckNAddStates(22, 24);
834
                  break;
835
               case 36:
836
                  if ((0x7fffffe87fffffeL & l) != 0L)
837
                     jjCheckNAddTwoStates(36, 37);
838
                  break;
839
               case 38:
840
                  if ((0x7fffffe87fffffeL & l) != 0L)
841
                     jjCheckNAddTwoStates(39, 40);
842
                  break;
843
               case 39:
844
                  if ((0x7fffffe87fffffeL & l) != 0L)
845
                     jjCheckNAddTwoStates(39, 40);
846
                  break;
847
               case 41:
848
                  if ((0x7fffffe87fffffeL & l) == 0L)
849
                     break;
850
                  if (kind > 57)
851
                     kind = 57;
852
                  jjCheckNAdd(41);
853
                  break;
854
               default : break;
855
            }
856
         } while(i != startsAt);
857
      }
858
      else
859
      {
860
         int hiByte = (int)(curChar >> 8);
861
         int i1 = hiByte >> 6;
862
         long l1 = 1L << (hiByte & 077);
863
         int i2 = (curChar & 0xff) >> 6;
864
         long l2 = 1L << (curChar & 077);
865
         MatchLoop: do
866
         {
867
            switch(jjstateSet[--i])
868
            {
869
               case 0:
870
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
871
                     break;
872
                  if (kind > 53)
873
                     kind = 53;
874
                  jjCheckNAddStates(5, 11);
875
                  break;
876
               case 42:
877
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
878
                  {
879
                     if (kind > 53)
880
                        kind = 53;
881
                     jjCheckNAdd(34);
882
                  }
883
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
884
                     jjCheckNAddStates(22, 24);
885
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
886
                     jjCheckNAddTwoStates(36, 37);
887
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
888
                     jjCheckNAddTwoStates(39, 40);
889
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
890
                  {
891
                     if (kind > 57)
892
                        kind = 57;
893
                     jjCheckNAdd(41);
894
                  }
895
                  break;
896
               case 18:
897
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
898
                     jjAddStates(25, 27);
899
                  break;
900
               case 22:
901
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
902
                     jjAddStates(37, 38);
903
                  break;
904
               case 24:
905
               case 32:
906
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
907
                     kind = 13;
908
                  break;
909
               case 26:
910
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
911
                     jjAddStates(28, 30);
912
                  break;
913
               case 30:
914
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
915
                     jjAddStates(39, 40);
916
                  break;
917
               case 34:
918
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
919
                     break;
920
                  if (kind > 53)
921
                     kind = 53;
922
                  jjCheckNAdd(34);
923
                  break;
924
               case 35:
925
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
926
                     jjCheckNAddStates(22, 24);
927
                  break;
928
               case 36:
929
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
930
                     jjCheckNAddTwoStates(36, 37);
931
                  break;
932
               case 38:
933
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
934
                     jjCheckNAddTwoStates(39, 40);
935
                  break;
936
               case 39:
937
                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
938
                     jjCheckNAddTwoStates(39, 40);
939
                  break;
940
               case 41:
941
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
942
                     break;
943
                  if (kind > 57)
944
                     kind = 57;
945
                  jjCheckNAdd(41);
946
                  break;
947
               default : break;
948
            }
949
         } while(i != startsAt);
950
      }
951
      if (kind != 0x7fffffff)
952
      {
953
         jjmatchedKind = kind;
954
         jjmatchedPos = curPos;
955
         kind = 0x7fffffff;
956
      }
957
      ++curPos;
958
      if ((i = jjnewStateCnt) == (startsAt = 42 - (jjnewStateCnt = startsAt)))
959
         return curPos;
960
      try { curChar = input_stream.readChar(); }
961
      catch(java.io.IOException e) { return curPos; }
962
   }
963
}
964
private final int jjStopStringLiteralDfa_0(int pos, long active0)
965
{
966
   switch (pos)
967
   {
968
      case 0:
969
         if ((active0 & 0x4L) != 0L)
970
         {
971
            jjmatchedKind = 1;
972
            return 4;
973
         }
974
         if ((active0 & 0x10L) != 0L)
975
            return 2;
976
         if ((active0 & 0x8L) != 0L)
977
         {
978
            jjmatchedKind = 1;
979
            return 6;
980
         }
981
         return -1;
982
      default :
983
         return -1;
984
   }
985
}
986
private final int jjStartNfa_0(int pos, long active0)
987
{
988
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
989
}
990
private final int jjStartNfaWithStates_0(int pos, int kind, int state)
991
{
992
   jjmatchedKind = kind;
993
   jjmatchedPos = pos;
994
   try { curChar = input_stream.readChar(); }
995
   catch(java.io.IOException e) { return pos + 1; }
996
   return jjMoveNfa_0(state, pos + 1);
997
}
998
private final int jjMoveStringLiteralDfa0_0()
999
{
1000
   switch(curChar)
1001
   {
1002
      case 35:
1003
         return jjMoveStringLiteralDfa1_0(0x8L);
1004
      case 36:
1005
         return jjMoveStringLiteralDfa1_0(0x4L);
1006
      case 92:
1007
         return jjStartNfaWithStates_0(0, 4, 2);
1008
      default :
1009
         return jjMoveNfa_0(7, 0);
1010
   }
1011
}
1012
private final int jjMoveStringLiteralDfa1_0(long active0)
1013
{
1014
   try { curChar = input_stream.readChar(); }
1015
   catch(java.io.IOException e) {
1016
      jjStopStringLiteralDfa_0(0, active0);
1017
      return 1;
1018
   }
1019
   switch(curChar)
1020
   {
1021
      case 123:
1022
         if ((active0 & 0x4L) != 0L)
1023
            return jjStopAtPos(1, 2);
1024
         else if ((active0 & 0x8L) != 0L)
1025
            return jjStopAtPos(1, 3);
1026
         break;
1027
      default :
1028
         break;
1029
   }
1030
   return jjStartNfa_0(0, active0);
1031
}
1032
private final int jjMoveNfa_0(int startState, int curPos)
1033
{
1034
   int[] nextStates;
1035
   int startsAt = 0;
1036
   jjnewStateCnt = 8;
1037
   int i = 1;
1038
   jjstateSet[0] = startState;
1039
   int j, kind = 0x7fffffff;
1040
   for (;;)
1041
   {
1042
      if (++jjround == 0x7fffffff)
1043
         ReInitRounds();
1044
      if (curChar < 64)
1045
      {
1046
         long l = 1L << curChar;
1047
         MatchLoop: do
1048
         {
1049
            switch(jjstateSet[--i])
1050
            {
1051
               case 7:
1052
                  if ((0xffffffe7ffffffffL & l) != 0L)
1053
                  {
1054
                     if (kind > 1)
1055
                        kind = 1;
1056
                     jjCheckNAddStates(41, 44);
1057
                  }
1058
                  else if ((0x1800000000L & l) != 0L)
1059
                  {
1060
                     if (kind > 1)
1061
                        kind = 1;
1062
                  }
1063
                  if (curChar == 35)
1064
                     jjstateSet[jjnewStateCnt++] = 6;
1065
                  else if (curChar == 36)
1066
                     jjstateSet[jjnewStateCnt++] = 4;
1067
                  break;
1068
               case 0:
1069
                  if ((0xffffffe7ffffffffL & l) == 0L)
1070
                     break;
1071
                  if (kind > 1)
1072
                     kind = 1;
1073
                  jjCheckNAddStates(41, 44);
1074
                  break;
1075
               case 2:
1076
                  if ((0x1800000000L & l) == 0L)
1077
                     break;
1078
                  if (kind > 1)
1079
                     kind = 1;
1080
                  jjCheckNAddStates(41, 44);
1081
                  break;
1082
               case 3:
1083
                  if (curChar == 36)
1084
                     jjstateSet[jjnewStateCnt++] = 4;
1085
                  break;
1086
               case 4:
1087
                  if ((0xffffffefffffffffL & l) == 0L)
1088
                     break;
1089
                  if (kind > 1)
1090
                     kind = 1;
1091
                  jjCheckNAddStates(41, 44);
1092
                  break;
1093
               case 5:
1094
                  if (curChar == 35)
1095
                     jjstateSet[jjnewStateCnt++] = 6;
1096
                  break;
1097
               case 6:
1098
                  if ((0xfffffff7ffffffffL & l) == 0L)
1099
                     break;
1100
                  if (kind > 1)
1101
                     kind = 1;
1102
                  jjCheckNAddStates(41, 44);
1103
                  break;
1104
               default : break;
1105
            }
1106
         } while(i != startsAt);
1107
      }
1108
      else if (curChar < 128)
1109
      {
1110
         long l = 1L << (curChar & 077);
1111
         MatchLoop: do
1112
         {
1113
            switch(jjstateSet[--i])
1114
            {
1115
               case 7:
1116
                  if ((0xffffffffefffffffL & l) != 0L)
1117
                  {
1118
                     if (kind > 1)
1119
                        kind = 1;
1120
                     jjCheckNAddStates(41, 44);
1121
                  }
1122
                  else if (curChar == 92)
1123
                     jjstateSet[jjnewStateCnt++] = 2;
1124
                  break;
1125
               case 0:
1126
                  if ((0xffffffffefffffffL & l) == 0L)
1127
                     break;
1128
                  if (kind > 1)
1129
                     kind = 1;
1130
                  jjCheckNAddStates(41, 44);
1131
                  break;
1132
               case 1:
1133
                  if (curChar == 92)
1134
                     jjstateSet[jjnewStateCnt++] = 2;
1135
                  break;
1136
               case 2:
1137
                  if (curChar != 92)
1138
                     break;
1139
                  if (kind > 1)
1140
                     kind = 1;
1141
                  jjCheckNAddStates(41, 44);
1142
                  break;
1143
               case 4:
1144
               case 6:
1145
                  if ((0xf7ffffffffffffffL & l) == 0L)
1146
                     break;
1147
                  if (kind > 1)
1148
                     kind = 1;
1149
                  jjCheckNAddStates(41, 44);
1150
                  break;
1151
               default : break;
1152
            }
1153
         } while(i != startsAt);
1154
      }
1155
      else
1156
      {
1157
         int hiByte = (int)(curChar >> 8);
1158
         int i1 = hiByte >> 6;
1159
         long l1 = 1L << (hiByte & 077);
1160
         int i2 = (curChar & 0xff) >> 6;
1161
         long l2 = 1L << (curChar & 077);
1162
         MatchLoop: do
1163
         {
1164
            switch(jjstateSet[--i])
1165
            {
1166
               case 7:
1167
               case 0:
1168
               case 4:
1169
               case 6:
1170
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1171
                     break;
1172
                  if (kind > 1)
1173
                     kind = 1;
1174
                  jjCheckNAddStates(41, 44);
1175
                  break;
1176
               default : break;
1177
            }
1178
         } while(i != startsAt);
1179
      }
1180
      if (kind != 0x7fffffff)
1181
      {
1182
         jjmatchedKind = kind;
1183
         jjmatchedPos = curPos;
1184
         kind = 0x7fffffff;
1185
      }
1186
      ++curPos;
1187
      if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
1188
         return curPos;
1189
      try { curChar = input_stream.readChar(); }
1190
      catch(java.io.IOException e) { return curPos; }
1191
   }
1192
}
1193
static final int[] jjnextStates = {
1194
   6, 7, 8, 13, 14, 34, 35, 36, 37, 39, 40, 41, 26, 27, 29, 30, 
1195
   31, 18, 19, 21, 22, 23, 35, 36, 37, 18, 19, 21, 26, 27, 29, 3, 
1196
   4, 11, 12, 15, 16, 22, 23, 30, 31, 0, 1, 3, 5, 
1197
};
1198
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1199
{
1200
   switch(hiByte)
1201
   {
1202
      case 0:
1203
         return ((jjbitVec2[i2] & l2) != 0L);
1204
      default : 
1205
         if ((jjbitVec0[i1] & l1) != 0L)
1206
            return true;
1207
         return false;
1208
   }
1209
}
1210
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1211
{
1212
   switch(hiByte)
1213
   {
1214
      case 0:
1215
         return ((jjbitVec4[i2] & l2) != 0L);
1216
      case 48:
1217
         return ((jjbitVec5[i2] & l2) != 0L);
1218
      case 49:
1219
         return ((jjbitVec6[i2] & l2) != 0L);
1220
      case 51:
1221
         return ((jjbitVec7[i2] & l2) != 0L);
1222
      case 61:
1223
         return ((jjbitVec8[i2] & l2) != 0L);
1224
      default : 
1225
         if ((jjbitVec3[i1] & l1) != 0L)
1226
            return true;
1227
         return false;
1228
   }
1229
}
1230
public static final String[] jjstrLiteralImages = {
1231
"", null, "\44\173", "\43\173", null, null, null, null, null, null, null, null, 
1232
null, null, "\164\162\165\145", "\146\141\154\163\145", "\156\165\154\154", "\175", 
1233
"\56", "\50", "\51", "\133", "\135", "\72", "\54", "\76", "\147\164", "\74", 
1234
"\154\164", "\76\75", "\147\145", "\74\75", "\154\145", "\75\75", "\145\161", "\41\75", 
1235
"\156\145", "\41", "\156\157\164", "\46\46", "\141\156\144", "\174\174", "\157\162", 
1236
"\145\155\160\164\171", "\151\156\163\164\141\156\143\145\157\146", "\52", "\53", "\55", "\77", "\57", 
1237
"\144\151\166", "\45", "\155\157\144", null, null, null, null, null, null, null, null, null, };
1238
public static final String[] lexStateNames = {
1239
   "DEFAULT", 
1240
   "IN_EXPRESSION", 
1241
};
1242
public static final int[] jjnewLexState = {
1243
   -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, 
1244
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1245
   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
1246
};
1247
static final long[] jjtoToken = {
1248
   0x233ffffffffff60fL, 
1249
};
1250
static final long[] jjtoSkip = {
1251
   0x1f0L, 
1252
};
1253
protected SimpleCharStream input_stream;
1254
private final int[] jjrounds = new int[42];
1255
private final int[] jjstateSet = new int[84];
1256
protected char curChar;
1257
public ELParserTokenManager(SimpleCharStream stream){
1258
   if (SimpleCharStream.staticFlag)
1259
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1260
   input_stream = stream;
1261
}
1262
public ELParserTokenManager(SimpleCharStream stream, int lexState){
1263
   this(stream);
1264
   SwitchTo(lexState);
1265
}
1266
public void ReInit(SimpleCharStream stream)
1267
{
1268
   jjmatchedPos = jjnewStateCnt = 0;
1269
   curLexState = defaultLexState;
1270
   input_stream = stream;
1271
   ReInitRounds();
1272
}
1273
private final void ReInitRounds()
1274
{
1275
   int i;
1276
   jjround = 0x80000001;
1277
   for (i = 42; i-- > 0;)
1278
      jjrounds[i] = 0x80000000;
1279
}
1280
public void ReInit(SimpleCharStream stream, int lexState)
1281
{
1282
   ReInit(stream);
1283
   SwitchTo(lexState);
1284
}
1285
public void SwitchTo(int lexState)
1286
{
1287
   if (lexState >= 2 || lexState < 0)
1288
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1289
   else
1290
      curLexState = lexState;
1291
}
6
1292
7
	public void setDebugStream(java.io.PrintStream ds) {
1293
protected Token jjFillToken()
8
		debugStream = ds;
1294
{
9
	}
1295
   Token t = Token.newToken(jjmatchedKind);
1296
   t.kind = jjmatchedKind;
1297
   String im = jjstrLiteralImages[jjmatchedKind];
1298
   t.image = (im == null) ? input_stream.GetImage() : im;
1299
   t.beginLine = input_stream.getBeginLine();
1300
   t.beginColumn = input_stream.getBeginColumn();
1301
   t.endLine = input_stream.getEndLine();
1302
   t.endColumn = input_stream.getEndColumn();
1303
   return t;
1304
}
10
1305
11
	private final int jjStopStringLiteralDfa_0(int pos, long active0) {
1306
int curLexState = 0;
12
		switch (pos) {
1307
int defaultLexState = 0;
13
		case 0:
1308
int jjnewStateCnt;
14
			if ((active0 & 0x10L) != 0L)
1309
int jjround;
15
				return 2;
1310
int jjmatchedPos;
16
			if ((active0 & 0x4L) != 0L) {
1311
int jjmatchedKind;
17
				jjmatchedKind = 1;
18
				return 4;
19
			}
20
			if ((active0 & 0x8L) != 0L) {
21
				jjmatchedKind = 1;
22
				return 6;
23
			}
24
			return -1;
25
		default:
26
			return -1;
27
		}
28
	}
29
1312
30
	private final int jjStartNfa_0(int pos, long active0) {
1313
public Token getNextToken() 
31
		return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
1314
{
32
	}
1315
  int kind;
1316
  Token specialToken = null;
1317
  Token matchedToken;
1318
  int curPos = 0;
33
1319
34
	private final int jjStopAtPos(int pos, int kind) {
1320
  EOFLoop :
35
		jjmatchedKind = kind;
1321
  for (;;)
36
		jjmatchedPos = pos;
1322
  {   
37
		return pos + 1;
1323
   try   
38
	}
1324
   {     
1325
      curChar = input_stream.BeginToken();
1326
   }     
1327
   catch(java.io.IOException e)
1328
   {        
1329
      jjmatchedKind = 0;
1330
      matchedToken = jjFillToken();
1331
      return matchedToken;
1332
   }
39
1333
40
	private final int jjStartNfaWithStates_0(int pos, int kind, int state) {
1334
   switch(curLexState)
41
		jjmatchedKind = kind;
1335
   {
42
		jjmatchedPos = pos;
1336
     case 0:
43
		try {
1337
       jjmatchedKind = 0x7fffffff;
44
			curChar = input_stream.readChar();
1338
       jjmatchedPos = 0;
45
		} catch (java.io.IOException e) {
1339
       curPos = jjMoveStringLiteralDfa0_0();
46
			return pos + 1;
1340
       break;
47
		}
1341
     case 1:
48
		return jjMoveNfa_0(state, pos + 1);
1342
       try { input_stream.backup(0);
49
	}
1343
          while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
1344
             curChar = input_stream.BeginToken();
1345
       }
1346
       catch (java.io.IOException e1) { continue EOFLoop; }
1347
       jjmatchedKind = 0x7fffffff;
1348
       jjmatchedPos = 0;
1349
       curPos = jjMoveStringLiteralDfa0_1();
1350
       if (jjmatchedPos == 0 && jjmatchedKind > 61)
1351
       {
1352
          jjmatchedKind = 61;
1353
       }
1354
       break;
1355
   }
1356
     if (jjmatchedKind != 0x7fffffff)
1357
     {
1358
        if (jjmatchedPos + 1 < curPos)
1359
           input_stream.backup(curPos - jjmatchedPos - 1);
1360
        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1361
        {
1362
           matchedToken = jjFillToken();
1363
       if (jjnewLexState[jjmatchedKind] != -1)
1364
         curLexState = jjnewLexState[jjmatchedKind];
1365
           return matchedToken;
1366
        }
1367
        else
1368
        {
1369
         if (jjnewLexState[jjmatchedKind] != -1)
1370
           curLexState = jjnewLexState[jjmatchedKind];
1371
           continue EOFLoop;
1372
        }
1373
     }
1374
     int error_line = input_stream.getEndLine();
1375
     int error_column = input_stream.getEndColumn();
1376
     String error_after = null;
1377
     boolean EOFSeen = false;
1378
     try { input_stream.readChar(); input_stream.backup(1); }
1379
     catch (java.io.IOException e1) {
1380
        EOFSeen = true;
1381
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1382
        if (curChar == '\n' || curChar == '\r') {
1383
           error_line++;
1384
           error_column = 0;
1385
        }
1386
        else
1387
           error_column++;
1388
     }
1389
     if (!EOFSeen) {
1390
        input_stream.backup(1);
1391
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1392
     }
1393
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1394
  }
1395
}
50
1396
51
	private final int jjMoveStringLiteralDfa0_0() {
52
		switch (curChar) {
53
		case 35:
54
			return jjMoveStringLiteralDfa1_0(0x8L);
55
		case 36:
56
			return jjMoveStringLiteralDfa1_0(0x4L);
57
		case 92:
58
			return jjStartNfaWithStates_0(0, 4, 2);
59
		default:
60
			return jjMoveNfa_0(7, 0);
61
		}
62
	}
63
64
	private final int jjMoveStringLiteralDfa1_0(long active0) {
65
		try {
66
			curChar = input_stream.readChar();
67
		} catch (java.io.IOException e) {
68
			jjStopStringLiteralDfa_0(0, active0);
69
			return 1;
70
		}
71
		switch (curChar) {
72
		case 123:
73
			if ((active0 & 0x4L) != 0L)
74
				return jjStopAtPos(1, 2);
75
			else if ((active0 & 0x8L) != 0L)
76
				return jjStopAtPos(1, 3);
77
			break;
78
		default:
79
			break;
80
		}
81
		return jjStartNfa_0(0, active0);
82
	}
83
84
	private final void jjCheckNAdd(int state) {
85
		if (jjrounds[state] != jjround) {
86
			jjstateSet[jjnewStateCnt++] = state;
87
			jjrounds[state] = jjround;
88
		}
89
	}
90
91
	private final void jjAddStates(int start, int end) {
92
		do {
93
			jjstateSet[jjnewStateCnt++] = jjnextStates[start];
94
		} while (start++ != end);
95
	}
96
97
	private final void jjCheckNAddTwoStates(int state1, int state2) {
98
		jjCheckNAdd(state1);
99
		jjCheckNAdd(state2);
100
	}
101
102
	private final void jjCheckNAddStates(int start, int end) {
103
		do {
104
			jjCheckNAdd(jjnextStates[start]);
105
		} while (start++ != end);
106
	}
107
108
	private final void jjCheckNAddStates(int start) {
109
		jjCheckNAdd(jjnextStates[start]);
110
		jjCheckNAdd(jjnextStates[start + 1]);
111
	}
112
113
	static final long[] jjbitVec0 = { 0xfffffffffffffffeL, 0xffffffffffffffffL,
114
			0xffffffffffffffffL, 0xffffffffffffffffL };
115
116
	static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL,
117
			0xffffffffffffffffL };
118
119
	private final int jjMoveNfa_0(int startState, int curPos) {
120
		int[] nextStates;
121
		int startsAt = 0;
122
		jjnewStateCnt = 8;
123
		int i = 1;
124
		jjstateSet[0] = startState;
125
		int j, kind = 0x7fffffff;
126
		for (;;) {
127
			if (++jjround == 0x7fffffff)
128
				ReInitRounds();
129
			if (curChar < 64) {
130
				long l = 1L << curChar;
131
				MatchLoop: do {
132
					switch (jjstateSet[--i]) {
133
					case 7:
134
						if ((0xffffffe7ffffffffL & l) != 0L) {
135
							if (kind > 1)
136
								kind = 1;
137
							jjCheckNAddStates(0, 3);
138
						} else if ((0x1800000000L & l) != 0L) {
139
							if (kind > 1)
140
								kind = 1;
141
						}
142
						if (curChar == 35)
143
							jjstateSet[jjnewStateCnt++] = 6;
144
						else if (curChar == 36)
145
							jjstateSet[jjnewStateCnt++] = 4;
146
						break;
147
					case 0:
148
						if ((0xffffffe7ffffffffL & l) == 0L)
149
							break;
150
						if (kind > 1)
151
							kind = 1;
152
						jjCheckNAddStates(0, 3);
153
						break;
154
					case 2:
155
						if ((0x1800000000L & l) == 0L)
156
							break;
157
						if (kind > 1)
158
							kind = 1;
159
						jjCheckNAddStates(0, 3);
160
						break;
161
					case 3:
162
						if (curChar == 36)
163
							jjstateSet[jjnewStateCnt++] = 4;
164
						break;
165
					case 4:
166
						if ((0xffffffefffffffffL & l) == 0L)
167
							break;
168
						if (kind > 1)
169
							kind = 1;
170
						jjCheckNAddStates(0, 3);
171
						break;
172
					case 5:
173
						if (curChar == 35)
174
							jjstateSet[jjnewStateCnt++] = 6;
175
						break;
176
					case 6:
177
						if ((0xfffffff7ffffffffL & l) == 0L)
178
							break;
179
						if (kind > 1)
180
							kind = 1;
181
						jjCheckNAddStates(0, 3);
182
						break;
183
					default:
184
						break;
185
					}
186
				} while (i != startsAt);
187
			} else if (curChar < 128) {
188
				long l = 1L << (curChar & 077);
189
				MatchLoop: do {
190
					switch (jjstateSet[--i]) {
191
					case 7:
192
						if ((0xffffffffefffffffL & l) != 0L) {
193
							if (kind > 1)
194
								kind = 1;
195
							jjCheckNAddStates(0, 3);
196
						} else if (curChar == 92)
197
							jjstateSet[jjnewStateCnt++] = 2;
198
						break;
199
					case 0:
200
						if ((0xffffffffefffffffL & l) == 0L)
201
							break;
202
						if (kind > 1)
203
							kind = 1;
204
						jjCheckNAddStates(0, 3);
205
						break;
206
					case 1:
207
						if (curChar == 92)
208
							jjstateSet[jjnewStateCnt++] = 2;
209
						break;
210
					case 2:
211
						if (curChar != 92)
212
							break;
213
						if (kind > 1)
214
							kind = 1;
215
						jjCheckNAddStates(0, 3);
216
						break;
217
					case 4:
218
					case 6:
219
						if ((0xf7ffffffffffffffL & l) == 0L)
220
							break;
221
						if (kind > 1)
222
							kind = 1;
223
						jjCheckNAddStates(0, 3);
224
						break;
225
					default:
226
						break;
227
					}
228
				} while (i != startsAt);
229
			} else {
230
				int hiByte = (int) (curChar >> 8);
231
				int i1 = hiByte >> 6;
232
				long l1 = 1L << (hiByte & 077);
233
				int i2 = (curChar & 0xff) >> 6;
234
				long l2 = 1L << (curChar & 077);
235
				MatchLoop: do {
236
					switch (jjstateSet[--i]) {
237
					case 7:
238
					case 0:
239
					case 4:
240
					case 6:
241
						if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
242
							break;
243
						if (kind > 1)
244
							kind = 1;
245
						jjCheckNAddStates(0, 3);
246
						break;
247
					default:
248
						break;
249
					}
250
				} while (i != startsAt);
251
			}
252
			if (kind != 0x7fffffff) {
253
				jjmatchedKind = kind;
254
				jjmatchedPos = curPos;
255
				kind = 0x7fffffff;
256
			}
257
			++curPos;
258
			if ((i = jjnewStateCnt) == (startsAt = 8 - (jjnewStateCnt = startsAt)))
259
				return curPos;
260
			try {
261
				curChar = input_stream.readChar();
262
			} catch (java.io.IOException e) {
263
				return curPos;
264
			}
265
		}
266
	}
267
268
	private final int jjStopStringLiteralDfa_1(int pos, long active0) {
269
		switch (pos) {
270
		case 0:
271
			if ((active0 & 0x141d555401c000L) != 0L) {
272
				jjmatchedKind = 53;
273
				return 41;
274
			}
275
			if ((active0 & 0x40000L) != 0L)
276
				return 1;
277
			return -1;
278
		case 1:
279
			if ((active0 & 0x41554000000L) != 0L)
280
				return 42;
281
			if ((active0 & 0x1419400001c000L) != 0L) {
282
				jjmatchedKind = 53;
283
				jjmatchedPos = 1;
284
				return 42;
285
			}
286
			return -1;
287
		case 2:
288
			if ((active0 & 0x14014000000000L) != 0L)
289
				return 42;
290
			if ((active0 & 0x18000001c000L) != 0L) {
291
				jjmatchedKind = 53;
292
				jjmatchedPos = 2;
293
				return 42;
294
			}
295
			return -1;
296
		case 3:
297
			if ((active0 & 0x14000L) != 0L)
298
				return 42;
299
			if ((active0 & 0x180000008000L) != 0L) {
300
				jjmatchedKind = 53;
301
				jjmatchedPos = 3;
302
				return 42;
303
			}
304
			return -1;
305
		case 4:
306
			if ((active0 & 0x80000008000L) != 0L)
307
				return 42;
308
			if ((active0 & 0x100000000000L) != 0L) {
309
				jjmatchedKind = 53;
310
				jjmatchedPos = 4;
311
				return 42;
312
			}
313
			return -1;
314
		case 5:
315
			if ((active0 & 0x100000000000L) != 0L) {
316
				jjmatchedKind = 53;
317
				jjmatchedPos = 5;
318
				return 42;
319
			}
320
			return -1;
321
		case 6:
322
			if ((active0 & 0x100000000000L) != 0L) {
323
				jjmatchedKind = 53;
324
				jjmatchedPos = 6;
325
				return 42;
326
			}
327
			return -1;
328
		case 7:
329
			if ((active0 & 0x100000000000L) != 0L) {
330
				jjmatchedKind = 53;
331
				jjmatchedPos = 7;
332
				return 42;
333
			}
334
			return -1;
335
		case 8:
336
			if ((active0 & 0x100000000000L) != 0L) {
337
				jjmatchedKind = 53;
338
				jjmatchedPos = 8;
339
				return 42;
340
			}
341
			return -1;
342
		default:
343
			return -1;
344
		}
345
	}
346
347
	private final int jjStartNfa_1(int pos, long active0) {
348
		return jjMoveNfa_1(jjStopStringLiteralDfa_1(pos, active0), pos + 1);
349
	}
350
351
	private final int jjStartNfaWithStates_1(int pos, int kind, int state) {
352
		jjmatchedKind = kind;
353
		jjmatchedPos = pos;
354
		try {
355
			curChar = input_stream.readChar();
356
		} catch (java.io.IOException e) {
357
			return pos + 1;
358
		}
359
		return jjMoveNfa_1(state, pos + 1);
360
	}
361
362
	private final int jjMoveStringLiteralDfa0_1() {
363
		switch (curChar) {
364
		case 33:
365
			jjmatchedKind = 37;
366
			return jjMoveStringLiteralDfa1_1(0x800000000L);
367
		case 37:
368
			return jjStopAtPos(0, 51);
369
		case 38:
370
			return jjMoveStringLiteralDfa1_1(0x8000000000L);
371
		case 40:
372
			return jjStopAtPos(0, 19);
373
		case 41:
374
			return jjStopAtPos(0, 20);
375
		case 42:
376
			return jjStopAtPos(0, 45);
377
		case 43:
378
			return jjStopAtPos(0, 46);
379
		case 44:
380
			return jjStopAtPos(0, 24);
381
		case 45:
382
			return jjStopAtPos(0, 47);
383
		case 46:
384
			return jjStartNfaWithStates_1(0, 18, 1);
385
		case 47:
386
			return jjStopAtPos(0, 49);
387
		case 58:
388
			return jjStopAtPos(0, 23);
389
		case 60:
390
			jjmatchedKind = 27;
391
			return jjMoveStringLiteralDfa1_1(0x80000000L);
392
		case 61:
393
			return jjMoveStringLiteralDfa1_1(0x200000000L);
394
		case 62:
395
			jjmatchedKind = 25;
396
			return jjMoveStringLiteralDfa1_1(0x20000000L);
397
		case 63:
398
			return jjStopAtPos(0, 48);
399
		case 91:
400
			return jjStopAtPos(0, 21);
401
		case 93:
402
			return jjStopAtPos(0, 22);
403
		case 97:
404
			return jjMoveStringLiteralDfa1_1(0x10000000000L);
405
		case 100:
406
			return jjMoveStringLiteralDfa1_1(0x4000000000000L);
407
		case 101:
408
			return jjMoveStringLiteralDfa1_1(0x80400000000L);
409
		case 102:
410
			return jjMoveStringLiteralDfa1_1(0x8000L);
411
		case 103:
412
			return jjMoveStringLiteralDfa1_1(0x44000000L);
413
		case 105:
414
			return jjMoveStringLiteralDfa1_1(0x100000000000L);
415
		case 108:
416
			return jjMoveStringLiteralDfa1_1(0x110000000L);
417
		case 109:
418
			return jjMoveStringLiteralDfa1_1(0x10000000000000L);
419
		case 110:
420
			return jjMoveStringLiteralDfa1_1(0x5000010000L);
421
		case 111:
422
			return jjMoveStringLiteralDfa1_1(0x40000000000L);
423
		case 116:
424
			return jjMoveStringLiteralDfa1_1(0x4000L);
425
		case 124:
426
			return jjMoveStringLiteralDfa1_1(0x20000000000L);
427
		case 125:
428
			return jjStopAtPos(0, 17);
429
		default:
430
			return jjMoveNfa_1(0, 0);
431
		}
432
	}
433
434
	private final int jjMoveStringLiteralDfa1_1(long active0) {
435
		try {
436
			curChar = input_stream.readChar();
437
		} catch (java.io.IOException e) {
438
			jjStopStringLiteralDfa_1(0, active0);
439
			return 1;
440
		}
441
		switch (curChar) {
442
		case 38:
443
			if ((active0 & 0x8000000000L) != 0L)
444
				return jjStopAtPos(1, 39);
445
			break;
446
		case 61:
447
			if ((active0 & 0x20000000L) != 0L)
448
				return jjStopAtPos(1, 29);
449
			else if ((active0 & 0x80000000L) != 0L)
450
				return jjStopAtPos(1, 31);
451
			else if ((active0 & 0x200000000L) != 0L)
452
				return jjStopAtPos(1, 33);
453
			else if ((active0 & 0x800000000L) != 0L)
454
				return jjStopAtPos(1, 35);
455
			break;
456
		case 97:
457
			return jjMoveStringLiteralDfa2_1(active0, 0x8000L);
458
		case 101:
459
			if ((active0 & 0x40000000L) != 0L)
460
				return jjStartNfaWithStates_1(1, 30, 42);
461
			else if ((active0 & 0x100000000L) != 0L)
462
				return jjStartNfaWithStates_1(1, 32, 42);
463
			else if ((active0 & 0x1000000000L) != 0L)
464
				return jjStartNfaWithStates_1(1, 36, 42);
465
			break;
466
		case 105:
467
			return jjMoveStringLiteralDfa2_1(active0, 0x4000000000000L);
468
		case 109:
469
			return jjMoveStringLiteralDfa2_1(active0, 0x80000000000L);
470
		case 110:
471
			return jjMoveStringLiteralDfa2_1(active0, 0x110000000000L);
472
		case 111:
473
			return jjMoveStringLiteralDfa2_1(active0, 0x10004000000000L);
474
		case 113:
475
			if ((active0 & 0x400000000L) != 0L)
476
				return jjStartNfaWithStates_1(1, 34, 42);
477
			break;
478
		case 114:
479
			if ((active0 & 0x40000000000L) != 0L)
480
				return jjStartNfaWithStates_1(1, 42, 42);
481
			return jjMoveStringLiteralDfa2_1(active0, 0x4000L);
482
		case 116:
483
			if ((active0 & 0x4000000L) != 0L)
484
				return jjStartNfaWithStates_1(1, 26, 42);
485
			else if ((active0 & 0x10000000L) != 0L)
486
				return jjStartNfaWithStates_1(1, 28, 42);
487
			break;
488
		case 117:
489
			return jjMoveStringLiteralDfa2_1(active0, 0x10000L);
490
		case 124:
491
			if ((active0 & 0x20000000000L) != 0L)
492
				return jjStopAtPos(1, 41);
493
			break;
494
		default:
495
			break;
496
		}
497
		return jjStartNfa_1(0, active0);
498
	}
499
500
	private final int jjMoveStringLiteralDfa2_1(long old0, long active0) {
501
		if (((active0 &= old0)) == 0L)
502
			return jjStartNfa_1(0, old0);
503
		try {
504
			curChar = input_stream.readChar();
505
		} catch (java.io.IOException e) {
506
			jjStopStringLiteralDfa_1(1, active0);
507
			return 2;
508
		}
509
		switch (curChar) {
510
		case 100:
511
			if ((active0 & 0x10000000000L) != 0L)
512
				return jjStartNfaWithStates_1(2, 40, 42);
513
			else if ((active0 & 0x10000000000000L) != 0L)
514
				return jjStartNfaWithStates_1(2, 52, 42);
515
			break;
516
		case 108:
517
			return jjMoveStringLiteralDfa3_1(active0, 0x18000L);
518
		case 112:
519
			return jjMoveStringLiteralDfa3_1(active0, 0x80000000000L);
520
		case 115:
521
			return jjMoveStringLiteralDfa3_1(active0, 0x100000000000L);
522
		case 116:
523
			if ((active0 & 0x4000000000L) != 0L)
524
				return jjStartNfaWithStates_1(2, 38, 42);
525
			break;
526
		case 117:
527
			return jjMoveStringLiteralDfa3_1(active0, 0x4000L);
528
		case 118:
529
			if ((active0 & 0x4000000000000L) != 0L)
530
				return jjStartNfaWithStates_1(2, 50, 42);
531
			break;
532
		default:
533
			break;
534
		}
535
		return jjStartNfa_1(1, active0);
536
	}
537
538
	private final int jjMoveStringLiteralDfa3_1(long old0, long active0) {
539
		if (((active0 &= old0)) == 0L)
540
			return jjStartNfa_1(1, old0);
541
		try {
542
			curChar = input_stream.readChar();
543
		} catch (java.io.IOException e) {
544
			jjStopStringLiteralDfa_1(2, active0);
545
			return 3;
546
		}
547
		switch (curChar) {
548
		case 101:
549
			if ((active0 & 0x4000L) != 0L)
550
				return jjStartNfaWithStates_1(3, 14, 42);
551
			break;
552
		case 108:
553
			if ((active0 & 0x10000L) != 0L)
554
				return jjStartNfaWithStates_1(3, 16, 42);
555
			break;
556
		case 115:
557
			return jjMoveStringLiteralDfa4_1(active0, 0x8000L);
558
		case 116:
559
			return jjMoveStringLiteralDfa4_1(active0, 0x180000000000L);
560
		default:
561
			break;
562
		}
563
		return jjStartNfa_1(2, active0);
564
	}
565
566
	private final int jjMoveStringLiteralDfa4_1(long old0, long active0) {
567
		if (((active0 &= old0)) == 0L)
568
			return jjStartNfa_1(2, old0);
569
		try {
570
			curChar = input_stream.readChar();
571
		} catch (java.io.IOException e) {
572
			jjStopStringLiteralDfa_1(3, active0);
573
			return 4;
574
		}
575
		switch (curChar) {
576
		case 97:
577
			return jjMoveStringLiteralDfa5_1(active0, 0x100000000000L);
578
		case 101:
579
			if ((active0 & 0x8000L) != 0L)
580
				return jjStartNfaWithStates_1(4, 15, 42);
581
			break;
582
		case 121:
583
			if ((active0 & 0x80000000000L) != 0L)
584
				return jjStartNfaWithStates_1(4, 43, 42);
585
			break;
586
		default:
587
			break;
588
		}
589
		return jjStartNfa_1(3, active0);
590
	}
591
592
	private final int jjMoveStringLiteralDfa5_1(long old0, long active0) {
593
		if (((active0 &= old0)) == 0L)
594
			return jjStartNfa_1(3, old0);
595
		try {
596
			curChar = input_stream.readChar();
597
		} catch (java.io.IOException e) {
598
			jjStopStringLiteralDfa_1(4, active0);
599
			return 5;
600
		}
601
		switch (curChar) {
602
		case 110:
603
			return jjMoveStringLiteralDfa6_1(active0, 0x100000000000L);
604
		default:
605
			break;
606
		}
607
		return jjStartNfa_1(4, active0);
608
	}
609
610
	private final int jjMoveStringLiteralDfa6_1(long old0, long active0) {
611
		if (((active0 &= old0)) == 0L)
612
			return jjStartNfa_1(4, old0);
613
		try {
614
			curChar = input_stream.readChar();
615
		} catch (java.io.IOException e) {
616
			jjStopStringLiteralDfa_1(5, active0);
617
			return 6;
618
		}
619
		switch (curChar) {
620
		case 99:
621
			return jjMoveStringLiteralDfa7_1(active0, 0x100000000000L);
622
		default:
623
			break;
624
		}
625
		return jjStartNfa_1(5, active0);
626
	}
627
628
	private final int jjMoveStringLiteralDfa7_1(long old0, long active0) {
629
		if (((active0 &= old0)) == 0L)
630
			return jjStartNfa_1(5, old0);
631
		try {
632
			curChar = input_stream.readChar();
633
		} catch (java.io.IOException e) {
634
			jjStopStringLiteralDfa_1(6, active0);
635
			return 7;
636
		}
637
		switch (curChar) {
638
		case 101:
639
			return jjMoveStringLiteralDfa8_1(active0, 0x100000000000L);
640
		default:
641
			break;
642
		}
643
		return jjStartNfa_1(6, active0);
644
	}
645
646
	private final int jjMoveStringLiteralDfa8_1(long old0, long active0) {
647
		if (((active0 &= old0)) == 0L)
648
			return jjStartNfa_1(6, old0);
649
		try {
650
			curChar = input_stream.readChar();
651
		} catch (java.io.IOException e) {
652
			jjStopStringLiteralDfa_1(7, active0);
653
			return 8;
654
		}
655
		switch (curChar) {
656
		case 111:
657
			return jjMoveStringLiteralDfa9_1(active0, 0x100000000000L);
658
		default:
659
			break;
660
		}
661
		return jjStartNfa_1(7, active0);
662
	}
663
664
	private final int jjMoveStringLiteralDfa9_1(long old0, long active0) {
665
		if (((active0 &= old0)) == 0L)
666
			return jjStartNfa_1(7, old0);
667
		try {
668
			curChar = input_stream.readChar();
669
		} catch (java.io.IOException e) {
670
			jjStopStringLiteralDfa_1(8, active0);
671
			return 9;
672
		}
673
		switch (curChar) {
674
		case 102:
675
			if ((active0 & 0x100000000000L) != 0L)
676
				return jjStartNfaWithStates_1(9, 44, 42);
677
			break;
678
		default:
679
			break;
680
		}
681
		return jjStartNfa_1(8, active0);
682
	}
683
684
	static final long[] jjbitVec3 = { 0x1ff00000fffffffeL, 0xffffffffffffc000L,
685
			0xffffffffL, 0x600000000000000L };
686
687
	static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL };
688
689
	static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL,
690
			0xffffffffffffffffL, 0xffffffffffffffffL };
691
692
	static final long[] jjbitVec6 = { 0xffffffffffffffffL, 0xffffffffffffffffL,
693
			0xffffL, 0x0L };
694
695
	static final long[] jjbitVec7 = { 0xffffffffffffffffL, 0xffffffffffffffffL,
696
			0x0L, 0x0L };
697
698
	static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
699
700
	private final int jjMoveNfa_1(int startState, int curPos) {
701
		int[] nextStates;
702
		int startsAt = 0;
703
		jjnewStateCnt = 41;
704
		int i = 1;
705
		jjstateSet[0] = startState;
706
		int j, kind = 0x7fffffff;
707
		for (;;) {
708
			if (++jjround == 0x7fffffff)
709
				ReInitRounds();
710
			if (curChar < 64) {
711
				long l = 1L << curChar;
712
				MatchLoop: do {
713
					switch (jjstateSet[--i]) {
714
					case 41:
715
						if ((0x3ff001000000000L & l) != 0L) {
716
							if (kind > 55)
717
								kind = 55;
718
							jjCheckNAdd(40);
719
						} else if ((0x600000000000L & l) != 0L)
720
							jjCheckNAddStates(4, 6);
721
						else if (curChar == 58) {
722
							if (kind > 54)
723
								kind = 54;
724
						}
725
						if ((0x3ff001000000000L & l) != 0L)
726
							jjCheckNAddStates(7, 10);
727
						if ((0x3ff001000000000L & l) != 0L) {
728
							if (kind > 53)
729
								kind = 53;
730
							jjCheckNAdd(34);
731
						}
732
						if ((0x1800000000L & l) != 0L)
733
							jjCheckNAddStates(11, 14);
734
						break;
735
					case 0:
736
						if ((0x3ff000000000000L & l) != 0L) {
737
							if (kind > 9)
738
								kind = 9;
739
							jjCheckNAddStates(15, 19);
740
						} else if ((0x1800000000L & l) != 0L) {
741
							if (kind > 53)
742
								kind = 53;
743
							jjCheckNAddStates(20, 25);
744
						} else if (curChar == 39)
745
							jjCheckNAddStates(26, 30);
746
						else if (curChar == 34)
747
							jjCheckNAddStates(31, 35);
748
						else if (curChar == 46)
749
							jjCheckNAdd(1);
750
						break;
751
					case 42:
752
						if ((0x3ff001000000000L & l) != 0L) {
753
							if (kind > 55)
754
								kind = 55;
755
							jjCheckNAdd(40);
756
						} else if ((0x600000000000L & l) != 0L)
757
							jjCheckNAddStates(4, 6);
758
						else if (curChar == 58) {
759
							if (kind > 54)
760
								kind = 54;
761
						}
762
						if ((0x3ff001000000000L & l) != 0L)
763
							jjCheckNAddStates(11, 14);
764
						if ((0x3ff001000000000L & l) != 0L)
765
							jjCheckNAddStates(7, 10);
766
						if ((0x3ff001000000000L & l) != 0L) {
767
							if (kind > 53)
768
								kind = 53;
769
							jjCheckNAdd(34);
770
						}
771
						if ((0x1800000000L & l) != 0L)
772
							jjCheckNAddStates(11, 14);
773
						break;
774
					case 1:
775
						if ((0x3ff000000000000L & l) == 0L)
776
							break;
777
						if (kind > 10)
778
							kind = 10;
779
						jjCheckNAddTwoStates(1, 2);
780
						break;
781
					case 3:
782
						if ((0x280000000000L & l) != 0L)
783
							jjCheckNAdd(4);
784
						break;
785
					case 4:
786
						if ((0x3ff000000000000L & l) == 0L)
787
							break;
788
						if (kind > 10)
789
							kind = 10;
790
						jjCheckNAdd(4);
791
						break;
792
					case 5:
793
						if ((0x3ff000000000000L & l) == 0L)
794
							break;
795
						if (kind > 9)
796
							kind = 9;
797
						jjCheckNAddStates(15, 19);
798
						break;
799
					case 6:
800
						if ((0x3ff000000000000L & l) == 0L)
801
							break;
802
						if (kind > 9)
803
							kind = 9;
804
						jjCheckNAdd(6);
805
						break;
806
					case 7:
807
						if ((0x3ff000000000000L & l) != 0L)
808
							jjCheckNAddTwoStates(7, 8);
809
						break;
810
					case 8:
811
						if (curChar != 46)
812
							break;
813
						if (kind > 10)
814
							kind = 10;
815
						jjCheckNAddTwoStates(9, 10);
816
						break;
817
					case 9:
818
						if ((0x3ff000000000000L & l) == 0L)
819
							break;
820
						if (kind > 10)
821
							kind = 10;
822
						jjCheckNAddTwoStates(9, 10);
823
						break;
824
					case 11:
825
						if ((0x280000000000L & l) != 0L)
826
							jjCheckNAdd(12);
827
						break;
828
					case 12:
829
						if ((0x3ff000000000000L & l) == 0L)
830
							break;
831
						if (kind > 10)
832
							kind = 10;
833
						jjCheckNAdd(12);
834
						break;
835
					case 13:
836
						if ((0x3ff000000000000L & l) != 0L)
837
							jjCheckNAddTwoStates(13, 14);
838
						break;
839
					case 15:
840
						if ((0x280000000000L & l) != 0L)
841
							jjCheckNAdd(16);
842
						break;
843
					case 16:
844
						if ((0x3ff000000000000L & l) == 0L)
845
							break;
846
						if (kind > 10)
847
							kind = 10;
848
						jjCheckNAdd(16);
849
						break;
850
					case 17:
851
						if (curChar == 34)
852
							jjCheckNAddStates(31, 35);
853
						break;
854
					case 18:
855
						if ((0xfffffffbffffffffL & l) != 0L)
856
							jjCheckNAddStates(36, 38);
857
						break;
858
					case 20:
859
						if (curChar == 34)
860
							jjCheckNAddStates(36, 38);
861
						break;
862
					case 21:
863
						if (curChar == 34 && kind > 12)
864
							kind = 12;
865
						break;
866
					case 22:
867
						if ((0xfffffffbffffffffL & l) != 0L)
868
							jjCheckNAddTwoStates(22, 23);
869
						break;
870
					case 24:
871
						if ((0xfffffffbffffffffL & l) != 0L && kind > 13)
872
							kind = 13;
873
						break;
874
					case 25:
875
						if (curChar == 39)
876
							jjCheckNAddStates(26, 30);
877
						break;
878
					case 26:
879
						if ((0xffffff7fffffffffL & l) != 0L)
880
							jjCheckNAddStates(39, 41);
881
						break;
882
					case 28:
883
						if (curChar == 39)
884
							jjCheckNAddStates(39, 41);
885
						break;
886
					case 29:
887
						if (curChar == 39 && kind > 12)
888
							kind = 12;
889
						break;
890
					case 30:
891
						if ((0xffffff7fffffffffL & l) != 0L)
892
							jjCheckNAddTwoStates(30, 31);
893
						break;
894
					case 32:
895
						if ((0xffffff7fffffffffL & l) != 0L && kind > 13)
896
							kind = 13;
897
						break;
898
					case 33:
899
						if ((0x1800000000L & l) == 0L)
900
							break;
901
						if (kind > 53)
902
							kind = 53;
903
						jjCheckNAddStates(20, 25);
904
						break;
905
					case 34:
906
						if ((0x3ff001000000000L & l) == 0L)
907
							break;
908
						if (kind > 53)
909
							kind = 53;
910
						jjCheckNAdd(34);
911
						break;
912
					case 35:
913
						if ((0x3ff001000000000L & l) != 0L)
914
							jjCheckNAddStates(7, 10);
915
						break;
916
					case 36:
917
						if ((0x1800000000L & l) != 0L)
918
							jjCheckNAddStates(11, 14);
919
						break;
920
					case 37:
921
						if ((0x3ff001000000000L & l) != 0L)
922
							jjCheckNAddStates(11, 14);
923
						break;
924
					case 38:
925
						if ((0x600000000000L & l) != 0L)
926
							jjCheckNAddStates(4, 6);
927
						break;
928
					case 39:
929
						if (curChar == 58 && kind > 54)
930
							kind = 54;
931
						break;
932
					case 40:
933
						if ((0x3ff001000000000L & l) == 0L)
934
							break;
935
						if (kind > 55)
936
							kind = 55;
937
						jjCheckNAdd(40);
938
						break;
939
					default:
940
						break;
941
					}
942
				} while (i != startsAt);
943
			} else if (curChar < 128) {
944
				long l = 1L << (curChar & 077);
945
				MatchLoop: do {
946
					switch (jjstateSet[--i]) {
947
					case 41:
948
						if ((0x7fffffe87fffffeL & l) != 0L) {
949
							if (kind > 55)
950
								kind = 55;
951
							jjCheckNAdd(40);
952
						}
953
						if ((0x7fffffe87fffffeL & l) != 0L)
954
							jjCheckNAddStates(11, 14);
955
						if ((0x7fffffe87fffffeL & l) != 0L)
956
							jjCheckNAddStates(7, 10);
957
						if ((0x7fffffe87fffffeL & l) != 0L) {
958
							if (kind > 53)
959
								kind = 53;
960
							jjCheckNAdd(34);
961
						}
962
						break;
963
					case 0:
964
						if ((0x7fffffe87fffffeL & l) == 0L)
965
							break;
966
						if (kind > 53)
967
							kind = 53;
968
						jjCheckNAddStates(20, 25);
969
						break;
970
					case 42:
971
						if ((0x7fffffe87fffffeL & l) != 0L) {
972
							if (kind > 55)
973
								kind = 55;
974
							jjCheckNAdd(40);
975
						}
976
						if ((0x7fffffe87fffffeL & l) != 0L)
977
							jjCheckNAddStates(11, 14);
978
						if ((0x7fffffe87fffffeL & l) != 0L)
979
							jjCheckNAddStates(11, 14);
980
						if ((0x7fffffe87fffffeL & l) != 0L)
981
							jjCheckNAddStates(7, 10);
982
						if ((0x7fffffe87fffffeL & l) != 0L) {
983
							if (kind > 53)
984
								kind = 53;
985
							jjCheckNAdd(34);
986
						}
987
						break;
988
					case 2:
989
						if ((0x2000000020L & l) != 0L)
990
							jjAddStates(42, 43);
991
						break;
992
					case 10:
993
						if ((0x2000000020L & l) != 0L)
994
							jjAddStates(44, 45);
995
						break;
996
					case 14:
997
						if ((0x2000000020L & l) != 0L)
998
							jjAddStates(46, 47);
999
						break;
1000
					case 18:
1001
						if ((0xffffffffefffffffL & l) != 0L)
1002
							jjCheckNAddStates(36, 38);
1003
						break;
1004
					case 19:
1005
						if (curChar == 92)
1006
							jjstateSet[jjnewStateCnt++] = 20;
1007
						break;
1008
					case 20:
1009
						if (curChar == 92)
1010
							jjCheckNAddStates(36, 38);
1011
						break;
1012
					case 22:
1013
						if ((0xffffffffefffffffL & l) != 0L)
1014
							jjAddStates(48, 49);
1015
						break;
1016
					case 23:
1017
						if (curChar == 92)
1018
							jjstateSet[jjnewStateCnt++] = 24;
1019
						break;
1020
					case 24:
1021
					case 32:
1022
						if ((0xffffffffefffffffL & l) != 0L && kind > 13)
1023
							kind = 13;
1024
						break;
1025
					case 26:
1026
						if ((0xffffffffefffffffL & l) != 0L)
1027
							jjCheckNAddStates(39, 41);
1028
						break;
1029
					case 27:
1030
						if (curChar == 92)
1031
							jjstateSet[jjnewStateCnt++] = 28;
1032
						break;
1033
					case 28:
1034
						if (curChar == 92)
1035
							jjCheckNAddStates(39, 41);
1036
						break;
1037
					case 30:
1038
						if ((0xffffffffefffffffL & l) != 0L)
1039
							jjAddStates(50, 51);
1040
						break;
1041
					case 31:
1042
						if (curChar == 92)
1043
							jjstateSet[jjnewStateCnt++] = 32;
1044
						break;
1045
					case 34:
1046
						if ((0x7fffffe87fffffeL & l) == 0L)
1047
							break;
1048
						if (kind > 53)
1049
							kind = 53;
1050
						jjCheckNAdd(34);
1051
						break;
1052
					case 35:
1053
						if ((0x7fffffe87fffffeL & l) != 0L)
1054
							jjCheckNAddStates(7, 10);
1055
						break;
1056
					case 36:
1057
						if ((0x7fffffe87fffffeL & l) != 0L)
1058
							jjCheckNAddStates(11, 14);
1059
						break;
1060
					case 37:
1061
						if ((0x7fffffe87fffffeL & l) != 0L)
1062
							jjCheckNAddStates(11, 14);
1063
						break;
1064
					case 40:
1065
						if ((0x7fffffe87fffffeL & l) == 0L)
1066
							break;
1067
						if (kind > 55)
1068
							kind = 55;
1069
						jjCheckNAdd(40);
1070
						break;
1071
					default:
1072
						break;
1073
					}
1074
				} while (i != startsAt);
1075
			} else {
1076
				int hiByte = (int) (curChar >> 8);
1077
				int i1 = hiByte >> 6;
1078
				long l1 = 1L << (hiByte & 077);
1079
				int i2 = (curChar & 0xff) >> 6;
1080
				long l2 = 1L << (curChar & 077);
1081
				MatchLoop: do {
1082
					switch (jjstateSet[--i]) {
1083
					case 41:
1084
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1085
							if (kind > 53)
1086
								kind = 53;
1087
							jjCheckNAdd(34);
1088
						}
1089
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1090
							jjCheckNAddStates(7, 10);
1091
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1092
							jjCheckNAddStates(11, 14);
1093
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1094
							if (kind > 55)
1095
								kind = 55;
1096
							jjCheckNAdd(40);
1097
						}
1098
						break;
1099
					case 0:
1100
						if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1101
							break;
1102
						if (kind > 53)
1103
							kind = 53;
1104
						jjCheckNAddStates(20, 25);
1105
						break;
1106
					case 42:
1107
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1108
							if (kind > 53)
1109
								kind = 53;
1110
							jjCheckNAdd(34);
1111
						}
1112
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1113
							jjCheckNAddStates(7, 10);
1114
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1115
							jjCheckNAddStates(11, 14);
1116
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1117
							jjCheckNAddStates(11, 14);
1118
						if (jjCanMove_1(hiByte, i1, i2, l1, l2)) {
1119
							if (kind > 55)
1120
								kind = 55;
1121
							jjCheckNAdd(40);
1122
						}
1123
						break;
1124
					case 18:
1125
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1126
							jjAddStates(36, 38);
1127
						break;
1128
					case 22:
1129
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1130
							jjAddStates(48, 49);
1131
						break;
1132
					case 24:
1133
					case 32:
1134
						if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
1135
							kind = 13;
1136
						break;
1137
					case 26:
1138
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1139
							jjAddStates(39, 41);
1140
						break;
1141
					case 30:
1142
						if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1143
							jjAddStates(50, 51);
1144
						break;
1145
					case 34:
1146
						if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1147
							break;
1148
						if (kind > 53)
1149
							kind = 53;
1150
						jjCheckNAdd(34);
1151
						break;
1152
					case 35:
1153
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1154
							jjCheckNAddStates(7, 10);
1155
						break;
1156
					case 36:
1157
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1158
							jjCheckNAddStates(11, 14);
1159
						break;
1160
					case 37:
1161
						if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1162
							jjCheckNAddStates(11, 14);
1163
						break;
1164
					case 40:
1165
						if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1166
							break;
1167
						if (kind > 55)
1168
							kind = 55;
1169
						jjCheckNAdd(40);
1170
						break;
1171
					default:
1172
						break;
1173
					}
1174
				} while (i != startsAt);
1175
			}
1176
			if (kind != 0x7fffffff) {
1177
				jjmatchedKind = kind;
1178
				jjmatchedPos = curPos;
1179
				kind = 0x7fffffff;
1180
			}
1181
			++curPos;
1182
			if ((i = jjnewStateCnt) == (startsAt = 41 - (jjnewStateCnt = startsAt)))
1183
				return curPos;
1184
			try {
1185
				curChar = input_stream.readChar();
1186
			} catch (java.io.IOException e) {
1187
				return curPos;
1188
			}
1189
		}
1190
	}
1191
1192
	static final int[] jjnextStates = { 0, 1, 3, 5, 36, 38, 39, 35, 36, 38, 39,
1193
			36, 37, 38, 39, 6, 7, 8, 13, 14, 34, 35, 36, 38, 39, 40, 26, 27,
1194
			29, 30, 31, 18, 19, 21, 22, 23, 18, 19, 21, 26, 27, 29, 3, 4, 11,
1195
			12, 15, 16, 22, 23, 30, 31, };
1196
1197
	private static final boolean jjCanMove_0(int hiByte, int i1, int i2,
1198
			long l1, long l2) {
1199
		switch (hiByte) {
1200
		case 0:
1201
			return ((jjbitVec2[i2] & l2) != 0L);
1202
		default:
1203
			if ((jjbitVec0[i1] & l1) != 0L)
1204
				return true;
1205
			return false;
1206
		}
1207
	}
1208
1209
	private static final boolean jjCanMove_1(int hiByte, int i1, int i2,
1210
			long l1, long l2) {
1211
		switch (hiByte) {
1212
		case 0:
1213
			return ((jjbitVec4[i2] & l2) != 0L);
1214
		case 48:
1215
			return ((jjbitVec5[i2] & l2) != 0L);
1216
		case 49:
1217
			return ((jjbitVec6[i2] & l2) != 0L);
1218
		case 51:
1219
			return ((jjbitVec7[i2] & l2) != 0L);
1220
		case 61:
1221
			return ((jjbitVec8[i2] & l2) != 0L);
1222
		default:
1223
			if ((jjbitVec3[i1] & l1) != 0L)
1224
				return true;
1225
			return false;
1226
		}
1227
	}
1228
1229
	public static final String[] jjstrLiteralImages = { "", null, "\44\173",
1230
			"\43\173", null, null, null, null, null, null, null, null, null,
1231
			null, "\164\162\165\145", "\146\141\154\163\145",
1232
			"\156\165\154\154", "\175", "\56", "\50", "\51", "\133", "\135",
1233
			"\72", "\54", "\76", "\147\164", "\74", "\154\164", "\76\75",
1234
			"\147\145", "\74\75", "\154\145", "\75\75", "\145\161", "\41\75",
1235
			"\156\145", "\41", "\156\157\164", "\46\46", "\141\156\144",
1236
			"\174\174", "\157\162", "\145\155\160\164\171",
1237
			"\151\156\163\164\141\156\143\145\157\146", "\52", "\53", "\55",
1238
			"\77", "\57", "\144\151\166", "\45", "\155\157\144", null, null,
1239
			null, null, null, null, null, };
1240
1241
	public static final String[] lexStateNames = { "DEFAULT", "IN_EXPRESSION", };
1242
1243
	public static final int[] jjnewLexState = { -1, -1, 1, 1, -1, -1, -1, -1,
1244
			-1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1,
1245
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1246
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1247
			-1, };
1248
1249
	static final long[] jjtoToken = { 0x8fffffffffff60fL, };
1250
1251
	static final long[] jjtoSkip = { 0x1f0L, };
1252
1253
	protected SimpleCharStream input_stream;
1254
1255
	private final int[] jjrounds = new int[41];
1256
1257
	private final int[] jjstateSet = new int[82];
1258
1259
	protected char curChar;
1260
1261
	public ELParserTokenManager(SimpleCharStream stream) {
1262
		if (SimpleCharStream.staticFlag)
1263
			throw new Error(
1264
					"ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1265
		input_stream = stream;
1266
	}
1267
1268
	public ELParserTokenManager(SimpleCharStream stream, int lexState) {
1269
		this(stream);
1270
		SwitchTo(lexState);
1271
	}
1272
1273
	public void ReInit(SimpleCharStream stream) {
1274
		jjmatchedPos = jjnewStateCnt = 0;
1275
		curLexState = defaultLexState;
1276
		input_stream = stream;
1277
		ReInitRounds();
1278
	}
1279
1280
	private final void ReInitRounds() {
1281
		int i;
1282
		jjround = 0x80000001;
1283
		for (i = 41; i-- > 0;)
1284
			jjrounds[i] = 0x80000000;
1285
	}
1286
1287
	public void ReInit(SimpleCharStream stream, int lexState) {
1288
		ReInit(stream);
1289
		SwitchTo(lexState);
1290
	}
1291
1292
	public void SwitchTo(int lexState) {
1293
		if (lexState >= 2 || lexState < 0)
1294
			throw new TokenMgrError("Error: Ignoring invalid lexical state : "
1295
					+ lexState + ". State unchanged.",
1296
					TokenMgrError.INVALID_LEXICAL_STATE);
1297
		else
1298
			curLexState = lexState;
1299
	}
1300
1301
	protected Token jjFillToken() {
1302
		Token t = Token.newToken(jjmatchedKind);
1303
		t.kind = jjmatchedKind;
1304
		String im = jjstrLiteralImages[jjmatchedKind];
1305
		t.image = (im == null) ? input_stream.GetImage() : im;
1306
		t.beginLine = input_stream.getBeginLine();
1307
		t.beginColumn = input_stream.getBeginColumn();
1308
		t.endLine = input_stream.getEndLine();
1309
		t.endColumn = input_stream.getEndColumn();
1310
		return t;
1311
	}
1312
1313
	int curLexState = 0;
1314
1315
	int defaultLexState = 0;
1316
1317
	int jjnewStateCnt;
1318
1319
	int jjround;
1320
1321
	int jjmatchedPos;
1322
1323
	int jjmatchedKind;
1324
1325
	public Token getNextToken() {
1326
		int kind;
1327
		Token specialToken = null;
1328
		Token matchedToken;
1329
		int curPos = 0;
1330
1331
		EOFLoop: for (;;) {
1332
			try {
1333
				curChar = input_stream.BeginToken();
1334
			} catch (java.io.IOException e) {
1335
				jjmatchedKind = 0;
1336
				matchedToken = jjFillToken();
1337
				return matchedToken;
1338
			}
1339
1340
			switch (curLexState) {
1341
			case 0:
1342
				jjmatchedKind = 0x7fffffff;
1343
				jjmatchedPos = 0;
1344
				curPos = jjMoveStringLiteralDfa0_0();
1345
				break;
1346
			case 1:
1347
				try {
1348
					input_stream.backup(0);
1349
					while (curChar <= 32
1350
							&& (0x100002600L & (1L << curChar)) != 0L)
1351
						curChar = input_stream.BeginToken();
1352
				} catch (java.io.IOException e1) {
1353
					continue EOFLoop;
1354
				}
1355
				jjmatchedKind = 0x7fffffff;
1356
				jjmatchedPos = 0;
1357
				curPos = jjMoveStringLiteralDfa0_1();
1358
				if (jjmatchedPos == 0 && jjmatchedKind > 59) {
1359
					jjmatchedKind = 59;
1360
				}
1361
				break;
1362
			}
1363
			if (jjmatchedKind != 0x7fffffff) {
1364
				if (jjmatchedPos + 1 < curPos)
1365
					input_stream.backup(curPos - jjmatchedPos - 1);
1366
				if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L) {
1367
					matchedToken = jjFillToken();
1368
					if (jjnewLexState[jjmatchedKind] != -1)
1369
						curLexState = jjnewLexState[jjmatchedKind];
1370
					return matchedToken;
1371
				} else {
1372
					if (jjnewLexState[jjmatchedKind] != -1)
1373
						curLexState = jjnewLexState[jjmatchedKind];
1374
					continue EOFLoop;
1375
				}
1376
			}
1377
			int error_line = input_stream.getEndLine();
1378
			int error_column = input_stream.getEndColumn();
1379
			String error_after = null;
1380
			boolean EOFSeen = false;
1381
			try {
1382
				input_stream.readChar();
1383
				input_stream.backup(1);
1384
			} catch (java.io.IOException e1) {
1385
				EOFSeen = true;
1386
				error_after = curPos <= 1 ? "" : input_stream.GetImage();
1387
				if (curChar == '\n' || curChar == '\r') {
1388
					error_line++;
1389
					error_column = 0;
1390
				} else
1391
					error_column++;
1392
			}
1393
			if (!EOFSeen) {
1394
				input_stream.backup(1);
1395
				error_after = curPos <= 1 ? "" : input_stream.GetImage();
1396
			}
1397
			throw new TokenMgrError(EOFSeen, curLexState, error_line,
1398
					error_column, error_after, curChar,
1399
					TokenMgrError.LEXICAL_ERROR);
1400
		}
1401
	}
1402
1403
}
1397
}
(-)ELParserConstants.java (-124 / +123 lines)
Lines 3-133 Link Here
3
3
4
public interface ELParserConstants {
4
public interface ELParserConstants {
5
5
6
	int EOF = 0;
6
  int EOF = 0;
7
  int LITERAL_EXPRESSION = 1;
8
  int START_DYNAMIC_EXPRESSION = 2;
9
  int START_DEFERRED_EXPRESSION = 3;
10
  int INTEGER_LITERAL = 9;
11
  int FLOATING_POINT_LITERAL = 10;
12
  int EXPONENT = 11;
13
  int STRING_LITERAL = 12;
14
  int BADLY_ESCAPED_STRING_LITERAL = 13;
15
  int TRUE = 14;
16
  int FALSE = 15;
17
  int NULL = 16;
18
  int END_EXPRESSION = 17;
19
  int DOT = 18;
20
  int LPAREN = 19;
21
  int RPAREN = 20;
22
  int LBRACK = 21;
23
  int RBRACK = 22;
24
  int COLON = 23;
25
  int COMMA = 24;
26
  int GT0 = 25;
27
  int GT1 = 26;
28
  int LT0 = 27;
29
  int LT1 = 28;
30
  int GE0 = 29;
31
  int GE1 = 30;
32
  int LE0 = 31;
33
  int LE1 = 32;
34
  int EQ0 = 33;
35
  int EQ1 = 34;
36
  int NE0 = 35;
37
  int NE1 = 36;
38
  int NOT0 = 37;
39
  int NOT1 = 38;
40
  int AND0 = 39;
41
  int AND1 = 40;
42
  int OR0 = 41;
43
  int OR1 = 42;
44
  int EMPTY = 43;
45
  int INSTANCEOF = 44;
46
  int MULT = 45;
47
  int PLUS = 46;
48
  int MINUS = 47;
49
  int QUESTIONMARK = 48;
50
  int DIV0 = 49;
51
  int DIV1 = 50;
52
  int MOD0 = 51;
53
  int MOD1 = 52;
54
  int IDENTIFIER = 53;
55
  int NAMESPACE = 54;
56
  int NAMESPACE_NAME = 55;
57
  int FUNCTION_CALL = 56;
58
  int FUNCTIONSUFFIX = 57;
59
  int IMPL_OBJ_START = 58;
60
  int LETTER = 59;
61
  int DIGIT = 60;
62
  int ILLEGAL_CHARACTER = 61;
7
63
8
	int LITERAL_EXPRESSION = 1;
64
  int DEFAULT = 0;
65
  int IN_EXPRESSION = 1;
9
66
10
	int START_DYNAMIC_EXPRESSION = 2;
67
  String[] tokenImage = {
68
    "<EOF>",
69
    "<LITERAL_EXPRESSION>",
70
    "\"${\"",
71
    "\"#{\"",
72
    "\"\\\\\"",
73
    "\" \"",
74
    "\"\\t\"",
75
    "\"\\n\"",
76
    "\"\\r\"",
77
    "<INTEGER_LITERAL>",
78
    "<FLOATING_POINT_LITERAL>",
79
    "<EXPONENT>",
80
    "<STRING_LITERAL>",
81
    "<BADLY_ESCAPED_STRING_LITERAL>",
82
    "\"true\"",
83
    "\"false\"",
84
    "\"null\"",
85
    "\"}\"",
86
    "\".\"",
87
    "\"(\"",
88
    "\")\"",
89
    "\"[\"",
90
    "\"]\"",
91
    "\":\"",
92
    "\",\"",
93
    "\">\"",
94
    "\"gt\"",
95
    "\"<\"",
96
    "\"lt\"",
97
    "\">=\"",
98
    "\"ge\"",
99
    "\"<=\"",
100
    "\"le\"",
101
    "\"==\"",
102
    "\"eq\"",
103
    "\"!=\"",
104
    "\"ne\"",
105
    "\"!\"",
106
    "\"not\"",
107
    "\"&&\"",
108
    "\"and\"",
109
    "\"||\"",
110
    "\"or\"",
111
    "\"empty\"",
112
    "\"instanceof\"",
113
    "\"*\"",
114
    "\"+\"",
115
    "\"-\"",
116
    "\"?\"",
117
    "\"/\"",
118
    "\"div\"",
119
    "\"%\"",
120
    "\"mod\"",
121
    "<IDENTIFIER>",
122
    "<NAMESPACE>",
123
    "<NAMESPACE_NAME>",
124
    "<FUNCTION_CALL>",
125
    "<FUNCTIONSUFFIX>",
126
    "\"#\"",
127
    "<LETTER>",
128
    "<DIGIT>",
129
    "<ILLEGAL_CHARACTER>",
130
  };
11
131
12
	int START_DEFERRED_EXPRESSION = 3;
13
14
	int INTEGER_LITERAL = 9;
15
16
	int FLOATING_POINT_LITERAL = 10;
17
18
	int EXPONENT = 11;
19
20
	int STRING_LITERAL = 12;
21
22
	int BADLY_ESCAPED_STRING_LITERAL = 13;
23
24
	int TRUE = 14;
25
26
	int FALSE = 15;
27
28
	int NULL = 16;
29
30
	int END_EXPRESSION = 17;
31
32
	int DOT = 18;
33
34
	int LPAREN = 19;
35
36
	int RPAREN = 20;
37
38
	int LBRACK = 21;
39
40
	int RBRACK = 22;
41
42
	int COLON = 23;
43
44
	int COMMA = 24;
45
46
	int GT0 = 25;
47
48
	int GT1 = 26;
49
50
	int LT0 = 27;
51
52
	int LT1 = 28;
53
54
	int GE0 = 29;
55
56
	int GE1 = 30;
57
58
	int LE0 = 31;
59
60
	int LE1 = 32;
61
62
	int EQ0 = 33;
63
64
	int EQ1 = 34;
65
66
	int NE0 = 35;
67
68
	int NE1 = 36;
69
70
	int NOT0 = 37;
71
72
	int NOT1 = 38;
73
74
	int AND0 = 39;
75
76
	int AND1 = 40;
77
78
	int OR0 = 41;
79
80
	int OR1 = 42;
81
82
	int EMPTY = 43;
83
84
	int INSTANCEOF = 44;
85
86
	int MULT = 45;
87
88
	int PLUS = 46;
89
90
	int MINUS = 47;
91
92
	int QUESTIONMARK = 48;
93
94
	int DIV0 = 49;
95
96
	int DIV1 = 50;
97
98
	int MOD0 = 51;
99
100
	int MOD1 = 52;
101
102
	int IDENTIFIER = 53;
103
104
	int NAMESPACE = 54;
105
106
	int FUNCTIONSUFFIX = 55;
107
108
	int IMPL_OBJ_START = 56;
109
110
	int LETTER = 57;
111
112
	int DIGIT = 58;
113
114
	int ILLEGAL_CHARACTER = 59;
115
116
	int DEFAULT = 0;
117
118
	int IN_EXPRESSION = 1;
119
120
	String[] tokenImage = { "<EOF>", "<LITERAL_EXPRESSION>", "\"${\"",
121
			"\"#{\"", "\"\\\\\"", "\" \"", "\"\\t\"", "\"\\n\"", "\"\\r\"",
122
			"<INTEGER_LITERAL>", "<FLOATING_POINT_LITERAL>", "<EXPONENT>",
123
			"<STRING_LITERAL>", "<BADLY_ESCAPED_STRING_LITERAL>", "\"true\"",
124
			"\"false\"", "\"null\"", "\"}\"", "\".\"", "\"(\"", "\")\"",
125
			"\"[\"", "\"]\"", "\":\"", "\",\"", "\">\"", "\"gt\"", "\"<\"",
126
			"\"lt\"", "\">=\"", "\"ge\"", "\"<=\"", "\"le\"", "\"==\"",
127
			"\"eq\"", "\"!=\"", "\"ne\"", "\"!\"", "\"not\"", "\"&&\"",
128
			"\"and\"", "\"||\"", "\"or\"", "\"empty\"", "\"instanceof\"",
129
			"\"*\"", "\"+\"", "\"-\"", "\"?\"", "\"/\"", "\"div\"", "\"%\"",
130
			"\"mod\"", "<IDENTIFIER>", "<NAMESPACE>", "<FUNCTIONSUFFIX>",
131
			"\"#\"", "<LETTER>", "<DIGIT>", "<ILLEGAL_CHARACTER>", };
132
133
}
132
}
(-)ELParser.java (-116 / +364 lines)
Lines 13-26 Link Here
13
    }
13
    }
14
  
14
  
15
  public static void main(String[] argv) throws Exception {
15
  public static void main(String[] argv) throws Exception {
16
	  String[] str = { "${foo()}", "${fn.fn:foo() ? a : b}", "${fn:foo() ? (fn_af.f:fd() ? a : b) : b}", "${a.b.c ? a : b}" };
16
	  String[] str = { "${foo()}", "${fn.fn:foo() ? a : b}", "${fn:foo() ? (fn_af.f:fd() ? a : b) : b}", "${a.b.c ? a : b}", "${true?false:true}" };
17
		for (int i = 0; i < str.length; i++) {
17
		for (int i = 0; i < str.length; i++) {
18
			SimpleNode sn = (SimpleNode) ELParser.parse(str[i]);
18
			SimpleNode sn = (SimpleNode) ELParser.parse(str[i]);
19
			System.out.println("====\n" + str[i]);
19
			System.out.println("====\n" + str[i]);
20
			sn.dump("\t");
20
			sn.dump("\t");
21
		}
21
		}
22
  }
22
  }
23
23
  
24
/*
24
/*
25
 * CompositeExpression
25
 * CompositeExpression
26
 * Allow most flexible parsing, restrict by examining
26
 * Allow most flexible parsing, restrict by examining
Lines 956-962 Link Here
956
    case NULL:
956
    case NULL:
957
    case LPAREN:
957
    case LPAREN:
958
    case IDENTIFIER:
958
    case IDENTIFIER:
959
    case NAMESPACE:
959
    case FUNCTION_CALL:
960
      Value();
960
      Value();
961
      break;
961
      break;
962
    default:
962
    default:
Lines 1026-1032 Link Here
1026
      break;
1026
      break;
1027
    case LPAREN:
1027
    case LPAREN:
1028
    case IDENTIFIER:
1028
    case IDENTIFIER:
1029
    case NAMESPACE:
1029
    case FUNCTION_CALL:
1030
      NonLiteral();
1030
      NonLiteral();
1031
      break;
1031
      break;
1032
    default:
1032
    default:
Lines 1169-1194 Link Here
1169
 /*@bgen(jjtree) Function */
1169
 /*@bgen(jjtree) Function */
1170
        AstFunction jjtn000 = new AstFunction(JJTFUNCTION);
1170
        AstFunction jjtn000 = new AstFunction(JJTFUNCTION);
1171
        boolean jjtc000 = true;
1171
        boolean jjtc000 = true;
1172
        jjtree.openNodeScope(jjtn000);Token t0 = null;
1172
        jjtree.openNodeScope(jjtn000);Token tx = null;
1173
        Token t1 = null;
1174
    try {
1173
    try {
1174
      tx = jj_consume_token(FUNCTION_CALL);
1175
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1175
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1176
      case NAMESPACE:
1177
        t0 = jj_consume_token(NAMESPACE);
1178
        break;
1179
      default:
1180
        jj_la1[30] = jj_gen;
1181
        ;
1182
      }
1183
      t1 = jj_consume_token(IDENTIFIER);
1184
                if (t0 != null) {
1185
                        jjtn000.setPrefix(t0.image.substring(0, t0.image.length() - 1));
1186
                        jjtn000.setLocalName(t1.image);
1187
                } else {
1188
                        jjtn000.setLocalName(t1.image);
1189
                }
1190
      jj_consume_token(LPAREN);
1191
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1192
      case INTEGER_LITERAL:
1176
      case INTEGER_LITERAL:
1193
      case FLOATING_POINT_LITERAL:
1177
      case FLOATING_POINT_LITERAL:
1194
      case STRING_LITERAL:
1178
      case STRING_LITERAL:
Lines 1201-1207 Link Here
1201
      case EMPTY:
1185
      case EMPTY:
1202
      case MINUS:
1186
      case MINUS:
1203
      case IDENTIFIER:
1187
      case IDENTIFIER:
1204
      case NAMESPACE:
1188
      case FUNCTION_CALL:
1205
        Expression();
1189
        Expression();
1206
        label_10:
1190
        label_10:
1207
        while (true) {
1191
        while (true) {
Lines 1210-1216 Link Here
1210
            ;
1194
            ;
1211
            break;
1195
            break;
1212
          default:
1196
          default:
1213
            jj_la1[31] = jj_gen;
1197
            jj_la1[30] = jj_gen;
1214
            break label_10;
1198
            break label_10;
1215
          }
1199
          }
1216
          jj_consume_token(COMMA);
1200
          jj_consume_token(COMMA);
Lines 1218-1227 Link Here
1218
        }
1202
        }
1219
        break;
1203
        break;
1220
      default:
1204
      default:
1221
        jj_la1[32] = jj_gen;
1205
        jj_la1[31] = jj_gen;
1222
        ;
1206
        ;
1223
      }
1207
      }
1224
      jj_consume_token(RPAREN);
1208
      jj_consume_token(RPAREN);
1209
          jjtree.closeNodeScope(jjtn000, true);
1210
          jjtc000 = false;
1211
                int split = tx.image.indexOf(":");
1212
                if (split!=-1) {
1213
                        jjtn000.setPrefix(tx.image.substring(0, split));
1214
                        jjtn000.setLocalName(tx.image.substring(split + 1, tx.image.length() - 1));
1215
                } else {
1216
                        jjtn000.setLocalName(tx.image.substring(0, tx.image.length() - 1));
1217
                }
1225
    } catch (Throwable jjte000) {
1218
    } catch (Throwable jjte000) {
1226
          if (jjtc000) {
1219
          if (jjtc000) {
1227
            jjtree.clearNodeScope(jjtn000);
1220
            jjtree.clearNodeScope(jjtn000);
Lines 1266-1272 Link Here
1266
      Null();
1259
      Null();
1267
      break;
1260
      break;
1268
    default:
1261
    default:
1269
      jj_la1[33] = jj_gen;
1262
      jj_la1[32] = jj_gen;
1270
      jj_consume_token(-1);
1263
      jj_consume_token(-1);
1271
      throw new ParseException();
1264
      throw new ParseException();
1272
    }
1265
    }
Lines 1303-1309 Link Here
1303
      }
1296
      }
1304
      break;
1297
      break;
1305
    default:
1298
    default:
1306
      jj_la1[34] = jj_gen;
1299
      jj_la1[33] = jj_gen;
1307
      jj_consume_token(-1);
1300
      jj_consume_token(-1);
1308
      throw new ParseException();
1301
      throw new ParseException();
1309
    }
1302
    }
Lines 1398-1431 Link Here
1398
  }
1391
  }
1399
1392
1400
  final private boolean jj_3R_11() {
1393
  final private boolean jj_3R_11() {
1394
    if (jj_scan_token(FUNCTION_CALL)) return true;
1401
    Token xsp;
1395
    Token xsp;
1402
    xsp = jj_scanpos;
1396
    xsp = jj_scanpos;
1403
    if (jj_scan_token(54)) jj_scanpos = xsp;
1404
    if (jj_scan_token(IDENTIFIER)) return true;
1405
    if (jj_scan_token(LPAREN)) return true;
1406
    xsp = jj_scanpos;
1407
    if (jj_3R_12()) jj_scanpos = xsp;
1397
    if (jj_3R_12()) jj_scanpos = xsp;
1408
    if (jj_scan_token(RPAREN)) return true;
1398
    if (jj_scan_token(RPAREN)) return true;
1409
    return false;
1399
    return false;
1410
  }
1400
  }
1411
1401
1412
  final private boolean jj_3R_20() {
1402
  final private boolean jj_3R_28() {
1413
    if (jj_3R_21()) return true;
1403
    if (jj_3R_34()) return true;
1404
    Token xsp;
1405
    while (true) {
1406
      xsp = jj_scanpos;
1407
      if (jj_3R_35()) { jj_scanpos = xsp; break; }
1408
    }
1414
    return false;
1409
    return false;
1415
  }
1410
  }
1416
1411
1417
  final private boolean jj_3R_44() {
1412
  final private boolean jj_3R_37() {
1413
    if (jj_scan_token(MINUS)) return true;
1414
    return false;
1415
  }
1416
1417
  final private boolean jj_3R_36() {
1418
    if (jj_scan_token(PLUS)) return true;
1419
    return false;
1420
  }
1421
1422
  final private boolean jj_3R_29() {
1423
    Token xsp;
1424
    xsp = jj_scanpos;
1425
    if (jj_3R_36()) {
1426
    jj_scanpos = xsp;
1427
    if (jj_3R_37()) return true;
1428
    }
1429
    return false;
1430
  }
1431
1432
  final private boolean jj_3R_69() {
1418
    if (jj_scan_token(IDENTIFIER)) return true;
1433
    if (jj_scan_token(IDENTIFIER)) return true;
1419
    return false;
1434
    return false;
1420
  }
1435
  }
1421
1436
1422
  final private boolean jj_3R_19() {
1437
  final private boolean jj_3R_61() {
1423
    if (jj_3R_20()) return true;
1438
    if (jj_3R_69()) return true;
1424
    return false;
1439
    return false;
1425
  }
1440
  }
1426
1441
1427
  final private boolean jj_3R_38() {
1442
  final private boolean jj_3R_24() {
1428
    if (jj_3R_44()) return true;
1443
    if (jj_3R_28()) return true;
1444
    Token xsp;
1445
    while (true) {
1446
      xsp = jj_scanpos;
1447
      if (jj_3R_29()) { jj_scanpos = xsp; break; }
1448
    }
1429
    return false;
1449
    return false;
1430
  }
1450
  }
1431
1451
Lines 1434-1620 Link Here
1434
    return false;
1454
    return false;
1435
  }
1455
  }
1436
1456
1437
  final private boolean jj_3R_31() {
1457
  final private boolean jj_3R_33() {
1438
    Token xsp;
1458
    Token xsp;
1439
    xsp = jj_scanpos;
1459
    xsp = jj_scanpos;
1440
    if (jj_3R_37()) {
1460
    if (jj_scan_token(29)) {
1441
    jj_scanpos = xsp;
1461
    jj_scanpos = xsp;
1462
    if (jj_scan_token(30)) return true;
1463
    }
1464
    return false;
1465
  }
1466
1467
  final private boolean jj_3R_60() {
1468
    if (jj_scan_token(LPAREN)) return true;
1469
    if (jj_3R_13()) return true;
1470
    return false;
1471
  }
1472
1473
  final private boolean jj_3R_52() {
1474
    Token xsp;
1475
    xsp = jj_scanpos;
1476
    if (jj_3R_60()) {
1477
    jj_scanpos = xsp;
1442
    if (jj_3_1()) {
1478
    if (jj_3_1()) {
1443
    jj_scanpos = xsp;
1479
    jj_scanpos = xsp;
1444
    if (jj_3R_38()) return true;
1480
    if (jj_3R_61()) return true;
1445
    }
1481
    }
1446
    }
1482
    }
1447
    return false;
1483
    return false;
1448
  }
1484
  }
1449
1485
1450
  final private boolean jj_3R_37() {
1486
  final private boolean jj_3R_32() {
1451
    if (jj_scan_token(LPAREN)) return true;
1487
    Token xsp;
1488
    xsp = jj_scanpos;
1489
    if (jj_scan_token(31)) {
1490
    jj_scanpos = xsp;
1491
    if (jj_scan_token(32)) return true;
1492
    }
1452
    return false;
1493
    return false;
1453
  }
1494
  }
1454
1495
1455
  final private boolean jj_3R_43() {
1496
  final private boolean jj_3R_31() {
1497
    Token xsp;
1498
    xsp = jj_scanpos;
1499
    if (jj_scan_token(25)) {
1500
    jj_scanpos = xsp;
1501
    if (jj_scan_token(26)) return true;
1502
    }
1503
    return false;
1504
  }
1505
1506
  final private boolean jj_3R_68() {
1456
    if (jj_scan_token(NULL)) return true;
1507
    if (jj_scan_token(NULL)) return true;
1457
    return false;
1508
    return false;
1458
  }
1509
  }
1459
1510
1460
  final private boolean jj_3R_42() {
1511
  final private boolean jj_3R_30() {
1512
    Token xsp;
1513
    xsp = jj_scanpos;
1514
    if (jj_scan_token(27)) {
1515
    jj_scanpos = xsp;
1516
    if (jj_scan_token(28)) return true;
1517
    }
1518
    return false;
1519
  }
1520
1521
  final private boolean jj_3R_25() {
1522
    Token xsp;
1523
    xsp = jj_scanpos;
1524
    if (jj_3R_30()) {
1525
    jj_scanpos = xsp;
1526
    if (jj_3R_31()) {
1527
    jj_scanpos = xsp;
1528
    if (jj_3R_32()) {
1529
    jj_scanpos = xsp;
1530
    if (jj_3R_33()) return true;
1531
    }
1532
    }
1533
    }
1534
    return false;
1535
  }
1536
1537
  final private boolean jj_3R_63() {
1538
    if (jj_scan_token(LBRACK)) return true;
1539
    return false;
1540
  }
1541
1542
  final private boolean jj_3R_67() {
1461
    if (jj_scan_token(STRING_LITERAL)) return true;
1543
    if (jj_scan_token(STRING_LITERAL)) return true;
1462
    return false;
1544
    return false;
1463
  }
1545
  }
1464
1546
1465
  final private boolean jj_3R_18() {
1547
  final private boolean jj_3R_54() {
1466
    if (jj_3R_19()) return true;
1548
    if (jj_3R_63()) return true;
1467
    return false;
1549
    return false;
1468
  }
1550
  }
1469
1551
1470
  final private boolean jj_3R_41() {
1552
  final private boolean jj_3R_22() {
1553
    if (jj_3R_24()) return true;
1554
    Token xsp;
1555
    while (true) {
1556
      xsp = jj_scanpos;
1557
      if (jj_3R_25()) { jj_scanpos = xsp; break; }
1558
    }
1559
    return false;
1560
  }
1561
1562
  final private boolean jj_3R_27() {
1563
    Token xsp;
1564
    xsp = jj_scanpos;
1565
    if (jj_scan_token(35)) {
1566
    jj_scanpos = xsp;
1567
    if (jj_scan_token(36)) return true;
1568
    }
1569
    return false;
1570
  }
1571
1572
  final private boolean jj_3R_62() {
1573
    if (jj_scan_token(DOT)) return true;
1574
    return false;
1575
  }
1576
1577
  final private boolean jj_3R_26() {
1578
    Token xsp;
1579
    xsp = jj_scanpos;
1580
    if (jj_scan_token(33)) {
1581
    jj_scanpos = xsp;
1582
    if (jj_scan_token(34)) return true;
1583
    }
1584
    return false;
1585
  }
1586
1587
  final private boolean jj_3R_23() {
1588
    Token xsp;
1589
    xsp = jj_scanpos;
1590
    if (jj_3R_26()) {
1591
    jj_scanpos = xsp;
1592
    if (jj_3R_27()) return true;
1593
    }
1594
    return false;
1595
  }
1596
1597
  final private boolean jj_3R_66() {
1471
    if (jj_scan_token(INTEGER_LITERAL)) return true;
1598
    if (jj_scan_token(INTEGER_LITERAL)) return true;
1472
    return false;
1599
    return false;
1473
  }
1600
  }
1474
1601
1475
  final private boolean jj_3R_17() {
1602
  final private boolean jj_3R_21() {
1476
    if (jj_3R_18()) return true;
1603
    Token xsp;
1604
    xsp = jj_scanpos;
1605
    if (jj_scan_token(39)) {
1606
    jj_scanpos = xsp;
1607
    if (jj_scan_token(40)) return true;
1608
    }
1477
    return false;
1609
    return false;
1478
  }
1610
  }
1479
1611
1480
  final private boolean jj_3R_40() {
1612
  final private boolean jj_3R_53() {
1613
    if (jj_3R_62()) return true;
1614
    return false;
1615
  }
1616
1617
  final private boolean jj_3R_50() {
1618
    Token xsp;
1619
    xsp = jj_scanpos;
1620
    if (jj_3R_53()) {
1621
    jj_scanpos = xsp;
1622
    if (jj_3R_54()) return true;
1623
    }
1624
    return false;
1625
  }
1626
1627
  final private boolean jj_3R_20() {
1628
    if (jj_3R_22()) return true;
1629
    Token xsp;
1630
    while (true) {
1631
      xsp = jj_scanpos;
1632
      if (jj_3R_23()) { jj_scanpos = xsp; break; }
1633
    }
1634
    return false;
1635
  }
1636
1637
  final private boolean jj_3R_47() {
1638
    if (jj_3R_50()) return true;
1639
    return false;
1640
  }
1641
1642
  final private boolean jj_3R_65() {
1481
    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
1643
    if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
1482
    return false;
1644
    return false;
1483
  }
1645
  }
1484
1646
1485
  final private boolean jj_3R_29() {
1647
  final private boolean jj_3R_49() {
1486
    if (jj_3R_31()) return true;
1648
    if (jj_3R_52()) return true;
1487
    return false;
1649
    return false;
1488
  }
1650
  }
1489
1651
1490
  final private boolean jj_3R_46() {
1652
  final private boolean jj_3R_14() {
1653
    if (jj_scan_token(COMMA)) return true;
1654
    return false;
1655
  }
1656
1657
  final private boolean jj_3R_71() {
1491
    if (jj_scan_token(FALSE)) return true;
1658
    if (jj_scan_token(FALSE)) return true;
1492
    return false;
1659
    return false;
1493
  }
1660
  }
1494
1661
1495
  final private boolean jj_3R_16() {
1662
  final private boolean jj_3R_48() {
1496
    if (jj_3R_17()) return true;
1663
    if (jj_3R_51()) return true;
1497
    return false;
1664
    return false;
1498
  }
1665
  }
1499
1666
1500
  final private boolean jj_3R_27() {
1667
  final private boolean jj_3R_46() {
1501
    Token xsp;
1668
    Token xsp;
1502
    xsp = jj_scanpos;
1669
    xsp = jj_scanpos;
1503
    if (jj_3R_28()) {
1670
    if (jj_3R_48()) {
1504
    jj_scanpos = xsp;
1671
    jj_scanpos = xsp;
1505
    if (jj_3R_29()) return true;
1672
    if (jj_3R_49()) return true;
1506
    }
1673
    }
1507
    return false;
1674
    return false;
1508
  }
1675
  }
1509
1676
1510
  final private boolean jj_3R_28() {
1677
  final private boolean jj_3R_18() {
1511
    if (jj_3R_30()) return true;
1678
    if (jj_3R_20()) return true;
1679
    Token xsp;
1680
    while (true) {
1681
      xsp = jj_scanpos;
1682
      if (jj_3R_21()) { jj_scanpos = xsp; break; }
1683
    }
1512
    return false;
1684
    return false;
1513
  }
1685
  }
1514
1686
1515
  final private boolean jj_3R_45() {
1687
  final private boolean jj_3R_19() {
1688
    Token xsp;
1689
    xsp = jj_scanpos;
1690
    if (jj_scan_token(41)) {
1691
    jj_scanpos = xsp;
1692
    if (jj_scan_token(42)) return true;
1693
    }
1694
    return false;
1695
  }
1696
1697
  final private boolean jj_3R_70() {
1516
    if (jj_scan_token(TRUE)) return true;
1698
    if (jj_scan_token(TRUE)) return true;
1517
    return false;
1699
    return false;
1518
  }
1700
  }
1519
1701
1520
  final private boolean jj_3R_39() {
1702
  final private boolean jj_3R_64() {
1521
    Token xsp;
1703
    Token xsp;
1522
    xsp = jj_scanpos;
1704
    xsp = jj_scanpos;
1523
    if (jj_3R_45()) {
1705
    if (jj_3R_70()) {
1524
    jj_scanpos = xsp;
1706
    jj_scanpos = xsp;
1525
    if (jj_3R_46()) return true;
1707
    if (jj_3R_71()) return true;
1526
    }
1708
    }
1527
    return false;
1709
    return false;
1528
  }
1710
  }
1529
1711
1530
  final private boolean jj_3R_15() {
1712
  final private boolean jj_3R_45() {
1531
    if (jj_3R_16()) return true;
1713
    if (jj_3R_46()) return true;
1714
    Token xsp;
1715
    while (true) {
1716
      xsp = jj_scanpos;
1717
      if (jj_3R_47()) { jj_scanpos = xsp; break; }
1718
    }
1532
    return false;
1719
    return false;
1533
  }
1720
  }
1534
1721
1535
  final private boolean jj_3R_26() {
1722
  final private boolean jj_3R_16() {
1536
    if (jj_3R_27()) return true;
1723
    if (jj_3R_18()) return true;
1724
    Token xsp;
1725
    while (true) {
1726
      xsp = jj_scanpos;
1727
      if (jj_3R_19()) { jj_scanpos = xsp; break; }
1728
    }
1537
    return false;
1729
    return false;
1538
  }
1730
  }
1539
1731
1540
  final private boolean jj_3R_25() {
1732
  final private boolean jj_3R_41() {
1541
    if (jj_3R_26()) return true;
1733
    if (jj_3R_45()) return true;
1542
    return false;
1734
    return false;
1543
  }
1735
  }
1544
1736
1545
  final private boolean jj_3R_36() {
1737
  final private boolean jj_3R_59() {
1546
    if (jj_3R_43()) return true;
1738
    if (jj_3R_68()) return true;
1547
    return false;
1739
    return false;
1548
  }
1740
  }
1549
1741
1550
  final private boolean jj_3R_35() {
1742
  final private boolean jj_3R_58() {
1551
    if (jj_3R_42()) return true;
1743
    if (jj_3R_67()) return true;
1552
    return false;
1744
    return false;
1553
  }
1745
  }
1554
1746
1555
  final private boolean jj_3R_24() {
1747
  final private boolean jj_3R_40() {
1556
    if (jj_scan_token(EMPTY)) return true;
1748
    if (jj_scan_token(EMPTY)) return true;
1749
    if (jj_3R_34()) return true;
1557
    return false;
1750
    return false;
1558
  }
1751
  }
1559
1752
1560
  final private boolean jj_3R_34() {
1753
  final private boolean jj_3R_17() {
1561
    if (jj_3R_41()) return true;
1754
    if (jj_scan_token(QUESTIONMARK)) return true;
1562
    return false;
1755
    return false;
1563
  }
1756
  }
1564
1757
1565
  final private boolean jj_3R_33() {
1758
  final private boolean jj_3R_57() {
1566
    if (jj_3R_40()) return true;
1759
    if (jj_3R_66()) return true;
1567
    return false;
1760
    return false;
1568
  }
1761
  }
1569
1762
1570
  final private boolean jj_3R_23() {
1763
  final private boolean jj_3R_12() {
1764
    if (jj_3R_13()) return true;
1571
    Token xsp;
1765
    Token xsp;
1766
    while (true) {
1767
      xsp = jj_scanpos;
1768
      if (jj_3R_14()) { jj_scanpos = xsp; break; }
1769
    }
1770
    return false;
1771
  }
1772
1773
  final private boolean jj_3R_56() {
1774
    if (jj_3R_65()) return true;
1775
    return false;
1776
  }
1777
1778
  final private boolean jj_3R_39() {
1779
    Token xsp;
1572
    xsp = jj_scanpos;
1780
    xsp = jj_scanpos;
1573
    if (jj_scan_token(37)) {
1781
    if (jj_scan_token(37)) {
1574
    jj_scanpos = xsp;
1782
    jj_scanpos = xsp;
1575
    if (jj_scan_token(38)) return true;
1783
    if (jj_scan_token(38)) return true;
1576
    }
1784
    }
1785
    if (jj_3R_34()) return true;
1577
    return false;
1786
    return false;
1578
  }
1787
  }
1579
1788
1580
  final private boolean jj_3R_12() {
1789
  final private boolean jj_3R_38() {
1581
    if (jj_3R_13()) return true;
1582
    return false;
1583
  }
1584
1585
  final private boolean jj_3R_22() {
1586
    if (jj_scan_token(MINUS)) return true;
1790
    if (jj_scan_token(MINUS)) return true;
1791
    if (jj_3R_34()) return true;
1587
    return false;
1792
    return false;
1588
  }
1793
  }
1589
1794
1590
  final private boolean jj_3R_21() {
1795
  final private boolean jj_3R_34() {
1591
    Token xsp;
1796
    Token xsp;
1592
    xsp = jj_scanpos;
1797
    xsp = jj_scanpos;
1593
    if (jj_3R_22()) {
1798
    if (jj_3R_38()) {
1594
    jj_scanpos = xsp;
1799
    jj_scanpos = xsp;
1595
    if (jj_3R_23()) {
1800
    if (jj_3R_39()) {
1596
    jj_scanpos = xsp;
1801
    jj_scanpos = xsp;
1597
    if (jj_3R_24()) {
1802
    if (jj_3R_40()) {
1598
    jj_scanpos = xsp;
1803
    jj_scanpos = xsp;
1599
    if (jj_3R_25()) return true;
1804
    if (jj_3R_41()) return true;
1600
    }
1805
    }
1601
    }
1806
    }
1602
    }
1807
    }
1603
    return false;
1808
    return false;
1604
  }
1809
  }
1605
1810
1606
  final private boolean jj_3R_30() {
1811
  final private boolean jj_3R_55() {
1812
    if (jj_3R_64()) return true;
1813
    return false;
1814
  }
1815
1816
  final private boolean jj_3R_51() {
1607
    Token xsp;
1817
    Token xsp;
1608
    xsp = jj_scanpos;
1818
    xsp = jj_scanpos;
1609
    if (jj_3R_32()) {
1819
    if (jj_3R_55()) {
1610
    jj_scanpos = xsp;
1820
    jj_scanpos = xsp;
1611
    if (jj_3R_33()) {
1821
    if (jj_3R_56()) {
1612
    jj_scanpos = xsp;
1822
    jj_scanpos = xsp;
1613
    if (jj_3R_34()) {
1823
    if (jj_3R_57()) {
1614
    jj_scanpos = xsp;
1824
    jj_scanpos = xsp;
1615
    if (jj_3R_35()) {
1825
    if (jj_3R_58()) {
1616
    jj_scanpos = xsp;
1826
    jj_scanpos = xsp;
1617
    if (jj_3R_36()) return true;
1827
    if (jj_3R_59()) return true;
1618
    }
1828
    }
1619
    }
1829
    }
1620
    }
1830
    }
Lines 1622-1642 Link Here
1622
    return false;
1832
    return false;
1623
  }
1833
  }
1624
1834
1625
  final private boolean jj_3R_32() {
1835
  final private boolean jj_3R_15() {
1626
    if (jj_3R_39()) return true;
1836
    if (jj_3R_16()) return true;
1837
    Token xsp;
1838
    while (true) {
1839
      xsp = jj_scanpos;
1840
      if (jj_3R_17()) { jj_scanpos = xsp; break; }
1841
    }
1627
    return false;
1842
    return false;
1628
  }
1843
  }
1629
1844
1630
  final private boolean jj_3R_14() {
1845
  final private boolean jj_3R_44() {
1631
    if (jj_3R_15()) return true;
1846
    Token xsp;
1847
    xsp = jj_scanpos;
1848
    if (jj_scan_token(51)) {
1849
    jj_scanpos = xsp;
1850
    if (jj_scan_token(52)) return true;
1851
    }
1632
    return false;
1852
    return false;
1633
  }
1853
  }
1634
1854
1635
  final private boolean jj_3R_13() {
1855
  final private boolean jj_3R_13() {
1636
    if (jj_3R_14()) return true;
1856
    if (jj_3R_15()) return true;
1637
    return false;
1857
    return false;
1638
  }
1858
  }
1639
1859
1860
  final private boolean jj_3R_43() {
1861
    Token xsp;
1862
    xsp = jj_scanpos;
1863
    if (jj_scan_token(49)) {
1864
    jj_scanpos = xsp;
1865
    if (jj_scan_token(50)) return true;
1866
    }
1867
    return false;
1868
  }
1869
1870
  final private boolean jj_3R_42() {
1871
    if (jj_scan_token(MULT)) return true;
1872
    return false;
1873
  }
1874
1875
  final private boolean jj_3R_35() {
1876
    Token xsp;
1877
    xsp = jj_scanpos;
1878
    if (jj_3R_42()) {
1879
    jj_scanpos = xsp;
1880
    if (jj_3R_43()) {
1881
    jj_scanpos = xsp;
1882
    if (jj_3R_44()) return true;
1883
    }
1884
    }
1885
    return false;
1886
  }
1887
1640
  public ELParserTokenManager token_source;
1888
  public ELParserTokenManager token_source;
1641
  SimpleCharStream jj_input_stream;
1889
  SimpleCharStream jj_input_stream;
1642
  public Token token, jj_nt;
1890
  public Token token, jj_nt;
Lines 1646-1652 Link Here
1646
  public boolean lookingAhead = false;
1894
  public boolean lookingAhead = false;
1647
  private boolean jj_semLA;
1895
  private boolean jj_semLA;
1648
  private int jj_gen;
1896
  private int jj_gen;
1649
  final private int[] jj_la1 = new int[35];
1897
  final private int[] jj_la1 = new int[34];
1650
  static private int[] jj_la1_0;
1898
  static private int[] jj_la1_0;
1651
  static private int[] jj_la1_1;
1899
  static private int[] jj_la1_1;
1652
  static {
1900
  static {
Lines 1654-1663 Link Here
1654
      jj_la1_1();
1902
      jj_la1_1();
1655
   }
1903
   }
1656
   private static void jj_la1_0() {
1904
   private static void jj_la1_0() {
1657
      jj_la1_0 = new int[] {0xe,0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe000000,0x18000000,0x6000000,0x80000000,0x60000000,0xfe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9d600,0x240000,0x9d600,0x240000,0x80000,0x0,0x0,0x1000000,0x9d600,0x1d600,0xc000,};
1905
      jj_la1_0 = new int[] {0xe,0xe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfe000000,0x18000000,0x6000000,0x80000000,0x60000000,0xfe000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9d600,0x240000,0x9d600,0x240000,0x80000,0x0,0x1000000,0x9d600,0x1d600,0xc000,};
1658
   }
1906
   }
1659
   private static void jj_la1_1() {
1907
   private static void jj_la1_1() {
1660
      jj_la1_1 = new int[] {0x0,0x0,0x10000,0x600,0x600,0x180,0x180,0x1e,0x6,0x18,0x1e,0x1,0x0,0x0,0x1,0x0,0x1,0xc000,0xc000,0x1e2000,0x60000,0x180000,0x1e2000,0x60,0x608860,0x0,0x600000,0x0,0x0,0x200000,0x400000,0x0,0x608860,0x0,0x0,};
1908
      jj_la1_1 = new int[] {0x0,0x0,0x10000,0x600,0x600,0x180,0x180,0x1e,0x6,0x18,0x1e,0x1,0x0,0x0,0x1,0x0,0x1,0xc000,0xc000,0x1e2000,0x60000,0x180000,0x1e2000,0x60,0x1208860,0x0,0x1200000,0x0,0x0,0x200000,0x0,0x1208860,0x0,0x0,};
1661
   }
1909
   }
1662
  final private JJCalls[] jj_2_rtns = new JJCalls[1];
1910
  final private JJCalls[] jj_2_rtns = new JJCalls[1];
1663
  private boolean jj_rescan = false;
1911
  private boolean jj_rescan = false;
Lines 1672-1678 Link Here
1672
    token = new Token();
1920
    token = new Token();
1673
    jj_ntk = -1;
1921
    jj_ntk = -1;
1674
    jj_gen = 0;
1922
    jj_gen = 0;
1675
    for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1923
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1676
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1924
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1677
  }
1925
  }
1678
1926
Lines 1686-1692 Link Here
1686
    jj_ntk = -1;
1934
    jj_ntk = -1;
1687
    jjtree.reset();
1935
    jjtree.reset();
1688
    jj_gen = 0;
1936
    jj_gen = 0;
1689
    for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1937
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1690
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1938
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1691
  }
1939
  }
1692
1940
Lines 1696-1702 Link Here
1696
    token = new Token();
1944
    token = new Token();
1697
    jj_ntk = -1;
1945
    jj_ntk = -1;
1698
    jj_gen = 0;
1946
    jj_gen = 0;
1699
    for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1947
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1700
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1948
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1701
  }
1949
  }
1702
1950
Lines 1707-1713 Link Here
1707
    jj_ntk = -1;
1955
    jj_ntk = -1;
1708
    jjtree.reset();
1956
    jjtree.reset();
1709
    jj_gen = 0;
1957
    jj_gen = 0;
1710
    for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1958
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1711
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1959
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1712
  }
1960
  }
1713
1961
Lines 1716-1722 Link Here
1716
    token = new Token();
1964
    token = new Token();
1717
    jj_ntk = -1;
1965
    jj_ntk = -1;
1718
    jj_gen = 0;
1966
    jj_gen = 0;
1719
    for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1967
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1720
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1968
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1721
  }
1969
  }
1722
1970
Lines 1726-1732 Link Here
1726
    jj_ntk = -1;
1974
    jj_ntk = -1;
1727
    jjtree.reset();
1975
    jjtree.reset();
1728
    jj_gen = 0;
1976
    jj_gen = 0;
1729
    for (int i = 0; i < 35; i++) jj_la1[i] = -1;
1977
    for (int i = 0; i < 34; i++) jj_la1[i] = -1;
1730
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1978
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
1731
  }
1979
  }
1732
1980
Lines 1837-1851 Link Here
1837
2085
1838
  public ParseException generateParseException() {
2086
  public ParseException generateParseException() {
1839
    jj_expentries.removeAllElements();
2087
    jj_expentries.removeAllElements();
1840
    boolean[] la1tokens = new boolean[60];
2088
    boolean[] la1tokens = new boolean[62];
1841
    for (int i = 0; i < 60; i++) {
2089
    for (int i = 0; i < 62; i++) {
1842
      la1tokens[i] = false;
2090
      la1tokens[i] = false;
1843
    }
2091
    }
1844
    if (jj_kind >= 0) {
2092
    if (jj_kind >= 0) {
1845
      la1tokens[jj_kind] = true;
2093
      la1tokens[jj_kind] = true;
1846
      jj_kind = -1;
2094
      jj_kind = -1;
1847
    }
2095
    }
1848
    for (int i = 0; i < 35; i++) {
2096
    for (int i = 0; i < 34; i++) {
1849
      if (jj_la1[i] == jj_gen) {
2097
      if (jj_la1[i] == jj_gen) {
1850
        for (int j = 0; j < 32; j++) {
2098
        for (int j = 0; j < 32; j++) {
1851
          if ((jj_la1_0[i] & (1<<j)) != 0) {
2099
          if ((jj_la1_0[i] & (1<<j)) != 0) {
Lines 1857-1863 Link Here
1857
        }
2105
        }
1858
      }
2106
      }
1859
    }
2107
    }
1860
    for (int i = 0; i < 60; i++) {
2108
    for (int i = 0; i < 62; i++) {
1861
      if (la1tokens[i]) {
2109
      if (la1tokens[i]) {
1862
        jj_expentry = new int[1];
2110
        jj_expentry = new int[1];
1863
        jj_expentry[0] = i;
2111
        jj_expentry[0] = i;
(-)ELParser.jjt (-10 / +11 lines)
Lines 31-37 Link Here
31
	NODE_DEFAULT_VOID=true;
31
	NODE_DEFAULT_VOID=true;
32
	JAVA_UNICODE_ESCAPE=false;
32
	JAVA_UNICODE_ESCAPE=false;
33
  	UNICODE_INPUT=true;
33
  	UNICODE_INPUT=true;
34
	BUILD_NODE_FILES=true;
34
	BUILD_NODE_FILES=false;
35
}
35
}
36
36
37
/* == Parser Declaration == */
37
/* == Parser Declaration == */
Lines 274-293 Link Here
274
 */
274
 */
275
void Function() #Function :
275
void Function() #Function :
276
{
276
{
277
	Token t0 = null;
277
	Token tx = null;
278
	Token t1 = null;
279
}
278
}
280
{
279
{
281
	(t0=<NAMESPACE>)? t1=<IDENTIFIER>
280
	(tx=<FUNCTION_CALL>) (Expression() (<COMMA> Expression())*)? <RPAREN>
282
	{
281
	{
283
		if (t0 != null) {
282
		int split = tx.image.indexOf(":");
284
			jjtThis.setPrefix(t0.image.substring(0, t0.image.length() - 1));
283
		if (split!=-1) {
285
			jjtThis.setLocalName(t1.image);
284
			jjtThis.setPrefix(tx.image.substring(0, split));
285
			jjtThis.setLocalName(tx.image.substring(split + 1, tx.image.length() - 1));
286
		} else {
286
		} else {
287
			jjtThis.setLocalName(t1.image);
287
			jjtThis.setLocalName(tx.image.substring(0, tx.image.length() - 1));
288
		}
288
		}
289
	}
289
	}
290
	<LPAREN> (Expression() (<COMMA> Expression())*)? <RPAREN>
291
}
290
}
292
291
293
/*
292
/*
Lines 428-434 Link Here
428
|	< MOD0 : "%" >
427
|	< MOD0 : "%" >
429
|	< MOD1 : "mod" >
428
|	< MOD1 : "mod" >
430
|	< IDENTIFIER : (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
429
|	< IDENTIFIER : (<LETTER>|<IMPL_OBJ_START>) (<LETTER>|<DIGIT>)* >
431
|   < NAMESPACE : (<IDENTIFIER> (<IDENTIFIER>|<MINUS>|<DOT>)* <COLON>) >
430
|	< #NAMESPACE : ( <NAMESPACE_NAME> <COLON>) >
431
|	< #NAMESPACE_NAME: (<IDENTIFIER> (<LETTER>|<DIGIT>|<MINUS>|<DOT>)*) >
432
|	< FUNCTION_CALL: (<NAMESPACE>)? <IDENTIFIER> <LPAREN> >
432
|	< FUNCTIONSUFFIX : (<IDENTIFIER>) >
433
|	< FUNCTIONSUFFIX : (<IDENTIFIER>) >
433
|	< #IMPL_OBJ_START: "#" >
434
|	< #IMPL_OBJ_START: "#" >
434
|	< #LETTER:
435
|	< #LETTER:

Return to bug 42565