← Back to branch summary

~ubuntu-branches/ubuntu/quantal/netbeans/quantal

« back to all changes in this revision

Viewing changes to debuggerjpda/src/org/netbeans/modules/debugger/jpda/expr/JavaParserTokenManager.java

  • Committer: Bazaar Package Importer
  • Author(s): Marek Slama
  • Date: 2008-01-29 14:11:22 UTC
  • Revision ID: james.westby@ubuntu.com-20080129141122-fnzjbo11ntghxfu7
Tags: upstream-6.0.1
Import upstream version 6.0.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
debuggerjpda/src/org/netbeans/modules/debugger/jpda/expr/JavaParserTokenManager.java
 
1
/*
 
2
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 
3
 *
 
4
 * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
 
5
 *
 
6
 * The contents of this file are subject to the terms of either the GNU
 
7
 * General Public License Version 2 only ("GPL") or the Common
 
8
 * Development and Distribution License("CDDL") (collectively, the
 
9
 * "License"). You may not use this file except in compliance with the
 
10
 * License. You can obtain a copy of the License at
 
11
 * http://www.netbeans.org/cddl-gplv2.html
 
12
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 
13
 * specific language governing permissions and limitations under the
 
14
 * License.  When distributing the software, include this License Header
 
15
 * Notice in each file and include the License file at
 
16
 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
 
17
 * particular file as subject to the "Classpath" exception as provided
 
18
 * by Sun in the GPL Version 2 section of the License file that
 
19
 * accompanied this code. If applicable, add the following below the
 
20
 * License Header, with the fields enclosed by brackets [] replaced by
 
21
 * your own identifying information:
 
22
 * "Portions Copyrighted [year] [name of copyright owner]"
 
23
 *
 
24
 * Contributor(s):
 
25
 *
 
26
 * The Original Software is NetBeans. The Initial Developer of the Original
 
27
 * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
 
28
 * Microsystems, Inc. All Rights Reserved.
 
29
 *
 
30
 * If you wish your version of this file to be governed by only the CDDL
 
31
 * or only the GPL Version 2, indicate your decision by adding
 
32
 * "[Contributor] elects to include this software in this distribution
 
33
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 
34
 * single choice of license, a recipient has the option to distribute
 
35
 * your version of this file under either the CDDL, the GPL Version 2 or
 
36
 * to extend the choice of license to its licensees as provided above.
 
37
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 
38
 * Version 2 license, then the option applies only if the new code is
 
39
 * made subject to such option by the copyright holder.
 
40
 */
 
41
 
 
42
/* Generated By:JJTree&JavaCC: Do not edit this line. JavaParserTokenManager.java */
 
43
package org.netbeans.modules.debugger.jpda.expr;
 
44
 
 
45
class JavaParserTokenManager implements JavaParserConstants
 
46
{
 
47
  public  java.io.PrintStream debugStream = System.out;
 
48
  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
 
49
private final int jjMoveStringLiteralDfa0_1()
 
50
{
 
51
   return 1;
 
52
}
 
53
private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1, long active2)
 
54
{
 
55
   switch (pos)
 
56
   {
 
57
      case 0:
 
58
         if ((active0 & 0x1a00L) != 0L || (active1 & 0x200400000000000L) != 0L)
 
59
            return 2;
 
60
         if ((active1 & 0xc000000L) != 0L)
 
61
            return 8;
 
62
         if ((active0 & 0xfffffffffffc0000L) != 0L || (active1 & 0x7fL) != 0L)
 
63
         {
 
64
            jjmatchedKind = 79;
 
65
            return 44;
 
66
         }
 
67
         return -1;
 
68
      case 1:
 
69
         if ((active0 & 0x1800L) != 0L)
 
70
            return 0;
 
71
         if ((active0 & 0xfffffdff3ffc0000L) != 0L || (active1 & 0x7fL) != 0L)
 
72
         {
 
73
            if (jjmatchedPos != 1)
 
74
            {
 
75
               jjmatchedKind = 79;
 
76
               jjmatchedPos = 1;
 
77
            }
 
78
            return 44;
 
79
         }
 
80
         if ((active0 & 0x200c0000000L) != 0L)
 
81
            return 44;
 
82
         return -1;
 
83
      case 2:
 
84
         if ((active0 & 0xfffd9d7fbffc0000L) != 0L || (active1 & 0x77L) != 0L)
 
85
         {
 
86
            if (jjmatchedPos != 2)
 
87
            {
 
88
               jjmatchedKind = 79;
 
89
               jjmatchedPos = 2;
 
90
            }
 
91
            return 44;
 
92
         }
 
93
         if ((active0 & 0x2608000000000L) != 0L || (active1 & 0x8L) != 0L)
 
94
            return 44;
 
95
         return -1;
 
96
      case 3:
 
97
         if ((active0 & 0xbff95c7cbd3c0000L) != 0L || (active1 & 0x63L) != 0L)
 
98
         {
 
99
            jjmatchedKind = 79;
 
100
            jjmatchedPos = 3;
 
101
            return 44;
 
102
         }
 
103
         if ((active0 & 0x4004810302c00000L) != 0L || (active1 & 0x14L) != 0L)
 
104
            return 44;
 
105
         return -1;
 
106
      case 4:
 
107
         if ((active0 & 0x36f95c04b01c0000L) != 0L || (active1 & 0x22L) != 0L)
 
108
         {
 
109
            if (jjmatchedPos != 4)
 
110
            {
 
111
               jjmatchedKind = 79;
 
112
               jjmatchedPos = 4;
 
113
            }
 
114
            return 44;
 
115
         }
 
116
         if ((active0 & 0x890000780d200000L) != 0L || (active1 & 0x41L) != 0L)
 
117
            return 44;
 
118
         return -1;
 
119
      case 5:
 
120
         if ((active0 & 0x2438542430140000L) != 0L || (active1 & 0x22L) != 0L)
 
121
         {
 
122
            jjmatchedKind = 79;
 
123
            jjmatchedPos = 5;
 
124
            return 44;
 
125
         }
 
126
         if ((active0 & 0x12c1080080080000L) != 0L || (active1 & 0x1L) != 0L)
 
127
            return 44;
 
128
         return -1;
 
129
      case 6:
 
130
         if ((active0 & 0x2420540010040000L) != 0L || (active1 & 0x22L) != 0L)
 
131
         {
 
132
            jjmatchedKind = 79;
 
133
            jjmatchedPos = 6;
 
134
            return 44;
 
135
         }
 
136
         if ((active0 & 0x18002420100000L) != 0L)
 
137
            return 44;
 
138
         return -1;
 
139
      case 7:
 
140
         if ((active0 & 0x2020540000000000L) != 0L || (active1 & 0x2L) != 0L)
 
141
         {
 
142
            jjmatchedKind = 79;
 
143
            jjmatchedPos = 7;
 
144
            return 44;
 
145
         }
 
146
         if ((active0 & 0x400000010040000L) != 0L || (active1 & 0x20L) != 0L)
 
147
            return 44;
 
148
         return -1;
 
149
      case 8:
 
150
         if ((active0 & 0x2000140000000000L) != 0L)
 
151
         {
 
152
            jjmatchedKind = 79;
 
153
            jjmatchedPos = 8;
 
154
            return 44;
 
155
         }
 
156
         if ((active0 & 0x20400000000000L) != 0L || (active1 & 0x2L) != 0L)
 
157
            return 44;
 
158
         return -1;
 
159
      case 9:
 
160
         if ((active0 & 0x2000000000000000L) != 0L)
 
161
         {
 
162
            jjmatchedKind = 79;
 
163
            jjmatchedPos = 9;
 
164
            return 44;
 
165
         }
 
166
         if ((active0 & 0x140000000000L) != 0L)
 
167
            return 44;
 
168
         return -1;
 
169
      case 10:
 
170
         if ((active0 & 0x2000000000000000L) != 0L)
 
171
         {
 
172
            jjmatchedKind = 79;
 
173
            jjmatchedPos = 10;
 
174
            return 44;
 
175
         }
 
176
         return -1;
 
177
      default :
 
178
         return -1;
 
179
   }
 
180
}
 
181
private final int jjStartNfa_0(int pos, long active0, long active1, long active2)
 
182
{
 
183
   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0, active1, active2), pos + 1);
 
184
}
 
185
private final int jjStopAtPos(int pos, int kind)
 
186
{
 
187
   jjmatchedKind = kind;
 
188
   jjmatchedPos = pos;
 
189
   return pos + 1;
 
190
}
 
191
private final int jjStartNfaWithStates_0(int pos, int kind, int state)
 
192
{
 
193
   jjmatchedKind = kind;
 
194
   jjmatchedPos = pos;
 
195
   try { curChar = input_stream.readChar(); }
 
196
   catch(java.io.IOException e) { return pos + 1; }
 
197
   return jjMoveNfa_0(state, pos + 1);
 
198
}
 
199
private final int jjMoveStringLiteralDfa0_0()
 
200
{
 
201
   switch(curChar)
 
202
   {
 
203
      case 10:
 
204
         return jjStopAtPos(0, 6);
 
205
      case 13:
 
206
         jjmatchedKind = 7;
 
207
         return jjMoveStringLiteralDfa1_0(0x100L, 0x0L, 0x0L);
 
208
      case 26:
 
209
         return jjStopAtPos(0, 4);
 
210
      case 33:
 
211
         jjmatchedKind = 95;
 
212
         return jjMoveStringLiteralDfa1_0(0x0L, 0x4000000000L, 0x0L);
 
213
      case 37:
 
214
         jjmatchedKind = 114;
 
215
         return jjMoveStringLiteralDfa1_0(0x0L, 0x2000000000000000L, 0x0L);
 
216
      case 38:
 
217
         jjmatchedKind = 111;
 
218
         return jjMoveStringLiteralDfa1_0(0x0L, 0x400010000000000L, 0x0L);
 
219
      case 40:
 
220
         return jjStopAtPos(0, 82);
 
221
      case 41:
 
222
         return jjStopAtPos(0, 83);
 
223
      case 42:
 
224
         jjmatchedKind = 109;
 
225
         return jjMoveStringLiteralDfa1_0(0x0L, 0x100000000000000L, 0x0L);
 
226
      case 43:
 
227
         jjmatchedKind = 107;
 
228
         return jjMoveStringLiteralDfa1_0(0x0L, 0x40020000000000L, 0x0L);
 
229
      case 44:
 
230
         return jjStopAtPos(0, 89);
 
231
      case 45:
 
232
         jjmatchedKind = 108;
 
233
         return jjMoveStringLiteralDfa1_0(0x0L, 0x80040000000000L, 0x0L);
 
234
      case 46:
 
235
         jjmatchedKind = 90;
 
236
         return jjMoveStringLiteralDfa1_0(0x0L, 0x8000000L, 0x0L);
 
237
      case 47:
 
238
         jjmatchedKind = 110;
 
239
         return jjMoveStringLiteralDfa1_0(0x1a00L, 0x200000000000000L, 0x0L);
 
240
      case 58:
 
241
         return jjStopAtPos(0, 98);
 
242
      case 59:
 
243
         return jjStopAtPos(0, 88);
 
244
      case 60:
 
245
         jjmatchedKind = 94;
 
246
         return jjMoveStringLiteralDfa1_0(0x0L, 0x4008001000000000L, 0x0L);
 
247
      case 61:
 
248
         jjmatchedKind = 92;
 
249
         return jjMoveStringLiteralDfa1_0(0x0L, 0x800000000L, 0x0L);
 
250
      case 62:
 
251
         jjmatchedKind = 93;
 
252
         return jjMoveStringLiteralDfa1_0(0x0L, 0x8030002000000000L, 0x1L);
 
253
      case 63:
 
254
         return jjStopAtPos(0, 97);
 
255
      case 64:
 
256
         return jjStopAtPos(0, 129);
 
257
      case 91:
 
258
         return jjStopAtPos(0, 86);
 
259
      case 93:
 
260
         return jjStopAtPos(0, 87);
 
261
      case 94:
 
262
         jjmatchedKind = 113;
 
263
         return jjMoveStringLiteralDfa1_0(0x0L, 0x1000000000000000L, 0x0L);
 
264
      case 97:
 
265
         return jjMoveStringLiteralDfa1_0(0xc0000L, 0x0L, 0x0L);
 
266
      case 98:
 
267
         return jjMoveStringLiteralDfa1_0(0x700000L, 0x0L, 0x0L);
 
268
      case 99:
 
269
         return jjMoveStringLiteralDfa1_0(0x1f800000L, 0x0L, 0x0L);
 
270
      case 100:
 
271
         return jjMoveStringLiteralDfa1_0(0xe0000000L, 0x0L, 0x0L);
 
272
      case 101:
 
273
         return jjMoveStringLiteralDfa1_0(0x700000000L, 0x0L, 0x0L);
 
274
      case 102:
 
275
         return jjMoveStringLiteralDfa1_0(0xf800000000L, 0x0L, 0x0L);
 
276
      case 103:
 
277
         return jjMoveStringLiteralDfa1_0(0x10000000000L, 0x0L, 0x0L);
 
278
      case 105:
 
279
         return jjMoveStringLiteralDfa1_0(0x7e0000000000L, 0x0L, 0x0L);
 
280
      case 108:
 
281
         return jjMoveStringLiteralDfa1_0(0x800000000000L, 0x0L, 0x0L);
 
282
      case 110:
 
283
         return jjMoveStringLiteralDfa1_0(0x7000000000000L, 0x0L, 0x0L);
 
284
      case 112:
 
285
         return jjMoveStringLiteralDfa1_0(0x78000000000000L, 0x0L, 0x0L);
 
286
      case 114:
 
287
         return jjMoveStringLiteralDfa1_0(0x80000000000000L, 0x0L, 0x0L);
 
288
      case 115:
 
289
         return jjMoveStringLiteralDfa1_0(0x3f00000000000000L, 0x0L, 0x0L);
 
290
      case 116:
 
291
         return jjMoveStringLiteralDfa1_0(0xc000000000000000L, 0xfL, 0x0L);
 
292
      case 118:
 
293
         return jjMoveStringLiteralDfa1_0(0x0L, 0x30L, 0x0L);
 
294
      case 119:
 
295
         return jjMoveStringLiteralDfa1_0(0x0L, 0x40L, 0x0L);
 
296
      case 123:
 
297
         return jjStopAtPos(0, 84);
 
298
      case 124:
 
299
         jjmatchedKind = 112;
 
300
         return jjMoveStringLiteralDfa1_0(0x0L, 0x800008000000000L, 0x0L);
 
301
      case 125:
 
302
         return jjStopAtPos(0, 85);
 
303
      case 126:
 
304
         return jjStopAtPos(0, 96);
 
305
      default :
 
306
         return jjMoveNfa_0(3, 0);
 
307
   }
 
308
}
 
309
private final int jjMoveStringLiteralDfa1_0(long active0, long active1, long active2)
 
310
{
 
311
   try { curChar = input_stream.readChar(); }
 
312
   catch(java.io.IOException e) {
 
313
      jjStopStringLiteralDfa_0(0, active0, active1, active2);
 
314
      return 1;
 
315
   }
 
316
   switch(curChar)
 
317
   {
 
318
      case 10:
 
319
         if ((active0 & 0x100L) != 0L)
 
320
            return jjStopAtPos(1, 8);
 
321
         break;
 
322
      case 38:
 
323
         if ((active1 & 0x10000000000L) != 0L)
 
324
            return jjStopAtPos(1, 104);
 
325
         break;
 
326
      case 42:
 
327
         if ((active0 & 0x800L) != 0L)
 
328
         {
 
329
            jjmatchedKind = 11;
 
330
            jjmatchedPos = 1;
 
331
         }
 
332
         return jjMoveStringLiteralDfa2_0(active0, 0x1000L, active1, 0L, active2, 0L);
 
333
      case 43:
 
334
         if ((active1 & 0x20000000000L) != 0L)
 
335
            return jjStopAtPos(1, 105);
 
336
         break;
 
337
      case 45:
 
338
         if ((active1 & 0x40000000000L) != 0L)
 
339
            return jjStopAtPos(1, 106);
 
340
         break;
 
341
      case 46:
 
342
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8000000L, active2, 0L);
 
343
      case 47:
 
344
         if ((active0 & 0x200L) != 0L)
 
345
            return jjStopAtPos(1, 9);
 
346
         break;
 
347
      case 60:
 
348
         if ((active1 & 0x8000000000000L) != 0L)
 
349
         {
 
350
            jjmatchedKind = 115;
 
351
            jjmatchedPos = 1;
 
352
         }
 
353
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x4000000000000000L, active2, 0L);
 
354
      case 61:
 
355
         if ((active1 & 0x800000000L) != 0L)
 
356
            return jjStopAtPos(1, 99);
 
357
         else if ((active1 & 0x1000000000L) != 0L)
 
358
            return jjStopAtPos(1, 100);
 
359
         else if ((active1 & 0x2000000000L) != 0L)
 
360
            return jjStopAtPos(1, 101);
 
361
         else if ((active1 & 0x4000000000L) != 0L)
 
362
            return jjStopAtPos(1, 102);
 
363
         else if ((active1 & 0x40000000000000L) != 0L)
 
364
            return jjStopAtPos(1, 118);
 
365
         else if ((active1 & 0x80000000000000L) != 0L)
 
366
            return jjStopAtPos(1, 119);
 
367
         else if ((active1 & 0x100000000000000L) != 0L)
 
368
            return jjStopAtPos(1, 120);
 
369
         else if ((active1 & 0x200000000000000L) != 0L)
 
370
            return jjStopAtPos(1, 121);
 
371
         else if ((active1 & 0x400000000000000L) != 0L)
 
372
            return jjStopAtPos(1, 122);
 
373
         else if ((active1 & 0x800000000000000L) != 0L)
 
374
            return jjStopAtPos(1, 123);
 
375
         else if ((active1 & 0x1000000000000000L) != 0L)
 
376
            return jjStopAtPos(1, 124);
 
377
         else if ((active1 & 0x2000000000000000L) != 0L)
 
378
            return jjStopAtPos(1, 125);
 
379
         break;
 
380
      case 62:
 
381
         if ((active1 & 0x10000000000000L) != 0L)
 
382
         {
 
383
            jjmatchedKind = 116;
 
384
            jjmatchedPos = 1;
 
385
         }
 
386
         return jjMoveStringLiteralDfa2_0(active0, 0L, active1, 0x8020000000000000L, active2, 0x1L);
 
387
      case 97:
 
388
         return jjMoveStringLiteralDfa2_0(active0, 0x9000801800000L, active1, 0L, active2, 0L);
 
389
      case 98:
 
390
         return jjMoveStringLiteralDfa2_0(active0, 0x40000L, active1, 0L, active2, 0L);
 
391
      case 101:
 
392
         return jjMoveStringLiteralDfa2_0(active0, 0x82000020000000L, active1, 0L, active2, 0L);
 
393
      case 102:
 
394
         if ((active0 & 0x20000000000L) != 0L)
 
395
            return jjStartNfaWithStates_0(1, 41, 44);
 
396
         break;
 
397
      case 104:
 
398
         return jjMoveStringLiteralDfa2_0(active0, 0xc100000002000000L, active1, 0x41L, active2, 0L);
 
399
      case 105:
 
400
         return jjMoveStringLiteralDfa2_0(active0, 0x3000000000L, active1, 0L, active2, 0L);
 
401
      case 108:
 
402
         return jjMoveStringLiteralDfa2_0(active0, 0x4104000000L, active1, 0L, active2, 0L);
 
403
      case 109:
 
404
         return jjMoveStringLiteralDfa2_0(active0, 0xc0000000000L, active1, 0L, active2, 0L);
 
405
      case 110:
 
406
         return jjMoveStringLiteralDfa2_0(active0, 0x700200000000L, active1, 0L, active2, 0L);
 
407
      case 111:
 
408
         if ((active0 & 0x40000000L) != 0L)
 
409
         {
 
410
            jjmatchedKind = 30;
 
411
            jjmatchedPos = 1;
 
412
         }
 
413
         return jjMoveStringLiteralDfa2_0(active0, 0x818098100000L, active1, 0x30L, active2, 0L);
 
414
      case 114:
 
415
         return jjMoveStringLiteralDfa2_0(active0, 0x30000000200000L, active1, 0xeL, active2, 0L);
 
416
      case 115:
 
417
         return jjMoveStringLiteralDfa2_0(active0, 0x80000L, active1, 0L, active2, 0L);
 
418
      case 116:
 
419
         return jjMoveStringLiteralDfa2_0(active0, 0x600000000000000L, active1, 0L, active2, 0L);
 
420
      case 117:
 
421
         return jjMoveStringLiteralDfa2_0(active0, 0x844000000000000L, active1, 0L, active2, 0L);
 
422
      case 119:
 
423
         return jjMoveStringLiteralDfa2_0(active0, 0x1000000000000000L, active1, 0L, active2, 0L);
 
424
      case 120:
 
425
         return jjMoveStringLiteralDfa2_0(active0, 0x400000000L, active1, 0L, active2, 0L);
 
426
      case 121:
 
427
         return jjMoveStringLiteralDfa2_0(active0, 0x2000000000400000L, active1, 0L, active2, 0L);
 
428
      case 124:
 
429
         if ((active1 & 0x8000000000L) != 0L)
 
430
            return jjStopAtPos(1, 103);
 
431
         break;
 
432
      default :
 
433
         break;
 
434
   }
 
435
   return jjStartNfa_0(0, active0, active1, active2);
 
436
}
 
437
private final int jjMoveStringLiteralDfa2_0(long old0, long active0, long old1, long active1, long old2, long active2)
 
438
{
 
439
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
 
440
      return jjStartNfa_0(0, old0, old1, old2); 
 
441
   try { curChar = input_stream.readChar(); }
 
442
   catch(java.io.IOException e) {
 
443
      jjStopStringLiteralDfa_0(1, active0, active1, active2);
 
444
      return 2;
 
445
   }
 
446
   switch(curChar)
 
447
   {
 
448
      case 46:
 
449
         if ((active1 & 0x8000000L) != 0L)
 
450
            return jjStopAtPos(2, 91);
 
451
         break;
 
452
      case 60:
 
453
         if ((active0 & 0x1000L) != 0L)
 
454
            return jjStopAtPos(2, 12);
 
455
         break;
 
456
      case 61:
 
457
         if ((active1 & 0x4000000000000000L) != 0L)
 
458
            return jjStopAtPos(2, 126);
 
459
         else if ((active1 & 0x8000000000000000L) != 0L)
 
460
            return jjStopAtPos(2, 127);
 
461
         break;
 
462
      case 62:
 
463
         if ((active1 & 0x20000000000000L) != 0L)
 
464
         {
 
465
            jjmatchedKind = 117;
 
466
            jjmatchedPos = 2;
 
467
         }
 
468
         return jjMoveStringLiteralDfa3_0(active0, 0L, active1, 0L, active2, 0x1L);
 
469
      case 97:
 
470
         return jjMoveStringLiteralDfa3_0(active0, 0x200000006000000L, active1, 0x2L, active2, 0L);
 
471
      case 98:
 
472
         return jjMoveStringLiteralDfa3_0(active0, 0x40000000000000L, active1, 0L, active2, 0L);
 
473
      case 99:
 
474
         return jjMoveStringLiteralDfa3_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
 
475
      case 101:
 
476
         return jjMoveStringLiteralDfa3_0(active0, 0x200000L, active1, 0L, active2, 0L);
 
477
      case 102:
 
478
         return jjMoveStringLiteralDfa3_0(active0, 0x20000000L, active1, 0L, active2, 0L);
 
479
      case 105:
 
480
         return jjMoveStringLiteralDfa3_0(active0, 0x5010000000000000L, active1, 0x50L, active2, 0L);
 
481
      case 108:
 
482
         return jjMoveStringLiteralDfa3_0(active0, 0x4000800000000L, active1, 0x20L, active2, 0L);
 
483
      case 110:
 
484
         return jjMoveStringLiteralDfa3_0(active0, 0x2000803018000000L, active1, 0L, active2, 0L);
 
485
      case 111:
 
486
         return jjMoveStringLiteralDfa3_0(active0, 0x120004000100000L, active1, 0L, active2, 0L);
 
487
      case 112:
 
488
         return jjMoveStringLiteralDfa3_0(active0, 0x8000c0000000000L, active1, 0L, active2, 0L);
 
489
      case 114:
 
490
         if ((active0 & 0x8000000000L) != 0L)
 
491
            return jjStartNfaWithStates_0(2, 39, 44);
 
492
         return jjMoveStringLiteralDfa3_0(active0, 0x8400000000000000L, active1, 0x1L, active2, 0L);
 
493
      case 115:
 
494
         return jjMoveStringLiteralDfa3_0(active0, 0x1001008c0000L, active1, 0L, active2, 0L);
 
495
      case 116:
 
496
         if ((active0 & 0x200000000000L) != 0L)
 
497
         {
 
498
            jjmatchedKind = 45;
 
499
            jjmatchedPos = 2;
 
500
         }
 
501
         return jjMoveStringLiteralDfa3_0(active0, 0x81410401400000L, active1, 0L, active2, 0L);
 
502
      case 117:
 
503
         return jjMoveStringLiteralDfa3_0(active0, 0x280000000L, active1, 0x4L, active2, 0L);
 
504
      case 119:
 
505
         if ((active0 & 0x2000000000000L) != 0L)
 
506
            return jjStartNfaWithStates_0(2, 49, 44);
 
507
         break;
 
508
      case 121:
 
509
         if ((active1 & 0x8L) != 0L)
 
510
            return jjStartNfaWithStates_0(2, 67, 44);
 
511
         break;
 
512
      default :
 
513
         break;
 
514
   }
 
515
   return jjStartNfa_0(1, active0, active1, active2);
 
516
}
 
517
private final int jjMoveStringLiteralDfa3_0(long old0, long active0, long old1, long active1, long old2, long active2)
 
518
{
 
519
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
 
520
      return jjStartNfa_0(1, old0, old1, old2); 
 
521
   try { curChar = input_stream.readChar(); }
 
522
   catch(java.io.IOException e) {
 
523
      jjStopStringLiteralDfa_0(2, active0, active1, active2);
 
524
      return 3;
 
525
   }
 
526
   switch(curChar)
 
527
   {
 
528
      case 61:
 
529
         if ((active2 & 0x1L) != 0L)
 
530
            return jjStopAtPos(3, 128);
 
531
         break;
 
532
      case 97:
 
533
         return jjMoveStringLiteralDfa4_0(active0, 0x7020200000L, active1, 0x20L, active2, 0L);
 
534
      case 98:
 
535
         return jjMoveStringLiteralDfa4_0(active0, 0x80000000L, active1, 0L, active2, 0L);
 
536
      case 99:
 
537
         return jjMoveStringLiteralDfa4_0(active0, 0x2000000001000000L, active1, 0L, active2, 0L);
 
538
      case 100:
 
539
         if ((active1 & 0x10L) != 0L)
 
540
            return jjStartNfaWithStates_0(3, 68, 44);
 
541
         break;
 
542
      case 101:
 
543
         if ((active0 & 0x400000L) != 0L)
 
544
            return jjStartNfaWithStates_0(3, 22, 44);
 
545
         else if ((active0 & 0x800000L) != 0L)
 
546
            return jjStartNfaWithStates_0(3, 23, 44);
 
547
         else if ((active0 & 0x100000000L) != 0L)
 
548
            return jjStartNfaWithStates_0(3, 32, 44);
 
549
         else if ((active1 & 0x4L) != 0L)
 
550
            return jjStartNfaWithStates_0(3, 66, 44);
 
551
         return jjMoveStringLiteralDfa4_0(active0, 0x800400400080000L, active1, 0L, active2, 0L);
 
552
      case 103:
 
553
         if ((active0 & 0x800000000000L) != 0L)
 
554
            return jjStartNfaWithStates_0(3, 47, 44);
 
555
         break;
 
556
      case 105:
 
557
         return jjMoveStringLiteralDfa4_0(active0, 0x401000000000000L, active1, 0L, active2, 0L);
 
558
      case 107:
 
559
         return jjMoveStringLiteralDfa4_0(active0, 0x8000000000000L, active1, 0L, active2, 0L);
 
560
      case 108:
 
561
         if ((active0 & 0x4000000000000L) != 0L)
 
562
            return jjStartNfaWithStates_0(3, 50, 44);
 
563
         return jjMoveStringLiteralDfa4_0(active0, 0x40040000100000L, active1, 0x40L, active2, 0L);
 
564
      case 109:
 
565
         if ((active0 & 0x200000000L) != 0L)
 
566
            return jjStartNfaWithStates_0(3, 33, 44);
 
567
         break;
 
568
      case 110:
 
569
         return jjMoveStringLiteralDfa4_0(active0, 0L, active1, 0x2L, active2, 0L);
 
570
      case 111:
 
571
         if ((active0 & 0x10000000000L) != 0L)
 
572
            return jjStartNfaWithStates_0(3, 40, 44);
 
573
         return jjMoveStringLiteralDfa4_0(active0, 0x8000080000000000L, active1, 0x1L, active2, 0L);
 
574
      case 114:
 
575
         if ((active0 & 0x2000000L) != 0L)
 
576
            return jjStartNfaWithStates_0(3, 25, 44);
 
577
         return jjMoveStringLiteralDfa4_0(active0, 0x100000000000000L, active1, 0L, active2, 0L);
 
578
      case 115:
 
579
         if ((active0 & 0x4000000000000000L) != 0L)
 
580
            return jjStartNfaWithStates_0(3, 62, 44);
 
581
         return jjMoveStringLiteralDfa4_0(active0, 0x80c000000L, active1, 0L, active2, 0L);
 
582
      case 116:
 
583
         return jjMoveStringLiteralDfa4_0(active0, 0x1220100010040000L, active1, 0L, active2, 0L);
 
584
      case 117:
 
585
         return jjMoveStringLiteralDfa4_0(active0, 0x80000000000000L, active1, 0L, active2, 0L);
 
586
      case 118:
 
587
         return jjMoveStringLiteralDfa4_0(active0, 0x10000000000000L, active1, 0L, active2, 0L);
 
588
      default :
 
589
         break;
 
590
   }
 
591
   return jjStartNfa_0(2, active0, active1, active2);
 
592
}
 
593
private final int jjMoveStringLiteralDfa4_0(long old0, long active0, long old1, long active1, long old2, long active2)
 
594
{
 
595
   if (((active0 &= old0) | (active1 &= old1) | (active2 &= old2)) == 0L)
 
596
      return jjStartNfa_0(2, old0, old1, old2); 
 
597
   try { curChar = input_stream.readChar(); }
 
598
   catch(java.io.IOException e) {
 
599
      jjStopStringLiteralDfa_0(3, active0, active1, 0L);
 
600
      return 4;
 
601
   }
 
602
   switch(curChar)
 
603
   {
 
604
      case 97:
 
605
         return jjMoveStringLiteralDfa5_0(active0, 0x18100000000000L, active1, 0L);
 
606
      case 99:
 
607
         return jjMoveStringLiteralDfa5_0(active0, 0x1400000000000000L, active1, 0L);
 
608
      case 101:
 
609
         if ((active0 & 0x800000000L) != 0L)
 
610
            return jjStartNfaWithStates_0(4, 35, 44);
 
611
         else if ((active1 & 0x40L) != 0L)
 
612
            return jjStartNfaWithStates_0(4, 70, 44);
 
613
         return jjMoveStringLiteralDfa5_0(active0, 0x20040000100000L, active1, 0L);
 
614
      case 104:
 
615
         if ((active0 & 0x1000000L) != 0L)
 
616
            return jjStartNfaWithStates_0(4, 24, 44);
 
617
         return jjMoveStringLiteralDfa5_0(active0, 0x2000000000000000L, active1, 0L);
 
618
      case 105:
 
619
         return jjMoveStringLiteralDfa5_0(active0, 0x240000010000000L, active1, 0L);
 
620
      case 107:
 
621
         if ((active0 & 0x200000L) != 0L)
 
622
            return jjStartNfaWithStates_0(4, 21, 44);
 
623
         break;
 
624
      case 108:
 
625
         if ((active0 & 0x1000000000L) != 0L)
 
626
         {
 
627
            jjmatchedKind = 36;
 
628
            jjmatchedPos = 4;
 
629
         }
 
630
         return jjMoveStringLiteralDfa5_0(active0, 0x2080000000L, active1, 0L);
 
631
      case 110:
 
632
         return jjMoveStringLiteralDfa5_0(active0, 0x400000000L, active1, 0L);
 
633
      case 114:
 
634
         if ((active0 & 0x800000000000000L) != 0L)
 
635
            return jjStartNfaWithStates_0(4, 59, 44);
 
636
         return jjMoveStringLiteralDfa5_0(active0, 0x804800000c0000L, active1, 0L);
 
637
      case 115:
 
638
         if ((active0 & 0x4000000L) != 0L)
 
639
            return jjStartNfaWithStates_0(4, 26, 44);
 
640
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x2L);
 
641
      case 116:
 
642
         if ((active0 & 0x8000000L) != 0L)
 
643
            return jjStartNfaWithStates_0(4, 27, 44);
 
644
         else if ((active0 & 0x4000000000L) != 0L)
 
645
            return jjStartNfaWithStates_0(4, 38, 44);
 
646
         else if ((active0 & 0x100000000000000L) != 0L)
 
647
            return jjStartNfaWithStates_0(4, 56, 44);
 
648
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x20L);
 
649
      case 117:
 
650
         return jjMoveStringLiteralDfa5_0(active0, 0x20000000L, active1, 0L);
 
651
      case 118:
 
652
         return jjMoveStringLiteralDfa5_0(active0, 0x1000000000000L, active1, 0L);
 
653
      case 119:
 
654
         if ((active0 & 0x8000000000000000L) != 0L)
 
655
         {
 
656
            jjmatchedKind = 63;
 
657
            jjmatchedPos = 4;
 
658
         }
 
659
         return jjMoveStringLiteralDfa5_0(active0, 0L, active1, 0x1L);
 
660
      default :
 
661
         break;
 
662
   }
 
663
   return jjStartNfa_0(3, active0, active1, 0L);
 
664
}
 
665
private final int jjMoveStringLiteralDfa5_0(long old0, long active0, long old1, long active1)
 
666
{
 
667
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 
668
      return jjStartNfa_0(3, old0, old1, 0L);
 
669
   try { curChar = input_stream.readChar(); }
 
670
   catch(java.io.IOException e) {
 
671
      jjStopStringLiteralDfa_0(4, active0, active1, 0L);
 
672
      return 5;
 
673
   }
 
674
   switch(curChar)
 
675
   {
 
676
      case 97:
 
677
         return jjMoveStringLiteralDfa6_0(active0, 0x140000L, active1, 0L);
 
678
      case 99:
 
679
         if ((active0 & 0x40000000000000L) != 0L)
 
680
            return jjStartNfaWithStates_0(5, 54, 44);
 
681
         else if ((active0 & 0x200000000000000L) != 0L)
 
682
            return jjStartNfaWithStates_0(5, 57, 44);
 
683
         return jjMoveStringLiteralDfa6_0(active0, 0x20000000000000L, active1, 0L);
 
684
      case 100:
 
685
         return jjMoveStringLiteralDfa6_0(active0, 0x400000000L, active1, 0L);
 
686
      case 101:
 
687
         if ((active0 & 0x80000000L) != 0L)
 
688
            return jjStartNfaWithStates_0(5, 31, 44);
 
689
         else if ((active0 & 0x1000000000000L) != 0L)
 
690
            return jjStartNfaWithStates_0(5, 48, 44);
 
691
         break;
 
692
      case 102:
 
693
         return jjMoveStringLiteralDfa6_0(active0, 0x400000000000L, active1, 0L);
 
694
      case 103:
 
695
         return jjMoveStringLiteralDfa6_0(active0, 0x8000000000000L, active1, 0L);
 
696
      case 104:
 
697
         if ((active0 & 0x1000000000000000L) != 0L)
 
698
            return jjStartNfaWithStates_0(5, 60, 44);
 
699
         break;
 
700
      case 105:
 
701
         return jjMoveStringLiteralDfa6_0(active0, 0L, active1, 0x22L);
 
702
      case 108:
 
703
         return jjMoveStringLiteralDfa6_0(active0, 0x2020000000L, active1, 0L);
 
704
      case 109:
 
705
         return jjMoveStringLiteralDfa6_0(active0, 0x40000000000L, active1, 0L);
 
706
      case 110:
 
707
         if ((active0 & 0x80000000000000L) != 0L)
 
708
            return jjStartNfaWithStates_0(5, 55, 44);
 
709
         return jjMoveStringLiteralDfa6_0(active0, 0x100010000000L, active1, 0L);
 
710
      case 114:
 
711
         return jjMoveStringLiteralDfa6_0(active0, 0x2000000000000000L, active1, 0L);
 
712
      case 115:
 
713
         if ((active1 & 0x1L) != 0L)
 
714
            return jjStartNfaWithStates_0(5, 64, 44);
 
715
         break;
 
716
      case 116:
 
717
         if ((active0 & 0x80000L) != 0L)
 
718
            return jjStartNfaWithStates_0(5, 19, 44);
 
719
         else if ((active0 & 0x80000000000L) != 0L)
 
720
            return jjStartNfaWithStates_0(5, 43, 44);
 
721
         return jjMoveStringLiteralDfa6_0(active0, 0x410000000000000L, active1, 0L);
 
722
      default :
 
723
         break;
 
724
   }
 
725
   return jjStartNfa_0(4, active0, active1, 0L);
 
726
}
 
727
private final int jjMoveStringLiteralDfa6_0(long old0, long active0, long old1, long active1)
 
728
{
 
729
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 
730
      return jjStartNfa_0(4, old0, old1, 0L);
 
731
   try { curChar = input_stream.readChar(); }
 
732
   catch(java.io.IOException e) {
 
733
      jjStopStringLiteralDfa_0(5, active0, active1, 0L);
 
734
      return 6;
 
735
   }
 
736
   switch(curChar)
 
737
   {
 
738
      case 97:
 
739
         return jjMoveStringLiteralDfa7_0(active0, 0x400000000000L, active1, 0L);
 
740
      case 99:
 
741
         return jjMoveStringLiteralDfa7_0(active0, 0x100000040000L, active1, 0L);
 
742
      case 101:
 
743
         if ((active0 & 0x8000000000000L) != 0L)
 
744
            return jjStartNfaWithStates_0(6, 51, 44);
 
745
         else if ((active0 & 0x10000000000000L) != 0L)
 
746
            return jjStartNfaWithStates_0(6, 52, 44);
 
747
         return jjMoveStringLiteralDfa7_0(active0, 0x40000000000L, active1, 0x2L);
 
748
      case 102:
 
749
         return jjMoveStringLiteralDfa7_0(active0, 0x400000000000000L, active1, 0L);
 
750
      case 108:
 
751
         return jjMoveStringLiteralDfa7_0(active0, 0L, active1, 0x20L);
 
752
      case 110:
 
753
         if ((active0 & 0x100000L) != 0L)
 
754
            return jjStartNfaWithStates_0(6, 20, 44);
 
755
         break;
 
756
      case 111:
 
757
         return jjMoveStringLiteralDfa7_0(active0, 0x2000000000000000L, active1, 0L);
 
758
      case 115:
 
759
         if ((active0 & 0x400000000L) != 0L)
 
760
            return jjStartNfaWithStates_0(6, 34, 44);
 
761
         break;
 
762
      case 116:
 
763
         if ((active0 & 0x20000000L) != 0L)
 
764
            return jjStartNfaWithStates_0(6, 29, 44);
 
765
         return jjMoveStringLiteralDfa7_0(active0, 0x20000000000000L, active1, 0L);
 
766
      case 117:
 
767
         return jjMoveStringLiteralDfa7_0(active0, 0x10000000L, active1, 0L);
 
768
      case 121:
 
769
         if ((active0 & 0x2000000000L) != 0L)
 
770
            return jjStartNfaWithStates_0(6, 37, 44);
 
771
         break;
 
772
      default :
 
773
         break;
 
774
   }
 
775
   return jjStartNfa_0(5, active0, active1, 0L);
 
776
}
 
777
private final int jjMoveStringLiteralDfa7_0(long old0, long active0, long old1, long active1)
 
778
{
 
779
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 
780
      return jjStartNfa_0(5, old0, old1, 0L);
 
781
   try { curChar = input_stream.readChar(); }
 
782
   catch(java.io.IOException e) {
 
783
      jjStopStringLiteralDfa_0(6, active0, active1, 0L);
 
784
      return 7;
 
785
   }
 
786
   switch(curChar)
 
787
   {
 
788
      case 99:
 
789
         return jjMoveStringLiteralDfa8_0(active0, 0x400000000000L, active1, 0L);
 
790
      case 101:
 
791
         if ((active0 & 0x10000000L) != 0L)
 
792
            return jjStartNfaWithStates_0(7, 28, 44);
 
793
         else if ((active1 & 0x20L) != 0L)
 
794
            return jjStartNfaWithStates_0(7, 69, 44);
 
795
         return jjMoveStringLiteralDfa8_0(active0, 0x20100000000000L, active1, 0L);
 
796
      case 110:
 
797
         return jjMoveStringLiteralDfa8_0(active0, 0x2000040000000000L, active1, 0x2L);
 
798
      case 112:
 
799
         if ((active0 & 0x400000000000000L) != 0L)
 
800
            return jjStartNfaWithStates_0(7, 58, 44);
 
801
         break;
 
802
      case 116:
 
803
         if ((active0 & 0x40000L) != 0L)
 
804
            return jjStartNfaWithStates_0(7, 18, 44);
 
805
         break;
 
806
      default :
 
807
         break;
 
808
   }
 
809
   return jjStartNfa_0(6, active0, active1, 0L);
 
810
}
 
811
private final int jjMoveStringLiteralDfa8_0(long old0, long active0, long old1, long active1)
 
812
{
 
813
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 
814
      return jjStartNfa_0(6, old0, old1, 0L);
 
815
   try { curChar = input_stream.readChar(); }
 
816
   catch(java.io.IOException e) {
 
817
      jjStopStringLiteralDfa_0(7, active0, active1, 0L);
 
818
      return 8;
 
819
   }
 
820
   switch(curChar)
 
821
   {
 
822
      case 100:
 
823
         if ((active0 & 0x20000000000000L) != 0L)
 
824
            return jjStartNfaWithStates_0(8, 53, 44);
 
825
         break;
 
826
      case 101:
 
827
         if ((active0 & 0x400000000000L) != 0L)
 
828
            return jjStartNfaWithStates_0(8, 46, 44);
 
829
         break;
 
830
      case 105:
 
831
         return jjMoveStringLiteralDfa9_0(active0, 0x2000000000000000L, active1, 0L);
 
832
      case 111:
 
833
         return jjMoveStringLiteralDfa9_0(active0, 0x100000000000L, active1, 0L);
 
834
      case 116:
 
835
         if ((active1 & 0x2L) != 0L)
 
836
            return jjStartNfaWithStates_0(8, 65, 44);
 
837
         return jjMoveStringLiteralDfa9_0(active0, 0x40000000000L, active1, 0L);
 
838
      default :
 
839
         break;
 
840
   }
 
841
   return jjStartNfa_0(7, active0, active1, 0L);
 
842
}
 
843
private final int jjMoveStringLiteralDfa9_0(long old0, long active0, long old1, long active1)
 
844
{
 
845
   if (((active0 &= old0) | (active1 &= old1)) == 0L)
 
846
      return jjStartNfa_0(7, old0, old1, 0L);
 
847
   try { curChar = input_stream.readChar(); }
 
848
   catch(java.io.IOException e) {
 
849
      jjStopStringLiteralDfa_0(8, active0, 0L, 0L);
 
850
      return 9;
 
851
   }
 
852
   switch(curChar)
 
853
   {
 
854
      case 102:
 
855
         if ((active0 & 0x100000000000L) != 0L)
 
856
            return jjStartNfaWithStates_0(9, 44, 44);
 
857
         break;
 
858
      case 115:
 
859
         if ((active0 & 0x40000000000L) != 0L)
 
860
            return jjStartNfaWithStates_0(9, 42, 44);
 
861
         break;
 
862
      case 122:
 
863
         return jjMoveStringLiteralDfa10_0(active0, 0x2000000000000000L);
 
864
      default :
 
865
         break;
 
866
   }
 
867
   return jjStartNfa_0(8, active0, 0L, 0L);
 
868
}
 
869
private final int jjMoveStringLiteralDfa10_0(long old0, long active0)
 
870
{
 
871
   if (((active0 &= old0)) == 0L)
 
872
      return jjStartNfa_0(8, old0, 0L, 0L);
 
873
   try { curChar = input_stream.readChar(); }
 
874
   catch(java.io.IOException e) {
 
875
      jjStopStringLiteralDfa_0(9, active0, 0L, 0L);
 
876
      return 10;
 
877
   }
 
878
   switch(curChar)
 
879
   {
 
880
      case 101:
 
881
         return jjMoveStringLiteralDfa11_0(active0, 0x2000000000000000L);
 
882
      default :
 
883
         break;
 
884
   }
 
885
   return jjStartNfa_0(9, active0, 0L, 0L);
 
886
}
 
887
private final int jjMoveStringLiteralDfa11_0(long old0, long active0)
 
888
{
 
889
   if (((active0 &= old0)) == 0L)
 
890
      return jjStartNfa_0(9, old0, 0L, 0L);
 
891
   try { curChar = input_stream.readChar(); }
 
892
   catch(java.io.IOException e) {
 
893
      jjStopStringLiteralDfa_0(10, active0, 0L, 0L);
 
894
      return 11;
 
895
   }
 
896
   switch(curChar)
 
897
   {
 
898
      case 100:
 
899
         if ((active0 & 0x2000000000000000L) != 0L)
 
900
            return jjStartNfaWithStates_0(11, 61, 44);
 
901
         break;
 
902
      default :
 
903
         break;
 
904
   }
 
905
   return jjStartNfa_0(10, active0, 0L, 0L);
 
906
}
 
907
private final void jjCheckNAdd(int state)
 
908
{
 
909
   if (jjrounds[state] != jjround)
 
910
   {
 
911
      jjstateSet[jjnewStateCnt++] = state;
 
912
      jjrounds[state] = jjround;
 
913
   }
 
914
}
 
915
private final void jjAddStates(int start, int end)
 
916
{
 
917
   do {
 
918
      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
 
919
   } while (start++ != end);
 
920
}
 
921
private final void jjCheckNAddTwoStates(int state1, int state2)
 
922
{
 
923
   jjCheckNAdd(state1);
 
924
   jjCheckNAdd(state2);
 
925
}
 
926
private final void jjCheckNAddStates(int start, int end)
 
927
{
 
928
   do {
 
929
      jjCheckNAdd(jjnextStates[start]);
 
930
   } while (start++ != end);
 
931
}
 
932
private final void jjCheckNAddStates(int start)
 
933
{
 
934
   jjCheckNAdd(jjnextStates[start]);
 
935
   jjCheckNAdd(jjnextStates[start + 1]);
 
936
}
 
937
static final long[] jjbitVec0 = {
 
938
   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 
939
};
 
940
static final long[] jjbitVec2 = {
 
941
   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
 
942
};
 
943
static final long[] jjbitVec3 = {
 
944
   0x1ff00000fffffffeL, 0xffffffffffffc000L, 0xffffffffL, 0x600000000000000L
 
945
};
 
946
static final long[] jjbitVec4 = {
 
947
   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
 
948
};
 
949
static final long[] jjbitVec5 = {
 
950
   0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
 
951
};
 
952
static final long[] jjbitVec6 = {
 
953
   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffL, 0x0L
 
954
};
 
955
static final long[] jjbitVec7 = {
 
956
   0xffffffffffffffffL, 0xffffffffffffffffL, 0x0L, 0x0L
 
957
};
 
958
static final long[] jjbitVec8 = {
 
959
   0x3fffffffffffL, 0x0L, 0x0L, 0x0L
 
960
};
 
961
private final int jjMoveNfa_0(int startState, int curPos)
 
962
{
 
963
   int[] nextStates;
 
964
   int startsAt = 0;
 
965
   jjnewStateCnt = 64;
 
966
   int i = 1;
 
967
   jjstateSet[0] = startState;
 
968
   int j, 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 3:
 
981
                  if ((0x3ff000000000000L & l) != 0L)
 
982
                     jjCheckNAddStates(0, 6);
 
983
                  else if (curChar == 36)
 
984
                  {
 
985
                     if (kind > 79)
 
986
                        kind = 79;
 
987
                     jjCheckNAdd(44);
 
988
                  }
 
989
                  else if (curChar == 34)
 
990
                     jjCheckNAddStates(7, 10);
 
991
                  else if (curChar == 39)
 
992
                     jjAddStates(11, 13);
 
993
                  else if (curChar == 46)
 
994
                     jjCheckNAdd(8);
 
995
                  else if (curChar == 47)
 
996
                     jjstateSet[jjnewStateCnt++] = 2;
 
997
                  if ((0x3fe000000000000L & l) != 0L)
 
998
                  {
 
999
                     if (kind > 71)
 
1000
                        kind = 71;
 
1001
                     jjCheckNAddTwoStates(5, 6);
 
1002
                  }
 
1003
                  else if (curChar == 48)
 
1004
                  {
 
1005
                     if (kind > 71)
 
1006
                        kind = 71;
 
1007
                     jjCheckNAddStates(14, 16);
 
1008
                  }
 
1009
                  break;
 
1010
               case 0:
 
1011
                  if (curChar == 42)
 
1012
                     jjstateSet[jjnewStateCnt++] = 1;
 
1013
                  break;
 
1014
               case 1:
 
1015
                  if ((0xffff7fffffffffffL & l) != 0L && kind > 10)
 
1016
                     kind = 10;
 
1017
                  break;
 
1018
               case 2:
 
1019
                  if (curChar == 42)
 
1020
                     jjstateSet[jjnewStateCnt++] = 0;
 
1021
                  break;
 
1022
               case 4:
 
1023
                  if ((0x3fe000000000000L & l) == 0L)
 
1024
                     break;
 
1025
                  if (kind > 71)
 
1026
                     kind = 71;
 
1027
                  jjCheckNAddTwoStates(5, 6);
 
1028
                  break;
 
1029
               case 5:
 
1030
                  if ((0x3ff000000000000L & l) == 0L)
 
1031
                     break;
 
1032
                  if (kind > 71)
 
1033
                     kind = 71;
 
1034
                  jjCheckNAddTwoStates(5, 6);
 
1035
                  break;
 
1036
               case 7:
 
1037
                  if (curChar == 46)
 
1038
                     jjCheckNAdd(8);
 
1039
                  break;
 
1040
               case 8:
 
1041
                  if ((0x3ff000000000000L & l) == 0L)
 
1042
                     break;
 
1043
                  if (kind > 75)
 
1044
                     kind = 75;
 
1045
                  jjCheckNAddStates(17, 19);
 
1046
                  break;
 
1047
               case 10:
 
1048
                  if ((0x280000000000L & l) != 0L)
 
1049
                     jjCheckNAdd(11);
 
1050
                  break;
 
1051
               case 11:
 
1052
                  if ((0x3ff000000000000L & l) == 0L)
 
1053
                     break;
 
1054
                  if (kind > 75)
 
1055
                     kind = 75;
 
1056
                  jjCheckNAddTwoStates(11, 12);
 
1057
                  break;
 
1058
               case 13:
 
1059
                  if (curChar == 39)
 
1060
                     jjAddStates(11, 13);
 
1061
                  break;
 
1062
               case 14:
 
1063
                  if ((0xffffff7fffffdbffL & l) != 0L)
 
1064
                     jjCheckNAdd(15);
 
1065
                  break;
 
1066
               case 15:
 
1067
                  if (curChar == 39 && kind > 77)
 
1068
                     kind = 77;
 
1069
                  break;
 
1070
               case 17:
 
1071
                  if ((0x8400000000L & l) != 0L)
 
1072
                     jjCheckNAdd(15);
 
1073
                  break;
 
1074
               case 18:
 
1075
                  if ((0xff000000000000L & l) != 0L)
 
1076
                     jjCheckNAddTwoStates(19, 15);
 
1077
                  break;
 
1078
               case 19:
 
1079
                  if ((0xff000000000000L & l) != 0L)
 
1080
                     jjCheckNAdd(15);
 
1081
                  break;
 
1082
               case 20:
 
1083
                  if ((0xf000000000000L & l) != 0L)
 
1084
                     jjstateSet[jjnewStateCnt++] = 21;
 
1085
                  break;
 
1086
               case 21:
 
1087
                  if ((0xff000000000000L & l) != 0L)
 
1088
                     jjCheckNAdd(19);
 
1089
                  break;
 
1090
               case 23:
 
1091
                  if ((0x3ff000000000000L & l) != 0L)
 
1092
                     jjstateSet[jjnewStateCnt++] = 24;
 
1093
                  break;
 
1094
               case 24:
 
1095
                  if ((0x3ff000000000000L & l) != 0L)
 
1096
                     jjstateSet[jjnewStateCnt++] = 25;
 
1097
                  break;
 
1098
               case 25:
 
1099
                  if ((0x3ff000000000000L & l) != 0L)
 
1100
                     jjstateSet[jjnewStateCnt++] = 26;
 
1101
                  break;
 
1102
               case 26:
 
1103
                  if ((0x3ff000000000000L & l) != 0L)
 
1104
                     jjCheckNAdd(15);
 
1105
                  break;
 
1106
               case 28:
 
1107
                  if (curChar == 34)
 
1108
                     jjCheckNAddStates(7, 10);
 
1109
                  break;
 
1110
               case 29:
 
1111
                  if ((0xfffffffbffffdbffL & l) != 0L)
 
1112
                     jjCheckNAddStates(7, 10);
 
1113
                  break;
 
1114
               case 31:
 
1115
                  if ((0x8400000000L & l) != 0L)
 
1116
                     jjCheckNAddStates(7, 10);
 
1117
                  break;
 
1118
               case 33:
 
1119
                  if ((0x3ff000000000000L & l) != 0L)
 
1120
                     jjstateSet[jjnewStateCnt++] = 34;
 
1121
                  break;
 
1122
               case 34:
 
1123
                  if ((0x3ff000000000000L & l) != 0L)
 
1124
                     jjstateSet[jjnewStateCnt++] = 35;
 
1125
                  break;
 
1126
               case 35:
 
1127
                  if ((0x3ff000000000000L & l) != 0L)
 
1128
                     jjstateSet[jjnewStateCnt++] = 36;
 
1129
                  break;
 
1130
               case 36:
 
1131
                  if ((0x3ff000000000000L & l) != 0L)
 
1132
                     jjCheckNAddStates(7, 10);
 
1133
                  break;
 
1134
               case 38:
 
1135
                  if (curChar == 34 && kind > 78)
 
1136
                     kind = 78;
 
1137
                  break;
 
1138
               case 39:
 
1139
                  if ((0xff000000000000L & l) != 0L)
 
1140
                     jjCheckNAddStates(20, 24);
 
1141
                  break;
 
1142
               case 40:
 
1143
                  if ((0xff000000000000L & l) != 0L)
 
1144
                     jjCheckNAddStates(7, 10);
 
1145
                  break;
 
1146
               case 41:
 
1147
                  if ((0xf000000000000L & l) != 0L)
 
1148
                     jjstateSet[jjnewStateCnt++] = 42;
 
1149
                  break;
 
1150
               case 42:
 
1151
                  if ((0xff000000000000L & l) != 0L)
 
1152
                     jjCheckNAdd(40);
 
1153
                  break;
 
1154
               case 43:
 
1155
                  if (curChar != 36)
 
1156
                     break;
 
1157
                  if (kind > 79)
 
1158
                     kind = 79;
 
1159
                  jjCheckNAdd(44);
 
1160
                  break;
 
1161
               case 44:
 
1162
                  if ((0x3ff001000000000L & l) == 0L)
 
1163
                     break;
 
1164
                  if (kind > 79)
 
1165
                     kind = 79;
 
1166
                  jjCheckNAdd(44);
 
1167
                  break;
 
1168
               case 45:
 
1169
                  if ((0x3ff000000000000L & l) != 0L)
 
1170
                     jjCheckNAddStates(0, 6);
 
1171
                  break;
 
1172
               case 46:
 
1173
                  if ((0x3ff000000000000L & l) != 0L)
 
1174
                     jjCheckNAddTwoStates(46, 47);
 
1175
                  break;
 
1176
               case 47:
 
1177
                  if (curChar != 46)
 
1178
                     break;
 
1179
                  if (kind > 75)
 
1180
                     kind = 75;
 
1181
                  jjCheckNAddStates(25, 27);
 
1182
                  break;
 
1183
               case 48:
 
1184
                  if ((0x3ff000000000000L & l) == 0L)
 
1185
                     break;
 
1186
                  if (kind > 75)
 
1187
                     kind = 75;
 
1188
                  jjCheckNAddStates(25, 27);
 
1189
                  break;
 
1190
               case 50:
 
1191
                  if ((0x280000000000L & l) != 0L)
 
1192
                     jjCheckNAdd(51);
 
1193
                  break;
 
1194
               case 51:
 
1195
                  if ((0x3ff000000000000L & l) == 0L)
 
1196
                     break;
 
1197
                  if (kind > 75)
 
1198
                     kind = 75;
 
1199
                  jjCheckNAddTwoStates(51, 12);
 
1200
                  break;
 
1201
               case 52:
 
1202
                  if ((0x3ff000000000000L & l) != 0L)
 
1203
                     jjCheckNAddTwoStates(52, 53);
 
1204
                  break;
 
1205
               case 54:
 
1206
                  if ((0x280000000000L & l) != 0L)
 
1207
                     jjCheckNAdd(55);
 
1208
                  break;
 
1209
               case 55:
 
1210
                  if ((0x3ff000000000000L & l) == 0L)
 
1211
                     break;
 
1212
                  if (kind > 75)
 
1213
                     kind = 75;
 
1214
                  jjCheckNAddTwoStates(55, 12);
 
1215
                  break;
 
1216
               case 56:
 
1217
                  if ((0x3ff000000000000L & l) != 0L)
 
1218
                     jjCheckNAddStates(28, 30);
 
1219
                  break;
 
1220
               case 58:
 
1221
                  if ((0x280000000000L & l) != 0L)
 
1222
                     jjCheckNAdd(59);
 
1223
                  break;
 
1224
               case 59:
 
1225
                  if ((0x3ff000000000000L & l) != 0L)
 
1226
                     jjCheckNAddTwoStates(59, 12);
 
1227
                  break;
 
1228
               case 60:
 
1229
                  if (curChar != 48)
 
1230
                     break;
 
1231
                  if (kind > 71)
 
1232
                     kind = 71;
 
1233
                  jjCheckNAddStates(14, 16);
 
1234
                  break;
 
1235
               case 62:
 
1236
                  if ((0x3ff000000000000L & l) == 0L)
 
1237
                     break;
 
1238
                  if (kind > 71)
 
1239
                     kind = 71;
 
1240
                  jjCheckNAddTwoStates(62, 6);
 
1241
                  break;
 
1242
               case 63:
 
1243
                  if ((0xff000000000000L & l) == 0L)
 
1244
                     break;
 
1245
                  if (kind > 71)
 
1246
                     kind = 71;
 
1247
                  jjCheckNAddTwoStates(63, 6);
 
1248
                  break;
 
1249
               default : break;
 
1250
            }
 
1251
         } while(i != startsAt);
 
1252
      }
 
1253
      else if (curChar < 128)
 
1254
      {
 
1255
         long l = 1L << (curChar & 077);
 
1256
         MatchLoop: do
 
1257
         {
 
1258
            switch(jjstateSet[--i])
 
1259
            {
 
1260
               case 3:
 
1261
               case 44:
 
1262
                  if ((0x7fffffe87fffffeL & l) == 0L)
 
1263
                     break;
 
1264
                  if (kind > 79)
 
1265
                     kind = 79;
 
1266
                  jjCheckNAdd(44);
 
1267
                  break;
 
1268
               case 1:
 
1269
                  if (kind > 10)
 
1270
                     kind = 10;
 
1271
                  break;
 
1272
               case 6:
 
1273
                  if ((0x100000001000L & l) != 0L && kind > 71)
 
1274
                     kind = 71;
 
1275
                  break;
 
1276
               case 9:
 
1277
                  if ((0x2000000020L & l) != 0L)
 
1278
                     jjAddStates(31, 32);
 
1279
                  break;
 
1280
               case 12:
 
1281
                  if ((0x5000000050L & l) != 0L && kind > 75)
 
1282
                     kind = 75;
 
1283
                  break;
 
1284
               case 14:
 
1285
                  if ((0xffffffffefffffffL & l) != 0L)
 
1286
                     jjCheckNAdd(15);
 
1287
                  break;
 
1288
               case 16:
 
1289
                  if (curChar == 92)
 
1290
                     jjAddStates(33, 35);
 
1291
                  break;
 
1292
               case 17:
 
1293
                  if ((0x14404410000000L & l) != 0L)
 
1294
                     jjCheckNAdd(15);
 
1295
                  break;
 
1296
               case 22:
 
1297
                  if (curChar == 117)
 
1298
                     jjstateSet[jjnewStateCnt++] = 23;
 
1299
                  break;
 
1300
               case 23:
 
1301
                  if ((0x7e0000007eL & l) != 0L)
 
1302
                     jjstateSet[jjnewStateCnt++] = 24;
 
1303
                  break;
 
1304
               case 24:
 
1305
                  if ((0x7e0000007eL & l) != 0L)
 
1306
                     jjstateSet[jjnewStateCnt++] = 25;
 
1307
                  break;
 
1308
               case 25:
 
1309
                  if ((0x7e0000007eL & l) != 0L)
 
1310
                     jjstateSet[jjnewStateCnt++] = 26;
 
1311
                  break;
 
1312
               case 26:
 
1313
                  if ((0x7e0000007eL & l) != 0L)
 
1314
                     jjCheckNAdd(15);
 
1315
                  break;
 
1316
               case 27:
 
1317
                  if (curChar == 92)
 
1318
                     jjstateSet[jjnewStateCnt++] = 22;
 
1319
                  break;
 
1320
               case 29:
 
1321
                  if ((0xffffffffefffffffL & l) != 0L)
 
1322
                     jjCheckNAddStates(7, 10);
 
1323
                  break;
 
1324
               case 30:
 
1325
                  if (curChar == 92)
 
1326
                     jjAddStates(36, 38);
 
1327
                  break;
 
1328
               case 31:
 
1329
                  if ((0x14404410000000L & l) != 0L)
 
1330
                     jjCheckNAddStates(7, 10);
 
1331
                  break;
 
1332
               case 32:
 
1333
                  if (curChar == 117)
 
1334
                     jjstateSet[jjnewStateCnt++] = 33;
 
1335
                  break;
 
1336
               case 33:
 
1337
                  if ((0x7e0000007eL & l) != 0L)
 
1338
                     jjstateSet[jjnewStateCnt++] = 34;
 
1339
                  break;
 
1340
               case 34:
 
1341
                  if ((0x7e0000007eL & l) != 0L)
 
1342
                     jjstateSet[jjnewStateCnt++] = 35;
 
1343
                  break;
 
1344
               case 35:
 
1345
                  if ((0x7e0000007eL & l) != 0L)
 
1346
                     jjstateSet[jjnewStateCnt++] = 36;
 
1347
                  break;
 
1348
               case 36:
 
1349
                  if ((0x7e0000007eL & l) != 0L)
 
1350
                     jjCheckNAddStates(7, 10);
 
1351
                  break;
 
1352
               case 37:
 
1353
                  if (curChar == 92)
 
1354
                     jjstateSet[jjnewStateCnt++] = 32;
 
1355
                  break;
 
1356
               case 49:
 
1357
                  if ((0x2000000020L & l) != 0L)
 
1358
                     jjAddStates(39, 40);
 
1359
                  break;
 
1360
               case 53:
 
1361
                  if ((0x2000000020L & l) != 0L)
 
1362
                     jjAddStates(41, 42);
 
1363
                  break;
 
1364
               case 57:
 
1365
                  if ((0x2000000020L & l) != 0L)
 
1366
                     jjAddStates(43, 44);
 
1367
                  break;
 
1368
               case 61:
 
1369
                  if ((0x100000001000000L & l) != 0L)
 
1370
                     jjCheckNAdd(62);
 
1371
                  break;
 
1372
               case 62:
 
1373
                  if ((0x7e0000007eL & l) == 0L)
 
1374
                     break;
 
1375
                  if (kind > 71)
 
1376
                     kind = 71;
 
1377
                  jjCheckNAddTwoStates(62, 6);
 
1378
                  break;
 
1379
               default : break;
 
1380
            }
 
1381
         } while(i != startsAt);
 
1382
      }
 
1383
      else
 
1384
      {
 
1385
         int hiByte = (int)(curChar >> 8);
 
1386
         int i1 = hiByte >> 6;
 
1387
         long l1 = 1L << (hiByte & 077);
 
1388
         int i2 = (curChar & 0xff) >> 6;
 
1389
         long l2 = 1L << (curChar & 077);
 
1390
         MatchLoop: do
 
1391
         {
 
1392
            switch(jjstateSet[--i])
 
1393
            {
 
1394
               case 3:
 
1395
               case 44:
 
1396
                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
 
1397
                     break;
 
1398
                  if (kind > 79)
 
1399
                     kind = 79;
 
1400
                  jjCheckNAdd(44);
 
1401
                  break;
 
1402
               case 1:
 
1403
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 10)
 
1404
                     kind = 10;
 
1405
                  break;
 
1406
               case 14:
 
1407
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 
1408
                     jjstateSet[jjnewStateCnt++] = 15;
 
1409
                  break;
 
1410
               case 29:
 
1411
                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
 
1412
                     jjAddStates(7, 10);
 
1413
                  break;
 
1414
               default : break;
 
1415
            }
 
1416
         } while(i != startsAt);
 
1417
      }
 
1418
      if (kind != 0x7fffffff)
 
1419
      {
 
1420
         jjmatchedKind = kind;
 
1421
         jjmatchedPos = curPos;
 
1422
         kind = 0x7fffffff;
 
1423
      }
 
1424
      ++curPos;
 
1425
      if ((i = jjnewStateCnt) == (startsAt = 64 - (jjnewStateCnt = startsAt)))
 
1426
         return curPos;
 
1427
      try { curChar = input_stream.readChar(); }
 
1428
      catch(java.io.IOException e) { return curPos; }
 
1429
   }
 
1430
}
 
1431
private final int jjMoveStringLiteralDfa0_4()
 
1432
{
 
1433
   switch(curChar)
 
1434
   {
 
1435
      case 42:
 
1436
         return jjMoveStringLiteralDfa1_4(0x8000L);
 
1437
      default :
 
1438
         return 1;
 
1439
   }
 
1440
}
 
1441
private final int jjMoveStringLiteralDfa1_4(long active0)
 
1442
{
 
1443
   try { curChar = input_stream.readChar(); }
 
1444
   catch(java.io.IOException e) {
 
1445
      return 1;
 
1446
   }
 
1447
   switch(curChar)
 
1448
   {
 
1449
      case 47:
 
1450
         if ((active0 & 0x8000L) != 0L)
 
1451
            return jjStopAtPos(1, 15);
 
1452
         break;
 
1453
      default :
 
1454
         return 2;
 
1455
   }
 
1456
   return 2;
 
1457
}
 
1458
private final int jjMoveStringLiteralDfa0_2()
 
1459
{
 
1460
   return jjMoveNfa_2(4, 0);
 
1461
}
 
1462
private final int jjMoveNfa_2(int startState, int curPos)
 
1463
{
 
1464
   int[] nextStates;
 
1465
   int startsAt = 0;
 
1466
   jjnewStateCnt = 4;
 
1467
   int i = 1;
 
1468
   jjstateSet[0] = startState;
 
1469
   int j, kind = 0x7fffffff;
 
1470
   for (;;)
 
1471
   {
 
1472
      if (++jjround == 0x7fffffff)
 
1473
         ReInitRounds();
 
1474
      if (curChar < 64)
 
1475
      {
 
1476
         long l = 1L << curChar;
 
1477
         MatchLoop: do
 
1478
         {
 
1479
            switch(jjstateSet[--i])
 
1480
            {
 
1481
               case 4:
 
1482
                  if ((0xfffffffffbffdbffL & l) != 0L)
 
1483
                  {
 
1484
                     if (kind > 13)
 
1485
                        kind = 13;
 
1486
                     jjCheckNAddStates(45, 47);
 
1487
                  }
 
1488
                  else if ((0x2400L & l) != 0L)
 
1489
                  {
 
1490
                     if (kind > 13)
 
1491
                        kind = 13;
 
1492
                  }
 
1493
                  if (curChar == 13)
 
1494
                     jjstateSet[jjnewStateCnt++] = 2;
 
1495
                  break;
 
1496
               case 0:
 
1497
                  if ((0xfffffffffbffdbffL & l) == 0L)
 
1498
                     break;
 
1499
                  kind = 13;
 
1500
                  jjCheckNAddStates(45, 47);
 
1501
                  break;
 
1502
               case 1:
 
1503
                  if ((0x2400L & l) != 0L && kind > 13)
 
1504
                     kind = 13;
 
1505
                  break;
 
1506
               case 2:
 
1507
                  if (curChar == 10 && kind > 13)
 
1508
                     kind = 13;
 
1509
                  break;
 
1510
               case 3:
 
1511
                  if (curChar == 13)
 
1512
                     jjstateSet[jjnewStateCnt++] = 2;
 
1513
                  break;
 
1514
               default : break;
 
1515
            }
 
1516
         } while(i != startsAt);
 
1517
      }
 
1518
      else if (curChar < 128)
 
1519
      {
 
1520
         long l = 1L << (curChar & 077);
 
1521
         MatchLoop: do
 
1522
         {
 
1523
            switch(jjstateSet[--i])
 
1524
            {
 
1525
               case 4:
 
1526
               case 0:
 
1527
                  kind = 13;
 
1528
                  jjCheckNAddStates(45, 47);
 
1529
                  break;
 
1530
               default : break;
 
1531
            }
 
1532
         } while(i != startsAt);
 
1533
      }
 
1534
      else
 
1535
      {
 
1536
         int hiByte = (int)(curChar >> 8);
 
1537
         int i1 = hiByte >> 6;
 
1538
         long l1 = 1L << (hiByte & 077);
 
1539
         int i2 = (curChar & 0xff) >> 6;
 
1540
         long l2 = 1L << (curChar & 077);
 
1541
         MatchLoop: do
 
1542
         {
 
1543
            switch(jjstateSet[--i])
 
1544
            {
 
1545
               case 4:
 
1546
               case 0:
 
1547
                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
 
1548
                     break;
 
1549
                  if (kind > 13)
 
1550
                     kind = 13;
 
1551
                  jjCheckNAddStates(45, 47);
 
1552
                  break;
 
1553
               default : break;
 
1554
            }
 
1555
         } while(i != startsAt);
 
1556
      }
 
1557
      if (kind != 0x7fffffff)
 
1558
      {
 
1559
         jjmatchedKind = kind;
 
1560
         jjmatchedPos = curPos;
 
1561
         kind = 0x7fffffff;
 
1562
      }
 
1563
      ++curPos;
 
1564
      if ((i = jjnewStateCnt) == (startsAt = 4 - (jjnewStateCnt = startsAt)))
 
1565
         return curPos;
 
1566
      try { curChar = input_stream.readChar(); }
 
1567
      catch(java.io.IOException e) { return curPos; }
 
1568
   }
 
1569
}
 
1570
private final int jjMoveStringLiteralDfa0_3()
 
1571
{
 
1572
   switch(curChar)
 
1573
   {
 
1574
      case 42:
 
1575
         return jjMoveStringLiteralDfa1_3(0x4000L);
 
1576
      default :
 
1577
         return 1;
 
1578
   }
 
1579
}
 
1580
private final int jjMoveStringLiteralDfa1_3(long active0)
 
1581
{
 
1582
   try { curChar = input_stream.readChar(); }
 
1583
   catch(java.io.IOException e) {
 
1584
      return 1;
 
1585
   }
 
1586
   switch(curChar)
 
1587
   {
 
1588
      case 47:
 
1589
         if ((active0 & 0x4000L) != 0L)
 
1590
            return jjStopAtPos(1, 14);
 
1591
         break;
 
1592
      default :
 
1593
         return 2;
 
1594
   }
 
1595
   return 2;
 
1596
}
 
1597
private final int jjMoveStringLiteralDfa0_5()
 
1598
{
 
1599
   switch(curChar)
 
1600
   {
 
1601
      case 42:
 
1602
         return jjMoveStringLiteralDfa1_5(0x10000L);
 
1603
      default :
 
1604
         return 1;
 
1605
   }
 
1606
}
 
1607
private final int jjMoveStringLiteralDfa1_5(long active0)
 
1608
{
 
1609
   try { curChar = input_stream.readChar(); }
 
1610
   catch(java.io.IOException e) {
 
1611
      return 1;
 
1612
   }
 
1613
   switch(curChar)
 
1614
   {
 
1615
      case 47:
 
1616
         if ((active0 & 0x10000L) != 0L)
 
1617
            return jjStopAtPos(1, 16);
 
1618
         break;
 
1619
      default :
 
1620
         return 2;
 
1621
   }
 
1622
   return 2;
 
1623
}
 
1624
static final int[] jjnextStates = {
 
1625
   46, 47, 52, 53, 56, 57, 12, 29, 30, 37, 38, 14, 16, 27, 61, 63, 
 
1626
   6, 8, 9, 12, 29, 30, 40, 37, 38, 48, 49, 12, 56, 57, 12, 10, 
 
1627
   11, 17, 18, 20, 31, 39, 41, 50, 51, 54, 55, 58, 59, 0, 1, 3, 
 
1628
};
 
1629
private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
 
1630
{
 
1631
   switch(hiByte)
 
1632
   {
 
1633
      case 0:
 
1634
         return ((jjbitVec2[i2] & l2) != 0L);
 
1635
      default : 
 
1636
         if ((jjbitVec0[i1] & l1) != 0L)
 
1637
            return true;
 
1638
         return false;
 
1639
   }
 
1640
}
 
1641
private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
 
1642
{
 
1643
   switch(hiByte)
 
1644
   {
 
1645
      case 0:
 
1646
         return ((jjbitVec4[i2] & l2) != 0L);
 
1647
      case 48:
 
1648
         return ((jjbitVec5[i2] & l2) != 0L);
 
1649
      case 49:
 
1650
         return ((jjbitVec6[i2] & l2) != 0L);
 
1651
      case 51:
 
1652
         return ((jjbitVec7[i2] & l2) != 0L);
 
1653
      case 61:
 
1654
         return ((jjbitVec8[i2] & l2) != 0L);
 
1655
      default : 
 
1656
         if ((jjbitVec3[i1] & l1) != 0L)
 
1657
            return true;
 
1658
         return false;
 
1659
   }
 
1660
}
 
1661
public static final String[] jjstrLiteralImages = {
 
1662
"", null, null, null, null, null, null, null, null, null, null, null, null, 
 
1663
null, null, null, null, null, "\141\142\163\164\162\141\143\164", 
 
1664
"\141\163\163\145\162\164", "\142\157\157\154\145\141\156", "\142\162\145\141\153", "\142\171\164\145", 
 
1665
"\143\141\163\145", "\143\141\164\143\150", "\143\150\141\162", "\143\154\141\163\163", 
 
1666
"\143\157\156\163\164", "\143\157\156\164\151\156\165\145", "\144\145\146\141\165\154\164", 
 
1667
"\144\157", "\144\157\165\142\154\145", "\145\154\163\145", "\145\156\165\155", 
 
1668
"\145\170\164\145\156\144\163", "\146\141\154\163\145", "\146\151\156\141\154", 
 
1669
"\146\151\156\141\154\154\171", "\146\154\157\141\164", "\146\157\162", "\147\157\164\157", "\151\146", 
 
1670
"\151\155\160\154\145\155\145\156\164\163", "\151\155\160\157\162\164", "\151\156\163\164\141\156\143\145\157\146", 
 
1671
"\151\156\164", "\151\156\164\145\162\146\141\143\145", "\154\157\156\147", 
 
1672
"\156\141\164\151\166\145", "\156\145\167", "\156\165\154\154", "\160\141\143\153\141\147\145", 
 
1673
"\160\162\151\166\141\164\145", "\160\162\157\164\145\143\164\145\144", "\160\165\142\154\151\143", 
 
1674
"\162\145\164\165\162\156", "\163\150\157\162\164", "\163\164\141\164\151\143", 
 
1675
"\163\164\162\151\143\164\146\160", "\163\165\160\145\162", "\163\167\151\164\143\150", 
 
1676
"\163\171\156\143\150\162\157\156\151\172\145\144", "\164\150\151\163", "\164\150\162\157\167", "\164\150\162\157\167\163", 
 
1677
"\164\162\141\156\163\151\145\156\164", "\164\162\165\145", "\164\162\171", "\166\157\151\144", 
 
1678
"\166\157\154\141\164\151\154\145", "\167\150\151\154\145", null, null, null, null, null, null, null, null, null, 
 
1679
null, null, "\50", "\51", "\173", "\175", "\133", "\135", "\73", "\54", "\56", 
 
1680
"\56\56\56", "\75", "\76", "\74", "\41", "\176", "\77", "\72", "\75\75", "\74\75", 
 
1681
"\76\75", "\41\75", "\174\174", "\46\46", "\53\53", "\55\55", "\53", "\55", "\52", 
 
1682
"\57", "\46", "\174", "\136", "\45", "\74\74", "\76\76", "\76\76\76", "\53\75", 
 
1683
"\55\75", "\52\75", "\57\75", "\46\75", "\174\75", "\136\75", "\45\75", "\74\74\75", 
 
1684
"\76\76\75", "\76\76\76\75", "\100", };
 
1685
public static final String[] lexStateNames = {
 
1686
   "DEFAULT", 
 
1687
   "IN_ONLY_EOF", 
 
1688
   "IN_SINGLE_LINE_COMMENT", 
 
1689
   "IN_FORMAL_COMMENT", 
 
1690
   "IN_MULTI_LINE_COMMENT", 
 
1691
   "IN_CATEGORY_COMMENT", 
 
1692
};
 
1693
public static final int[] jjnewLexState = {
 
1694
   -1, -1, -1, -1, 1, -1, -1, -1, -1, 2, 3, 4, 5, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, 
 
1695
   -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, 
 
1696
   -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, 
 
1697
   -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, 
 
1698
   -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, 
 
1699
   -1, -1, -1, -1, -1, 
 
1700
};
 
1701
static final long[] jjtoToken = {
 
1702
   0xfffffffffffc0001L, 0xfffffffffffce8ffL, 0x3L, 
 
1703
};
 
1704
static final long[] jjtoSkip = {
 
1705
   0x1e1deL, 0x0L, 0x0L, 
 
1706
};
 
1707
static final long[] jjtoSpecial = {
 
1708
   0x1e1c0L, 0x0L, 0x0L, 
 
1709
};
 
1710
static final long[] jjtoMore = {
 
1711
   0x21e20L, 0x0L, 0x0L, 
 
1712
};
 
1713
protected SimpleCharStream input_stream;
 
1714
private final int[] jjrounds = new int[64];
 
1715
private final int[] jjstateSet = new int[128];
 
1716
StringBuffer image;
 
1717
int jjimageLen;
 
1718
int lengthOfMatch;
 
1719
protected char curChar;
 
1720
public JavaParserTokenManager(SimpleCharStream stream)
 
1721
{
 
1722
   if (SimpleCharStream.staticFlag)
 
1723
      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
 
1724
   input_stream = stream;
 
1725
}
 
1726
public JavaParserTokenManager(SimpleCharStream stream, int lexState)
 
1727
{
 
1728
   this(stream);
 
1729
   SwitchTo(lexState);
 
1730
}
 
1731
public void ReInit(SimpleCharStream stream)
 
1732
{
 
1733
   jjmatchedPos = jjnewStateCnt = 0;
 
1734
   curLexState = defaultLexState;
 
1735
   input_stream = stream;
 
1736
   ReInitRounds();
 
1737
}
 
1738
private final void ReInitRounds()
 
1739
{
 
1740
   int i;
 
1741
   jjround = 0x80000001;
 
1742
   for (i = 64; i-- > 0;)
 
1743
      jjrounds[i] = 0x80000000;
 
1744
}
 
1745
public void ReInit(SimpleCharStream stream, int lexState)
 
1746
{
 
1747
   ReInit(stream);
 
1748
   SwitchTo(lexState);
 
1749
}
 
1750
public void SwitchTo(int lexState)
 
1751
{
 
1752
   if (lexState >= 6 || lexState < 0)
 
1753
      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
 
1754
   else
 
1755
      curLexState = lexState;
 
1756
}
 
1757
 
 
1758
protected Token jjFillToken()
 
1759
{
 
1760
   Token t = Token.newToken(jjmatchedKind);
 
1761
   t.kind = jjmatchedKind;
 
1762
   if (jjmatchedPos < 0)
 
1763
   {
 
1764
      if (image == null)
 
1765
         t.image = "";
 
1766
      else
 
1767
         t.image = image.toString();
 
1768
      t.beginLine = t.endLine = input_stream.getBeginLine();
 
1769
      t.beginColumn = t.endColumn = input_stream.getBeginColumn();
 
1770
   }
 
1771
   else
 
1772
   {
 
1773
      String im = jjstrLiteralImages[jjmatchedKind];
 
1774
      t.image = (im == null) ? input_stream.GetImage() : im;
 
1775
      t.beginLine = input_stream.getBeginLine();
 
1776
      t.beginColumn = input_stream.getBeginColumn();
 
1777
      t.endLine = input_stream.getEndLine();
 
1778
      t.endColumn = input_stream.getEndColumn();
 
1779
   }
 
1780
   return t;
 
1781
}
 
1782
 
 
1783
int curLexState = 0;
 
1784
int defaultLexState = 0;
 
1785
int jjnewStateCnt;
 
1786
int jjround;
 
1787
int jjmatchedPos;
 
1788
int jjmatchedKind;
 
1789
 
 
1790
public Token getNextToken() 
 
1791
{
 
1792
  int kind;
 
1793
  Token specialToken = null;
 
1794
  Token matchedToken;
 
1795
  int curPos = 0;
 
1796
 
 
1797
  EOFLoop :
 
1798
  for (;;)
 
1799
  {   
 
1800
   try   
 
1801
   {     
 
1802
      curChar = input_stream.BeginToken();
 
1803
   }     
 
1804
   catch(java.io.IOException e)
 
1805
   {        
 
1806
      jjmatchedKind = 0;
 
1807
      matchedToken = jjFillToken();
 
1808
      matchedToken.specialToken = specialToken;
 
1809
      return matchedToken;
 
1810
   }
 
1811
   image = null;
 
1812
   jjimageLen = 0;
 
1813
 
 
1814
   for (;;)
 
1815
   {
 
1816
     switch(curLexState)
 
1817
     {
 
1818
       case 0:
 
1819
         try { input_stream.backup(0);
 
1820
            while (curChar <= 32 && (0x100001200L & (1L << curChar)) != 0L)
 
1821
               curChar = input_stream.BeginToken();
 
1822
         }
 
1823
         catch (java.io.IOException e1) { continue EOFLoop; }
 
1824
         jjmatchedKind = 0x7fffffff;
 
1825
         jjmatchedPos = 0;
 
1826
         curPos = jjMoveStringLiteralDfa0_0();
 
1827
         break;
 
1828
       case 1:
 
1829
         jjmatchedKind = 0x7fffffff;
 
1830
         jjmatchedPos = 0;
 
1831
         curPos = jjMoveStringLiteralDfa0_1();
 
1832
         if (jjmatchedPos == 0 && jjmatchedKind > 5)
 
1833
         {
 
1834
            jjmatchedKind = 5;
 
1835
         }
 
1836
         break;
 
1837
       case 2:
 
1838
         jjmatchedKind = 13;
 
1839
         jjmatchedPos = -1;
 
1840
         curPos = 0;
 
1841
         curPos = jjMoveStringLiteralDfa0_2();
 
1842
         if (jjmatchedPos < 0 || (jjmatchedPos == 0 && jjmatchedKind > 17))
 
1843
         {
 
1844
            jjmatchedKind = 17;
 
1845
            jjmatchedPos = 0;
 
1846
         }
 
1847
         break;
 
1848
       case 3:
 
1849
         jjmatchedKind = 0x7fffffff;
 
1850
         jjmatchedPos = 0;
 
1851
         curPos = jjMoveStringLiteralDfa0_3();
 
1852
         if (jjmatchedPos == 0 && jjmatchedKind > 17)
 
1853
         {
 
1854
            jjmatchedKind = 17;
 
1855
         }
 
1856
         break;
 
1857
       case 4:
 
1858
         jjmatchedKind = 0x7fffffff;
 
1859
         jjmatchedPos = 0;
 
1860
         curPos = jjMoveStringLiteralDfa0_4();
 
1861
         if (jjmatchedPos == 0 && jjmatchedKind > 17)
 
1862
         {
 
1863
            jjmatchedKind = 17;
 
1864
         }
 
1865
         break;
 
1866
       case 5:
 
1867
         jjmatchedKind = 0x7fffffff;
 
1868
         jjmatchedPos = 0;
 
1869
         curPos = jjMoveStringLiteralDfa0_5();
 
1870
         if (jjmatchedPos == 0 && jjmatchedKind > 17)
 
1871
         {
 
1872
            jjmatchedKind = 17;
 
1873
         }
 
1874
         break;
 
1875
     }
 
1876
     if (jjmatchedKind != 0x7fffffff)
 
1877
     {
 
1878
        if (jjmatchedPos + 1 < curPos)
 
1879
           input_stream.backup(curPos - jjmatchedPos - 1);
 
1880
        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 
1881
        {
 
1882
           matchedToken = jjFillToken();
 
1883
           matchedToken.specialToken = specialToken;
 
1884
       if (jjnewLexState[jjmatchedKind] != -1)
 
1885
         curLexState = jjnewLexState[jjmatchedKind];
 
1886
           return matchedToken;
 
1887
        }
 
1888
        else if ((jjtoSkip[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 
1889
        {
 
1890
           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
 
1891
           {
 
1892
              matchedToken = jjFillToken();
 
1893
              if (specialToken == null)
 
1894
                 specialToken = matchedToken;
 
1895
              else
 
1896
              {
 
1897
                 matchedToken.specialToken = specialToken;
 
1898
                 specialToken = (specialToken.next = matchedToken);
 
1899
              }
 
1900
              SkipLexicalActions(matchedToken);
 
1901
           }
 
1902
           else 
 
1903
              SkipLexicalActions(null);
 
1904
         if (jjnewLexState[jjmatchedKind] != -1)
 
1905
           curLexState = jjnewLexState[jjmatchedKind];
 
1906
           continue EOFLoop;
 
1907
        }
 
1908
        MoreLexicalActions();
 
1909
      if (jjnewLexState[jjmatchedKind] != -1)
 
1910
        curLexState = jjnewLexState[jjmatchedKind];
 
1911
        curPos = 0;
 
1912
        jjmatchedKind = 0x7fffffff;
 
1913
        try {
 
1914
           curChar = input_stream.readChar();
 
1915
           continue;
 
1916
        }
 
1917
        catch (java.io.IOException e1) { }
 
1918
     }
 
1919
     int error_line = input_stream.getEndLine();
 
1920
     int error_column = input_stream.getEndColumn();
 
1921
     String error_after = null;
 
1922
     boolean EOFSeen = false;
 
1923
     try { input_stream.readChar(); input_stream.backup(1); }
 
1924
     catch (java.io.IOException e1) {
 
1925
        EOFSeen = true;
 
1926
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
 
1927
        if (curChar == '\n' || curChar == '\r') {
 
1928
           error_line++;
 
1929
           error_column = 0;
 
1930
        }
 
1931
        else
 
1932
           error_column++;
 
1933
     }
 
1934
     if (!EOFSeen) {
 
1935
        input_stream.backup(1);
 
1936
        error_after = curPos <= 1 ? "" : input_stream.GetImage();
 
1937
     }
 
1938
     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
 
1939
   }
 
1940
  }
 
1941
}
 
1942
 
 
1943
void SkipLexicalActions(Token matchedToken)
 
1944
{
 
1945
   switch(jjmatchedKind)
 
1946
   {
 
1947
      case 4 :
 
1948
         if (image == null)
 
1949
            image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
 
1950
         else
 
1951
            image.append(new String(input_stream.GetSuffix(jjimageLen + (lengthOfMatch = jjmatchedPos + 1))));
 
1952
              System.out.println("Warning: cntl-z found at end of file");
 
1953
         break;
 
1954
      default :
 
1955
         break;
 
1956
   }
 
1957
}
 
1958
void MoreLexicalActions()
 
1959
{
 
1960
   jjimageLen += (lengthOfMatch = jjmatchedPos + 1);
 
1961
   switch(jjmatchedKind)
 
1962
   {
 
1963
      case 5 :
 
1964
         if (image == null)
 
1965
              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
 
1966
         else
 
1967
            image.append(new String(input_stream.GetSuffix(jjimageLen)));
 
1968
         jjimageLen = 0;
 
1969
               System.out.println("Error: no characters should follow cntl-z at end of file");
 
1970
         break;
 
1971
      case 10 :
 
1972
         if (image == null)
 
1973
              image = new StringBuffer(new String(input_stream.GetSuffix(jjimageLen)));
 
1974
         else
 
1975
            image.append(new String(input_stream.GetSuffix(jjimageLen)));
 
1976
         jjimageLen = 0;
 
1977
                   input_stream.backup(1);
 
1978
         break;
 
1979
      default : 
 
1980
         break;
 
1981
   }
 
1982
}
 
1983
}