← Back to branch summary

~tapaal-contributor/tapaal/weight-values-fix-1770637

« back to all changes in this revision

Viewing changes to src/dk/aau/cs/TCTL/CTLParsing/TAPAALCTLQueryParserTokenManager.java

merged branch lp:~tapaal-contributor/tapaal/ctl-query-fix-1540367

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dk/aau/cs/TCTL/CTLParsing/TAPAALCTLQueryParserTokenManager.java
 
1
/* TAPAALCTLQueryParserTokenManager.java */
 
2
/* Generated By:JavaCC: Do not edit this line. TAPAALCTLQueryParserTokenManager.java */
 
3
package dk.aau.cs.TCTL.CTLParsing;
 
4
import java.io.StringReader;
 
5
import java.util.ArrayList;
 
6
import dk.aau.cs.TCTL.AritmeticOperator;
 
7
import dk.aau.cs.TCTL.TCTLTermListNode;
 
8
import dk.aau.cs.TCTL.TCTLPlaceNode;
 
9
import dk.aau.cs.TCTL.TCTLTransitionNode;
 
10
import dk.aau.cs.TCTL.TCTLConstNode;
 
11
import dk.aau.cs.TCTL.TCTLAFNode;
 
12
import dk.aau.cs.TCTL.TCTLAGNode;
 
13
import dk.aau.cs.TCTL.TCTLAUNode;
 
14
import dk.aau.cs.TCTL.TCTLAXNode;
 
15
import dk.aau.cs.TCTL.TCTLAbstractProperty;
 
16
import dk.aau.cs.TCTL.TCTLAbstractStateProperty;
 
17
import dk.aau.cs.TCTL.TCTLAbstractPathProperty;
 
18
import dk.aau.cs.TCTL.TCTLAndListNode;
 
19
import dk.aau.cs.TCTL.TCTLAtomicPropositionNode;
 
20
import dk.aau.cs.TCTL.TCTLEFNode;
 
21
import dk.aau.cs.TCTL.TCTLEGNode;
 
22
import dk.aau.cs.TCTL.TCTLEUNode;
 
23
import dk.aau.cs.TCTL.TCTLEXNode;
 
24
import dk.aau.cs.TCTL.TCTLFalseNode;
 
25
import dk.aau.cs.TCTL.TCTLNotNode;
 
26
import dk.aau.cs.TCTL.TCTLOrListNode;
 
27
import dk.aau.cs.TCTL.TCTLTrueNode;
 
28
import dk.aau.cs.TCTL.TCTLDeadlockNode;
 
29
import dk.aau.cs.TCTL.TCTLPathToStateConverter;
 
30
import dk.aau.cs.TCTL.TCTLStateToPathConverter;
 
31
 
 
32
/** Token Manager. */
 
33
public class TAPAALCTLQueryParserTokenManager implements TAPAALCTLQueryParserConstants {
 
34
 
 
35
  /** Debug output. */
 
36
  public  java.io.PrintStream debugStream = System.out;
 
37
  /** Set debug output. */
 
38
  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 
39
private final int jjStopStringLiteralDfa_0(int pos, long active0){
 
40
   switch (pos)
 
41
   {
 
42
      case 0:
 
43
         if ((active0 & 0x100L) != 0L)
 
44
            return 49;
 
45
         if ((active0 & 0x240L) != 0L)
 
46
            return 64;
 
47
         if ((active0 & 0x1080L) != 0L)
 
48
            return 57;
 
49
         return -1;
 
50
      default :
 
51
         return -1;
 
52
   }
 
53
}
 
54
private final int jjStartNfa_0(int pos, long active0){
 
55
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
 
56
}
 
57
private int jjStopAtPos(int pos, int kind)
 
58
{
 
59
   jjmatchedKind = kind;
 
60
   jjmatchedPos = pos;
 
61
   return pos + 1;
 
62
}
 
63
private int jjMoveStringLiteralDfa0_0(){
 
64
   switch(curChar)
 
65
   {
 
66
      case 40:
 
67
         return jjStopAtPos(0, 26);
 
68
      case 41:
 
69
         return jjStopAtPos(0, 27);
 
70
      case 42:
 
71
         return jjStopAtPos(0, 18);
 
72
      case 43:
 
73
         return jjStopAtPos(0, 16);
 
74
      case 45:
 
75
         return jjStopAtPos(0, 17);
 
76
      case 46:
 
77
         return jjStopAtPos(0, 28);
 
78
      case 65:
 
79
         jjmatchedKind = 7;
 
80
         return jjMoveStringLiteralDfa1_0(0x1000L);
 
81
      case 69:
 
82
         jjmatchedKind = 6;
 
83
         return jjMoveStringLiteralDfa1_0(0x200L);
 
84
      case 85:
 
85
         return jjStartNfaWithStates_0(0, 8, 49);
 
86
      default :
 
87
         return jjMoveNfa_0(3, 0);
 
88
   }
 
89
}
 
90
private int jjMoveStringLiteralDfa1_0(long active0){
 
91
   try { curChar = input_stream.readChar(); }
 
92
   catch(java.io.IOException e) {
 
93
      jjStopStringLiteralDfa_0(0, active0);
 
94
      return 1;
 
95
   }
 
96
   switch(curChar)
 
97
   {
 
98
      case 88:
 
99
         if ((active0 & 0x200L) != 0L)
 
100
            return jjStartNfaWithStates_0(1, 9, 49);
 
101
         else if ((active0 & 0x1000L) != 0L)
 
102
            return jjStartNfaWithStates_0(1, 12, 49);
 
103
         break;
 
104
      default :
 
105
         break;
 
106
   }
 
107
   return jjStartNfa_0(0, active0);
 
108
}
 
109
private int jjStartNfaWithStates_0(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_0(state, pos + 1);
 
116
}
 
117
private int jjMoveNfa_0(int startState, int curPos)
 
118
{
 
119
   int startsAt = 0;
 
120
   jjnewStateCnt = 70;
 
121
   int i = 1;
 
122
   jjstateSet[0] = startState;
 
123
   int kind = 0x7fffffff;
 
124
   for (;;)
 
125
   {
 
126
      if (++jjround == 0x7fffffff)
 
127
         ReInitRounds();
 
128
      if (curChar < 64)
 
129
      {
 
130
         long l = 1L << curChar;
 
131
         do
 
132
         {
 
133
            switch(jjstateSet[--i])
 
134
            {
 
135
               case 3:
 
136
                  if ((0x3ff000000000000L & l) != 0L)
 
137
                  {
 
138
                     if (kind > 19)
 
139
                        kind = 19;
 
140
                     { jjCheckNAdd(47); }
 
141
                  }
 
142
                  else if ((0x7000000000000000L & l) != 0L)
 
143
                  {
 
144
                     if (kind > 21)
 
145
                        kind = 21;
 
146
                  }
 
147
                  else if (curChar == 33)
 
148
                     { jjCheckNAdd(51); }
 
149
                  else if (curChar == 38)
 
150
                     jjstateSet[jjnewStateCnt++] = 41;
 
151
                  if (curChar == 62)
 
152
                     { jjCheckNAdd(51); }
 
153
                  else if (curChar == 61)
 
154
                     { jjCheckNAdd(51); }
 
155
                  else if (curChar == 60)
 
156
                     { jjCheckNAdd(51); }
 
157
                  else if (curChar == 33)
 
158
                  {
 
159
                     if (kind > 15)
 
160
                        kind = 15;
 
161
                  }
 
162
                  break;
 
163
               case 64:
 
164
                  if ((0x3ff000000000000L & l) != 0L)
 
165
                  {
 
166
                     if (kind > 20)
 
167
                        kind = 20;
 
168
                     { jjCheckNAdd(49); }
 
169
                  }
 
170
                  else if (curChar == 60)
 
171
                     jjstateSet[jjnewStateCnt++] = 65;
 
172
                  break;
 
173
               case 57:
 
174
                  if ((0x3ff000000000000L & l) != 0L)
 
175
                  {
 
176
                     if (kind > 20)
 
177
                        kind = 20;
 
178
                     { jjCheckNAdd(49); }
 
179
                  }
 
180
                  else if (curChar == 60)
 
181
                     jjstateSet[jjnewStateCnt++] = 58;
 
182
                  break;
 
183
               case 41:
 
184
                  if (curChar == 38 && kind > 14)
 
185
                     kind = 14;
 
186
                  break;
 
187
               case 42:
 
188
                  if (curChar == 38)
 
189
                     jjstateSet[jjnewStateCnt++] = 41;
 
190
                  break;
 
191
               case 46:
 
192
                  if (curChar == 33 && kind > 15)
 
193
                     kind = 15;
 
194
                  break;
 
195
               case 47:
 
196
                  if ((0x3ff000000000000L & l) == 0L)
 
197
                     break;
 
198
                  if (kind > 19)
 
199
                     kind = 19;
 
200
                  { jjCheckNAdd(47); }
 
201
                  break;
 
202
               case 49:
 
203
                  if ((0x3ff000000000000L & l) == 0L)
 
204
                     break;
 
205
                  if (kind > 20)
 
206
                     kind = 20;
 
207
                  { jjCheckNAdd(49); }
 
208
                  break;
 
209
               case 50:
 
210
                  if ((0x7000000000000000L & l) != 0L && kind > 21)
 
211
                     kind = 21;
 
212
                  break;
 
213
               case 51:
 
214
                  if (curChar == 61 && kind > 21)
 
215
                     kind = 21;
 
216
                  break;
 
217
               case 52:
 
218
                  if (curChar == 33)
 
219
                     { jjCheckNAdd(51); }
 
220
                  break;
 
221
               case 53:
 
222
                  if (curChar == 60)
 
223
                     { jjCheckNAdd(51); }
 
224
                  break;
 
225
               case 54:
 
226
                  if (curChar == 61)
 
227
                     { jjCheckNAdd(51); }
 
228
                  break;
 
229
               case 55:
 
230
                  if (curChar == 62)
 
231
                     { jjCheckNAdd(51); }
 
232
                  break;
 
233
               case 58:
 
234
                  if (curChar == 62 && kind > 10)
 
235
                     kind = 10;
 
236
                  break;
 
237
               case 59:
 
238
                  if (curChar == 60)
 
239
                     jjstateSet[jjnewStateCnt++] = 58;
 
240
                  break;
 
241
               case 65:
 
242
                  if (curChar == 62 && kind > 4)
 
243
                     kind = 4;
 
244
                  break;
 
245
               case 66:
 
246
                  if (curChar == 60)
 
247
                     jjstateSet[jjnewStateCnt++] = 65;
 
248
                  break;
 
249
               default : break;
 
250
            }
 
251
         } while(i != startsAt);
 
252
      }
 
253
      else if (curChar < 128)
 
254
      {
 
255
         long l = 1L << (curChar & 077);
 
256
         do
 
257
         {
 
258
            switch(jjstateSet[--i])
 
259
            {
 
260
               case 3:
 
261
                  if ((0x7fffffe87fffffeL & l) != 0L)
 
262
                  {
 
263
                     if (kind > 20)
 
264
                        kind = 20;
 
265
                     { jjCheckNAdd(49); }
 
266
                  }
 
267
                  else if (curChar == 124)
 
268
                     jjstateSet[jjnewStateCnt++] = 36;
 
269
                  if (curChar == 69)
 
270
                     { jjAddStates(0, 3); }
 
271
                  else if (curChar == 65)
 
272
                     { jjAddStates(4, 7); }
 
273
                  else if (curChar == 110)
 
274
                     jjstateSet[jjnewStateCnt++] = 44;
 
275
                  else if (curChar == 97)
 
276
                     jjstateSet[jjnewStateCnt++] = 39;
 
277
                  else if (curChar == 111)
 
278
                     jjstateSet[jjnewStateCnt++] = 34;
 
279
                  else if (curChar == 68)
 
280
                     jjstateSet[jjnewStateCnt++] = 32;
 
281
                  else if (curChar == 100)
 
282
                     jjstateSet[jjnewStateCnt++] = 24;
 
283
                  else if (curChar == 70)
 
284
                     jjstateSet[jjnewStateCnt++] = 16;
 
285
                  else if (curChar == 102)
 
286
                     jjstateSet[jjnewStateCnt++] = 11;
 
287
                  else if (curChar == 84)
 
288
                     jjstateSet[jjnewStateCnt++] = 6;
 
289
                  else if (curChar == 116)
 
290
                     jjstateSet[jjnewStateCnt++] = 2;
 
291
                  break;
 
292
               case 64:
 
293
                  if ((0x7fffffe87fffffeL & l) != 0L)
 
294
                  {
 
295
                     if (kind > 20)
 
296
                        kind = 20;
 
297
                     { jjCheckNAdd(49); }
 
298
                  }
 
299
                  else if (curChar == 91)
 
300
                     jjstateSet[jjnewStateCnt++] = 68;
 
301
                  if (curChar == 71)
 
302
                  {
 
303
                     if (kind > 5)
 
304
                        kind = 5;
 
305
                  }
 
306
                  else if (curChar == 70)
 
307
                  {
 
308
                     if (kind > 4)
 
309
                        kind = 4;
 
310
                  }
 
311
                  break;
 
312
               case 57:
 
313
                  if ((0x7fffffe87fffffeL & l) != 0L)
 
314
                  {
 
315
                     if (kind > 20)
 
316
                        kind = 20;
 
317
                     { jjCheckNAdd(49); }
 
318
                  }
 
319
                  else if (curChar == 91)
 
320
                     jjstateSet[jjnewStateCnt++] = 61;
 
321
                  if (curChar == 71)
 
322
                  {
 
323
                     if (kind > 11)
 
324
                        kind = 11;
 
325
                  }
 
326
                  else if (curChar == 70)
 
327
                  {
 
328
                     if (kind > 10)
 
329
                        kind = 10;
 
330
                  }
 
331
                  break;
 
332
               case 0:
 
333
                  if (curChar == 101 && kind > 1)
 
334
                     kind = 1;
 
335
                  break;
 
336
               case 1:
 
337
                  if (curChar == 117)
 
338
                     jjstateSet[jjnewStateCnt++] = 0;
 
339
                  break;
 
340
               case 2:
 
341
                  if (curChar == 114)
 
342
                     jjstateSet[jjnewStateCnt++] = 1;
 
343
                  break;
 
344
               case 4:
 
345
                  if (curChar == 69 && kind > 1)
 
346
                     kind = 1;
 
347
                  break;
 
348
               case 5:
 
349
                  if (curChar == 85)
 
350
                     jjstateSet[jjnewStateCnt++] = 4;
 
351
                  break;
 
352
               case 6:
 
353
                  if (curChar == 82)
 
354
                     jjstateSet[jjnewStateCnt++] = 5;
 
355
                  break;
 
356
               case 7:
 
357
                  if (curChar == 84)
 
358
                     jjstateSet[jjnewStateCnt++] = 6;
 
359
                  break;
 
360
               case 8:
 
361
                  if (curChar == 101 && kind > 2)
 
362
                     kind = 2;
 
363
                  break;
 
364
               case 9:
 
365
                  if (curChar == 115)
 
366
                     jjstateSet[jjnewStateCnt++] = 8;
 
367
                  break;
 
368
               case 10:
 
369
                  if (curChar == 108)
 
370
                     jjstateSet[jjnewStateCnt++] = 9;
 
371
                  break;
 
372
               case 11:
 
373
                  if (curChar == 97)
 
374
                     jjstateSet[jjnewStateCnt++] = 10;
 
375
                  break;
 
376
               case 12:
 
377
                  if (curChar == 102)
 
378
                     jjstateSet[jjnewStateCnt++] = 11;
 
379
                  break;
 
380
               case 13:
 
381
                  if (curChar == 69 && kind > 2)
 
382
                     kind = 2;
 
383
                  break;
 
384
               case 14:
 
385
                  if (curChar == 83)
 
386
                     jjstateSet[jjnewStateCnt++] = 13;
 
387
                  break;
 
388
               case 15:
 
389
                  if (curChar == 76)
 
390
                     jjstateSet[jjnewStateCnt++] = 14;
 
391
                  break;
 
392
               case 16:
 
393
                  if (curChar == 65)
 
394
                     jjstateSet[jjnewStateCnt++] = 15;
 
395
                  break;
 
396
               case 17:
 
397
                  if (curChar == 70)
 
398
                     jjstateSet[jjnewStateCnt++] = 16;
 
399
                  break;
 
400
               case 18:
 
401
                  if (curChar == 107 && kind > 3)
 
402
                     kind = 3;
 
403
                  break;
 
404
               case 19:
 
405
                  if (curChar == 99)
 
406
                     jjstateSet[jjnewStateCnt++] = 18;
 
407
                  break;
 
408
               case 20:
 
409
                  if (curChar == 111)
 
410
                     jjstateSet[jjnewStateCnt++] = 19;
 
411
                  break;
 
412
               case 21:
 
413
                  if (curChar == 108)
 
414
                     jjstateSet[jjnewStateCnt++] = 20;
 
415
                  break;
 
416
               case 22:
 
417
                  if (curChar == 100)
 
418
                     jjstateSet[jjnewStateCnt++] = 21;
 
419
                  break;
 
420
               case 23:
 
421
                  if (curChar == 97)
 
422
                     jjstateSet[jjnewStateCnt++] = 22;
 
423
                  break;
 
424
               case 24:
 
425
                  if (curChar == 101)
 
426
                     jjstateSet[jjnewStateCnt++] = 23;
 
427
                  break;
 
428
               case 25:
 
429
                  if (curChar == 100)
 
430
                     jjstateSet[jjnewStateCnt++] = 24;
 
431
                  break;
 
432
               case 26:
 
433
                  if (curChar == 75 && kind > 3)
 
434
                     kind = 3;
 
435
                  break;
 
436
               case 27:
 
437
                  if (curChar == 67)
 
438
                     jjstateSet[jjnewStateCnt++] = 26;
 
439
                  break;
 
440
               case 28:
 
441
                  if (curChar == 79)
 
442
                     jjstateSet[jjnewStateCnt++] = 27;
 
443
                  break;
 
444
               case 29:
 
445
                  if (curChar == 76)
 
446
                     jjstateSet[jjnewStateCnt++] = 28;
 
447
                  break;
 
448
               case 30:
 
449
                  if (curChar == 68)
 
450
                     jjstateSet[jjnewStateCnt++] = 29;
 
451
                  break;
 
452
               case 31:
 
453
                  if (curChar == 65)
 
454
                     jjstateSet[jjnewStateCnt++] = 30;
 
455
                  break;
 
456
               case 32:
 
457
                  if (curChar == 69)
 
458
                     jjstateSet[jjnewStateCnt++] = 31;
 
459
                  break;
 
460
               case 33:
 
461
                  if (curChar == 68)
 
462
                     jjstateSet[jjnewStateCnt++] = 32;
 
463
                  break;
 
464
               case 34:
 
465
                  if (curChar == 114 && kind > 13)
 
466
                     kind = 13;
 
467
                  break;
 
468
               case 35:
 
469
                  if (curChar == 111)
 
470
                     jjstateSet[jjnewStateCnt++] = 34;
 
471
                  break;
 
472
               case 36:
 
473
                  if (curChar == 124 && kind > 13)
 
474
                     kind = 13;
 
475
                  break;
 
476
               case 37:
 
477
                  if (curChar == 124)
 
478
                     jjstateSet[jjnewStateCnt++] = 36;
 
479
                  break;
 
480
               case 38:
 
481
                  if (curChar == 100 && kind > 14)
 
482
                     kind = 14;
 
483
                  break;
 
484
               case 39:
 
485
                  if (curChar == 110)
 
486
                     jjstateSet[jjnewStateCnt++] = 38;
 
487
                  break;
 
488
               case 40:
 
489
                  if (curChar == 97)
 
490
                     jjstateSet[jjnewStateCnt++] = 39;
 
491
                  break;
 
492
               case 43:
 
493
                  if (curChar == 116 && kind > 15)
 
494
                     kind = 15;
 
495
                  break;
 
496
               case 44:
 
497
                  if (curChar == 111)
 
498
                     jjstateSet[jjnewStateCnt++] = 43;
 
499
                  break;
 
500
               case 45:
 
501
                  if (curChar == 110)
 
502
                     jjstateSet[jjnewStateCnt++] = 44;
 
503
                  break;
 
504
               case 48:
 
505
                  if ((0x7fffffe87fffffeL & l) == 0L)
 
506
                     break;
 
507
                  if (kind > 20)
 
508
                     kind = 20;
 
509
                  { jjCheckNAdd(49); }
 
510
                  break;
 
511
               case 49:
 
512
                  if ((0x7fffffe87fffffeL & l) == 0L)
 
513
                     break;
 
514
                  if (kind > 20)
 
515
                     kind = 20;
 
516
                  { jjCheckNAdd(49); }
 
517
                  break;
 
518
               case 56:
 
519
                  if (curChar == 65)
 
520
                     { jjAddStates(4, 7); }
 
521
                  break;
 
522
               case 60:
 
523
                  if (curChar == 71 && kind > 11)
 
524
                     kind = 11;
 
525
                  break;
 
526
               case 61:
 
527
                  if (curChar == 93 && kind > 11)
 
528
                     kind = 11;
 
529
                  break;
 
530
               case 62:
 
531
                  if (curChar == 91)
 
532
                     jjstateSet[jjnewStateCnt++] = 61;
 
533
                  break;
 
534
               case 63:
 
535
                  if (curChar == 69)
 
536
                     { jjAddStates(0, 3); }
 
537
                  break;
 
538
               case 67:
 
539
                  if (curChar == 71 && kind > 5)
 
540
                     kind = 5;
 
541
                  break;
 
542
               case 68:
 
543
                  if (curChar == 93 && kind > 5)
 
544
                     kind = 5;
 
545
                  break;
 
546
               case 69:
 
547
                  if (curChar == 91)
 
548
                     jjstateSet[jjnewStateCnt++] = 68;
 
549
                  break;
 
550
               default : break;
 
551
            }
 
552
         } while(i != startsAt);
 
553
      }
 
554
      else
 
555
      {
 
556
         int i2 = (curChar & 0xff) >> 6;
 
557
         long l2 = 1L << (curChar & 077);
 
558
         do
 
559
         {
 
560
            switch(jjstateSet[--i])
 
561
            {
 
562
               default : break;
 
563
            }
 
564
         } while(i != startsAt);
 
565
      }
 
566
      if (kind != 0x7fffffff)
 
567
      {
 
568
         jjmatchedKind = kind;
 
569
         jjmatchedPos = curPos;
 
570
         kind = 0x7fffffff;
 
571
      }
 
572
      ++curPos;
 
573
      if ((i = jjnewStateCnt) == (startsAt = 70 - (jjnewStateCnt = startsAt)))
 
574
         return curPos;
 
575
      try { curChar = input_stream.readChar(); }
 
576
      catch(java.io.IOException e) { return curPos; }
 
577
   }
 
578
}
 
579
 
 
580
/** Token literal values. */
 
581
public static final String[] jjstrLiteralImages = {
 
582
"", null, null, null, null, null, "\105", "\101", "\125", "\105\130", null, 
 
583
null, "\101\130", null, null, null, "\53", "\55", "\52", null, null, null, null, 
 
584
null, null, null, "\50", "\51", "\56", };
 
585
protected Token jjFillToken()
 
586
{
 
587
   final Token t;
 
588
   final String curTokenImage;
 
589
   final int beginLine;
 
590
   final int endLine;
 
591
   final int beginColumn;
 
592
   final int endColumn;
 
593
   String im = jjstrLiteralImages[jjmatchedKind];
 
594
   curTokenImage = (im == null) ? input_stream.GetImage() : im;
 
595
   beginLine = input_stream.getBeginLine();
 
596
   beginColumn = input_stream.getBeginColumn();
 
597
   endLine = input_stream.getEndLine();
 
598
   endColumn = input_stream.getEndColumn();
 
599
   t = Token.newToken(jjmatchedKind);
 
600
   t.kind = jjmatchedKind;
 
601
   t.image = curTokenImage;
 
602
 
 
603
   t.beginLine = beginLine;
 
604
   t.endLine = endLine;
 
605
   t.beginColumn = beginColumn;
 
606
   t.endColumn = endColumn;
 
607
 
 
608
   return t;
 
609
}
 
610
static final int[] jjnextStates = {
 
611
   64, 66, 67, 69, 57, 59, 60, 62, 
 
612
};
 
613
 
 
614
int curLexState = 0;
 
615
int defaultLexState = 0;
 
616
int jjnewStateCnt;
 
617
int jjround;
 
618
int jjmatchedPos;
 
619
int jjmatchedKind;
 
620
 
 
621
/** Get the next Token. */
 
622
public Token getNextToken() 
 
623
{
 
624
  Token matchedToken;
 
625
  int curPos = 0;
 
626
 
 
627
  EOFLoop :
 
628
  for (;;)
 
629
  {
 
630
   try
 
631
   {
 
632
      curChar = input_stream.BeginToken();
 
633
   }
 
634
   catch(Exception e)
 
635
   {
 
636
      jjmatchedKind = 0;
 
637
      jjmatchedPos = -1;
 
638
      matchedToken = jjFillToken();
 
639
      return matchedToken;
 
640
   }
 
641
 
 
642
   try { input_stream.backup(0);
 
643
      while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
 
644
         curChar = input_stream.BeginToken();
 
645
   }
 
646
   catch (java.io.IOException e1) { continue EOFLoop; }
 
647
   jjmatchedKind = 0x7fffffff;
 
648
   jjmatchedPos = 0;
 
649
   curPos = jjMoveStringLiteralDfa0_0();
 
650
   if (jjmatchedKind != 0x7fffffff)
 
651
   {
 
652
      if (jjmatchedPos + 1 < curPos)
 
653
         input_stream.backup(curPos - jjmatchedPos - 1);
 
654
      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 
655
      {
 
656
         matchedToken = jjFillToken();
 
657
         return matchedToken;
 
658
      }
 
659
      else
 
660
      {
 
661
         continue EOFLoop;
 
662
      }
 
663
   }
 
664
   int error_line = input_stream.getEndLine();
 
665
   int error_column = input_stream.getEndColumn();
 
666
   String error_after = null;
 
667
   boolean EOFSeen = false;
 
668
   try { input_stream.readChar(); input_stream.backup(1); }
 
669
   catch (java.io.IOException e1) {
 
670
      EOFSeen = true;
 
671
      error_after = curPos <= 1 ? "" : input_stream.GetImage();
 
672
      if (curChar == '\n' || curChar == '\r') {
 
673
         error_line++;
 
674
         error_column = 0;
 
675
      }
 
676
      else
 
677
         error_column++;
 
678
   }
 
679
   if (!EOFSeen) {
 
680
      input_stream.backup(1);
 
681
      error_after = curPos <= 1 ? "" : input_stream.GetImage();
 
682
   }
 
683
   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 
684
  }
 
685
}
 
686
 
 
687
void SkipLexicalActions(Token matchedToken)
 
688
{
 
689
   switch(jjmatchedKind)
 
690
   {
 
691
      default :
 
692
         break;
 
693
   }
 
694
}
 
695
void MoreLexicalActions()
 
696
{
 
697
   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
 
698
   switch(jjmatchedKind)
 
699
   {
 
700
      default :
 
701
         break;
 
702
   }
 
703
}
 
704
void TokenLexicalActions(Token matchedToken)
 
705
{
 
706
   switch(jjmatchedKind)
 
707
   {
 
708
      default :
 
709
         break;
 
710
   }
 
711
}
 
712
private void jjCheckNAdd(int state)
 
713
{
 
714
   if (jjrounds[state] != jjround)
 
715
   {
 
716
      jjstateSet[jjnewStateCnt++] = state;
 
717
      jjrounds[state] = jjround;
 
718
   }
 
719
}
 
720
private void jjAddStates(int start, int end)
 
721
{
 
722
   do {
 
723
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 
724
   } while (start++ != end);
 
725
}
 
726
private void jjCheckNAddTwoStates(int state1, int state2)
 
727
{
 
728
   jjCheckNAdd(state1);
 
729
   jjCheckNAdd(state2);
 
730
}
 
731
 
 
732
    /** Constructor. */
 
733
    public TAPAALCTLQueryParserTokenManager(SimpleCharStream stream){
 
734
 
 
735
      if (SimpleCharStream.staticFlag)
 
736
            throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 
737
 
 
738
    input_stream = stream;
 
739
  }
 
740
 
 
741
  /** Constructor. */
 
742
  public TAPAALCTLQueryParserTokenManager (SimpleCharStream stream, int lexState){
 
743
    ReInit(stream);
 
744
    SwitchTo(lexState);
 
745
  }
 
746
 
 
747
  /** Reinitialise parser. */
 
748
  
 
749
  public void ReInit(SimpleCharStream stream)
 
750
  {
 
751
 
 
752
 
 
753
    jjmatchedPos =
 
754
    jjnewStateCnt =
 
755
    0;
 
756
    curLexState = defaultLexState;
 
757
    input_stream = stream;
 
758
    ReInitRounds();
 
759
  }
 
760
 
 
761
  private void ReInitRounds()
 
762
  {
 
763
    int i;
 
764
    jjround = 0x80000001;
 
765
    for (i = 70; i-- > 0;)
 
766
      jjrounds[i] = 0x80000000;
 
767
  }
 
768
 
 
769
  /** Reinitialise parser. */
 
770
  public void ReInit(SimpleCharStream stream, int lexState)
 
771
  
 
772
  {
 
773
    ReInit(stream);
 
774
    SwitchTo(lexState);
 
775
  }
 
776
 
 
777
  /** Switch to specified lex state. */
 
778
  public void SwitchTo(int lexState)
 
779
  {
 
780
    if (lexState >= 1 || lexState < 0)
 
781
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 
782
    else
 
783
      curLexState = lexState;
 
784
  }
 
785
 
 
786
 
 
787
/** Lexer state names. */
 
788
public static final String[] lexStateNames = {
 
789
   "DEFAULT",
 
790
};
 
791
 
 
792
/** Lex State array. */
 
793
public static final int[] jjnewLexState = {
 
794
   -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, 
 
795
   -1, -1, -1, -1, 
 
796
};
 
797
static final long[] jjtoToken = {
 
798
   0x1c3fffffL, 
 
799
};
 
800
static final long[] jjtoSkip = {
 
801
   0x3c00000L, 
 
802
};
 
803
static final long[] jjtoSpecial = {
 
804
   0x0L, 
 
805
};
 
806
static final long[] jjtoMore = {
 
807
   0x0L, 
 
808
};
 
809
    protected SimpleCharStream  input_stream;
 
810
 
 
811
    private final int[] jjrounds = new int[70];
 
812
    private final int[] jjstateSet = new int[2 * 70];
 
813
    private final StringBuilder jjimage = new StringBuilder();
 
814
    private StringBuilder image = jjimage;
 
815
    private int jjimageLen;
 
816
    private int lengthOfMatch;
 
817
    protected int curChar;
 
818
}