Coverage Report

Coverage Report - org.apache.commons.configuration.plist.PropertyListParserTokenManager

Classes in this File

Line Coverage

Branch Coverage

Complexity

PropertyListParserTokenManager

60%

136/227

53%

32/60

9,133

 /* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
 package org.apache.commons.configuration.plist;
 
 import java.io.IOException;
 import java.io.PrintStream;
 
 class PropertyListParserTokenManager implements PropertyListParserConstants
 {
     public PrintStream debugStream = System.out;
 
     private final int jjStopStringLiteralDfa_0(int pos, long active0)
     {
         switch (pos)
         {
             case 0:
                 if ((active0 & 0x4000L) != 0L)
                     return 9;
                 if ((active0 & 0x1000L) != 0L)
                     return 10;
                 if ((active0 & 0x2000L) != 0L)
                     return 3;
                 if ((active0 & 0x200000L) != 0L)
                 {
                     jjmatchedKind = 19;
                     return 3;
                 }
                 return -1;
             default :
                 return -1;
         }
     }
 
     private final int jjStartNfa_0(int pos, long active0)
     {
         return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
     }
 
     private final int jjStopAtPos(int pos, int kind)
     {
         jjmatchedKind = kind;
         jjmatchedPos = pos;
         return pos + 1;
     }
 
     private final int jjStartNfaWithStates_0(int pos, int kind, int state)
     {
         jjmatchedKind = kind;
         jjmatchedPos = pos;
         try
         {
             curChar = input_stream.readChar();
         }
         catch (IOException e)
         {
             return pos + 1;
         }
         return jjMoveNfa_0(state, pos + 1);
     }
 
     private final int jjMoveStringLiteralDfa0_0()
     {
         switch (curChar)
         {
             case 34:
                 return jjStartNfaWithStates_0(0, 14, 9);
             case 40:
                 return jjStopAtPos(0, 5);
             case 41:
                 return jjStopAtPos(0, 6);
             case 44:
                 return jjStopAtPos(0, 7);
             case 59:
                 return jjStopAtPos(0, 10);
             case 60:
                 return jjStartNfaWithStates_0(0, 12, 10);
             case 61:
                 return jjStopAtPos(0, 11);
             case 62:
                 return jjStartNfaWithStates_0(0, 13, 3);
             case 92:
                 return jjMoveStringLiteralDfa1_0(0x200000L);
             case 123:
                 return jjStopAtPos(0, 8);
             case 125:
                 return jjStopAtPos(0, 9);
             default :
                 return jjMoveNfa_0(0, 0);
         }
     }
 
     private final int jjMoveStringLiteralDfa1_0(long active0)
     {
         try
         {
             curChar = input_stream.readChar();
         }
         catch (IOException e)
         {
             jjStopStringLiteralDfa_0(0, active0);
             return 1;
         }
         switch (curChar)
         {
             case 34:
                 if ((active0 & 0x200000L) != 0L)
                     return jjStopAtPos(1, 21);
                 break;
             default :
                 break;
         }
         return jjStartNfa_0(0, active0);
     }
 
     private final void jjCheckNAdd(int state)
     {
         if (jjrounds[state] != jjround)
         {
             jjstateSet[jjnewStateCnt++] = state;
             jjrounds[state] = jjround;
         }
     }
 
     private final void jjCheckNAddTwoStates(int state1, int state2)
     {
         jjCheckNAdd(state1);
         jjCheckNAdd(state2);
     }
 
     private final void jjCheckNAddStates(int start, int end)
     {
         do
         {
             jjCheckNAdd(jjnextStates[start]);
         }
         while (start++ != end);
     }
 
     static final long[] jjbitVec0 = {
         0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
     };
 
     private final int jjMoveNfa_0(int startState, int curPos)
     {
         int startsAt = 0;
         jjnewStateCnt = 9;
         int i = 1;
         jjstateSet[0] = startState;
         int kind = 0x7fffffff;
         for (; ;)
         {
             if (++jjround == 0x7fffffff)
                 ReInitRounds();
             if (curChar < 64)
             {
                 long l = 1L << curChar;
                 MatchLoop: do
                 {
                     switch (jjstateSet[--i])
                     {
                         case 9:
                             if ((0xfffffffbffffffffL & l) != 0L)
                                 jjCheckNAddStates(0, 2);
                             else if (curChar == 34)
                             {
                                 if (kind > 20)
                                     kind = 20;
                             }
                             break;
                         case 10:
                             if ((0xd7ffecfaffffd9ffL & l) != 0L)
                             {
                                 if (kind > 19)
                                     kind = 19;
                                 jjCheckNAdd(3);
                             }
                             if ((0x3ff000100002600L & l) != 0L)
                                 jjCheckNAddTwoStates(1, 2);
                             else if (curChar == 62)
                             {
                                 if (kind > 18)
                                     kind = 18;
                             }
                             break;
                         case 0:
                             if ((0xd7ffecfaffffd9ffL & l) != 0L)
                             {
                                 if (kind > 19)
                                     kind = 19;
                                 jjCheckNAdd(3);
                             }
                             else if (curChar == 34)
                                 jjCheckNAddStates(0, 2);
                             if (curChar == 60)
                                 jjCheckNAddTwoStates(1, 2);
                             break;
                         case 1:
                             if ((0x3ff000100002600L & l) != 0L)
                                 jjCheckNAddTwoStates(1, 2);
                             break;
                         case 2:
                             if (curChar == 62 && kind > 18)
                                 kind = 18;
                             break;
                         case 3:
                             if ((0xd7ffecfaffffd9ffL & l) == 0L)
                                 break;
                             if (kind > 19)
                                 kind = 19;
                             jjCheckNAdd(3);
                             break;
                         case 4:
                         case 6:
                             if (curChar == 34)
                                 jjCheckNAddStates(0, 2);
                             break;
                         case 5:
                             if ((0xfffffffbffffffffL & l) != 0L)
                                 jjCheckNAddStates(0, 2);
                             break;
                         case 8:
                             if (curChar == 34 && kind > 20)
                                 kind = 20;
                             break;
                         default :
                             break;
                     }
                 }
                 while (i != startsAt);
             }
             else if (curChar < 128)
             {
                 long l = 1L << (curChar & 077);
                 MatchLoop: do
                 {
                     switch (jjstateSet[--i])
                     {
                         case 9:
                             jjCheckNAddStates(0, 2);
                             if (curChar == 92)
                                 jjstateSet[jjnewStateCnt++] = 6;
                             break;
                         case 10:
                             if ((0xd7ffffffffffffffL & l) != 0L)
                             {
                                 if (kind > 19)
                                     kind = 19;
                                 jjCheckNAdd(3);
                             }
                             if ((0x7e0000007eL & l) != 0L)
                                 jjCheckNAddTwoStates(1, 2);
                             break;
                         case 0:
                         case 3:
                             if ((0xd7ffffffffffffffL & l) == 0L)
                                 break;
                             if (kind > 19)
                                 kind = 19;
                             jjCheckNAdd(3);
                             break;
                         case 1:
                             if ((0x7e0000007eL & l) != 0L)
                                 jjCheckNAddTwoStates(1, 2);
                             break;
                         case 5:
                             jjCheckNAddStates(0, 2);
                             break;
                         case 7:
                             if (curChar == 92)
                                 jjstateSet[jjnewStateCnt++] = 6;
                             break;
                         default :
                             break;
                     }
                 }
                 while (i != startsAt);
             }
             else
             {
                 int i2 = (curChar & 0xff) >> 6;
                 long l2 = 1L << (curChar & 077);
                 MatchLoop: do
                 {
                     switch (jjstateSet[--i])
                     {
                         case 9:
                         case 5:
                             if ((jjbitVec0[i2] & l2) != 0L)
                                 jjCheckNAddStates(0, 2);
                             break;
                         case 10:
                         case 3:
                             if ((jjbitVec0[i2] & l2) == 0L)
                                 break;
                             if (kind > 19)
                                 kind = 19;
                             jjCheckNAdd(3);
                             break;
                         case 0:
                             if ((jjbitVec0[i2] & l2) == 0L)
                                 break;
                             if (kind > 19)
                                 kind = 19;
                             jjCheckNAdd(3);
                             break;
                         default :
                             break;
                     }
                 }
                 while (i != startsAt);
             }
             if (kind != 0x7fffffff)
             {
                 jjmatchedKind = kind;
                 jjmatchedPos = curPos;
                 kind = 0x7fffffff;
             }
             ++curPos;
             if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
                 return curPos;
             try
             {
                 curChar = input_stream.readChar();
             }
             catch (IOException e)
             {
                 return curPos;
             }
         }
     }
 
     static final int[] jjnextStates = {
         5, 7, 8,
     };
     public static final String[] jjstrLiteralImages = {
         "", null, null, null, null, "\50", "\51", "\54", "\173", "\175", "\73", "\75",
         "\74", "\76", "\42", null, null, null, null, null, null, "\134\42", };
     public static final String[] lexStateNames = {
         "DEFAULT",
     };
     static final long[] jjtoToken = {
         0x3c7fe1L,
     };
     static final long[] jjtoSkip = {
         0x1eL,
     };
     protected SimpleCharStream input_stream;
     private final int[] jjrounds = new int[9];
     private final int[] jjstateSet = new int[18];
     protected char curChar;
 
     public PropertyListParserTokenManager(SimpleCharStream stream)
     {
         if (SimpleCharStream.staticFlag)
             throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
         input_stream = stream;
     }
 
     public void ReInit(SimpleCharStream stream)
     {
         jjmatchedPos = jjnewStateCnt = 0;
         curLexState = defaultLexState;
         input_stream = stream;
         ReInitRounds();
     }
 
     private final void ReInitRounds()
     {
         int i;
         jjround = 0x80000001;
         for (i = 9; i-- > 0;)
             jjrounds[i] = 0x80000000;
     }
 
     protected Token jjFillToken()
     {
         Token t = Token.newToken(jjmatchedKind);
         t.kind = jjmatchedKind;
         String im = jjstrLiteralImages[jjmatchedKind];
         t.image = (im == null) ? input_stream.GetImage() : im;
         t.beginLine = input_stream.getBeginLine();
         t.beginColumn = input_stream.getBeginColumn();
         t.endLine = input_stream.getEndLine();
         t.endColumn = input_stream.getEndColumn();
         return t;
     }
 
     int curLexState = 0;
     int defaultLexState = 0;
     int jjnewStateCnt;
     int jjround;
     int jjmatchedPos;
     int jjmatchedKind;
 
     public Token getNextToken()
     {
         Token matchedToken;
         int curPos = 0;
 
         EOFLoop :
         for (; ;)
         {
             try
             {
                 curChar = input_stream.BeginToken();
             }
             catch (IOException e)
             {
                 jjmatchedKind = 0;
                 matchedToken = jjFillToken();
                 return matchedToken;
             }
 
             try
             {
                 input_stream.backup(0);
                 while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
                     curChar = input_stream.BeginToken();
             }
             catch (IOException e1)
             {
                 continue EOFLoop;
             }
             jjmatchedKind = 0x7fffffff;
             jjmatchedPos = 0;
             curPos = jjMoveStringLiteralDfa0_0();
             if (jjmatchedKind != 0x7fffffff)
             {
                 if (jjmatchedPos + 1 < curPos)
                     input_stream.backup(curPos - jjmatchedPos - 1);
                 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
                 {
                     matchedToken = jjFillToken();
                     return matchedToken;
                 }
                 else
                 {
                     continue EOFLoop;
                 }
             }
             int error_line = input_stream.getEndLine();
             int error_column = input_stream.getEndColumn();
             String error_after = null;
             boolean EOFSeen = false;
             try
             {
                 input_stream.readChar();
                 input_stream.backup(1);
             }
             catch (IOException e1)
             {
                 EOFSeen = true;
                 error_after = curPos <= 1 ? "" : input_stream.GetImage();
                 if (curChar == '\n' || curChar == '\r')
                 {
                     error_line++;
                     error_column = 0;
                 }
                 else
                     error_column++;
             }
             if (!EOFSeen)
             {
                 input_stream.backup(1);
                 error_after = curPos <= 1 ? "" : input_stream.GetImage();
             }
             throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
         }
     }
 
 }

1		/* Generated By:JavaCC: Do not edit this line. PropertyListParserTokenManager.java */
2		package org.apache.commons.configuration.plist;
3
4		import java.io.IOException;
5		import java.io.PrintStream;
6
7		class PropertyListParserTokenManager implements PropertyListParserConstants
8		{
9	18	public PrintStream debugStream = System.out;
10
11		private final int jjStopStringLiteralDfa_0(int pos, long active0)
12		{
13	0	switch (pos)
14		{
15		case 0:
16	0	if ((active0 & 0x4000L) != 0L)
17	0	return 9;
18	0	if ((active0 & 0x1000L) != 0L)
19	0	return 10;
20	0	if ((active0 & 0x2000L) != 0L)
21	0	return 3;
22	0	if ((active0 & 0x200000L) != 0L)
23		{
24	0	jjmatchedKind = 19;
25	0	return 3;
26		}
27	0	return -1;
28		default :
29	0	return -1;
30		}
31		}
32
33		private final int jjStartNfa_0(int pos, long active0)
34		{
35	0	return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
36		}
37
38		private final int jjStopAtPos(int pos, int kind)
39		{
40	937	jjmatchedKind = kind;
41	937	jjmatchedPos = pos;
42	937	return pos + 1;
43		}
44
45		private final int jjStartNfaWithStates_0(int pos, int kind, int state)
46		{
47	147	jjmatchedKind = kind;
48	147	jjmatchedPos = pos;
49		try
50		{
51	147	curChar = input_stream.readChar();
52	147	}
53		catch (IOException e)
54		{
55	0	return pos + 1;
56		}
57	147	return jjMoveNfa_0(state, pos + 1);
58		}
59
60		private final int jjMoveStringLiteralDfa0_0()
61		{
62	1468	switch (curChar)
63		{
64		case 34:
65	119	return jjStartNfaWithStates_0(0, 14, 9);
66		case 40:
67	84	return jjStopAtPos(0, 5);
68		case 41:
69	84	return jjStopAtPos(0, 6);
70		case 44:
71	84	return jjStopAtPos(0, 7);
72		case 59:
73	184	return jjStopAtPos(0, 10);
74		case 60:
75	28	return jjStartNfaWithStates_0(0, 12, 10);
76		case 61:
77	279	return jjStopAtPos(0, 11);
78		case 62:
79	0	return jjStartNfaWithStates_0(0, 13, 3);
80		case 92:
81	0	return jjMoveStringLiteralDfa1_0(0x200000L);
82		case 123:
83	111	return jjStopAtPos(0, 8);
84		case 125:
85	111	return jjStopAtPos(0, 9);
86		default :
87	384	return jjMoveNfa_0(0, 0);
88		}
89		}
90
91		private final int jjMoveStringLiteralDfa1_0(long active0)
92		{
93		try
94		{
95	0	curChar = input_stream.readChar();
96	0	}
97		catch (IOException e)
98		{
99	0	jjStopStringLiteralDfa_0(0, active0);
100	0	return 1;
101		}
102	0	switch (curChar)
103		{
104		case 34:
105	0	if ((active0 & 0x200000L) != 0L)
106	0	return jjStopAtPos(1, 21);
107		break;
108		default :
109		break;
110		}
111	0	return jjStartNfa_0(0, active0);
112		}
113
114		private final void jjCheckNAdd(int state)
115		{
116	7286	if (jjrounds[state] != jjround)
117		{
118	7286	jjstateSet[jjnewStateCnt++] = state;
119	7286	jjrounds[state] = jjround;
120		}
121	7286	}
122
123		private final void jjCheckNAddTwoStates(int state1, int state2)
124		{
125	235	jjCheckNAdd(state1);
126	235	jjCheckNAdd(state2);
127	235	}
128
129		private final void jjCheckNAddStates(int start, int end)
130		{
131		do
132		{
133	4017	jjCheckNAdd(jjnextStates[start]);
134		}
135	4017	while (start++ != end);
136	1339	}
137
138	4	static final long[] jjbitVec0 = {
139		0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
140		};
141
142		private final int jjMoveNfa_0(int startState, int curPos)
143		{
144	531	int startsAt = 0;
145	531	jjnewStateCnt = 9;
146	531	int i = 1;
147	531	jjstateSet[0] = startState;
148	531	int kind = 0x7fffffff;
149	531	for (; ;)
150		{
151	4812	if (++jjround == 0x7fffffff)
152	0	ReInitRounds();
153	4812	if (curChar < 64)
154		{
155	1229	long l = 1L << curChar;
156		MatchLoop: do
157		{
158	2316	switch (jjstateSet[--i])
159		{
160		case 9:
161	0	if ((0xfffffffbffffffffL & l) != 0L)
162	0	jjCheckNAddStates(0, 2);
163	0	else if (curChar == 34)
164		{
165	0	if (kind > 20)
166	0	kind = 20;
167		}
168		break;
169		case 10:
170	28	if ((0xd7ffecfaffffd9ffL & l) != 0L)
171		{
172	15	if (kind > 19)
173	15	kind = 19;
174	15	jjCheckNAdd(3);
175		}
176	28	if ((0x3ff000100002600L & l) != 0L)
177	27	jjCheckNAddTwoStates(1, 2);
178	1	else if (curChar == 62)
179		{
180	1	if (kind > 18)
181	1	kind = 18;
182		}
183		break;
184		case 0:
185	0	if ((0xd7ffecfaffffd9ffL & l) != 0L)
186		{
187	0	if (kind > 19)
188	0	kind = 19;
189	0	jjCheckNAdd(3);
190		}
191	0	else if (curChar == 34)
192	0	jjCheckNAddStates(0, 2);
193	0	if (curChar == 60)
194	0	jjCheckNAddTwoStates(1, 2);
195		break;
196		case 1:
197	207	if ((0x3ff000100002600L & l) != 0L)
198	180	jjCheckNAddTwoStates(1, 2);
199		break;
200		case 2:
201	207	if (curChar == 62 && kind > 18)
202	27	kind = 18;
203		break;
204		case 3:
205	664	if ((0xd7ffecfaffffd9ffL & l) == 0L)
206	399	break;
207	265	if (kind > 19)
208	265	kind = 19;
209	265	jjCheckNAdd(3);
210	265	break;
211		case 4:
212		case 6:
213	28	if (curChar == 34)
214	28	jjCheckNAddStates(0, 2);
215		break;
216		case 5:
217	394	if ((0xfffffffbffffffffL & l) != 0L)
218	247	jjCheckNAddStates(0, 2);
219		break;
220		case 8:
221	394	if (curChar == 34 && kind > 20)
222	147	kind = 20;
223		break;
224		default :
225		break;
226		}
227		}
228	2316	while (i != startsAt);
229		}
230	3583	else if (curChar < 128)
231		{
232	3583	long l = 1L << (curChar & 077);
233		MatchLoop: do
234		{
235	5529	switch (jjstateSet[--i])
236		{
237		case 9:
238	119	jjCheckNAddStates(0, 2);
239	119	if (curChar == 92)
240	0	jjstateSet[jjnewStateCnt++] = 6;
241		break;
242		case 10:
243	0	if ((0xd7ffffffffffffffL & l) != 0L)
244		{
245	0	if (kind > 19)
246	0	kind = 19;
247	0	jjCheckNAdd(3);
248		}
249	0	if ((0x7e0000007eL & l) != 0L)
250	0	jjCheckNAddTwoStates(1, 2);
251		break;
252		case 0:
253		case 3:
254	2519	if ((0xd7ffffffffffffffL & l) == 0L)
255	0	break;
256	2519	if (kind > 19)
257	2519	kind = 19;
258	2519	jjCheckNAdd(3);
259	2519	break;
260		case 1:
261	28	if ((0x7e0000007eL & l) != 0L)
262	28	jjCheckNAddTwoStates(1, 2);
263		break;
264		case 5:
265	945	jjCheckNAddStates(0, 2);
266	945	break;
267		case 7:
268	945	if (curChar == 92)
269	28	jjstateSet[jjnewStateCnt++] = 6;
270		break;
271		default :
272		break;
273		}
274		}
275	5529	while (i != startsAt);
276		}
277		else
278		{
279	0	int i2 = (curChar & 0xff) >> 6;
280	0	long l2 = 1L << (curChar & 077);
281		MatchLoop: do
282		{
283	0	switch (jjstateSet[--i])
284		{
285		case 9:
286		case 5:
287	0	if ((jjbitVec0[i2] & l2) != 0L)
288	0	jjCheckNAddStates(0, 2);
289		break;
290		case 10:
291		case 3:
292	0	if ((jjbitVec0[i2] & l2) == 0L)
293	0	break;
294	0	if (kind > 19)
295	0	kind = 19;
296	0	jjCheckNAdd(3);
297	0	break;
298		case 0:
299	0	if ((jjbitVec0[i2] & l2) == 0L)
300	0	break;
301	0	if (kind > 19)
302	0	kind = 19;
303	0	jjCheckNAdd(3);
304	0	break;
305		default :
306		break;
307		}
308		}
309	0	while (i != startsAt);
310		}
311	4812	if (kind != 0x7fffffff)
312		{
313	2972	jjmatchedKind = kind;
314	2972	jjmatchedPos = curPos;
315	2972	kind = 0x7fffffff;
316		}
317	4812	++curPos;
318	4812	if ((i = jjnewStateCnt) == (startsAt = 9 - (jjnewStateCnt = startsAt)))
319	531	return curPos;
320		try
321		{
322	4281	curChar = input_stream.readChar();
323	4281	}
324		catch (IOException e)
325		{
326	0	return curPos;
327	4281	}
328		}
329		}
330
331	2	static final int[] jjnextStates = {
332		5, 7, 8,
333		};
334	2	public static final String[] jjstrLiteralImages = {
335		"", null, null, null, null, "\50", "\51", "\54", "\173", "\175", "\73", "\75",
336		"\74", "\76", "\42", null, null, null, null, null, null, "\134\42", };
337	2	public static final String[] lexStateNames = {
338		"DEFAULT",
339		};
340	2	static final long[] jjtoToken = {
341		0x3c7fe1L,
342		};
343	2	static final long[] jjtoSkip = {
344		0x1eL,
345		};
346		protected SimpleCharStream input_stream;
347	18	private final int[] jjrounds = new int[9];
348	18	private final int[] jjstateSet = new int[18];
349		protected char curChar;
350
351		public PropertyListParserTokenManager(SimpleCharStream stream)
352	18	{
353		if (SimpleCharStream.staticFlag)
354		throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
355	18	input_stream = stream;
356	18	}
357
358		public void ReInit(SimpleCharStream stream)
359		{
360	0	jjmatchedPos = jjnewStateCnt = 0;
361	0	curLexState = defaultLexState;
362	0	input_stream = stream;
363	0	ReInitRounds();
364	0	}
365
366		private final void ReInitRounds()
367		{
368		int i;
369	0	jjround = 0x80000001;
370	0	for (i = 9; i-- > 0;)
371	0	jjrounds[i] = 0x80000000;
372	0	}
373
374		protected Token jjFillToken()
375		{
376	1483	Token t = Token.newToken(jjmatchedKind);
377	1483	t.kind = jjmatchedKind;
378	1483	String im = jjstrLiteralImages[jjmatchedKind];
379	1483	t.image = (im == null) ? input_stream.GetImage() : im;
380	1483	t.beginLine = input_stream.getBeginLine();
381	1483	t.beginColumn = input_stream.getBeginColumn();
382	1483	t.endLine = input_stream.getEndLine();
383	1483	t.endColumn = input_stream.getEndColumn();
384	1483	return t;
385		}
386
387	18	int curLexState = 0;
388	18	int defaultLexState = 0;
389		int jjnewStateCnt;
390		int jjround;
391		int jjmatchedPos;
392		int jjmatchedKind;
393
394		public Token getNextToken()
395		{
396		Token matchedToken;
397	1483	int curPos = 0;
398
399		EOFLoop :
400	1483	for (; ;)
401		{
402		try
403		{
404	1496	curChar = input_stream.BeginToken();
405	1481	}
406		catch (IOException e)
407		{
408	15	jjmatchedKind = 0;
409	15	matchedToken = jjFillToken();
410	15	return matchedToken;
411		}
412
413		try
414		{
415	1481	input_stream.backup(0);
416	7414	while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
417	4465	curChar = input_stream.BeginToken();
418	1468	}
419		catch (IOException e1)
420		{
421	13	continue EOFLoop;
422		}
423	1468	jjmatchedKind = 0x7fffffff;
424	1468	jjmatchedPos = 0;
425	1468	curPos = jjMoveStringLiteralDfa0_0();
426	1468	if (jjmatchedKind != 0x7fffffff)
427		{
428	1468	if (jjmatchedPos + 1 < curPos)
429	386	input_stream.backup(curPos - jjmatchedPos - 1);
430	1468	if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
431		{
432	1468	matchedToken = jjFillToken();
433	1468	return matchedToken;
434		}
435		else
436		{
437		continue EOFLoop;
438		}
439		}
440	0	int error_line = input_stream.getEndLine();
441	0	int error_column = input_stream.getEndColumn();
442	0	String error_after = null;
443	0	boolean EOFSeen = false;
444		try
445		{
446	0	input_stream.readChar();
447	0	input_stream.backup(1);
448	0	}
449		catch (IOException e1)
450		{
451	0	EOFSeen = true;
452	0	error_after = curPos <= 1 ? "" : input_stream.GetImage();
453	0	if (curChar == '\n' \|\| curChar == '\r')
454		{
455	0	error_line++;
456	0	error_column = 0;
457		}
458		else
459	0	error_column++;
460		}
461	0	if (!EOFSeen)
462		{
463	0	input_stream.backup(1);
464	0	error_after = curPos <= 1 ? "" : input_stream.GetImage();
465		}
466	0	throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
467		}
468		}
469
470		}