001    /* Generated By:JavaCC: Do not edit this line. JavaParserTokenManager.java */
002    
003    /*
004     * Cobertura - http://cobertura.sourceforge.net/
005     *
006     * This file was taken from JavaNCSS
007     * http://www.kclee.com/clemens/java/javancss/
008     * Copyright (C) 2000 Chr. Clemens Lee <clemens a.t kclee d.o.t com>
009     *
010     * Cobertura is free software; you can redistribute it and/or modify
011     * it under the terms of the GNU General Public License as published
012     * by the Free Software Foundation; either version 2 of the License,
013     * or (at your option) any later version.
014     *
015     * Cobertura is distributed in the hope that it will be useful, but
016     * WITHOUT ANY WARRANTY; without even the implied warranty of
017     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
018     * General Public License for more details.
019     *
020     * You should have received a copy of the GNU General Public License
021     * along with Cobertura; if not, write to the Free Software
022     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
023     * USA
024     */
025    
026    package net.sourceforge.cobertura.javancss;
027    
028    public class JavaParserTokenManager implements JavaParserConstants
029    {
030    
031            // added by SMS
032    
033            private final int jjStopStringLiteralDfa_0(int pos, long active0, long active1)
034            {
035                    switch (pos)
036                    {
037                            case 0:
038                                    if ((active1 & 0x100000L) != 0L)
039                                            return 4;
040                                    if ((active0 & 0xffffffffffffe000L) != 0L || (active1 & 0x1L) != 0L)
041                                    {
042                                            jjmatchedKind = 73;
043                                            return 28;
044                                    }
045                                    return -1;
046                            case 1:
047                                    if ((active0 & 0x806000000L) != 0L)
048                                            return 28;
049                                    if ((active0 & 0xfffffff7f9ffe000L) != 0L || (active1 & 0x1L) != 0L)
050                                    {
051                                            if (jjmatchedPos != 1)
052                                            {
053                                                    jjmatchedKind = 73;
054                                                    jjmatchedPos = 1;
055                                            }
056                                            return 28;
057                                    }
058                                    return -1;
059                            case 2:
060                                    if ((active0 & 0x2000098200000000L) != 0L)
061                                            return 28;
062                                    if ((active0 & 0xdffff675fdffe000L) != 0L || (active1 & 0x1L) != 0L)
063                                    {
064                                            if (jjmatchedPos != 2)
065                                            {
066                                                    jjmatchedKind = 73;
067                                                    jjmatchedPos = 2;
068                                            }
069                                            return 28;
070                                    }
071                                    return -1;
072                            case 3:
073                                    if ((active0 & 0x8effe571f5e9e000L) != 0L || (active1 & 0x1L) != 0L)
074                                    {
075                                            jjmatchedKind = 73;
076                                            jjmatchedPos = 3;
077                                            return 28;
078                                    }
079                                    if ((active0 & 0x5100120408160000L) != 0L)
080                                            return 28;
081                                    return -1;
082                            case 4:
083                                    if ((active0 & 0x6240001e0690000L) != 0L || (active1 & 0x1L) != 0L)
084                                            return 28;
085                                    if ((active0 & 0x88dbe5701580e000L) != 0L)
086                                    {
087                                            if (jjmatchedPos != 4)
088                                            {
089                                                    jjmatchedKind = 73;
090                                                    jjmatchedPos = 4;
091                                            }
092                                            return 28;
093                                    }
094                                    return -1;
095                            case 5:
096                                    if ((active0 & 0x44b042004004000L) != 0L)
097                                            return 28;
098                                    if ((active0 & 0x8890e1509180a000L) != 0L)
099                                    {
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    }