CompactSyntaxTokenManager.java revision 524:dcaa586ab756 
1141104Sharti/*
294589Sobrien * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
394589Sobrien * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
41590Srgrimes *
594589Sobrien * This code is free software; you can redistribute it and/or modify it
694589Sobrien * under the terms of the GNU General Public License version 2 only, as
794589Sobrien * published by the Free Software Foundation.  Oracle designates this
81590Srgrimes * particular file as subject to the "Classpath" exception as provided
91590Srgrimes * by Oracle in the LICENSE file that accompanied this code.
101590Srgrimes *
111590Srgrimes * This code is distributed in the hope that it will be useful, but WITHOUT
121590Srgrimes * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
131590Srgrimes * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
141590Srgrimes * version 2 for more details (a copy is included in the LICENSE file that
151590Srgrimes * accompanied this code).
16141104Sharti *
171590Srgrimes * You should have received a copy of the GNU General Public License version
181590Srgrimes * 2 along with this work; if not, write to the Free Software Foundation,
191590Srgrimes * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
201590Srgrimes *
211590Srgrimes * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
221590Srgrimes * or visit www.oracle.com if you need additional information or have any
231590Srgrimes * questions.
241590Srgrimes */
251590Srgrimes/*
261590Srgrimes * Copyright (C) 2004-2011
271590Srgrimes *
281590Srgrimes * Permission is hereby granted, free of charge, to any person obtaining a copy
291590Srgrimes * of this software and associated documentation files (the "Software"), to deal
301590Srgrimes * in the Software without restriction, including without limitation the rights
3162833Swsanchez * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
3262833Swsanchez * copies of the Software, and to permit persons to whom the Software is
331590Srgrimes * furnished to do so, subject to the following conditions:
341590Srgrimes *
3562833Swsanchez * The above copyright notice and this permission notice shall be included in
3694587Sobrien * all copies or substantial portions of the Software.
371590Srgrimes *
381590Srgrimes * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
391590Srgrimes * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
401590Srgrimes * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
411590Srgrimes * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
421590Srgrimes * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
431590Srgrimes * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
441590Srgrimes * THE SOFTWARE.
451590Srgrimes */
461590Srgrimes/* Generated By:JavaCC: Do not edit this line. CompactSyntaxTokenManager.java */
471590Srgrimespackage com.sun.xml.internal.rngom.parse.compact;
48141104Shartiimport java.io.Reader;
49141104Shartiimport java.net.MalformedURLException;
50141104Shartiimport java.net.URL;
511590Srgrimesimport java.util.Arrays;
52141104Shartiimport java.util.ArrayList;
53141104Shartiimport java.util.Collections;
54141104Shartiimport java.util.Enumeration;
55141104Shartiimport java.util.Hashtable;
56141104Shartiimport java.util.List;
57177545Sruimport com.sun.xml.internal.rngom.ast.builder.Annotations;
58141104Shartiimport com.sun.xml.internal.rngom.ast.builder.BuildException;
59141104Shartiimport com.sun.xml.internal.rngom.ast.builder.CommentList;
60141104Shartiimport com.sun.xml.internal.rngom.ast.builder.DataPatternBuilder;
611590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.Div;
621590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.ElementAnnotationBuilder;
631590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.Grammar;
641590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.GrammarSection;
651590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.Include;
661590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.IncludedGrammar;
671590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.NameClassBuilder;
681590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.SchemaBuilder;
691590Srgrimesimport com.sun.xml.internal.rngom.ast.builder.Scope;
701590Srgrimesimport com.sun.xml.internal.rngom.ast.om.Location;
718874Srgrimesimport com.sun.xml.internal.rngom.ast.om.ParsedElementAnnotation;
721590Srgrimesimport com.sun.xml.internal.rngom.ast.om.ParsedNameClass;
731590Srgrimesimport com.sun.xml.internal.rngom.ast.om.ParsedPattern;
741590Srgrimesimport com.sun.xml.internal.rngom.parse.Context;
75142298Shartiimport com.sun.xml.internal.rngom.parse.IllegalSchemaException;
76142298Shartiimport com.sun.xml.internal.rngom.parse.Parseable;
77142298Shartiimport org.xml.sax.ErrorHandler;
78142298Shartiimport org.xml.sax.SAXException;
791590Srgrimesimport org.xml.sax.SAXParseException;
80144894Shartiimport org.xml.sax.helpers.LocatorImpl;
81144894Shartiimport com.sun.xml.internal.rngom.util.Localizer;
821590Srgrimesimport com.sun.xml.internal.rngom.xml.util.WellKnownNamespaces;
831590Srgrimes
841590Srgrimes/** Token Manager. */
85144894Shartipublic class CompactSyntaxTokenManager implements CompactSyntaxConstants
861590Srgrimes{
871590Srgrimes
88144894Sharti  /** Debug output. */
89144894Sharti  public  java.io.PrintStream debugStream = System.out;
901590Srgrimes  /** Set debug output. */
91144894Sharti  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
92144894Shartiprivate final int jjStopStringLiteralDfa_0(int pos, long active0)
931590Srgrimes{
94142298Sharti   switch (pos)
95144894Sharti   {
96142298Sharti      case 0:
97144894Sharti         if ((active0 & 0x1f8c0fe4e0L) != 0L)
98144894Sharti         {
99177545Sru            jjmatchedKind = 54;
100177545Sru            return 43;
1011590Srgrimes         }
102142298Sharti         if ((active0 & 0x800000000000000L) != 0L)
1031590Srgrimes         {
104144894Sharti            jjmatchedKind = 60;
105144894Sharti            return -1;
106144894Sharti         }
107144894Sharti         return -1;
108144894Sharti      case 1:
1091590Srgrimes         if ((active0 & 0x1f8c0fe4e0L) != 0L)
110144894Sharti         {
111144894Sharti            jjmatchedKind = 54;
112144894Sharti            jjmatchedPos = 1;
113144894Sharti            return 43;
114144894Sharti         }
1151590Srgrimes         if ((active0 & 0x800000000000000L) != 0L)
116144894Sharti         {
117144894Sharti            if (jjmatchedPos == 0)
118144894Sharti            {
1198874Srgrimes               jjmatchedKind = 60;
120144894Sharti               jjmatchedPos = 0;
121144894Sharti            }
122144894Sharti            return -1;
123144894Sharti         }
124144894Sharti         return -1;
125144894Sharti      case 2:
1268874Srgrimes         if ((active0 & 0x1f8c0fe4a0L) != 0L)
127144894Sharti         {
128144894Sharti            jjmatchedKind = 54;
129144894Sharti            jjmatchedPos = 2;
130144894Sharti            return 43;
131144894Sharti         }
1321590Srgrimes         if ((active0 & 0x40L) != 0L)
133144894Sharti            return 43;
134144894Sharti         return -1;
135144894Sharti      case 3:
136144894Sharti         if ((active0 & 0x1f0c0be4a0L) != 0L)
137144894Sharti         {
138144894Sharti            jjmatchedKind = 54;
139144894Sharti            jjmatchedPos = 3;
140144894Sharti            return 43;
141144894Sharti         }
142144894Sharti         if ((active0 & 0x80040000L) != 0L)
1431590Srgrimes            return 43;
144144894Sharti         return -1;
145144894Sharti      case 4:
146144894Sharti         if ((active0 & 0xe0c09e480L) != 0L)
147144894Sharti         {
148144894Sharti            jjmatchedKind = 54;
1491590Srgrimes            jjmatchedPos = 4;
150144894Sharti            return 43;
151144894Sharti         }
152144894Sharti         if ((active0 & 0x1100020020L) != 0L)
153146027Sharti            return 43;
154177545Sru         return -1;
155144894Sharti      case 5:
156177545Sru         if ((active0 & 0x20c09e480L) != 0L)
157177545Sru         {
158177545Sru            jjmatchedKind = 54;
159144894Sharti            jjmatchedPos = 5;
160177545Sru            return 43;
161144894Sharti         }
162144894Sharti         if ((active0 & 0xc00000000L) != 0L)
1638874Srgrimes            return 43;
164144894Sharti         return -1;
165144894Sharti      case 6:
166144894Sharti         if ((active0 & 0x208092000L) != 0L)
167144894Sharti         {
168144894Sharti            jjmatchedKind = 54;
169144894Sharti            jjmatchedPos = 6;
170144894Sharti            return 43;
171144894Sharti         }
172144894Sharti         if ((active0 & 0x400c480L) != 0L)
173144894Sharti            return 43;
174144894Sharti         return -1;
175144894Sharti      case 7:
176144894Sharti         if ((active0 & 0x8092000L) != 0L)
177144894Sharti         {
178144894Sharti            jjmatchedKind = 54;
179144894Sharti            jjmatchedPos = 7;
180144894Sharti            return 43;
181142298Sharti         }
182142298Sharti         if ((active0 & 0x200000000L) != 0L)
183142298Sharti            return 43;
184142298Sharti         return -1;
185142298Sharti      case 8:
186144894Sharti         if ((active0 & 0x80000L) != 0L)
187142298Sharti         {
1881590Srgrimes            jjmatchedKind = 54;
189144894Sharti            jjmatchedPos = 8;
190142298Sharti            return 43;
191144894Sharti         }
192142298Sharti         if ((active0 & 0x8012000L) != 0L)
193144894Sharti            return 43;
194144894Sharti         return -1;
195144894Sharti      default :
196142298Sharti         return -1;
197144894Sharti   }
1981590Srgrimes}
199142298Shartiprivate final int jjStartNfa_0(int pos, long active0)
200144894Sharti{
201142298Sharti   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
202142298Sharti}
203142298Shartiprivate int jjStopAtPos(int pos, int kind)
2041590Srgrimes{
205142298Sharti   jjmatchedKind = kind;
206142298Sharti   jjmatchedPos = pos;
207142298Sharti   return pos + 1;
208142298Sharti}
209142298Shartiprivate int jjMoveStringLiteralDfa0_0()
210142298Sharti{
211142298Sharti   switch(curChar)
212144894Sharti   {
2131590Srgrimes      case 38:
2141590Srgrimes         jjmatchedKind = 21;
215144894Sharti         return jjMoveStringLiteralDfa1_0(0x8L);
2161590Srgrimes      case 40:
2171590Srgrimes         return jjStopAtPos(0, 28);
2181590Srgrimes      case 41:
2191590Srgrimes         return jjStopAtPos(0, 29);
2201590Srgrimes      case 42:
221228992Suqs         return jjStopAtPos(0, 25);
2221590Srgrimes      case 43:
2231590Srgrimes         return jjStopAtPos(0, 23);
2241590Srgrimes      case 44:
2251590Srgrimes         return jjStopAtPos(0, 22);
2261590Srgrimes      case 45:
227142299Sharti         return jjStopAtPos(0, 30);
2281590Srgrimes      case 61:
2291590Srgrimes         return jjStopAtPos(0, 2);
2301590Srgrimes      case 62:
2311590Srgrimes         return jjMoveStringLiteralDfa1_0(0x800000000000000L);
232126824Sru      case 63:
2331590Srgrimes         return jjStopAtPos(0, 24);
234142299Sharti      case 91:
235142299Sharti         return jjStopAtPos(0, 1);
236142299Sharti      case 93:
237142299Sharti         return jjStopAtPos(0, 9);
238142299Sharti      case 97:
239142457Sharti         return jjMoveStringLiteralDfa1_0(0x8000000L);
2401590Srgrimes      case 100:
241142298Sharti         return jjMoveStringLiteralDfa1_0(0x14040L);
242142298Sharti      case 101:
243138916Sharti         return jjMoveStringLiteralDfa1_0(0x204020000L);
244142299Sharti      case 103:
245142299Sharti         return jjMoveStringLiteralDfa1_0(0x400L);
246142299Sharti      case 105:
247142299Sharti         return jjMoveStringLiteralDfa1_0(0x8080L);
248142299Sharti      case 108:
249138916Sharti         return jjMoveStringLiteralDfa1_0(0x80000000L);
250142298Sharti      case 109:
251142298Sharti         return jjMoveStringLiteralDfa1_0(0x100000000L);
2521590Srgrimes      case 110:
253142299Sharti         return jjMoveStringLiteralDfa1_0(0x82000L);
254142299Sharti      case 112:
255186558Sobrien         return jjMoveStringLiteralDfa1_0(0x400000000L);
2561590Srgrimes      case 115:
257142299Sharti         return jjMoveStringLiteralDfa1_0(0x800000020L);
258146048Sharti      case 116:
259142299Sharti         return jjMoveStringLiteralDfa1_0(0x1000040000L);
260142457Sharti      case 123:
261142299Sharti         return jjStopAtPos(0, 11);
262142299Sharti      case 124:
263142299Sharti         jjmatchedKind = 20;
264142299Sharti         return jjMoveStringLiteralDfa1_0(0x10L);
265142299Sharti      case 125:
266142299Sharti         return jjStopAtPos(0, 12);
2671590Srgrimes      case 126:
268         return jjStopAtPos(0, 8);
269      default :
270         return jjMoveNfa_0(3, 0);
271   }
272}
273private int jjMoveStringLiteralDfa1_0(long active0)
274{
275   try { curChar = input_stream.readChar(); }
276   catch(java.io.IOException e) {
277      jjStopStringLiteralDfa_0(0, active0);
278      return 1;
279   }
280   switch(curChar)
281   {
282      case 61:
283         if ((active0 & 0x8L) != 0L)
284            return jjStopAtPos(1, 3);
285         else if ((active0 & 0x10L) != 0L)
286            return jjStopAtPos(1, 4);
287         break;
288      case 62:
289         if ((active0 & 0x800000000000000L) != 0L)
290            return jjStopAtPos(1, 59);
291         break;
292      case 97:
293         return jjMoveStringLiteralDfa2_0(active0, 0x400012000L);
294      case 101:
295         return jjMoveStringLiteralDfa2_0(active0, 0x44000L);
296      case 105:
297         return jjMoveStringLiteralDfa2_0(active0, 0x180000040L);
298      case 108:
299         return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
300      case 109:
301         return jjMoveStringLiteralDfa2_0(active0, 0x20000L);
302      case 110:
303         return jjMoveStringLiteralDfa2_0(active0, 0x8080L);
304      case 111:
305         return jjMoveStringLiteralDfa2_0(active0, 0x1000080000L);
306      case 114:
307         return jjMoveStringLiteralDfa2_0(active0, 0x400L);
308      case 116:
309         return jjMoveStringLiteralDfa2_0(active0, 0x808000020L);
310      case 120:
311         return jjMoveStringLiteralDfa2_0(active0, 0x200000000L);
312      default :
313         break;
314   }
315   return jjStartNfa_0(0, active0);
316}
317private int jjMoveStringLiteralDfa2_0(long old0, long active0)
318{
319   if (((active0 &= old0)) == 0L)
320      return jjStartNfa_0(0, old0);
321   try { curChar = input_stream.readChar(); }
322   catch(java.io.IOException e) {
323      jjStopStringLiteralDfa_0(1, active0);
324      return 2;
325   }
326   switch(curChar)
327   {
328      case 97:
329         return jjMoveStringLiteralDfa3_0(active0, 0x420L);
330      case 99:
331         return jjMoveStringLiteralDfa3_0(active0, 0x80L);
332      case 101:
333         return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
334      case 102:
335         return jjMoveStringLiteralDfa3_0(active0, 0x4000L);
336      case 104:
337         return jjMoveStringLiteralDfa3_0(active0, 0x8000L);
338      case 107:
339         return jjMoveStringLiteralDfa3_0(active0, 0x1000000000L);
340      case 109:
341         return jjMoveStringLiteralDfa3_0(active0, 0x2000L);
342      case 112:
343         return jjMoveStringLiteralDfa3_0(active0, 0x20000L);
344      case 114:
345         return jjMoveStringLiteralDfa3_0(active0, 0xc00000000L);
346      case 115:
347         return jjMoveStringLiteralDfa3_0(active0, 0x80000000L);
348      case 116:
349         return jjMoveStringLiteralDfa3_0(active0, 0x208090000L);
350      case 118:
351         if ((active0 & 0x40L) != 0L)
352            return jjStartNfaWithStates_0(2, 6, 43);
353         break;
354      case 120:
355         return jjMoveStringLiteralDfa3_0(active0, 0x100040000L);
356      default :
357         break;
358   }
359   return jjStartNfa_0(1, active0);
360}
361private int jjMoveStringLiteralDfa3_0(long old0, long active0)
362{
363   if (((active0 &= old0)) == 0L)
364      return jjStartNfa_0(1, old0);
365   try { curChar = input_stream.readChar(); }
366   catch(java.io.IOException e) {
367      jjStopStringLiteralDfa_0(2, active0);
368      return 3;
369   }
370   switch(curChar)
371   {
372      case 65:
373         return jjMoveStringLiteralDfa4_0(active0, 0x80000L);
374      case 97:
375         return jjMoveStringLiteralDfa4_0(active0, 0x14000L);
376      case 101:
377         return jjMoveStringLiteralDfa4_0(active0, 0x170000a000L);
378      case 105:
379         return jjMoveStringLiteralDfa4_0(active0, 0x800000000L);
380      case 108:
381         return jjMoveStringLiteralDfa4_0(active0, 0x80L);
382      case 109:
383         return jjMoveStringLiteralDfa4_0(active0, 0x4000400L);
384      case 114:
385         return jjMoveStringLiteralDfa4_0(active0, 0x8000020L);
386      case 116:
387         if ((active0 & 0x40000L) != 0L)
388            return jjStartNfaWithStates_0(3, 18, 43);
389         else if ((active0 & 0x80000000L) != 0L)
390            return jjStartNfaWithStates_0(3, 31, 43);
391         return jjMoveStringLiteralDfa4_0(active0, 0x20000L);
392      default :
393         break;
394   }
395   return jjStartNfa_0(2, active0);
396}
397private int jjMoveStringLiteralDfa4_0(long old0, long active0)
398{
399   if (((active0 &= old0)) == 0L)
400      return jjStartNfa_0(2, old0);
401   try { curChar = input_stream.readChar(); }
402   catch(java.io.IOException e) {
403      jjStopStringLiteralDfa_0(3, active0);
404      return 4;
405   }
406   switch(curChar)
407   {
408      case 100:
409         if ((active0 & 0x100000000L) != 0L)
410            return jjStartNfaWithStates_0(4, 32, 43);
411         break;
412      case 101:
413         return jjMoveStringLiteralDfa5_0(active0, 0x4000000L);
414      case 105:
415         return jjMoveStringLiteralDfa5_0(active0, 0x8000000L);
416      case 108:
417         return jjMoveStringLiteralDfa5_0(active0, 0x80000L);
418      case 109:
419         return jjMoveStringLiteralDfa5_0(active0, 0x400L);
420      case 110:
421         if ((active0 & 0x1000000000L) != 0L)
422            return jjStartNfaWithStates_0(4, 36, 43);
423         return jjMoveStringLiteralDfa5_0(active0, 0xc00000000L);
424      case 114:
425         return jjMoveStringLiteralDfa5_0(active0, 0x200008000L);
426      case 115:
427         return jjMoveStringLiteralDfa5_0(active0, 0x2000L);
428      case 116:
429         if ((active0 & 0x20L) != 0L)
430            return jjStartNfaWithStates_0(4, 5, 43);
431         return jjMoveStringLiteralDfa5_0(active0, 0x10000L);
432      case 117:
433         return jjMoveStringLiteralDfa5_0(active0, 0x4080L);
434      case 121:
435         if ((active0 & 0x20000L) != 0L)
436            return jjStartNfaWithStates_0(4, 17, 43);
437         break;
438      default :
439         break;
440   }
441   return jjStartNfa_0(3, active0);
442}
443private int jjMoveStringLiteralDfa5_0(long old0, long active0)
444{
445   if (((active0 &= old0)) == 0L)
446      return jjStartNfa_0(3, old0);
447   try { curChar = input_stream.readChar(); }
448   catch(java.io.IOException e) {
449      jjStopStringLiteralDfa_0(4, active0);
450      return 5;
451   }
452   switch(curChar)
453   {
454      case 97:
455         return jjMoveStringLiteralDfa6_0(active0, 0x400L);
456      case 98:
457         return jjMoveStringLiteralDfa6_0(active0, 0x8000000L);
458      case 100:
459         return jjMoveStringLiteralDfa6_0(active0, 0x80L);
460      case 103:
461         if ((active0 & 0x800000000L) != 0L)
462            return jjStartNfaWithStates_0(5, 35, 43);
463         break;
464      case 105:
465         return jjMoveStringLiteralDfa6_0(active0, 0x8000L);
466      case 108:
467         return jjMoveStringLiteralDfa6_0(active0, 0x84000L);
468      case 110:
469         return jjMoveStringLiteralDfa6_0(active0, 0x204000000L);
470      case 112:
471         return jjMoveStringLiteralDfa6_0(active0, 0x2000L);
472      case 116:
473         if ((active0 & 0x400000000L) != 0L)
474            return jjStartNfaWithStates_0(5, 34, 43);
475         break;
476      case 121:
477         return jjMoveStringLiteralDfa6_0(active0, 0x10000L);
478      default :
479         break;
480   }
481   return jjStartNfa_0(4, active0);
482}
483private int jjMoveStringLiteralDfa6_0(long old0, long active0)
484{
485   if (((active0 &= old0)) == 0L)
486      return jjStartNfa_0(4, old0);
487   try { curChar = input_stream.readChar(); }
488   catch(java.io.IOException e) {
489      jjStopStringLiteralDfa_0(5, active0);
490      return 6;
491   }
492   switch(curChar)
493   {
494      case 97:
495         return jjMoveStringLiteralDfa7_0(active0, 0x200002000L);
496      case 101:
497         if ((active0 & 0x80L) != 0L)
498            return jjStartNfaWithStates_0(6, 7, 43);
499         break;
500      case 111:
501         return jjMoveStringLiteralDfa7_0(active0, 0x80000L);
502      case 112:
503         return jjMoveStringLiteralDfa7_0(active0, 0x10000L);
504      case 114:
505         if ((active0 & 0x400L) != 0L)
506            return jjStartNfaWithStates_0(6, 10, 43);
507         break;
508      case 116:
509         if ((active0 & 0x4000L) != 0L)
510            return jjStartNfaWithStates_0(6, 14, 43);
511         else if ((active0 & 0x8000L) != 0L)
512            return jjStartNfaWithStates_0(6, 15, 43);
513         else if ((active0 & 0x4000000L) != 0L)
514            return jjStartNfaWithStates_0(6, 26, 43);
515         break;
516      case 117:
517         return jjMoveStringLiteralDfa7_0(active0, 0x8000000L);
518      default :
519         break;
520   }
521   return jjStartNfa_0(5, active0);
522}
523private int jjMoveStringLiteralDfa7_0(long old0, long active0)
524{
525   if (((active0 &= old0)) == 0L)
526      return jjStartNfa_0(5, old0);
527   try { curChar = input_stream.readChar(); }
528   catch(java.io.IOException e) {
529      jjStopStringLiteralDfa_0(6, active0);
530      return 7;
531   }
532   switch(curChar)
533   {
534      case 99:
535         return jjMoveStringLiteralDfa8_0(active0, 0x2000L);
536      case 101:
537         return jjMoveStringLiteralDfa8_0(active0, 0x10000L);
538      case 108:
539         if ((active0 & 0x200000000L) != 0L)
540            return jjStartNfaWithStates_0(7, 33, 43);
541         break;
542      case 116:
543         return jjMoveStringLiteralDfa8_0(active0, 0x8000000L);
544      case 119:
545         return jjMoveStringLiteralDfa8_0(active0, 0x80000L);
546      default :
547         break;
548   }
549   return jjStartNfa_0(6, active0);
550}
551private int jjMoveStringLiteralDfa8_0(long old0, long active0)
552{
553   if (((active0 &= old0)) == 0L)
554      return jjStartNfa_0(6, old0);
555   try { curChar = input_stream.readChar(); }
556   catch(java.io.IOException e) {
557      jjStopStringLiteralDfa_0(7, active0);
558      return 8;
559   }
560   switch(curChar)
561   {
562      case 101:
563         if ((active0 & 0x2000L) != 0L)
564            return jjStartNfaWithStates_0(8, 13, 43);
565         else if ((active0 & 0x8000000L) != 0L)
566            return jjStartNfaWithStates_0(8, 27, 43);
567         return jjMoveStringLiteralDfa9_0(active0, 0x80000L);
568      case 115:
569         if ((active0 & 0x10000L) != 0L)
570            return jjStartNfaWithStates_0(8, 16, 43);
571         break;
572      default :
573         break;
574   }
575   return jjStartNfa_0(7, active0);
576}
577private int jjMoveStringLiteralDfa9_0(long old0, long active0)
578{
579   if (((active0 &= old0)) == 0L)
580      return jjStartNfa_0(7, old0);
581   try { curChar = input_stream.readChar(); }
582   catch(java.io.IOException e) {
583      jjStopStringLiteralDfa_0(8, active0);
584      return 9;
585   }
586   switch(curChar)
587   {
588      case 100:
589         if ((active0 & 0x80000L) != 0L)
590            return jjStartNfaWithStates_0(9, 19, 43);
591         break;
592      default :
593         break;
594   }
595   return jjStartNfa_0(8, active0);
596}
597private int jjStartNfaWithStates_0(int pos, int kind, int state)
598{
599   jjmatchedKind = kind;
600   jjmatchedPos = pos;
601   try { curChar = input_stream.readChar(); }
602   catch(java.io.IOException e) { return pos + 1; }
603   return jjMoveNfa_0(state, pos + 1);
604}
605static final long[] jjbitVec0 = {
606   0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
607};
608static final long[] jjbitVec2 = {
609   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
610};
611static final long[] jjbitVec3 = {
612   0x0L, 0xffffffffffffc000L, 0xfffff0007fffffffL, 0x7fffffL
613};
614static final long[] jjbitVec4 = {
615   0x0L, 0x0L, 0x0L, 0xff7fffffff7fffffL
616};
617static final long[] jjbitVec5 = {
618   0x7ff3ffffffffffffL, 0x7ffffffffffffdfeL, 0xffffffffffffffffL, 0xfc31ffffffffe00fL
619};
620static final long[] jjbitVec6 = {
621   0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x3L
622};
623static final long[] jjbitVec7 = {
624   0x0L, 0x0L, 0xfffffffbffffd740L, 0xffffd547f7fffL
625};
626static final long[] jjbitVec8 = {
627   0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff0003L, 0x33fcfffffff199fL
628};
629static final long[] jjbitVec9 = {
630   0xfffe000000000000L, 0xfffffffe027fffffL, 0x7fL, 0x707ffffff0000L
631};
632static final long[] jjbitVec10 = {
633   0x7fffffe00000000L, 0xfffe0000000007feL, 0x7cffffffffffffffL, 0x60002f7fffL
634};
635static final long[] jjbitVec11 = {
636   0x23ffffffffffffe0L, 0x3ff000000L, 0x3c5fdfffff99fe0L, 0x30003b0000000L
637};
638static final long[] jjbitVec12 = {
639   0x36dfdfffff987e0L, 0x1c00005e000000L, 0x23edfdfffffbafe0L, 0x100000000L
640};
641static final long[] jjbitVec13 = {
642   0x23cdfdfffff99fe0L, 0x3b0000000L, 0x3bfc718d63dc7e0L, 0x0L
643};
644static final long[] jjbitVec14 = {
645   0x3effdfffffddfe0L, 0x300000000L, 0x3effdfffffddfe0L, 0x340000000L
646};
647static final long[] jjbitVec15 = {
648   0x3fffdfffffddfe0L, 0x300000000L, 0x0L, 0x0L
649};
650static final long[] jjbitVec16 = {
651   0xd7ffffffffffeL, 0x3fL, 0x200d6caefef02596L, 0x1fL
652};
653static final long[] jjbitVec17 = {
654   0x0L, 0x3fffffffeffL, 0x0L, 0x0L
655};
656static final long[] jjbitVec18 = {
657   0x0L, 0x0L, 0xffffffff00000000L, 0x7fffffffff003fL
658};
659static final long[] jjbitVec19 = {
660   0x500000000007daedL, 0x2c62ab82315001L, 0xf580c90040000000L, 0x201080000000007L
661};
662static final long[] jjbitVec20 = {
663   0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffff0fffffffL, 0x3ffffffffffffffL
664};
665static final long[] jjbitVec21 = {
666   0xffffffff3f3fffffL, 0x3fffffffaaff3f3fL, 0x5fdfffffffffffffL, 0x1fdc1fff0fcf1fdcL
667};
668static final long[] jjbitVec22 = {
669   0x4c4000000000L, 0x0L, 0x7L, 0x0L
670};
671static final long[] jjbitVec23 = {
672   0x3fe00000080L, 0xfffffffffffffffeL, 0xfffffffe001fffffL, 0x7ffffffffffffffL
673};
674static final long[] jjbitVec24 = {
675   0x1fffffffffe0L, 0x0L, 0x0L, 0x0L
676};
677static final long[] jjbitVec25 = {
678   0xffffffffffffffffL, 0xffffffffffffffffL, 0x3fffffffffL, 0x0L
679};
680static final long[] jjbitVec26 = {
681   0xffffffffffffffffL, 0xffffffffffffffffL, 0xfffffffffL, 0x0L
682};
683static final long[] jjbitVec27 = {
684   0x0L, 0x0L, 0x80000000000000L, 0xff7fffffff7fffffL
685};
686static final long[] jjbitVec28 = {
687   0xffffffL, 0xffffffffffff0000L, 0xf80001ffffffffffL, 0x30003L
688};
689static final long[] jjbitVec29 = {
690   0xffffffffffffffffL, 0x30000003fL, 0xfffffffbffffd7c0L, 0xffffd547f7fffL
691};
692static final long[] jjbitVec30 = {
693   0xffffffffffffdffeL, 0xffffffffdffeffffL, 0xffffffffffff007bL, 0x33fcfffffff199fL
694};
695static final long[] jjbitVec31 = {
696   0xfffe000000000000L, 0xfffffffe027fffffL, 0xbbfffffbfffe007fL, 0x707ffffff0016L
697};
698static final long[] jjbitVec32 = {
699   0x7fffffe00000000L, 0xffff03ff0007ffffL, 0x7cffffffffffffffL, 0x3ff3dffffef7fffL
700};
701static final long[] jjbitVec33 = {
702   0xf3ffffffffffffeeL, 0xffcfff1e3fffL, 0xd3c5fdfffff99feeL, 0x3ffcfb080399fL
703};
704static final long[] jjbitVec34 = {
705   0xd36dfdfffff987e4L, 0x1fffc05e003987L, 0xf3edfdfffffbafeeL, 0xffc100003bbfL
706};
707static final long[] jjbitVec35 = {
708   0xf3cdfdfffff99feeL, 0xffc3b0c0398fL, 0xc3bfc718d63dc7ecL, 0xff8000803dc7L
709};
710static final long[] jjbitVec36 = {
711   0xc3effdfffffddfeeL, 0xffc300603ddfL, 0xc3effdfffffddfecL, 0xffc340603ddfL
712};
713static final long[] jjbitVec37 = {
714   0xc3fffdfffffddfecL, 0xffc300803dcfL, 0x0L, 0x0L
715};
716static final long[] jjbitVec38 = {
717   0x7ff7ffffffffffeL, 0x3ff7fffL, 0x3bff6caefef02596L, 0x3ff3f5fL
718};
719static final long[] jjbitVec39 = {
720   0xc2a003ff03000000L, 0xfffe03fffffffeffL, 0x2fe3ffffebf0fdfL, 0x0L
721};
722static final long[] jjbitVec40 = {
723   0x0L, 0x0L, 0x0L, 0x21fff0000L
724};
725static final long[] jjbitVec41 = {
726   0x3efffe000000a0L, 0xfffffffffffffffeL, 0xfffffffe661fffffL, 0x77ffffffffffffffL
727};
728private int jjMoveNfa_0(int startState, int curPos)
729{
730   int startsAt = 0;
731   jjnewStateCnt = 43;
732   int i = 1;
733   jjstateSet[0] = startState;
734   int kind = 0x7fffffff;
735   for (;;)
736   {
737      if (++jjround == 0x7fffffff)
738         ReInitRounds();
739      if (curChar < 64)
740      {
741         long l = 1L << curChar;
742         do
743         {
744            switch(jjstateSet[--i])
745            {
746               case 3:
747                  if ((0xfffffffffffff9ffL & l) != 0L)
748                  {
749                     if (kind > 60)
750                        kind = 60;
751                  }
752                  if ((0x100000601L & l) != 0L)
753                  {
754                     if (kind > 39)
755                        kind = 39;
756                     jjCheckNAdd(0);
757                  }
758                  else if (curChar == 39)
759                     jjstateSet[jjnewStateCnt++] = 31;
760                  else if (curChar == 34)
761                     jjstateSet[jjnewStateCnt++] = 22;
762                  else if (curChar == 35)
763                  {
764                     if (kind > 42)
765                        kind = 42;
766                     jjCheckNAdd(5);
767                  }
768                  if (curChar == 39)
769                     jjCheckNAddTwoStates(13, 14);
770                  else if (curChar == 34)
771                     jjCheckNAddTwoStates(10, 11);
772                  else if (curChar == 35)
773                     jjstateSet[jjnewStateCnt++] = 1;
774                  break;
775               case 43:
776                  if ((0x3ff600000000000L & l) != 0L)
777                     jjCheckNAddTwoStates(39, 40);
778                  else if (curChar == 58)
779                     jjstateSet[jjnewStateCnt++] = 41;
780                  if ((0x3ff600000000000L & l) != 0L)
781                     jjCheckNAddTwoStates(36, 38);
782                  else if (curChar == 58)
783                     jjstateSet[jjnewStateCnt++] = 37;
784                  if ((0x3ff600000000000L & l) != 0L)
785                  {
786                     if (kind > 54)
787                        kind = 54;
788                     jjCheckNAdd(35);
789                  }
790                  break;
791               case 0:
792                  if ((0x100000601L & l) == 0L)
793                     break;
794                  if (kind > 39)
795                     kind = 39;
796                  jjCheckNAdd(0);
797                  break;
798               case 1:
799                  if (curChar != 35)
800                     break;
801                  if (kind > 40)
802                     kind = 40;
803                  jjCheckNAdd(2);
804                  break;
805               case 2:
806                  if ((0xfffffffffffffbfeL & l) == 0L)
807                     break;
808                  if (kind > 40)
809                     kind = 40;
810                  jjCheckNAdd(2);
811                  break;
812               case 4:
813                  if (curChar != 35)
814                     break;
815                  if (kind > 42)
816                     kind = 42;
817                  jjCheckNAdd(5);
818                  break;
819               case 5:
820                  if ((0xfffffffffffffbfeL & l) == 0L)
821                     break;
822                  if (kind > 42)
823                     kind = 42;
824                  jjCheckNAdd(5);
825                  break;
826               case 8:
827                  if ((0x3ff600000000000L & l) == 0L)
828                     break;
829                  if (kind > 55)
830                     kind = 55;
831                  jjstateSet[jjnewStateCnt++] = 8;
832                  break;
833               case 9:
834                  if (curChar == 34)
835                     jjCheckNAddTwoStates(10, 11);
836                  break;
837               case 10:
838                  if ((0xfffffffbfffffffeL & l) != 0L)
839                     jjCheckNAddTwoStates(10, 11);
840                  break;
841               case 11:
842               case 20:
843                  if (curChar == 34 && kind > 58)
844                     kind = 58;
845                  break;
846               case 12:
847                  if (curChar == 39)
848                     jjCheckNAddTwoStates(13, 14);
849                  break;
850               case 13:
851                  if ((0xffffff7ffffffffeL & l) != 0L)
852                     jjCheckNAddTwoStates(13, 14);
853                  break;
854               case 14:
855               case 29:
856                  if (curChar == 39 && kind > 58)
857                     kind = 58;
858                  break;
859               case 15:
860                  if (curChar == 34)
861                     jjCheckNAddStates(0, 2);
862                  break;
863               case 16:
864                  if ((0xfffffffbffffffffL & l) != 0L)
865                     jjCheckNAddStates(0, 2);
866                  break;
867               case 17:
868               case 19:
869                  if (curChar == 34)
870                     jjCheckNAdd(16);
871                  break;
872               case 18:
873                  if (curChar == 34)
874                     jjAddStates(3, 4);
875                  break;
876               case 21:
877                  if (curChar == 34)
878                     jjstateSet[jjnewStateCnt++] = 20;
879                  break;
880               case 22:
881                  if (curChar == 34)
882                     jjstateSet[jjnewStateCnt++] = 15;
883                  break;
884               case 23:
885                  if (curChar == 34)
886                     jjstateSet[jjnewStateCnt++] = 22;
887                  break;
888               case 24:
889                  if (curChar == 39)
890                     jjCheckNAddStates(5, 7);
891                  break;
892               case 25:
893                  if ((0xffffff7fffffffffL & l) != 0L)
894                     jjCheckNAddStates(5, 7);
895                  break;
896               case 26:
897               case 28:
898                  if (curChar == 39)
899                     jjCheckNAdd(25);
900                  break;
901               case 27:
902                  if (curChar == 39)
903                     jjAddStates(8, 9);
904                  break;
905               case 30:
906                  if (curChar == 39)
907                     jjstateSet[jjnewStateCnt++] = 29;
908                  break;
909               case 31:
910                  if (curChar == 39)
911                     jjstateSet[jjnewStateCnt++] = 24;
912                  break;
913               case 32:
914                  if (curChar == 39)
915                     jjstateSet[jjnewStateCnt++] = 31;
916                  break;
917               case 33:
918                  if ((0xfffffffffffff9ffL & l) != 0L && kind > 60)
919                     kind = 60;
920                  break;
921               case 35:
922                  if ((0x3ff600000000000L & l) == 0L)
923                     break;
924                  if (kind > 54)
925                     kind = 54;
926                  jjCheckNAdd(35);
927                  break;
928               case 36:
929                  if ((0x3ff600000000000L & l) != 0L)
930                     jjCheckNAddTwoStates(36, 38);
931                  break;
932               case 37:
933                  if (curChar == 42 && kind > 56)
934                     kind = 56;
935                  break;
936               case 38:
937                  if (curChar == 58)
938                     jjstateSet[jjnewStateCnt++] = 37;
939                  break;
940               case 39:
941                  if ((0x3ff600000000000L & l) != 0L)
942                     jjCheckNAddTwoStates(39, 40);
943                  break;
944               case 40:
945                  if (curChar == 58)
946                     jjstateSet[jjnewStateCnt++] = 41;
947                  break;
948               case 42:
949                  if ((0x3ff600000000000L & l) == 0L)
950                     break;
951                  if (kind > 57)
952                     kind = 57;
953                  jjstateSet[jjnewStateCnt++] = 42;
954                  break;
955               default : break;
956            }
957         } while(i != startsAt);
958      }
959      else if (curChar < 128)
960      {
961         long l = 1L << (curChar & 077);
962         do
963         {
964            switch(jjstateSet[--i])
965            {
966               case 3:
967                  if (kind > 60)
968                     kind = 60;
969                  if ((0x7fffffe87fffffeL & l) != 0L)
970                  {
971                     if (kind > 54)
972                        kind = 54;
973                     jjCheckNAddStates(10, 14);
974                  }
975                  else if (curChar == 92)
976                     jjstateSet[jjnewStateCnt++] = 7;
977                  break;
978               case 43:
979                  if ((0x7fffffe87fffffeL & l) != 0L)
980                     jjCheckNAddTwoStates(39, 40);
981                  if ((0x7fffffe87fffffeL & l) != 0L)
982                     jjCheckNAddTwoStates(36, 38);
983                  if ((0x7fffffe87fffffeL & l) != 0L)
984                  {
985                     if (kind > 54)
986                        kind = 54;
987                     jjCheckNAdd(35);
988                  }
989                  break;
990               case 2:
991                  if (kind > 40)
992                     kind = 40;
993                  jjstateSet[jjnewStateCnt++] = 2;
994                  break;
995               case 5:
996                  if (kind > 42)
997                     kind = 42;
998                  jjstateSet[jjnewStateCnt++] = 5;
999                  break;
1000               case 6:
1001                  if (curChar == 92)
1002                     jjstateSet[jjnewStateCnt++] = 7;
1003                  break;
1004               case 7:
1005               case 8:
1006                  if ((0x7fffffe87fffffeL & l) == 0L)
1007                     break;
1008                  if (kind > 55)
1009                     kind = 55;
1010                  jjCheckNAdd(8);
1011                  break;
1012               case 10:
1013                  jjAddStates(15, 16);
1014                  break;
1015               case 13:
1016                  jjAddStates(17, 18);
1017                  break;
1018               case 16:
1019                  jjAddStates(0, 2);
1020                  break;
1021               case 25:
1022                  jjAddStates(5, 7);
1023                  break;
1024               case 33:
1025                  if (kind > 60)
1026                     kind = 60;
1027                  break;
1028               case 34:
1029                  if ((0x7fffffe87fffffeL & l) == 0L)
1030                     break;
1031                  if (kind > 54)
1032                     kind = 54;
1033                  jjCheckNAddStates(10, 14);
1034                  break;
1035               case 35:
1036                  if ((0x7fffffe87fffffeL & l) == 0L)
1037                     break;
1038                  if (kind > 54)
1039                     kind = 54;
1040                  jjCheckNAdd(35);
1041                  break;
1042               case 36:
1043                  if ((0x7fffffe87fffffeL & l) != 0L)
1044                     jjCheckNAddTwoStates(36, 38);
1045                  break;
1046               case 39:
1047                  if ((0x7fffffe87fffffeL & l) != 0L)
1048                     jjCheckNAddTwoStates(39, 40);
1049                  break;
1050               case 41:
1051               case 42:
1052                  if ((0x7fffffe87fffffeL & l) == 0L)
1053                     break;
1054                  if (kind > 57)
1055                     kind = 57;
1056                  jjCheckNAdd(42);
1057                  break;
1058               default : break;
1059            }
1060         } while(i != startsAt);
1061      }
1062      else
1063      {
1064         int hiByte = (int)(curChar >> 8);
1065         int i1 = hiByte >> 6;
1066         long l1 = 1L << (hiByte & 077);
1067         int i2 = (curChar & 0xff) >> 6;
1068         long l2 = 1L << (curChar & 077);
1069         do
1070         {
1071            switch(jjstateSet[--i])
1072            {
1073               case 3:
1074                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1075                  {
1076                     if (kind > 60)
1077                        kind = 60;
1078                  }
1079                  if (jjCanMove_1(hiByte, i1, i2, l1, l2))
1080                  {
1081                     if (kind > 54)
1082                        kind = 54;
1083                     jjCheckNAddStates(10, 14);
1084                  }
1085                  break;
1086               case 43:
1087                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1088                  {
1089                     if (kind > 54)
1090                        kind = 54;
1091                     jjCheckNAdd(35);
1092                  }
1093                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1094                     jjCheckNAddTwoStates(36, 38);
1095                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1096                     jjCheckNAddTwoStates(39, 40);
1097                  break;
1098               case 2:
1099                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1100                     break;
1101                  if (kind > 40)
1102                     kind = 40;
1103                  jjstateSet[jjnewStateCnt++] = 2;
1104                  break;
1105               case 5:
1106                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1107                     break;
1108                  if (kind > 42)
1109                     kind = 42;
1110                  jjstateSet[jjnewStateCnt++] = 5;
1111                  break;
1112               case 7:
1113                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1114                     break;
1115                  if (kind > 55)
1116                     kind = 55;
1117                  jjCheckNAdd(8);
1118                  break;
1119               case 8:
1120                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1121                     break;
1122                  if (kind > 55)
1123                     kind = 55;
1124                  jjCheckNAdd(8);
1125                  break;
1126               case 10:
1127                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1128                     jjAddStates(15, 16);
1129                  break;
1130               case 13:
1131                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1132                     jjAddStates(17, 18);
1133                  break;
1134               case 16:
1135                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1136                     jjAddStates(0, 2);
1137                  break;
1138               case 25:
1139                  if (jjCanMove_0(hiByte, i1, i2, l1, l2))
1140                     jjAddStates(5, 7);
1141                  break;
1142               case 33:
1143                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1144                     kind = 60;
1145                  break;
1146               case 34:
1147                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1148                     break;
1149                  if (kind > 54)
1150                     kind = 54;
1151                  jjCheckNAddStates(10, 14);
1152                  break;
1153               case 35:
1154                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1155                     break;
1156                  if (kind > 54)
1157                     kind = 54;
1158                  jjCheckNAdd(35);
1159                  break;
1160               case 36:
1161                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1162                     jjCheckNAddTwoStates(36, 38);
1163                  break;
1164               case 39:
1165                  if (jjCanMove_2(hiByte, i1, i2, l1, l2))
1166                     jjCheckNAddTwoStates(39, 40);
1167                  break;
1168               case 41:
1169                  if (!jjCanMove_1(hiByte, i1, i2, l1, l2))
1170                     break;
1171                  if (kind > 57)
1172                     kind = 57;
1173                  jjCheckNAdd(42);
1174                  break;
1175               case 42:
1176                  if (!jjCanMove_2(hiByte, i1, i2, l1, l2))
1177                     break;
1178                  if (kind > 57)
1179                     kind = 57;
1180                  jjCheckNAdd(42);
1181                  break;
1182               default : break;
1183            }
1184         } while(i != startsAt);
1185      }
1186      if (kind != 0x7fffffff)
1187      {
1188         jjmatchedKind = kind;
1189         jjmatchedPos = curPos;
1190         kind = 0x7fffffff;
1191      }
1192      ++curPos;
1193      if ((i = jjnewStateCnt) == (startsAt = 43 - (jjnewStateCnt = startsAt)))
1194         return curPos;
1195      try { curChar = input_stream.readChar(); }
1196      catch(java.io.IOException e) { return curPos; }
1197   }
1198}
1199private int jjMoveStringLiteralDfa0_1()
1200{
1201   return jjMoveNfa_1(1, 0);
1202}
1203private int jjMoveNfa_1(int startState, int curPos)
1204{
1205   int startsAt = 0;
1206   jjnewStateCnt = 10;
1207   int i = 1;
1208   jjstateSet[0] = startState;
1209   int kind = 0x7fffffff;
1210   for (;;)
1211   {
1212      if (++jjround == 0x7fffffff)
1213         ReInitRounds();
1214      if (curChar < 64)
1215      {
1216         long l = 1L << curChar;
1217         do
1218         {
1219            switch(jjstateSet[--i])
1220            {
1221               case 1:
1222                  if ((0xfffffffffffff9ffL & l) != 0L)
1223                  {
1224                     if (kind > 60)
1225                        kind = 60;
1226                  }
1227                  if ((0x100000601L & l) != 0L)
1228                  {
1229                     if (kind > 39)
1230                        kind = 39;
1231                     jjCheckNAdd(0);
1232                  }
1233                  if ((0x401L & l) != 0L)
1234                     jjCheckNAddStates(19, 22);
1235                  break;
1236               case 0:
1237                  if ((0x100000601L & l) == 0L)
1238                     break;
1239                  if (kind > 39)
1240                     kind = 39;
1241                  jjCheckNAdd(0);
1242                  break;
1243               case 2:
1244                  if ((0x401L & l) != 0L)
1245                     jjCheckNAddStates(19, 22);
1246                  break;
1247               case 3:
1248                  if ((0x100000200L & l) != 0L)
1249                     jjCheckNAddTwoStates(3, 6);
1250                  break;
1251               case 4:
1252                  if (curChar != 35)
1253                     break;
1254                  if (kind > 43)
1255                     kind = 43;
1256                  jjCheckNAdd(5);
1257                  break;
1258               case 5:
1259                  if ((0xfffffffffffffbfeL & l) == 0L)
1260                     break;
1261                  if (kind > 43)
1262                     kind = 43;
1263                  jjCheckNAdd(5);
1264                  break;
1265               case 6:
1266                  if (curChar == 35)
1267                     jjstateSet[jjnewStateCnt++] = 4;
1268                  break;
1269               case 7:
1270                  if ((0x100000200L & l) != 0L)
1271                     jjCheckNAddTwoStates(7, 8);
1272                  break;
1273               case 8:
1274                  if (curChar != 35)
1275                     break;
1276                  if (kind > 44)
1277                     kind = 44;
1278                  jjCheckNAdd(9);
1279                  break;
1280               case 9:
1281                  if ((0xfffffffffffffbfeL & l) == 0L)
1282                     break;
1283                  if (kind > 44)
1284                     kind = 44;
1285                  jjCheckNAdd(9);
1286                  break;
1287               default : break;
1288            }
1289         } while(i != startsAt);
1290      }
1291      else if (curChar < 128)
1292      {
1293         long l = 1L << (curChar & 077);
1294         do
1295         {
1296            switch(jjstateSet[--i])
1297            {
1298               case 1:
1299                  if (kind > 60)
1300                     kind = 60;
1301                  break;
1302               case 5:
1303                  if (kind > 43)
1304                     kind = 43;
1305                  jjstateSet[jjnewStateCnt++] = 5;
1306                  break;
1307               case 9:
1308                  if (kind > 44)
1309                     kind = 44;
1310                  jjstateSet[jjnewStateCnt++] = 9;
1311                  break;
1312               default : break;
1313            }
1314         } while(i != startsAt);
1315      }
1316      else
1317      {
1318         int hiByte = (int)(curChar >> 8);
1319         int i1 = hiByte >> 6;
1320         long l1 = 1L << (hiByte & 077);
1321         int i2 = (curChar & 0xff) >> 6;
1322         long l2 = 1L << (curChar & 077);
1323         do
1324         {
1325            switch(jjstateSet[--i])
1326            {
1327               case 1:
1328                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1329                     kind = 60;
1330                  break;
1331               case 5:
1332                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1333                     break;
1334                  if (kind > 43)
1335                     kind = 43;
1336                  jjstateSet[jjnewStateCnt++] = 5;
1337                  break;
1338               case 9:
1339                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1340                     break;
1341                  if (kind > 44)
1342                     kind = 44;
1343                  jjstateSet[jjnewStateCnt++] = 9;
1344                  break;
1345               default : break;
1346            }
1347         } while(i != startsAt);
1348      }
1349      if (kind != 0x7fffffff)
1350      {
1351         jjmatchedKind = kind;
1352         jjmatchedPos = curPos;
1353         kind = 0x7fffffff;
1354      }
1355      ++curPos;
1356      if ((i = jjnewStateCnt) == (startsAt = 10 - (jjnewStateCnt = startsAt)))
1357         return curPos;
1358      try { curChar = input_stream.readChar(); }
1359      catch(java.io.IOException e) { return curPos; }
1360   }
1361}
1362private int jjMoveStringLiteralDfa0_2()
1363{
1364   return jjMoveNfa_2(1, 0);
1365}
1366private int jjMoveNfa_2(int startState, int curPos)
1367{
1368   int startsAt = 0;
1369   jjnewStateCnt = 7;
1370   int i = 1;
1371   jjstateSet[0] = startState;
1372   int kind = 0x7fffffff;
1373   for (;;)
1374   {
1375      if (++jjround == 0x7fffffff)
1376         ReInitRounds();
1377      if (curChar < 64)
1378      {
1379         long l = 1L << curChar;
1380         do
1381         {
1382            switch(jjstateSet[--i])
1383            {
1384               case 1:
1385                  if ((0xfffffffffffff9ffL & l) != 0L)
1386                  {
1387                     if (kind > 60)
1388                        kind = 60;
1389                  }
1390                  if ((0x100000601L & l) != 0L)
1391                  {
1392                     if (kind > 39)
1393                        kind = 39;
1394                     jjCheckNAdd(0);
1395                  }
1396                  if ((0x401L & l) != 0L)
1397                     jjCheckNAddTwoStates(2, 5);
1398                  break;
1399               case 0:
1400                  if ((0x100000601L & l) == 0L)
1401                     break;
1402                  if (kind > 39)
1403                     kind = 39;
1404                  jjCheckNAdd(0);
1405                  break;
1406               case 2:
1407                  if ((0x100000200L & l) != 0L)
1408                     jjCheckNAddTwoStates(2, 5);
1409                  break;
1410               case 3:
1411                  if (curChar != 35)
1412                     break;
1413                  if (kind > 41)
1414                     kind = 41;
1415                  jjCheckNAdd(4);
1416                  break;
1417               case 4:
1418                  if ((0xfffffffffffffbfeL & l) == 0L)
1419                     break;
1420                  if (kind > 41)
1421                     kind = 41;
1422                  jjCheckNAdd(4);
1423                  break;
1424               case 5:
1425                  if (curChar == 35)
1426                     jjstateSet[jjnewStateCnt++] = 3;
1427                  break;
1428               case 6:
1429                  if ((0xfffffffffffff9ffL & l) != 0L && kind > 60)
1430                     kind = 60;
1431                  break;
1432               default : break;
1433            }
1434         } while(i != startsAt);
1435      }
1436      else if (curChar < 128)
1437      {
1438         long l = 1L << (curChar & 077);
1439         do
1440         {
1441            switch(jjstateSet[--i])
1442            {
1443               case 1:
1444                  if (kind > 60)
1445                     kind = 60;
1446                  break;
1447               case 4:
1448                  if (kind > 41)
1449                     kind = 41;
1450                  jjstateSet[jjnewStateCnt++] = 4;
1451                  break;
1452               default : break;
1453            }
1454         } while(i != startsAt);
1455      }
1456      else
1457      {
1458         int hiByte = (int)(curChar >> 8);
1459         int i1 = hiByte >> 6;
1460         long l1 = 1L << (hiByte & 077);
1461         int i2 = (curChar & 0xff) >> 6;
1462         long l2 = 1L << (curChar & 077);
1463         do
1464         {
1465            switch(jjstateSet[--i])
1466            {
1467               case 1:
1468                  if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 60)
1469                     kind = 60;
1470                  break;
1471               case 4:
1472                  if (!jjCanMove_0(hiByte, i1, i2, l1, l2))
1473                     break;
1474                  if (kind > 41)
1475                     kind = 41;
1476                  jjstateSet[jjnewStateCnt++] = 4;
1477                  break;
1478               default : break;
1479            }
1480         } while(i != startsAt);
1481      }
1482      if (kind != 0x7fffffff)
1483      {
1484         jjmatchedKind = kind;
1485         jjmatchedPos = curPos;
1486         kind = 0x7fffffff;
1487      }
1488      ++curPos;
1489      if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
1490         return curPos;
1491      try { curChar = input_stream.readChar(); }
1492      catch(java.io.IOException e) { return curPos; }
1493   }
1494}
1495static final int[] jjnextStates = {
1496   16, 17, 18, 19, 21, 25, 26, 27, 28, 30, 35, 36, 38, 39, 40, 10,
1497   11, 13, 14, 3, 6, 7, 8,
1498};
1499private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
1500{
1501   switch(hiByte)
1502   {
1503      case 0:
1504         return ((jjbitVec2[i2] & l2) != 0L);
1505      default :
1506         if ((jjbitVec0[i1] & l1) != 0L)
1507            return true;
1508         return false;
1509   }
1510}
1511private static final boolean jjCanMove_1(int hiByte, int i1, int i2, long l1, long l2)
1512{
1513   switch(hiByte)
1514   {
1515      case 0:
1516         return ((jjbitVec4[i2] & l2) != 0L);
1517      case 1:
1518         return ((jjbitVec5[i2] & l2) != 0L);
1519      case 2:
1520         return ((jjbitVec6[i2] & l2) != 0L);
1521      case 3:
1522         return ((jjbitVec7[i2] & l2) != 0L);
1523      case 4:
1524         return ((jjbitVec8[i2] & l2) != 0L);
1525      case 5:
1526         return ((jjbitVec9[i2] & l2) != 0L);
1527      case 6:
1528         return ((jjbitVec10[i2] & l2) != 0L);
1529      case 9:
1530         return ((jjbitVec11[i2] & l2) != 0L);
1531      case 10:
1532         return ((jjbitVec12[i2] & l2) != 0L);
1533      case 11:
1534         return ((jjbitVec13[i2] & l2) != 0L);
1535      case 12:
1536         return ((jjbitVec14[i2] & l2) != 0L);
1537      case 13:
1538         return ((jjbitVec15[i2] & l2) != 0L);
1539      case 14:
1540         return ((jjbitVec16[i2] & l2) != 0L);
1541      case 15:
1542         return ((jjbitVec17[i2] & l2) != 0L);
1543      case 16:
1544         return ((jjbitVec18[i2] & l2) != 0L);
1545      case 17:
1546         return ((jjbitVec19[i2] & l2) != 0L);
1547      case 30:
1548         return ((jjbitVec20[i2] & l2) != 0L);
1549      case 31:
1550         return ((jjbitVec21[i2] & l2) != 0L);
1551      case 33:
1552         return ((jjbitVec22[i2] & l2) != 0L);
1553      case 48:
1554         return ((jjbitVec23[i2] & l2) != 0L);
1555      case 49:
1556         return ((jjbitVec24[i2] & l2) != 0L);
1557      case 159:
1558         return ((jjbitVec25[i2] & l2) != 0L);
1559      case 215:
1560         return ((jjbitVec26[i2] & l2) != 0L);
1561      default :
1562         if ((jjbitVec3[i1] & l1) != 0L)
1563            return true;
1564         return false;
1565   }
1566}
1567private static final boolean jjCanMove_2(int hiByte, int i1, int i2, long l1, long l2)
1568{
1569   switch(hiByte)
1570   {
1571      case 0:
1572         return ((jjbitVec27[i2] & l2) != 0L);
1573      case 1:
1574         return ((jjbitVec5[i2] & l2) != 0L);
1575      case 2:
1576         return ((jjbitVec28[i2] & l2) != 0L);
1577      case 3:
1578         return ((jjbitVec29[i2] & l2) != 0L);
1579      case 4:
1580         return ((jjbitVec30[i2] & l2) != 0L);
1581      case 5:
1582         return ((jjbitVec31[i2] & l2) != 0L);
1583      case 6:
1584         return ((jjbitVec32[i2] & l2) != 0L);
1585      case 9:
1586         return ((jjbitVec33[i2] & l2) != 0L);
1587      case 10:
1588         return ((jjbitVec34[i2] & l2) != 0L);
1589      case 11:
1590         return ((jjbitVec35[i2] & l2) != 0L);
1591      case 12:
1592         return ((jjbitVec36[i2] & l2) != 0L);
1593      case 13:
1594         return ((jjbitVec37[i2] & l2) != 0L);
1595      case 14:
1596         return ((jjbitVec38[i2] & l2) != 0L);
1597      case 15:
1598         return ((jjbitVec39[i2] & l2) != 0L);
1599      case 16:
1600         return ((jjbitVec18[i2] & l2) != 0L);
1601      case 17:
1602         return ((jjbitVec19[i2] & l2) != 0L);
1603      case 30:
1604         return ((jjbitVec20[i2] & l2) != 0L);
1605      case 31:
1606         return ((jjbitVec21[i2] & l2) != 0L);
1607      case 32:
1608         return ((jjbitVec40[i2] & l2) != 0L);
1609      case 33:
1610         return ((jjbitVec22[i2] & l2) != 0L);
1611      case 48:
1612         return ((jjbitVec41[i2] & l2) != 0L);
1613      case 49:
1614         return ((jjbitVec24[i2] & l2) != 0L);
1615      case 159:
1616         return ((jjbitVec25[i2] & l2) != 0L);
1617      case 215:
1618         return ((jjbitVec26[i2] & l2) != 0L);
1619      default :
1620         if ((jjbitVec3[i1] & l1) != 0L)
1621            return true;
1622         return false;
1623   }
1624}
1625
1626/** Token literal values. */
1627public static final String[] jjstrLiteralImages = {
1628"", "\133", "\75", "\46\75", "\174\75", "\163\164\141\162\164",
1629"\144\151\166", "\151\156\143\154\165\144\145", "\176", "\135",
1630"\147\162\141\155\155\141\162", "\173", "\175", "\156\141\155\145\163\160\141\143\145",
1631"\144\145\146\141\165\154\164", "\151\156\150\145\162\151\164", "\144\141\164\141\164\171\160\145\163",
1632"\145\155\160\164\171", "\164\145\170\164", "\156\157\164\101\154\154\157\167\145\144", "\174", "\46",
1633"\54", "\53", "\77", "\52", "\145\154\145\155\145\156\164",
1634"\141\164\164\162\151\142\165\164\145", "\50", "\51", "\55", "\154\151\163\164", "\155\151\170\145\144",
1635"\145\170\164\145\162\156\141\154", "\160\141\162\145\156\164", "\163\164\162\151\156\147",
1636"\164\157\153\145\156", null, null, null, null, null, null, null, null, null, null, null, null, null,
1637null, null, null, null, null, null, null, null, null, "\76\76", null, };
1638
1639/** Lexer state names. */
1640public static final String[] lexStateNames = {
1641   "DEFAULT",
1642   "AFTER_SINGLE_LINE_COMMENT",
1643   "AFTER_DOCUMENTATION",
1644};
1645
1646/** Lex State array. */
1647public static final int[] jjnewLexState = {
1648   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1649   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 2, -1, 1, 2, -1, -1, -1, -1, -1, -1,
1650   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1651};
1652static final long[] jjtoToken = {
1653   0x1fc00b1fffffffffL,
1654};
1655static final long[] jjtoSkip = {
1656   0x148000000000L,
1657};
1658static final long[] jjtoSpecial = {
1659   0x140000000000L,
1660};
1661protected JavaCharStream input_stream;
1662private final int[] jjrounds = new int[43];
1663private final int[] jjstateSet = new int[86];
1664private final StringBuilder jjimage = new StringBuilder();
1665private StringBuilder image = jjimage;
1666private int jjimageLen;
1667private int lengthOfMatch;
1668protected char curChar;
1669/** Constructor. */
1670public CompactSyntaxTokenManager(JavaCharStream stream){
1671   if (JavaCharStream.staticFlag)
1672      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
1673   input_stream = stream;
1674}
1675
1676/** Constructor. */
1677public CompactSyntaxTokenManager(JavaCharStream stream, int lexState){
1678   this(stream);
1679   SwitchTo(lexState);
1680}
1681
1682/** Reinitialise parser. */
1683public void ReInit(JavaCharStream stream)
1684{
1685   jjmatchedPos = jjnewStateCnt = 0;
1686   curLexState = defaultLexState;
1687   input_stream = stream;
1688   ReInitRounds();
1689}
1690private void ReInitRounds()
1691{
1692   int i;
1693   jjround = 0x80000001;
1694   for (i = 43; i-- > 0;)
1695      jjrounds[i] = 0x80000000;
1696}
1697
1698/** Reinitialise parser. */
1699public void ReInit(JavaCharStream stream, int lexState)
1700{
1701   ReInit(stream);
1702   SwitchTo(lexState);
1703}
1704
1705/** Switch to specified lex state. */
1706public void SwitchTo(int lexState)
1707{
1708   if (lexState >= 3 || lexState < 0)
1709      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
1710   else
1711      curLexState = lexState;
1712}
1713
1714protected Token jjFillToken()
1715{
1716   final Token t;
1717   final String curTokenImage;
1718   final int beginLine;
1719   final int endLine;
1720   final int beginColumn;
1721   final int endColumn;
1722   String im = jjstrLiteralImages[jjmatchedKind];
1723   curTokenImage = (im == null) ? input_stream.GetImage() : im;
1724   beginLine = input_stream.getBeginLine();
1725   beginColumn = input_stream.getBeginColumn();
1726   endLine = input_stream.getEndLine();
1727   endColumn = input_stream.getEndColumn();
1728   t = Token.newToken(jjmatchedKind, curTokenImage);
1729
1730   t.beginLine = beginLine;
1731   t.endLine = endLine;
1732   t.beginColumn = beginColumn;
1733   t.endColumn = endColumn;
1734
1735   return t;
1736}
1737
1738int curLexState = 0;
1739int defaultLexState = 0;
1740int jjnewStateCnt;
1741int jjround;
1742int jjmatchedPos;
1743int jjmatchedKind;
1744
1745/** Get the next Token. */
1746public Token getNextToken()
1747{
1748  Token specialToken = null;
1749  Token matchedToken;
1750  int curPos = 0;
1751
1752  EOFLoop :
1753  for (;;)
1754  {
1755   try
1756   {
1757      curChar = input_stream.BeginToken();
1758   }
1759   catch(java.io.IOException e)
1760   {
1761      jjmatchedKind = 0;
1762      matchedToken = jjFillToken();
1763      matchedToken.specialToken = specialToken;
1764      return matchedToken;
1765   }
1766   image = jjimage;
1767   image.setLength(0);
1768   jjimageLen = 0;
1769
1770   switch(curLexState)
1771   {
1772     case 0:
1773       jjmatchedKind = 0x7fffffff;
1774       jjmatchedPos = 0;
1775       curPos = jjMoveStringLiteralDfa0_0();
1776       break;
1777     case 1:
1778       jjmatchedKind = 0x7fffffff;
1779       jjmatchedPos = 0;
1780       curPos = jjMoveStringLiteralDfa0_1();
1781       break;
1782     case 2:
1783       jjmatchedKind = 0x7fffffff;
1784       jjmatchedPos = 0;
1785       curPos = jjMoveStringLiteralDfa0_2();
1786       break;
1787   }
1788     if (jjmatchedKind != 0x7fffffff)
1789     {
1790        if (jjmatchedPos + 1 < curPos)
1791           input_stream.backup(curPos - jjmatchedPos - 1);
1792        if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1793        {
1794           matchedToken = jjFillToken();
1795           matchedToken.specialToken = specialToken;
1796       if (jjnewLexState[jjmatchedKind] != -1)
1797         curLexState = jjnewLexState[jjmatchedKind];
1798           return matchedToken;
1799        }
1800        else
1801        {
1802           if ((jjtoSpecial[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
1803           {
1804              matchedToken = jjFillToken();
1805              if (specialToken == null)
1806                 specialToken = matchedToken;
1807              else
1808              {
1809                 matchedToken.specialToken = specialToken;
1810                 specialToken = (specialToken.next = matchedToken);
1811              }
1812              SkipLexicalActions(matchedToken);
1813           }
1814           else
1815              SkipLexicalActions(null);
1816         if (jjnewLexState[jjmatchedKind] != -1)
1817           curLexState = jjnewLexState[jjmatchedKind];
1818           continue EOFLoop;
1819        }
1820     }
1821     int error_line = input_stream.getEndLine();
1822     int error_column = input_stream.getEndColumn();
1823     String error_after = null;
1824     boolean EOFSeen = false;
1825     try { input_stream.readChar(); input_stream.backup(1); }
1826     catch (java.io.IOException e1) {
1827        EOFSeen = true;
1828        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1829        if (curChar == '\n' || curChar == '\r') {
1830           error_line++;
1831           error_column = 0;
1832        }
1833        else
1834           error_column++;
1835     }
1836     if (!EOFSeen) {
1837        input_stream.backup(1);
1838        error_after = curPos <= 1 ? "" : input_stream.GetImage();
1839     }
1840     throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
1841  }
1842}
1843
1844void SkipLexicalActions(Token matchedToken)
1845{
1846   switch(jjmatchedKind)
1847   {
1848      default :
1849         break;
1850   }
1851}
1852private void jjCheckNAdd(int state)
1853{
1854   if (jjrounds[state] != jjround)
1855   {
1856      jjstateSet[jjnewStateCnt++] = state;
1857      jjrounds[state] = jjround;
1858   }
1859}
1860private void jjAddStates(int start, int end)
1861{
1862   do {
1863      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
1864   } while (start++ != end);
1865}
1866private void jjCheckNAddTwoStates(int state1, int state2)
1867{
1868   jjCheckNAdd(state1);
1869   jjCheckNAdd(state2);
1870}
1871
1872private void jjCheckNAddStates(int start, int end)
1873{
1874   do {
1875      jjCheckNAdd(jjnextStates[start]);
1876   } while (start++ != end);
1877}
1878
1879}
1880