~ubuntu-branches/ubuntu/vivid/cobertura/vivid-proposed
» Revision
3
: src/net/sourceforge/cobertura/javancss/JavaParserTokenManager.java
« back to all changes in this revision
Viewing changes to src/net/sourceforge/cobertura/javancss/JavaParserTokenManager.java
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Miguel Landaeta
- Date: 2010-05-11 19:21:46 UTC
- mfrom: (0.1.4 sid) (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20100511192146-j742v5jsl89ztndu
Tags: 1.9.4.1+dfsg-2
* Now Build-Depends on libservlet2.5-java and add a missing Depends
on the same package. (Closes: #580842).
* Simplify list of JRE dependences for cobertura and drop JRE dependences for
libcobertura-java as Java libraries are no longer required to depend on a
JVM.
on the same package. (Closes: #580842).
* Simplify list of JRE dependences for cobertura and drop JRE dependences for
libcobertura-java as Java libraries are no longer required to depend on a
JVM.
- files added:
- .pc
- .pc/add_classpath_to_manifest.diff
- .pc/build_with_system_jars.diff
- antLibrary
- antLibrary/common
- antLibrary/common/groovy
- antLibrary/common/junit
- debian/patches
- debian/source
- src/net/sourceforge/cobertura/coveragedata/countermaps
- src/net/sourceforge/cobertura/javancss/ccl
- src/net/sourceforge/cobertura/javancss/parser
- src/net/sourceforge/cobertura/javancss/parser/debug
- src/net/sourceforge/cobertura/javancss/parser/java15
- src/net/sourceforge/cobertura/javancss/parser/java15/debug
- src/net/sourceforge/cobertura/javancss/test
- src/net/sourceforge/cobertura/webapp
- test/net/sourceforge/cobertura/coveragedata/countermaps
- test/net/sourceforge/cobertura/test
- test/net/sourceforge/cobertura/test/util
- test/net/sourceforge/cobertura/thread
- test/net/sourceforge/cobertura/thread/test
- test/net/sourceforge/cobertura/webapp
- test/net/sourceforge/cobertura/webapp/test
- files removed:
- debian/README.source
- files modified:
- COPYRIGHT
added
removed
src/net/sourceforge/cobertura/javancss/JavaParserTokenManager.java
1
/* Generated By:JavaCC: Do not edit this line. JavaParserTokenManager.java */
2
3
/*
4
* Cobertura - http://cobertura.sourceforge.net/
5
*
6
* This file was taken from JavaNCSS
7
* http://www.kclee.com/clemens/java/javancss/
8
* Copyright (C) 2000 Chr. Clemens Lee <clemens a.t kclee d.o.t com>
9
*
10
* Cobertura is free software; you can redistribute it and/or modify
11
* it under the terms of the GNU General Public License as published
12
* by the Free Software Foundation; either version 2 of the License,
13
* or (at your option) any later version.
14
*
15
* Cobertura is distributed in the hope that it will be useful, but
16
* WITHOUT ANY WARRANTY; without even the implied warranty of
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18
* General Public License for more details.
19
*
20
* You should have received a copy of the GNU General Public License
21
* along with Cobertura; if not, write to the Free Software
22
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
23
* USA
24
*/
25
26
package net.sourceforge.cobertura.javancss;
27
28
public class JavaParserTokenManager implements JavaParserConstants
29
{
30
31
// added by SMS
32
33
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
34
{
35
switch (pos)
36
{
37
case 0:
38
if ((active1 & 0x100000L) != 0L)
39
return 4;
40
if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
41
{
42
jjmatchedKind = 73;
43
return 28;
44
}
45
return -1;
46
case 1:
47
if ((active0 & 0x806000000L) != 0L)
48
return 28;
49
if ((active0 & 0xfffffff7f9ffe000L) != 0L || (active1 & 0x1L) != 0L)
50
{
51
if (jjmatchedPos != 1)
52
{
53
jjmatchedKind = 73;
54
jjmatchedPos = 1;
55
}
56
return 28;
57
}
58
return -1;
59
case 2:
60
if ((active0 & 0x2000098200000000L) != 0L)
61
return 28;
62
if ((active0 & 0xdffff675fdffe000L) != 0L || (active1 & 0x1L) != 0L)
63
{
64
if (jjmatchedPos != 2)
65
{
66
jjmatchedKind = 73;
67
jjmatchedPos = 2;
68
}
69
return 28;
70
}
71
return -1;
72
case 3:
73
if ((active0 & 0x8effe571f5e9e000L) != 0L || (active1 & 0x1L) != 0L)
74
{
75
jjmatchedKind = 73;
76
jjmatchedPos = 3;
77
return 28;
78
}
79
if ((active0 & 0x5100120408160000L) != 0L)
80
return 28;
81
return -1;
82
case 4:
83
if ((active0 & 0x6240001e0690000L) != 0L || (active1 & 0x1L) != 0L)
84
return 28;
85
if ((active0 & 0x88dbe5701580e000L) != 0L)
86
{
87
if (jjmatchedPos != 4)
88
{
89
jjmatchedKind = 73;
90
jjmatchedPos = 4;
91
}
92
return 28;
93
}
94
return -1;
95
case 5:
96
if ((active0 & 0x44b042004004000L) != 0L)
97
return 28;
98
if ((active0 & 0x8890e1509180a000L) != 0L)
99
{
100
jjmatchedKind = 73;
101
jjmatchedPos = 5;
102
return 28;
103
}
104
return -1;
105
case 6:
106
if ((active0 & 0x8890815000802000L) != 0L)
107
{
108
jjmatchedKind = 73;
109
jjmatchedPos = 6;
110
return 28;
111
}
112
if ((active0 & 0x600091008000L) != 0L)
113
return 28;
114
return -1;
115
case 7:
116
if ((active0 & 0x8010000000802000L) != 0L)
117
return 28;
118
if ((active0 & 0x880815000000000L) != 0L)
119
{
120
jjmatchedKind = 73;
121
jjmatchedPos = 7;
122
return 28;
123
}
124
return -1;
125
case 8:
126
if ((active0 & 0x800810000000000L) != 0L)
127
return 28;
128
if ((active0 & 0x80005000000000L) != 0L)
129
{
130
jjmatchedKind = 73;
131
jjmatchedPos = 8;
132
return 28;
133
}
134
return -1;
135
case 9:
136
if ((active0 & 0x5000000000L) != 0L)
137
return 28;
138
if ((active0 & 0x80000000000000L) != 0L)
139
{
140
jjmatchedKind = 73;
141
jjmatchedPos = 9;
142
return 28;
143
}
144
return -1;
145
case 10:
146
if ((active0 & 0x80000000000000L) != 0L)
147
{
148
jjmatchedKind = 73;
149
jjmatchedPos = 10;
150
return 28;
151
}
152
return -1;
153
default:
154
return -1;
155
}
156
}
157
158
private final int jjStartNfa_0(int pos, long active0, long active1)
159
{
160
return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1), pos + 1);
161
}
162
163
private final int jjStopAtPos(int pos, int kind)
164
{
165
jjmatchedKind = kind;
166
jjmatchedPos = pos;
167
return pos + 1;
168
}
169
170
private final int jjStartNfaWithStates_0(int pos, int kind, int state)
171
{
172
jjmatchedKind = kind;
173
jjmatchedPos = pos;
174
try
175
{
176
curChar = input_stream.readChar();
177
}
178
catch (java.io.IOException e)
179
{
180
return pos + 1;
181
}
182
return jjMoveNfa_0(state, pos + 1);
183
}
184
185
private final int jjMoveStringLiteralDfa0_0()
186
{
187
switch (curChar)
188
{
189
case 33:
190
jjmatchedKind = 88;
191
return jjMoveStringLiteralDfa1_0(0x0L, 0x80000000L);
192
case 37:
193
jjmatchedKind = 107;
194
return jjMoveStringLiteralDfa1_0(0x0L, 0x40000000000000L);
195
case 38:
196
jjmatchedKind = 104;
197
return jjMoveStringLiteralDfa1_0(0x0L, 0x8000200000000L);
198
case 40:
199
return jjStopAtPos(0, 76);
200
case 41:
201
return jjStopAtPos(0, 77);
202
case 42:
203
jjmatchedKind = 102;
204
return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000L);
205
case 43:
206
jjmatchedKind = 100;
207
return jjMoveStringLiteralDfa1_0(0x0L, 0x800400000000L);
208
case 44:
209
return jjStopAtPos(0, 83);
210
case 45:
211
jjmatchedKind = 101;
212
return jjMoveStringLiteralDfa1_0(0x0L, 0x1000800000000L);
213
case 46:
214
return jjStartNfaWithStates_0(0, 84, 4);
215
case 47:
216
jjmatchedKind = 103;
217
return jjMoveStringLiteralDfa1_0(0x180L, 0x4000000000000L);
218
case 58:
219
return jjStopAtPos(0, 91);
220
case 59:
221
return jjStopAtPos(0, 82);
222
case 60:
223
jjmatchedKind = 87;
224
return jjMoveStringLiteralDfa1_0(0x0L, 0x80100020000000L);
225
case 61:
226
jjmatchedKind = 85;
227
return jjMoveStringLiteralDfa1_0(0x0L, 0x10000000L);
228
case 62:
229
jjmatchedKind = 86;
230
return jjMoveStringLiteralDfa1_0(0x0L, 0x300600040000000L);
231
case 63:
232
return jjStopAtPos(0, 90);
233
case 91:
234
return jjStopAtPos(0, 80);
235
case 93:
236
return jjStopAtPos(0, 81);
237
case 94:
238
jjmatchedKind = 106;
239
return jjMoveStringLiteralDfa1_0(0x0L, 0x20000000000000L);
240
case 97:
241
return jjMoveStringLiteralDfa1_0(0x6000L, 0x0L);
242
case 98:
243
return jjMoveStringLiteralDfa1_0(0x38000L, 0x0L);
244
case 99:
245
return jjMoveStringLiteralDfa1_0(0xfc0000L, 0x0L);
246
case 100:
247
return jjMoveStringLiteralDfa1_0(0x7000000L, 0x0L);
248
case 101:
249
return jjMoveStringLiteralDfa1_0(0x18000000L, 0x0L);
250
case 102:
251
return jjMoveStringLiteralDfa1_0(0x3e0000000L, 0x0L);
252
case 103:
253
return jjMoveStringLiteralDfa1_0(0x400000000L, 0x0L);
254
case 105:
255
return jjMoveStringLiteralDfa1_0(0x1f800000000L, 0x0L);
256
case 108:
257
return jjMoveStringLiteralDfa1_0(0x20000000000L, 0x0L);
258
case 110:
259
return jjMoveStringLiteralDfa1_0(0x1c0000000000L, 0x0L);
260
case 112:
261
return jjMoveStringLiteralDfa1_0(0x1e00000000000L, 0x0L);
262
case 114:
263
return jjMoveStringLiteralDfa1_0(0x2000000000000L, 0x0L);
264
case 115:
265
return jjMoveStringLiteralDfa1_0(0xfc000000000000L, 0x0L);
266
case 116:
267
return jjMoveStringLiteralDfa1_0(0x3f00000000000000L, 0x0L);
268
case 118:
269
return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0x0L);
270
case 119:
271
return jjMoveStringLiteralDfa1_0(0x0L, 0x1L);
272
case 123:
273
return jjStopAtPos(0, 78);
274
case 124:
275
jjmatchedKind = 105;
276
return jjMoveStringLiteralDfa1_0(0x0L, 0x10000100000000L);
277
case 125:
278
return jjStopAtPos(0, 79);
279
case 126:
280
return jjStopAtPos(0, 89);
281
default:
282
return jjMoveNfa_0(0, 0);
283
}
284
}
285
286
private final int jjMoveStringLiteralDfa1_0(long active0, long active1)
287
{
288
try
289
{
290
curChar = input_stream.readChar();
291
}
292
catch (java.io.IOException e)
293
{
294
jjStopStringLiteralDfa_0(0, active0, active1);
295
return 1;
296
}
297
switch (curChar)
298
{
299
case 38:
300
if ((active1 & 0x200000000L) != 0L)
301
return jjStopAtPos(1, 97);
302
break;
303
case 42:
304
if ((active0 & 0x80L) != 0L)
305
return jjStopAtPos(1, 7);
306
break;
307
case 43:
308
if ((active1 & 0x400000000L) != 0L)
309
return jjStopAtPos(1, 98);
310
break;
311
case 45:
312
if ((active1 & 0x800000000L) != 0L)
313
return jjStopAtPos(1, 99);
314
break;
315
case 47:
316
if ((active0 & 0x100L) != 0L)
317
return jjStopAtPos(1, 8);
318
break;
319
case 60:
320
if ((active1 & 0x100000000000L) != 0L)
321
{
322
jjmatchedKind = 108;
323
jjmatchedPos = 1;
324
}
325
return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x80000000000000L);
326
case 61:
327
if ((active1 & 0x10000000L) != 0L)
328
return jjStopAtPos(1, 92);
329
else if ((active1 & 0x20000000L) != 0L)
330
return jjStopAtPos(1, 93);
331
else if ((active1 & 0x40000000L) != 0L)
332
return jjStopAtPos(1, 94);
333
else if ((active1 & 0x80000000L) != 0L)
334
return jjStopAtPos(1, 95);
335
else if ((active1 & 0x800000000000L) != 0L)
336
return jjStopAtPos(1, 111);
337
else if ((active1 & 0x1000000000000L) != 0L)
338
return jjStopAtPos(1, 112);
339
else if ((active1 & 0x2000000000000L) != 0L)
340
return jjStopAtPos(1, 113);
341
else if ((active1 & 0x4000000000000L) != 0L)
342
return jjStopAtPos(1, 114);
343
else if ((active1 & 0x8000000000000L) != 0L)
344
return jjStopAtPos(1, 115);
345
else if ((active1 & 0x10000000000000L) != 0L)
346
return jjStopAtPos(1, 116);
347
else if ((active1 & 0x20000000000000L) != 0L)
348
return jjStopAtPos(1, 117);
349
else if ((active1 & 0x40000000000000L) != 0L)
350
return jjStopAtPos(1, 118);
351
break;
352
case 62:
353
if ((active1 & 0x200000000000L) != 0L)
354
{
355
jjmatchedKind = 109;
356
jjmatchedPos = 1;
357
}
358
return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x300400000000000L);
359
case 97:
360
return jjMoveStringLiteralDfa2_0(active0, 0x2400200c0000L, active1, 0L);
361
case 98:
362
return jjMoveStringLiteralDfa2_0(active0, 0x2000L, active1, 0L);
363
case 101:
364
return jjMoveStringLiteralDfa2_0(active0, 0x2080001000000L, active1, 0L);
365
case 102:
366
if ((active0 & 0x800000000L) != 0L)
367
return jjStartNfaWithStates_0(1, 35, 28);
368
break;
369
case 104:
370
return jjMoveStringLiteralDfa2_0(active0, 0x704000000100000L, active1, 0x1L);
371
case 105:
372
return jjMoveStringLiteralDfa2_0(active0, 0xc0000000L, active1, 0L);
373
case 108:
374
return jjMoveStringLiteralDfa2_0(active0, 0x108200000L, active1, 0L);
375
case 109:
376
return jjMoveStringLiteralDfa2_0(active0, 0x3000000000L, active1, 0L);
377
case 110:
378
return jjMoveStringLiteralDfa2_0(active0, 0x1c000000000L, active1, 0L);
379
case 111:
380
if ((active0 & 0x2000000L) != 0L)
381
{
382
jjmatchedKind = 25;
383
jjmatchedPos = 1;
384
}
385
return jjMoveStringLiteralDfa2_0(active0, 0xc000020604c08000L, active1, 0L);
386
case 114:
387
return jjMoveStringLiteralDfa2_0(active0, 0x3800c00000010000L, active1, 0L);
388
case 115:
389
return jjMoveStringLiteralDfa2_0(active0, 0x4000L, active1, 0L);
390
case 116:
391
return jjMoveStringLiteralDfa2_0(active0, 0x18000000000000L, active1, 0L);
392
case 117:
393
return jjMoveStringLiteralDfa2_0(active0, 0x21100000000000L, active1, 0L);
394
case 119:
395
return jjMoveStringLiteralDfa2_0(active0, 0x40000000000000L, active1, 0L);
396
case 120:
397
return jjMoveStringLiteralDfa2_0(active0, 0x10000000L, active1, 0L);
398
case 121:
399
return jjMoveStringLiteralDfa2_0(active0, 0x80000000020000L, active1, 0L);
400
case 124:
401
if ((active1 & 0x100000000L) != 0L)
402
return jjStopAtPos(1, 96);
403
break;
404
default:
405
break;
406
}
407
return jjStartNfa_0(0, active0, active1);
408
}
409
410
private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1)
411
{
412
if (((active0 &= old0) | (active1 &= old1)) == 0L)
413
return jjStartNfa_0(0, old0, old1);
414
try
415
{
416
curChar = input_stream.readChar();
417
}
418
catch (java.io.IOException e)
419
{
420
jjStopStringLiteralDfa_0(1, active0, active1);
421
return 2;
422
}
423
switch (curChar)
424
{
425
case 61:
426
if ((active1 & 0x80000000000000L) != 0L)
427
return jjStopAtPos(2, 119);
428
else if ((active1 & 0x100000000000000L) != 0L)
429
return jjStopAtPos(2, 120);
430
break;
431
case 62:
432
if ((active1 & 0x400000000000L) != 0L)
433
{
434
jjmatchedKind = 110;
435
jjmatchedPos = 2;
436
}
437
return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0x200000000000000L);
438
case 97:
439
return jjMoveStringLiteralDfa3_0(active0, 0x808000000300000L, active1, 0L);
440
case 98:
441
return jjMoveStringLiteralDfa3_0(active0, 0x1000000000000L, active1, 0L);
442
case 99:
443
return jjMoveStringLiteralDfa3_0(active0, 0x200000000000L, active1, 0L);
444
case 101:
445
return jjMoveStringLiteralDfa3_0(active0, 0x10000L, active1, 0L);
446
case 102:
447
return jjMoveStringLiteralDfa3_0(active0, 0x1000000L, active1, 0L);
448
case 105:
449
return jjMoveStringLiteralDfa3_0(active0, 0x4140400000000000L, active1, 0x1L);
450
case 108:
451
return jjMoveStringLiteralDfa3_0(active0, 0x8000100020000000L, active1, 0L);
452
case 110:
453
return jjMoveStringLiteralDfa3_0(active0, 0x800200c0c00000L, active1, 0L);
454
case 111:
455
return jjMoveStringLiteralDfa3_0(active0, 0x4800100008000L, active1, 0L);
456
case 112:
457
return jjMoveStringLiteralDfa3_0(active0, 0x20003000000000L, active1, 0L);
458
case 114:
459
if ((active0 & 0x200000000L) != 0L)
460
return jjStartNfaWithStates_0(2, 33, 28);
461
return jjMoveStringLiteralDfa3_0(active0, 0x610000000000000L, active1, 0L);
462
case 115:
463
return jjMoveStringLiteralDfa3_0(active0, 0x4008046000L, active1, 0L);
464
case 116:
465
if ((active0 & 0x8000000000L) != 0L)
466
{
467
jjmatchedKind = 39;
468
jjmatchedPos = 2;
469
}
470
return jjMoveStringLiteralDfa3_0(active0, 0x20504100a0000L, active1, 0L);
471
case 117:
472
return jjMoveStringLiteralDfa3_0(active0, 0x1000000004000000L, active1, 0L);
473
case 119:
474
if ((active0 & 0x80000000000L) != 0L)
475
return jjStartNfaWithStates_0(2, 43, 28);
476
break;
477
case 121:
478
if ((active0 & 0x2000000000000000L) != 0L)
479
return jjStartNfaWithStates_0(2, 61, 28);
480
break;
481
default:
482
break;
483
}
484
return jjStartNfa_0(1, active0, active1);
485
}
486
487
private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1)
488
{
489
if (((active0 &= old0) | (active1 &= old1)) == 0L)
490
return jjStartNfa_0(1, old0, old1);
491
try
492
{
493
curChar = input_stream.readChar();
494
}
495
catch (java.io.IOException e)
496
{
497
jjStopStringLiteralDfa_0(2, active0, active1);
498
return 3;
499
}
500
switch (curChar)
501
{
502
case 61:
503
if ((active1 & 0x200000000000000L) != 0L)
504
return jjStopAtPos(3, 121);
505
break;
506
case 97:
507
return jjMoveStringLiteralDfa4_0(active0, 0x80000001c1010000L, active1, 0L);
508
case 98:
509
return jjMoveStringLiteralDfa4_0(active0, 0x4000000L, active1, 0L);
510
case 99:
511
return jjMoveStringLiteralDfa4_0(active0, 0x80000000080000L, active1, 0L);
512
case 100:
513
if ((active0 & 0x4000000000000000L) != 0L)
514
return jjStartNfaWithStates_0(3, 62, 28);
515
break;
516
case 101:
517
if ((active0 & 0x20000L) != 0L)
518
return jjStartNfaWithStates_0(3, 17, 28);
519
else if ((active0 & 0x40000L) != 0L)
520
return jjStartNfaWithStates_0(3, 18, 28);
521
else if ((active0 & 0x8000000L) != 0L)
522
return jjStartNfaWithStates_0(3, 27, 28);
523
else if ((active0 & 0x1000000000000000L) != 0L)
524
return jjStartNfaWithStates_0(3, 60, 28);
525
return jjMoveStringLiteralDfa4_0(active0, 0x20010010004000L, active1, 0L);
526
case 103:
527
if ((active0 & 0x20000000000L) != 0L)
528
return jjStartNfaWithStates_0(3, 41, 28);
529
break;
530
case 105:
531
return jjMoveStringLiteralDfa4_0(active0, 0x10040000000000L, active1, 0L);
532
case 107:
533
return jjMoveStringLiteralDfa4_0(active0, 0x200000000000L, active1, 0L);
534
case 108:
535
if ((active0 & 0x100000000000L) != 0L)
536
return jjStartNfaWithStates_0(3, 44, 28);
537
return jjMoveStringLiteralDfa4_0(active0, 0x1001000008000L, active1, 0x1L);
538
case 110:
539
return jjMoveStringLiteralDfa4_0(active0, 0x800000000000000L, active1, 0L);
540
case 111:
541
if ((active0 & 0x400000000L) != 0L)
542
return jjStartNfaWithStates_0(3, 34, 28);
543
return jjMoveStringLiteralDfa4_0(active0, 0x600002000000000L, active1, 0L);
544
case 114:
545
if ((active0 & 0x100000L) != 0L)
546
return jjStartNfaWithStates_0(3, 20, 28);
547
return jjMoveStringLiteralDfa4_0(active0, 0x4000000000000L, active1, 0L);
548
case 115:
549
if ((active0 & 0x100000000000000L) != 0L)
550
return jjStartNfaWithStates_0(3, 56, 28);
551
return jjMoveStringLiteralDfa4_0(active0, 0x20600000L, active1, 0L);
552
case 116:
553
return jjMoveStringLiteralDfa4_0(active0, 0x48804000802000L, active1, 0L);
554
case 117:
555
return jjMoveStringLiteralDfa4_0(active0, 0x2000000000000L, active1, 0L);
556
case 118:
557
return jjMoveStringLiteralDfa4_0(active0, 0x400000000000L, active1, 0L);
558
default:
559
break;
560
}
561
return jjStartNfa_0(2, active0, active1);
562
}
563
564
private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1)
565
{
566
if (((active0 &= old0) | (active1 &= old1)) == 0L)
567
return jjStartNfa_0(2, old0, old1);
568
try
569
{
570
curChar = input_stream.readChar();
571
}
572
catch (java.io.IOException e)
573
{
574
jjStopStringLiteralDfa_0(3, active0, active1);
575
return 4;
576
}
577
switch (curChar)
578
{
579
case 97:
580
return jjMoveStringLiteralDfa5_0(active0, 0x604000000000L, active1, 0L);
581
case 99:
582
return jjMoveStringLiteralDfa5_0(active0, 0x50000000000000L, active1, 0L);
583
case 101:
584
if ((active0 & 0x20000000L) != 0L)
585
return jjStartNfaWithStates_0(4, 29, 28);
586
else if ((active1 & 0x1L) != 0L)
587
return jjStartNfaWithStates_0(4, 64, 28);
588
return jjMoveStringLiteralDfa5_0(active0, 0x801000008000L, active1, 0L);
589
case 104:
590
if ((active0 & 0x80000L) != 0L)
591
return jjStartNfaWithStates_0(4, 19, 28);
592
return jjMoveStringLiteralDfa5_0(active0, 0x80000000000000L, active1, 0L);
593
case 105:
594
return jjMoveStringLiteralDfa5_0(active0, 0x9000000800000L, active1, 0L);
595
case 107:
596
if ((active0 & 0x10000L) != 0L)
597
return jjStartNfaWithStates_0(4, 16, 28);
598
break;
599
case 108:
600
if ((active0 & 0x40000000L) != 0L)
601
{
602
jjmatchedKind = 30;
603
jjmatchedPos = 4;
604
}
605
return jjMoveStringLiteralDfa5_0(active0, 0x84000000L, active1, 0L);
606
case 110:
607
return jjMoveStringLiteralDfa5_0(active0, 0x10000000L, active1, 0L);
608
case 114:
609
if ((active0 & 0x20000000000000L) != 0L)
610
return jjStartNfaWithStates_0(4, 53, 28);
611
return jjMoveStringLiteralDfa5_0(active0, 0x2012000006000L, active1, 0L);
612
case 115:
613
if ((active0 & 0x200000L) != 0L)
614
return jjStartNfaWithStates_0(4, 21, 28);
615
return jjMoveStringLiteralDfa5_0(active0, 0x800000000000000L, active1, 0L);
616
case 116:
617
if ((active0 & 0x400000L) != 0L)
618
return jjStartNfaWithStates_0(4, 22, 28);
619
else if ((active0 & 0x100000000L) != 0L)
620
return jjStartNfaWithStates_0(4, 32, 28);
621
else if ((active0 & 0x4000000000000L) != 0L)
622
return jjStartNfaWithStates_0(4, 50, 28);
623
return jjMoveStringLiteralDfa5_0(active0, 0x8000000000000000L, active1, 0L);
624
case 117:
625
return jjMoveStringLiteralDfa5_0(active0, 0x1000000L, active1, 0L);
626
case 118:
627
return jjMoveStringLiteralDfa5_0(active0, 0x40000000000L, active1, 0L);
628
case 119:
629
if ((active0 & 0x200000000000000L) != 0L)
630
{
631
jjmatchedKind = 57;
632
jjmatchedPos = 4;
633
}
634
return jjMoveStringLiteralDfa5_0(active0, 0x400000000000000L, active1, 0L);
635
default:
636
break;
637
}
638
return jjStartNfa_0(3, active0, active1);
639
}
640
641
private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
642
{
643
if (((active0 &= old0) | (active1 &= old1)) == 0L)
644
return jjStartNfa_0(3, old0, old1);
645
try
646
{
647
curChar = input_stream.readChar();
648
}
649
catch (java.io.IOException e)
650
{
651
jjStopStringLiteralDfa_0(4, active0, 0L);
652
return 5;
653
}
654
switch (curChar)
655
{
656
case 97:
657
return jjMoveStringLiteralDfa6_0(active0, 0xa000L);
658
case 99:
659
if ((active0 & 0x1000000000000L) != 0L)
660
return jjStartNfaWithStates_0(5, 48, 28);
661
else if ((active0 & 0x8000000000000L) != 0L)
662
return jjStartNfaWithStates_0(5, 51, 28);
663
return jjMoveStringLiteralDfa6_0(active0, 0x800000000000L);
664
case 100:
665
return jjMoveStringLiteralDfa6_0(active0, 0x10000000L);
666
case 101:
667
if ((active0 & 0x4000000L) != 0L)
668
return jjStartNfaWithStates_0(5, 26, 28);
669
else if ((active0 & 0x40000000000L) != 0L)
670
return jjStartNfaWithStates_0(5, 42, 28);
671
break;
672
case 102:
673
return jjMoveStringLiteralDfa6_0(active0, 0x10000000000L);
674
case 103:
675
return jjMoveStringLiteralDfa6_0(active0, 0x200000000000L);
676
case 104:
677
if ((active0 & 0x40000000000000L) != 0L)
678
return jjStartNfaWithStates_0(5, 54, 28);
679
break;
680
case 105:
681
return jjMoveStringLiteralDfa6_0(active0, 0x8800000000000000L);
682
case 108:
683
return jjMoveStringLiteralDfa6_0(active0, 0x81000000L);
684
case 109:
685
return jjMoveStringLiteralDfa6_0(active0, 0x1000000000L);
686
case 110:
687
if ((active0 & 0x2000000000000L) != 0L)
688
return jjStartNfaWithStates_0(5, 49, 28);
689
return jjMoveStringLiteralDfa6_0(active0, 0x4000800000L);
690
case 114:
691
return jjMoveStringLiteralDfa6_0(active0, 0x80000000000000L);
692
case 115:
693
if ((active0 & 0x400000000000000L) != 0L)
694
return jjStartNfaWithStates_0(5, 58, 28);
695
break;
696
case 116:
697
if ((active0 & 0x4000L) != 0L)
698
return jjStartNfaWithStates_0(5, 14, 28);
699
else if ((active0 & 0x2000000000L) != 0L)
700
return jjStartNfaWithStates_0(5, 37, 28);
701
return jjMoveStringLiteralDfa6_0(active0, 0x10400000000000L);
702
default:
703
break;
704
}
705
return jjStartNfa_0(4, active0, 0L);
706
}
707
708
private final int jjMoveStringLiteralDfa6_0(long old0, long active0)
709
{
710
if (((active0 &= old0)) == 0L)
711
return jjStartNfa_0(4, old0, 0L);
712
try
713
{
714
curChar = input_stream.readChar();
715
}
716
catch (java.io.IOException e)
717
{
718
jjStopStringLiteralDfa_0(5, active0, 0L);
719
return 6;
720
}
721
switch (curChar)
722
{
723
case 97:
724
return jjMoveStringLiteralDfa7_0(active0, 0x10000000000L);
725
case 99:
726
return jjMoveStringLiteralDfa7_0(active0, 0x4000002000L);
727
case 101:
728
if ((active0 & 0x200000000000L) != 0L)
729
return jjStartNfaWithStates_0(6, 45, 28);
730
else if ((active0 & 0x400000000000L) != 0L)
731
return jjStartNfaWithStates_0(6, 46, 28);
732
return jjMoveStringLiteralDfa7_0(active0, 0x800001000000000L);
733
case 102:
734
return jjMoveStringLiteralDfa7_0(active0, 0x10000000000000L);
735
case 108:
736
return jjMoveStringLiteralDfa7_0(active0, 0x8000000000000000L);
737
case 110:
738
if ((active0 & 0x8000L) != 0L)
739
return jjStartNfaWithStates_0(6, 15, 28);
740
break;
741
case 111:
742
return jjMoveStringLiteralDfa7_0(active0, 0x80000000000000L);
743
case 115:
744
if ((active0 & 0x10000000L) != 0L)
745
return jjStartNfaWithStates_0(6, 28, 28);
746
break;
747
case 116:
748
if ((active0 & 0x1000000L) != 0L)
749
return jjStartNfaWithStates_0(6, 24, 28);
750
return jjMoveStringLiteralDfa7_0(active0, 0x800000000000L);
751
case 117:
752
return jjMoveStringLiteralDfa7_0(active0, 0x800000L);
753
case 121:
754
if ((active0 & 0x80000000L) != 0L)
755
return jjStartNfaWithStates_0(6, 31, 28);
756
break;
757
default:
758
break;
759
}
760
return jjStartNfa_0(5, active0, 0L);
761
}
762
763
private final int jjMoveStringLiteralDfa7_0(long old0, long active0)
764
{
765
if (((active0 &= old0)) == 0L)
766
return jjStartNfa_0(5, old0, 0L);
767
try
768
{
769
curChar = input_stream.readChar();
770
}
771
catch (java.io.IOException e)
772
{
773
jjStopStringLiteralDfa_0(6, active0, 0L);
774
return 7;
775
}
776
switch (curChar)
777
{
778
case 99:
779
return jjMoveStringLiteralDfa8_0(active0, 0x10000000000L);
780
case 101:
781
if ((active0 & 0x800000L) != 0L)
782
return jjStartNfaWithStates_0(7, 23, 28);
783
else if ((active0 & 0x8000000000000000L) != 0L)
784
return jjStartNfaWithStates_0(7, 63, 28);
785
return jjMoveStringLiteralDfa8_0(active0, 0x804000000000L);
786
case 110:
787
return jjMoveStringLiteralDfa8_0(active0, 0x880001000000000L);
788
case 112:
789
if ((active0 & 0x10000000000000L) != 0L)
790
return jjStartNfaWithStates_0(7, 52, 28);
791
break;
792
case 116:
793
if ((active0 & 0x2000L) != 0L)
794
return jjStartNfaWithStates_0(7, 13, 28);
795
break;
796
default:
797
break;
798
}
799
return jjStartNfa_0(6, active0, 0L);
800
}
801
802
private final int jjMoveStringLiteralDfa8_0(long old0, long active0)
803
{
804
if (((active0 &= old0)) == 0L)
805
return jjStartNfa_0(6, old0, 0L);
806
try
807
{
808
curChar = input_stream.readChar();
809
}
810
catch (java.io.IOException e)
811
{
812
jjStopStringLiteralDfa_0(7, active0, 0L);
813
return 8;
814
}
815
switch (curChar)
816
{
817
case 100:
818
if ((active0 & 0x800000000000L) != 0L)
819
return jjStartNfaWithStates_0(8, 47, 28);
820
break;
821
case 101:
822
if ((active0 & 0x10000000000L) != 0L)
823
return jjStartNfaWithStates_0(8, 40, 28);
824
break;
825
case 105:
826
return jjMoveStringLiteralDfa9_0(active0, 0x80000000000000L);
827
case 111:
828
return jjMoveStringLiteralDfa9_0(active0, 0x4000000000L);
829
case 116:
830
if ((active0 & 0x800000000000000L) != 0L)
831
return jjStartNfaWithStates_0(8, 59, 28);
832
return jjMoveStringLiteralDfa9_0(active0, 0x1000000000L);
833
default:
834
break;
835
}
836
return jjStartNfa_0(7, active0, 0L);
837
}
838
839
private final int jjMoveStringLiteralDfa9_0(long old0, long active0)
840
{
841
if (((active0 &= old0)) == 0L)
842
return jjStartNfa_0(7, old0, 0L);
843
try
844
{
845
curChar = input_stream.readChar();
846
}
847
catch (java.io.IOException e)
848
{
849
jjStopStringLiteralDfa_0(8, active0, 0L);
850
return 9;
851
}
852
switch (curChar)
853
{
854
case 102:
855
if ((active0 & 0x4000000000L) != 0L)
856
return jjStartNfaWithStates_0(9, 38, 28);
857
break;
858
case 115:
859
if ((active0 & 0x1000000000L) != 0L)
860
return jjStartNfaWithStates_0(9, 36, 28);
861
break;
862
case 122:
863
return jjMoveStringLiteralDfa10_0(active0, 0x80000000000000L);
864
default:
865
break;
866
}
867
return jjStartNfa_0(8, active0, 0L);
868
}
869
870
private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
871
{
872
if (((active0 &= old0)) == 0L)
873
return jjStartNfa_0(8, old0, 0L);
874
try
875
{
876
curChar = input_stream.readChar();
877
}
878
catch (java.io.IOException e)
879
{
880
jjStopStringLiteralDfa_0(9, active0, 0L);
881
return 10;
882
}
883
switch (curChar)
884
{
885
case 101:
886
return jjMoveStringLiteralDfa11_0(active0, 0x80000000000000L);
887
default:
888
break;
889
}
890
return jjStartNfa_0(9, active0, 0L);
891
}
892
893
private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
894
{
895
if (((active0 &= old0)) == 0L)
896
return jjStartNfa_0(9, old0, 0L);
897
try
898
{
899
curChar = input_stream.readChar();
900
}
901
catch (java.io.IOException e)
902
{
903
jjStopStringLiteralDfa_0(10, active0, 0L);
904
return 11;
905
}
906
switch (curChar)
907
{
908
case 100:
909
if ((active0 & 0x80000000000000L) != 0L)
910
return jjStartNfaWithStates_0(11, 55, 28);
911
break;
912
default:
913
break;
914
}
915
return jjStartNfa_0(10, active0, 0L);
916
}
917
918
private final void jjCheckNAdd(int state)
919
{
920
if (jjrounds[state] != jjround)
921
{
922
jjstateSet[jjnewStateCnt++] = state;
923
jjrounds[state] = jjround;
924
}
925
}
926
927
private final void jjAddStates(int start, int end)
928
{
929
do
930
{
931
jjstateSet[jjnewStateCnt++] = jjnextStates[start];
932
} while (start++ != end);
933
}
934
935
private final void jjCheckNAddTwoStates(int state1, int state2)
936
{
937
jjCheckNAdd(state1);
938
jjCheckNAdd(state2);
939
}
940
941
private final void jjCheckNAddStates(int start, int end)
942
{
943
do
944
{
945
jjCheckNAdd(jjnextStates[start]);
946
} while (start++ != end);
947
}
948
949
private static final long[] jjbitVec0 = { 0xfffffffffffffffeL, 0xffffffffffffffffL,
950
0xffffffffffffffffL, 0xffffffffffffffffL };
951
private static final long[] jjbitVec2 = { 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL };
952
private static final long[] jjbitVec3 = { 0x1ff00000fffffffeL, 0xffffffffffffc000L,
953
0xffffffffL, 0x600000000000000L };
954
private static final long[] jjbitVec4 = { 0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL };
955
private static final long[] jjbitVec5 = { 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL,
956
0xffffffffffffffffL };
957
private static final long[] jjbitVec6 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL,
958
0x0L };
959
private static final long[] jjbitVec7 = { 0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L };
960
private static final long[] jjbitVec8 = { 0x3fffffffffffL, 0x0L, 0x0L, 0x0L };
961
962
private final int jjMoveNfa_0(int startState, int curPos)
963
{
964
int startsAt = 0;
965
jjnewStateCnt = 48;
966
int i = 1;
967
jjstateSet[0] = startState;
968
int kind = 0x7fffffff;
969
for (;;)
970
{
971
if (++jjround == 0x7fffffff)
972
ReInitRounds();
973
if (curChar < 64)
974
{
975
long l = 1L << curChar;
976
MatchLoop: do
977
{
978
switch (jjstateSet[--i])
979
{
980
case 0:
981
if ((0x3ff000000000000L & l) != 0L)
982
jjCheckNAddStates(0, 6);
983
else if (curChar == 36)
984
{
985
if (kind > 73)
986
kind = 73;
987
jjCheckNAdd(28);
988
}
989
else if (curChar == 34)
990
jjCheckNAddStates(7, 9);
991
else if (curChar == 39)
992
jjAddStates(10, 11);
993
else if (curChar == 46)
994
jjCheckNAdd(4);
995
if ((0x3fe000000000000L & l) != 0L)
996
{
997
if (kind > 65)
998
kind = 65;
999
jjCheckNAddTwoStates(1, 2);
1000
}
1001
else if (curChar == 48)
1002
{
1003
if (kind > 65)
1004
kind = 65;
1005
jjCheckNAddStates(12, 14);
1006
}
1007
break;
1008
case 1:
1009
if ((0x3ff000000000000L & l) == 0L)
1010
break;
1011
if (kind > 65)
1012
kind = 65;
1013
jjCheckNAddTwoStates(1, 2);
1014
break;
1015
case 3:
1016
if (curChar == 46)
1017
jjCheckNAdd(4);
1018
break;
1019
case 4:
1020
if ((0x3ff000000000000L & l) == 0L)
1021
break;
1022
if (kind > 69)
1023
kind = 69;
1024
jjCheckNAddStates(15, 17);
1025
break;
1026
case 6:
1027
if ((0x280000000000L & l) != 0L)
1028
jjCheckNAdd(7);
1029
break;
1030
case 7:
1031
if ((0x3ff000000000000L & l) == 0L)
1032
break;
1033
if (kind > 69)
1034
kind = 69;
1035
jjCheckNAddTwoStates(7, 8);
1036
break;
1037
case 9:
1038
if (curChar == 39)
1039
jjAddStates(10, 11);
1040
break;
1041
case 10:
1042
if ((0xfffffffffffffbffL & l) != 0L)
1043
jjCheckNAdd(11);
1044
break;
1045
case 11:
1046
if (curChar == 39 && kind > 71)
1047
kind = 71;
1048
break;
1049
case 13:
1050
if ((0x8400000000L & l) != 0L)
1051
jjCheckNAdd(11);
1052
break;
1053
case 14:
1054
if ((0xff000000000000L & l) != 0L)
1055
jjCheckNAddTwoStates(15, 11);
1056
break;
1057
case 15:
1058
if ((0xff000000000000L & l) != 0L)
1059
jjCheckNAdd(11);
1060
break;
1061
case 16:
1062
if ((0xf000000000000L & l) != 0L)
1063
jjstateSet[jjnewStateCnt++] = 17;
1064
break;
1065
case 17:
1066
if ((0xff000000000000L & l) != 0L)
1067
jjCheckNAdd(15);
1068
break;
1069
case 18:
1070
if (curChar == 34)
1071
jjCheckNAddStates(7, 9);
1072
break;
1073
case 19:
1074
if ((0xfffffffbffffdbffL & l) != 0L)
1075
jjCheckNAddStates(7, 9);
1076
break;
1077
case 21:
1078
if ((0x8400000000L & l) != 0L)
1079
jjCheckNAddStates(7, 9);
1080
break;
1081
case 22:
1082
if (curChar == 34 && kind > 72)
1083
kind = 72;
1084
break;
1085
case 23:
1086
if ((0xff000000000000L & l) != 0L)
1087
jjCheckNAddStates(18, 21);
1088
break;
1089
case 24:
1090
if ((0xff000000000000L & l) != 0L)
1091
jjCheckNAddStates(7, 9);
1092
break;
1093
case 25:
1094
if ((0xf000000000000L & l) != 0L)
1095
jjstateSet[jjnewStateCnt++] = 26;
1096
break;
1097
case 26:
1098
if ((0xff000000000000L & l) != 0L)
1099
jjCheckNAdd(24);
1100
break;
1101
case 27:
1102
if (curChar != 36)
1103
break;
1104
if (kind > 73)
1105
kind = 73;
1106
jjCheckNAdd(28);
1107
break;
1108
case 28:
1109
if ((0x3ff001000000000L & l) == 0L)
1110
break;
1111
if (kind > 73)
1112
kind = 73;
1113
jjCheckNAdd(28);
1114
break;
1115
case 29:
1116
if ((0x3ff000000000000L & l) != 0L)
1117
jjCheckNAddStates(0, 6);
1118
break;
1119
case 30:
1120
if ((0x3ff000000000000L & l) != 0L)
1121
jjCheckNAddTwoStates(30, 31);
1122
break;
1123
case 31:
1124
if (curChar != 46)
1125
break;
1126
if (kind > 69)
1127
kind = 69;
1128
jjCheckNAddStates(22, 24);
1129
break;
1130
case 32:
1131
if ((0x3ff000000000000L & l) == 0L)
1132
break;
1133
if (kind > 69)
1134
kind = 69;
1135
jjCheckNAddStates(22, 24);
1136
break;
1137
case 34:
1138
if ((0x280000000000L & l) != 0L)
1139
jjCheckNAdd(35);
1140
break;
1141
case 35:
1142
if ((0x3ff000000000000L & l) == 0L)
1143
break;
1144
if (kind > 69)
1145
kind = 69;
1146
jjCheckNAddTwoStates(35, 8);
1147
break;
1148
case 36:
1149
if ((0x3ff000000000000L & l) != 0L)
1150
jjCheckNAddTwoStates(36, 37);
1151
break;
1152
case 38:
1153
if ((0x280000000000L & l) != 0L)
1154
jjCheckNAdd(39);
1155
break;
1156
case 39:
1157
if ((0x3ff000000000000L & l) == 0L)
1158
break;
1159
if (kind > 69)
1160
kind = 69;
1161
jjCheckNAddTwoStates(39, 8);
1162
break;
1163
case 40:
1164
if ((0x3ff000000000000L & l) != 0L)
1165
jjCheckNAddStates(25, 27);
1166
break;
1167
case 42:
1168
if ((0x280000000000L & l) != 0L)
1169
jjCheckNAdd(43);
1170
break;
1171
case 43:
1172
if ((0x3ff000000000000L & l) != 0L)
1173
jjCheckNAddTwoStates(43, 8);
1174
break;
1175
case 44:
1176
if (curChar != 48)
1177
break;
1178
if (kind > 65)
1179
kind = 65;
1180
jjCheckNAddStates(12, 14);
1181
break;
1182
case 46:
1183
if ((0x3ff000000000000L & l) == 0L)
1184
break;
1185
if (kind > 65)
1186
kind = 65;
1187
jjCheckNAddTwoStates(46, 2);
1188
break;
1189
case 47:
1190
if ((0xff000000000000L & l) == 0L)
1191
break;
1192
if (kind > 65)
1193
kind = 65;
1194
jjCheckNAddTwoStates(47, 2);
1195
break;
1196
default:
1197
break;
1198
}
1199
} while (i != startsAt);
1200
}
1201
else if (curChar < 128)
1202
{
1203
long l = 1L << (curChar & 077);
1204
MatchLoop: do
1205
{
1206
switch (jjstateSet[--i])
1207
{
1208
case 0:
1209
case 28:
1210
if ((0x7fffffe87fffffeL & l) == 0L)
1211
break;
1212
if (kind > 73)
1213
kind = 73;
1214
jjCheckNAdd(28);
1215
break;
1216
case 2:
1217
if ((0x100000001000L & l) != 0L && kind > 65)
1218
kind = 65;
1219
break;
1220
case 5:
1221
if ((0x2000000020L & l) != 0L)
1222
jjAddStates(28, 29);
1223
break;
1224
case 8:
1225
if ((0x5000000050L & l) != 0L && kind > 69)
1226
kind = 69;
1227
break;
1228
case 10:
1229
if ((0xffffffffefffffffL & l) != 0L)
1230
jjCheckNAdd(11);
1231
break;
1232
case 12:
1233
if (curChar == 92)
1234
jjAddStates(30, 32);
1235
break;
1236
case 13:
1237
if ((0x14404410000000L & l) != 0L)
1238
jjCheckNAdd(11);
1239
break;
1240
case 19:
1241
if ((0xffffffffefffffffL & l) != 0L)
1242
jjCheckNAddStates(7, 9);
1243
break;
1244
case 20:
1245
if (curChar == 92)
1246
jjAddStates(33, 35);
1247
break;
1248
case 21:
1249
if ((0x14404410000000L & l) != 0L)
1250
jjCheckNAddStates(7, 9);
1251
break;
1252
case 33:
1253
if ((0x2000000020L & l) != 0L)
1254
jjAddStates(36, 37);
1255
break;
1256
case 37:
1257
if ((0x2000000020L & l) != 0L)
1258
jjAddStates(38, 39);
1259
break;
1260
case 41:
1261
if ((0x2000000020L & l) != 0L)
1262
jjAddStates(40, 41);
1263
break;
1264
case 45:
1265
if ((0x100000001000000L & l) != 0L)
1266
jjCheckNAdd(46);
1267
break;
1268
case 46:
1269
if ((0x7e0000007eL & l) == 0L)
1270
break;
1271
if (kind > 65)
1272
kind = 65;
1273
jjCheckNAddTwoStates(46, 2);
1274
break;
1275
default:
1276
break;
1277
}
1278
} while (i != startsAt);
1279
}
1280
else
1281
{
1282
int hiByte = curChar >> 8;
1283
int i1 = hiByte >> 6;
1284
long l1 = 1L << (hiByte & 077);
1285
int i2 = (curChar & 0xff) >> 6;
1286
long l2 = 1L << (curChar & 077);
1287
MatchLoop: do
1288
{
1289
switch (jjstateSet[--i])
1290
{
1291
case 0:
1292
case 28:
1293
if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1294
break;
1295
if (kind > 73)
1296
kind = 73;
1297
jjCheckNAdd(28);
1298
break;
1299
case 10:
1300
if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1301
jjstateSet[jjnewStateCnt++] = 11;
1302
break;
1303
case 19:
1304
if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1305
jjAddStates(7, 9);
1306
break;
1307
default:
1308
break;
1309
}
1310
} while (i != startsAt);
1311
}
1312
if (kind != 0x7fffffff)
1313
{
1314
jjmatchedKind = kind;
1315
jjmatchedPos = curPos;
1316
kind = 0x7fffffff;
1317
}
1318
++curPos;
1319
if ((i = jjnewStateCnt) == (startsAt = 48 - (jjnewStateCnt = startsAt)))
1320
return curPos;
1321
try
1322
{
1323
curChar = input_stream.readChar();
1324
}
1325
catch (java.io.IOException e)
1326
{
1327
return curPos;
1328
}
1329
}
1330
}
1331
1332
private final int jjStopStringLiteralDfa_2(int pos)
1333
{
1334
switch (pos)
1335
{
1336
default:
1337
return -1;
1338
}
1339
}
1340
1341
private final int jjStartNfa_2(int pos)
1342
{
1343
return jjMoveNfa_2(jjStopStringLiteralDfa_2(pos), pos + 1);
1344
}
1345
1346
private final int jjMoveStringLiteralDfa0_2()
1347
{
1348
switch (curChar)
1349
{
1350
case 42:
1351
return jjMoveStringLiteralDfa1_2(0x800L);
1352
default:
1353
return jjMoveNfa_2(0, 0);
1354
}
1355
}
1356
1357
private final int jjMoveStringLiteralDfa1_2(long active0)
1358
{
1359
try
1360
{
1361
curChar = input_stream.readChar();
1362
}
1363
catch (java.io.IOException e)
1364
{
1365
jjStopStringLiteralDfa_2(0);
1366
return 1;
1367
}
1368
switch (curChar)
1369
{
1370
case 47:
1371
if ((active0 & 0x800L) != 0L)
1372
return jjStopAtPos(1, 11);
1373
break;
1374
default:
1375
break;
1376
}
1377
return jjStartNfa_2(0);
1378
}
1379
1380
private final int jjMoveNfa_2(int startState, int curPos)
1381
{
1382
int startsAt = 0;
1383
jjnewStateCnt = 3;
1384
int i = 1;
1385
jjstateSet[0] = startState;
1386
int kind = 0x7fffffff;
1387
for (;;)
1388
{
1389
if (++jjround == 0x7fffffff)
1390
ReInitRounds();
1391
if (curChar < 64)
1392
{
1393
long l = 1L << curChar;
1394
MatchLoop: do
1395
{
1396
switch (jjstateSet[--i])
1397
{
1398
case 0:
1399
if ((0x2400L & l) != 0L)
1400
{
1401
if (kind > 10)
1402
kind = 10;
1403
}
1404
if (curChar == 13)
1405
jjstateSet[jjnewStateCnt++] = 1;
1406
break;
1407
case 1:
1408
if (curChar == 10 && kind > 10)
1409
kind = 10;
1410
break;
1411
case 2:
1412
if (curChar == 13)
1413
jjstateSet[jjnewStateCnt++] = 1;
1414
break;
1415
default:
1416
break;
1417
}
1418
} while (i != startsAt);
1419
}
1420
else
1421
{
1422
MatchLoop: do
1423
{
1424
switch (jjstateSet[--i])
1425
{
1426
default:
1427
break;
1428
}
1429
} while (i != startsAt);
1430
}
1431
if (kind != 0x7fffffff)
1432
{
1433
jjmatchedKind = kind;
1434
jjmatchedPos = curPos;
1435
kind = 0x7fffffff;
1436
}
1437
++curPos;
1438
if ((i = jjnewStateCnt) == (startsAt = 3 - (jjnewStateCnt = startsAt)))
1439
return curPos;
1440
try
1441
{
1442
curChar = input_stream.readChar();
1443
}
1444
catch (java.io.IOException e)
1445
{
1446
return curPos;
1447
}
1448
}
1449
}
1450
1451
private final int jjMoveStringLiteralDfa0_1()
1452
{
1453
return jjMoveNfa_1(4, 0);
1454
}
1455
1456
private final int jjMoveNfa_1(int startState, int curPos)
1457
{
1458
int startsAt = 0;
1459
jjnewStateCnt = 4;
1460
int i = 1;
1461
jjstateSet[0] = startState;
1462
int kind = 0x7fffffff;
1463
for (;;)
1464
{
1465
if (++jjround == 0x7fffffff)
1466
ReInitRounds();
1467
if (curChar < 64)
1468
{
1469
long l = 1L << curChar;
1470
MatchLoop: do
1471
{
1472
switch (jjstateSet[--i])
1473
{
1474
case 4:
1475
if ((0xffffffffffffdbffL & l) != 0L)
1476
{
1477
if (kind > 9)
1478
kind = 9;
1479
jjCheckNAddStates(42, 44);
1480
}
1481
else if ((0x2400L & l) != 0L)
1482
{
1483
if (kind > 9)
1484
kind = 9;
1485
}
1486
if (curChar == 13)
1487
jjstateSet[jjnewStateCnt++] = 2;
1488
break;
1489
case 0:
1490
if ((0xffffffffffffdbffL & l) == 0L)
1491
break;
1492
kind = 9;
1493
jjCheckNAddStates(42, 44);
1494
break;
1495
case 1:
1496
if ((0x2400L & l) != 0L && kind > 9)
1497
kind = 9;
1498
break;
1499
case 2:
1500
if (curChar == 10 && kind > 9)
1501
kind = 9;
1502
break;
1503
case 3:
1504
if (curChar == 13)
1505
jjstateSet[jjnewStateCnt++] = 2;
1506
break;
1507
default:
1508
break;
1509
}
1510
} while (i != startsAt);
1511
}
1512
else if (curChar < 128)
1513
{
1514
MatchLoop: do
1515
{
1516
switch (jjstateSet[--i])
1517
{
1518
case 4:
1519
case 0:
1520
kind = 9;
1521
jjCheckNAddStates(42, 44);
1522
break;
1523
default:
1524
break;
1525
}
1526
} while (i != startsAt);
1527
}
1528
else
1529
{
1530
int hiByte = curChar >> 8;
1531
int i1 = hiByte >> 6;
1532
long l1 = 1L << (hiByte & 077);
1533
int i2 = (curChar & 0xff) >> 6;
1534
long l2 = 1L << (curChar & 077);
1535
MatchLoop: do
1536
{
1537
switch (jjstateSet[--i])
1538
{
1539
case 4:
1540
case 0:
1541
if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1542
break;
1543
if (kind > 9)
1544
kind = 9;
1545
jjCheckNAddStates(42, 44);
1546
break;
1547
default:
1548
break;
1549
}
1550
} while (i != startsAt);
1551
}
1552
if (kind != 0x7fffffff)
1553
{
1554
jjmatchedKind = kind;
1555
jjmatchedPos = curPos;
1556
kind = 0x7fffffff;
1557
}
1558
++curPos;
1559
if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
1560
return curPos;
1561
try
1562
{
1563
curChar = input_stream.readChar();
1564
}
1565
catch (java.io.IOException e)
1566
{
1567
return curPos;
1568
}
1569
}
1570
}
1571
1572
private static final int[] jjnextStates = { 30, 31, 36, 37, 40, 41, 8, 19, 20, 22, 10, 12, 45,
1573
47, 2, 4, 5, 8, 19, 20, 24, 22, 32, 33, 8, 40, 41, 8, 6, 7, 13, 14, 16, 21, 23, 25, 34,
1574
35, 38, 39, 42, 43, 0, 1, 3, };
1575
1576
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1577
{
1578
switch (hiByte)
1579
{
1580
case 0:
1581
return ((jjbitVec2[i2] & l2) != 0L);
1582
default:
1583
if ((jjbitVec0[i1] & l1) != 0L)
1584
return true;
1585
return false;
1586
}
1587
}
1588
1589
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1590
{
1591
switch (hiByte)
1592
{
1593
case 0:
1594
return ((jjbitVec4[i2] & l2) != 0L);
1595
case 48:
1596
return ((jjbitVec5[i2] & l2) != 0L);
1597
case 49:
1598
return ((jjbitVec6[i2] & l2) != 0L);
1599
case 51:
1600
return ((jjbitVec7[i2] & l2) != 0L);
1601
case 61:
1602
return ((jjbitVec8[i2] & l2) != 0L);
1603
default:
1604
if ((jjbitVec3[i1] & l1) != 0L)
1605
return true;
1606
return false;
1607
}
1608
}
1609
1610
private static final String[] jjstrLiteralImages = { "", null, null, null, null, null, null,
1611
null, null, null, null, null, null, "\141\142\163\164\162\141\143\164",
1612
"\141\163\163\145\162\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153",
1613
"\142\171\164\145", "\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162",
1614
"\143\154\141\163\163", "\143\157\156\163\164", "\143\157\156\164\151\156\165\145",
1615
"\144\145\146\141\165\154\164", "\144\157", "\144\157\165\142\154\145",
1616
"\145\154\163\145", "\145\170\164\145\156\144\163", "\146\141\154\163\145",
1617
"\146\151\156\141\154", "\146\151\156\141\154\154\171", "\146\154\157\141\164",
1618
"\146\157\162", "\147\157\164\157", "\151\146",
1619
"\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164",
1620
"\151\156\163\164\141\156\143\145\157\146", "\151\156\164",
1621
"\151\156\164\145\162\146\141\143\145", "\154\157\156\147", "\156\141\164\151\166\145",
1622
"\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145",
1623
"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144",
1624
"\160\165\142\154\151\143", "\162\145\164\165\162\156", "\163\150\157\162\164",
1625
"\163\164\141\164\151\143", "\163\164\162\151\143\164\146\160", "\163\165\160\145\162",
1626
"\163\167\151\164\143\150", "\163\171\156\143\150\162\157\156\151\172\145\144",
1627
"\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163",
1628
"\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171",
1629
"\166\157\151\144", "\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null,
1630
null, null, null, null, null, null, null, null, null, null, "\50", "\51", "\173",
1631
"\175", "\133", "\135", "\73", "\54", "\56", "\75", "\76", "\74", "\41", "\176", "\77",
1632
"\72", "\75\75", "\74\75", "\76\75", "\41\75", "\174\174", "\46\46", "\53\53",
1633
"\55\55", "\53", "\55", "\52", "\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76",
1634
"\76\76\76", "\53\75", "\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75",
1635
"\45\75", "\74\74\75", "\76\76\75", "\76\76\76\75", };
1636
private static final int[] jjnewLexState = { -1, -1, -1, -1, -1, -1, -1, 2, 1, 0, -1, 0, -1,
1637
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1638
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1639
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1640
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1641
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, };
1642
private static final long[] jjtoToken = { 0xffffffffffffe001L, 0x3fffffffffff3a3L, };
1643
private static final long[] jjtoSkip = { 0xf7eL, 0x0L, };
1644
private static final long[] jjtoSpecial = { 0xf00L, 0x0L, };
1645
private ASCII_UCodeESC_CharStream input_stream;
1646
private final int[] jjrounds = new int[48];
1647
private final int[] jjstateSet = new int[96];
1648
private StringBuffer image;
1649
private int jjimageLen;
1650
private char curChar;
1651
1652
public JavaParserTokenManager(ASCII_UCodeESC_CharStream stream)
1653
{
1654
if (ASCII_UCodeESC_CharStream.staticFlag)
1655
throw new Error(
1656
"ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1657
input_stream = stream;
1658
}
1659
1660
private final void ReInitRounds()
1661
{
1662
int i;
1663
jjround = 0x80000001;
1664
for (i = 48; i-- > 0;)
1665
jjrounds[i] = 0x80000000;
1666
}
1667
1668
private final Token jjFillToken()
1669
{
1670
Token t = Token.newToken(jjmatchedKind);
1671
t.kind = jjmatchedKind;
1672
if (jjmatchedPos < 0)
1673
{
1674
t.image = "";
1675
t.beginLine = t.endLine = input_stream.getBeginLine();
1676
t.beginColumn = t.endColumn = input_stream.getBeginColumn();
1677
}
1678
else
1679
{
1680
String im = jjstrLiteralImages[jjmatchedKind];
1681
t.image = (im == null) ? input_stream.getImage() : im;
1682
t.beginLine = input_stream.getBeginLine();
1683
t.beginColumn = input_stream.getBeginColumn();
1684
t.endLine = input_stream.getEndLine();
1685
t.endColumn = input_stream.getEndColumn();
1686
}
1687
return t;
1688
}
1689
1690
private int curLexState = 0;
1691
private int jjnewStateCnt;
1692
private int jjround;
1693
private int jjmatchedPos;
1694
private int jjmatchedKind;
1695
1696
public final Token getNextToken()
1697
{
1698
Token specialToken = null;
1699
Token matchedToken;
1700
int curPos = 0;
1701
1702
EOFLoop: for (;;)
1703
{
1704
try
1705
{
1706
curChar = input_stream.beginToken();
1707
}
1708
catch (java.io.IOException e)
1709
{
1710
jjmatchedKind = 0;
1711
matchedToken = jjFillToken();
1712
matchedToken.specialToken = specialToken;
1713
return matchedToken;
1714
}
1715
image = null;
1716
jjimageLen = 0;
1717
1718
for (;;)
1719
{
1720
switch (curLexState)
1721
{
1722
case 0:
1723
try
1724
{
1725
input_stream.backup(0);
1726
while (curChar <= 32 && (0x104003600L & (1L << curChar)) != 0L)
1727
curChar = input_stream.beginToken();
1728
}
1729
catch (java.io.IOException e1)
1730
{
1731
continue EOFLoop;
1732
}
1733
jjmatchedKind = 0x7fffffff;
1734
jjmatchedPos = 0;
1735
curPos = jjMoveStringLiteralDfa0_0();
1736
break;
1737
case 1:
1738
jjmatchedKind = 9;
1739
jjmatchedPos = -1;
1740
curPos = 0;
1741
curPos = jjMoveStringLiteralDfa0_1();
1742
if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 12))
1743
{
1744
jjmatchedKind = 12;
1745
jjmatchedPos = 0;
1746
}
1747
break;
1748
case 2:
1749
jjmatchedKind = 0x7fffffff;
1750
jjmatchedPos = 0;
1751
curPos = jjMoveStringLiteralDfa0_2();
1752
if (jjmatchedPos == 0 && jjmatchedKind > 12)
1753
{
1754
jjmatchedKind = 12;
1755
}
1756
break;
1757
}
1758
if (jjmatchedKind != 0x7fffffff)
1759
{
1760
if (jjmatchedPos + 1 < curPos)
1761
input_stream.backup(curPos - jjmatchedPos - 1);
1762
if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1763
{
1764
matchedToken = jjFillToken();
1765
matchedToken.specialToken = specialToken;
1766
if (jjnewLexState[jjmatchedKind] != -1)
1767
curLexState = jjnewLexState[jjmatchedKind];
1768
return matchedToken;
1769
}
1770
else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1771
{
1772
if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1773
{
1774
matchedToken = jjFillToken();
1775
if (specialToken == null)
1776
specialToken = matchedToken;
1777
else
1778
{
1779
matchedToken.specialToken = specialToken;
1780
specialToken = (specialToken.next = matchedToken);
1781
}
1782
SkipLexicalActions();
1783
}
1784
else
1785
SkipLexicalActions();
1786
if (jjnewLexState[jjmatchedKind] != -1)
1787
curLexState = jjnewLexState[jjmatchedKind];
1788
continue EOFLoop;
1789
}
1790
MoreLexicalActions();
1791
if (jjnewLexState[jjmatchedKind] != -1)
1792
curLexState = jjnewLexState[jjmatchedKind];
1793
curPos = 0;
1794
jjmatchedKind = 0x7fffffff;
1795
try
1796
{
1797
curChar = input_stream.readChar();
1798
continue;
1799
}
1800
catch (java.io.IOException e1)
1801
{
1802
}
1803
}
1804
int error_line = input_stream.getEndLine();
1805
int error_column = input_stream.getEndColumn();
1806
String error_after = null;
1807
boolean EOFSeen = false;
1808
try
1809
{
1810
input_stream.readChar();
1811
input_stream.backup(1);
1812
}
1813
catch (java.io.IOException e1)
1814
{
1815
EOFSeen = true;
1816
error_after = curPos <= 1 ? "" : input_stream.getImage();
1817
if (curChar == '\n' || curChar == '\r')
1818
{
1819
error_line++;
1820
error_column = 0;
1821
}
1822
else
1823
error_column++;
1824
}
1825
if (!EOFSeen)
1826
{
1827
input_stream.backup(1);
1828
error_after = curPos <= 1 ? "" : input_stream.getImage();
1829
}
1830
throw new TokenMgrError(EOFSeen, error_line, error_column, error_after, curChar,
1831
TokenMgrError.LEXICAL_ERROR);
1832
}
1833
}
1834
}
1835
1836
private final void SkipLexicalActions()
1837
{
1838
switch (jjmatchedKind)
1839
{
1840
case 8:
1841
if (image == null)
1842
image = new StringBuffer(new String(input_stream.getSuffix(jjimageLen
1843
+ jjmatchedPos + 1)));
1844
else
1845
image.append(input_stream.getSuffix(jjimageLen + jjmatchedPos + 1));
1846
break;
1847
case 10:
1848
if (image == null)
1849
image = new StringBuffer(new String(input_stream.getSuffix(jjimageLen
1850
+ jjmatchedPos + 1)));
1851
else
1852
image.append(input_stream.getSuffix(jjimageLen + jjmatchedPos + 1));
1853
break;
1854
case 11:
1855
if (image == null)
1856
image = new StringBuffer(new String(input_stream.getSuffix(jjimageLen
1857
+ jjmatchedPos + 1)));
1858
else
1859
image.append(input_stream.getSuffix(jjimageLen + jjmatchedPos + 1));
1860
break;
1861
default:
1862
break;
1863
}
1864
}
1865
1866
private final void MoreLexicalActions()
1867
{
1868
jjimageLen += jjmatchedPos + 1;
1869
switch (jjmatchedKind)
1870
{
1871
case 7:
1872
if (image == null)
1873
image = new StringBuffer(new String(input_stream.getSuffix(jjimageLen)));
1874
else
1875
image.append(input_stream.getSuffix(jjimageLen));
1876
jjimageLen = 0;
1877
break;
1878
default:
1879
break;
1880
}
1881
}
1882
1883
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1