13 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } |
13 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; } |
14 private final int jjStopStringLiteralDfa_0(int pos, long active0) |
14 private final int jjStopStringLiteralDfa_0(int pos, long active0) |
15 { |
15 { |
16 switch (pos) |
16 switch (pos) |
17 { |
17 { |
18 case 0: |
|
19 if ((active0 & 0x8000L) != 0L) |
|
20 { |
|
21 jjmatchedKind = 16; |
|
22 return 14; |
|
23 } |
|
24 return -1; |
|
25 case 1: |
|
26 if ((active0 & 0x8000L) != 0L) |
|
27 { |
|
28 jjmatchedKind = 16; |
|
29 jjmatchedPos = 1; |
|
30 return 14; |
|
31 } |
|
32 return -1; |
|
33 case 2: |
|
34 if ((active0 & 0x8000L) != 0L) |
|
35 { |
|
36 jjmatchedKind = 16; |
|
37 jjmatchedPos = 2; |
|
38 return 14; |
|
39 } |
|
40 return -1; |
|
41 default : |
18 default : |
42 return -1; |
19 return -1; |
43 } |
20 } |
44 } |
21 } |
45 private final int jjStartNfa_0(int pos, long active0) |
22 private final int jjStartNfa_0(int pos, long active0) |
55 private int jjMoveStringLiteralDfa0_0() |
32 private int jjMoveStringLiteralDfa0_0() |
56 { |
33 { |
57 switch(curChar) |
34 switch(curChar) |
58 { |
35 { |
59 case 44: |
36 case 44: |
60 return jjStopAtPos(0, 19); |
37 return jjStopAtPos(0, 18); |
61 case 58: |
38 case 58: |
62 return jjStopAtPos(0, 18); |
39 return jjStopAtPos(0, 17); |
63 case 91: |
40 case 91: |
|
41 return jjStopAtPos(0, 20); |
|
42 case 93: |
64 return jjStopAtPos(0, 21); |
43 return jjStopAtPos(0, 21); |
65 case 93: |
44 case 78: |
66 return jjStopAtPos(0, 22); |
|
67 case 110: |
45 case 110: |
68 return jjMoveStringLiteralDfa1_0(0x8000L); |
46 return jjMoveStringLiteralDfa1_0(0x8000L); |
69 case 123: |
47 case 123: |
70 return jjStopAtPos(0, 17); |
48 return jjStopAtPos(0, 16); |
71 case 125: |
49 case 125: |
72 return jjStopAtPos(0, 20); |
50 return jjStopAtPos(0, 19); |
73 default : |
51 default : |
74 return jjMoveNfa_0(0, 0); |
52 return jjMoveNfa_0(0, 0); |
75 } |
53 } |
76 } |
54 } |
77 private int jjMoveStringLiteralDfa1_0(long active0) |
55 private int jjMoveStringLiteralDfa1_0(long active0) |
117 jjStopStringLiteralDfa_0(2, active0); |
97 jjStopStringLiteralDfa_0(2, active0); |
118 return 3; |
98 return 3; |
119 } |
99 } |
120 switch(curChar) |
100 switch(curChar) |
121 { |
101 { |
|
102 case 76: |
122 case 108: |
103 case 108: |
123 if ((active0 & 0x8000L) != 0L) |
104 if ((active0 & 0x8000L) != 0L) |
124 return jjStartNfaWithStates_0(3, 15, 14); |
105 return jjStopAtPos(3, 15); |
125 break; |
106 break; |
126 default : |
107 default : |
127 break; |
108 break; |
128 } |
109 } |
129 return jjStartNfa_0(2, active0); |
110 return jjStartNfa_0(2, active0); |
130 } |
|
131 private int jjStartNfaWithStates_0(int pos, int kind, int state) |
|
132 { |
|
133 jjmatchedKind = kind; |
|
134 jjmatchedPos = pos; |
|
135 try { curChar = input_stream.readChar(); } |
|
136 catch(java.io.IOException e) { return pos + 1; } |
|
137 return jjMoveNfa_0(state, pos + 1); |
|
138 } |
111 } |
139 static final long[] jjbitVec0 = { |
112 static final long[] jjbitVec0 = { |
140 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL |
113 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL |
141 }; |
114 }; |
142 static final long[] jjbitVec2 = { |
115 static final long[] jjbitVec2 = { |
143 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
116 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL |
144 }; |
117 }; |
145 private int jjMoveNfa_0(int startState, int curPos) |
118 private int jjMoveNfa_0(int startState, int curPos) |
146 { |
119 { |
147 int startsAt = 0; |
120 int startsAt = 0; |
148 jjnewStateCnt = 31; |
121 jjnewStateCnt = 29; |
149 int i = 1; |
122 int i = 1; |
150 jjstateSet[0] = startState; |
123 jjstateSet[0] = startState; |
151 int kind = 0x7fffffff; |
124 int kind = 0x7fffffff; |
152 for (;;) |
125 for (;;) |
153 { |
126 { |
182 break; |
155 break; |
183 case 4: |
156 case 4: |
184 if (curChar == 34 && kind > 13) |
157 if (curChar == 34 && kind > 13) |
185 kind = 13; |
158 kind = 13; |
186 break; |
159 break; |
187 case 14: |
160 case 13: |
188 if ((0x3ff200000000000L & l) == 0L) |
|
189 break; |
|
190 if (kind > 16) |
|
191 kind = 16; |
|
192 jjstateSet[jjnewStateCnt++] = 14; |
|
193 break; |
|
194 case 15: |
|
195 if (curChar == 45) |
161 if (curChar == 45) |
196 jjCheckNAddStates(7, 10); |
162 jjCheckNAddStates(7, 10); |
197 break; |
163 break; |
198 case 16: |
164 case 14: |
199 if ((0x3ff000000000000L & l) == 0L) |
165 if ((0x3ff000000000000L & l) == 0L) |
200 break; |
166 break; |
201 if (kind > 7) |
167 if (kind > 7) |
202 kind = 7; |
168 kind = 7; |
203 jjCheckNAdd(16); |
169 jjCheckNAdd(14); |
|
170 break; |
|
171 case 15: |
|
172 if ((0x3ff000000000000L & l) != 0L) |
|
173 jjCheckNAddTwoStates(15, 16); |
|
174 break; |
|
175 case 16: |
|
176 if (curChar == 46) |
|
177 jjCheckNAdd(17); |
204 break; |
178 break; |
205 case 17: |
179 case 17: |
206 if ((0x3ff000000000000L & l) != 0L) |
|
207 jjCheckNAddTwoStates(17, 18); |
|
208 break; |
|
209 case 18: |
|
210 if (curChar == 46) |
|
211 jjCheckNAdd(19); |
|
212 break; |
|
213 case 19: |
|
214 if ((0x3ff000000000000L & l) == 0L) |
180 if ((0x3ff000000000000L & l) == 0L) |
215 break; |
181 break; |
216 if (kind > 8) |
182 if (kind > 8) |
217 kind = 8; |
183 kind = 8; |
218 jjCheckNAdd(19); |
184 jjCheckNAdd(17); |
|
185 break; |
|
186 case 18: |
|
187 if ((0x3ff000000000000L & l) != 0L) |
|
188 jjCheckNAddTwoStates(18, 19); |
219 break; |
189 break; |
220 case 20: |
190 case 20: |
221 if ((0x3ff000000000000L & l) != 0L) |
|
222 jjCheckNAddTwoStates(20, 21); |
|
223 break; |
|
224 case 22: |
|
225 if ((0x280000000000L & l) != 0L) |
191 if ((0x280000000000L & l) != 0L) |
226 jjCheckNAdd(23); |
192 jjCheckNAdd(21); |
227 break; |
193 break; |
228 case 23: |
194 case 21: |
229 if ((0x3ff000000000000L & l) == 0L) |
195 if ((0x3ff000000000000L & l) == 0L) |
230 break; |
196 break; |
231 if (kind > 8) |
197 if (kind > 8) |
232 kind = 8; |
198 kind = 8; |
233 jjCheckNAdd(23); |
199 jjCheckNAdd(21); |
|
200 break; |
|
201 case 22: |
|
202 if ((0x3ff000000000000L & l) != 0L) |
|
203 jjCheckNAddTwoStates(22, 23); |
|
204 break; |
|
205 case 23: |
|
206 if (curChar == 46) |
|
207 jjCheckNAdd(24); |
234 break; |
208 break; |
235 case 24: |
209 case 24: |
236 if ((0x3ff000000000000L & l) != 0L) |
210 if ((0x3ff000000000000L & l) != 0L) |
237 jjCheckNAddTwoStates(24, 25); |
211 jjCheckNAddTwoStates(24, 25); |
238 break; |
212 break; |
239 case 25: |
|
240 if (curChar == 46) |
|
241 jjCheckNAdd(26); |
|
242 break; |
|
243 case 26: |
213 case 26: |
244 if ((0x3ff000000000000L & l) != 0L) |
|
245 jjCheckNAddTwoStates(26, 27); |
|
246 break; |
|
247 case 28: |
|
248 if ((0x280000000000L & l) != 0L) |
214 if ((0x280000000000L & l) != 0L) |
249 jjCheckNAdd(29); |
215 jjCheckNAdd(27); |
250 break; |
216 break; |
251 case 29: |
217 case 27: |
252 if ((0x3ff000000000000L & l) == 0L) |
218 if ((0x3ff000000000000L & l) == 0L) |
253 break; |
219 break; |
254 if (kind > 8) |
220 if (kind > 8) |
255 kind = 8; |
221 kind = 8; |
256 jjCheckNAdd(29); |
222 jjCheckNAdd(27); |
257 break; |
223 break; |
258 case 30: |
224 case 28: |
259 if ((0x3ff000000000000L & l) == 0L) |
225 if ((0x3ff000000000000L & l) == 0L) |
260 break; |
226 break; |
261 if (kind > 7) |
227 if (kind > 7) |
262 kind = 7; |
228 kind = 7; |
263 jjCheckNAddStates(0, 6); |
229 jjCheckNAddStates(0, 6); |
272 do |
238 do |
273 { |
239 { |
274 switch(jjstateSet[--i]) |
240 switch(jjstateSet[--i]) |
275 { |
241 { |
276 case 0: |
242 case 0: |
277 if ((0x7fffffe87fffffeL & l) != 0L) |
243 if ((0x4000000040L & l) != 0L) |
278 { |
|
279 if (kind > 16) |
|
280 kind = 16; |
|
281 jjCheckNAdd(14); |
|
282 } |
|
283 if (curChar == 102) |
|
284 jjstateSet[jjnewStateCnt++] = 11; |
244 jjstateSet[jjnewStateCnt++] = 11; |
285 else if (curChar == 116) |
245 else if ((0x10000000100000L & l) != 0L) |
286 jjstateSet[jjnewStateCnt++] = 7; |
246 jjstateSet[jjnewStateCnt++] = 7; |
287 break; |
247 break; |
288 case 1: |
248 case 1: |
289 if ((0xffffffffefffffffL & l) != 0L) |
249 if ((0xffffffffefffffffL & l) != 0L) |
290 jjCheckNAddStates(11, 13); |
250 jjCheckNAddStates(11, 13); |
292 case 2: |
252 case 2: |
293 if (curChar == 92) |
253 if (curChar == 92) |
294 jjstateSet[jjnewStateCnt++] = 3; |
254 jjstateSet[jjnewStateCnt++] = 3; |
295 break; |
255 break; |
296 case 3: |
256 case 3: |
297 if ((0x14404410000000L & l) != 0L) |
257 if ((0x14404410144044L & l) != 0L) |
298 jjCheckNAddStates(11, 13); |
258 jjCheckNAddStates(11, 13); |
299 break; |
259 break; |
300 case 5: |
260 case 5: |
301 if (curChar == 101 && kind > 14) |
261 if ((0x2000000020L & l) != 0L && kind > 14) |
302 kind = 14; |
262 kind = 14; |
303 break; |
263 break; |
304 case 6: |
264 case 6: |
305 if (curChar == 117) |
265 if ((0x20000000200000L & l) != 0L) |
306 jjCheckNAdd(5); |
266 jjCheckNAdd(5); |
307 break; |
267 break; |
308 case 7: |
268 case 7: |
309 if (curChar == 114) |
269 if ((0x4000000040000L & l) != 0L) |
310 jjstateSet[jjnewStateCnt++] = 6; |
270 jjstateSet[jjnewStateCnt++] = 6; |
311 break; |
271 break; |
312 case 8: |
272 case 8: |
313 if (curChar == 116) |
273 if ((0x10000000100000L & l) != 0L) |
314 jjstateSet[jjnewStateCnt++] = 7; |
274 jjstateSet[jjnewStateCnt++] = 7; |
315 break; |
275 break; |
316 case 9: |
276 case 9: |
317 if (curChar == 115) |
277 if ((0x8000000080000L & l) != 0L) |
318 jjCheckNAdd(5); |
278 jjCheckNAdd(5); |
319 break; |
279 break; |
320 case 10: |
280 case 10: |
321 if (curChar == 108) |
281 if ((0x100000001000L & l) != 0L) |
322 jjstateSet[jjnewStateCnt++] = 9; |
282 jjstateSet[jjnewStateCnt++] = 9; |
323 break; |
283 break; |
324 case 11: |
284 case 11: |
325 if (curChar == 97) |
285 if ((0x200000002L & l) != 0L) |
326 jjstateSet[jjnewStateCnt++] = 10; |
286 jjstateSet[jjnewStateCnt++] = 10; |
327 break; |
287 break; |
328 case 12: |
288 case 12: |
329 if (curChar == 102) |
289 if ((0x4000000040L & l) != 0L) |
330 jjstateSet[jjnewStateCnt++] = 11; |
290 jjstateSet[jjnewStateCnt++] = 11; |
331 break; |
291 break; |
332 case 13: |
292 case 19: |
333 case 14: |
|
334 if ((0x7fffffe87fffffeL & l) == 0L) |
|
335 break; |
|
336 if (kind > 16) |
|
337 kind = 16; |
|
338 jjCheckNAdd(14); |
|
339 break; |
|
340 case 21: |
|
341 if ((0x2000000020L & l) != 0L) |
293 if ((0x2000000020L & l) != 0L) |
342 jjAddStates(14, 15); |
294 jjAddStates(14, 15); |
343 break; |
295 break; |
344 case 27: |
296 case 25: |
345 if ((0x2000000020L & l) != 0L) |
297 if ((0x2000000020L & l) != 0L) |
346 jjAddStates(16, 17); |
298 jjAddStates(16, 17); |
347 break; |
299 break; |
348 default : break; |
300 default : break; |
349 } |
301 } |
373 jjmatchedKind = kind; |
325 jjmatchedKind = kind; |
374 jjmatchedPos = curPos; |
326 jjmatchedPos = curPos; |
375 kind = 0x7fffffff; |
327 kind = 0x7fffffff; |
376 } |
328 } |
377 ++curPos; |
329 ++curPos; |
378 if ((i = jjnewStateCnt) == (startsAt = 31 - (jjnewStateCnt = startsAt))) |
330 if ((i = jjnewStateCnt) == (startsAt = 29 - (jjnewStateCnt = startsAt))) |
379 return curPos; |
331 return curPos; |
380 try { curChar = input_stream.readChar(); } |
332 try { curChar = input_stream.readChar(); } |
381 catch(java.io.IOException e) { return curPos; } |
333 catch(java.io.IOException e) { return curPos; } |
382 } |
334 } |
383 } |
335 } |
384 static final int[] jjnextStates = { |
336 static final int[] jjnextStates = { |
385 16, 17, 18, 20, 21, 24, 25, 16, 17, 20, 24, 1, 2, 4, 22, 23, |
337 14, 15, 16, 18, 19, 22, 23, 14, 15, 18, 22, 1, 2, 4, 20, 21, |
386 28, 29, |
338 26, 27, |
387 }; |
339 }; |
388 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) |
340 private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2) |
389 { |
341 { |
390 switch(hiByte) |
342 switch(hiByte) |
391 { |
343 { |
399 } |
351 } |
400 |
352 |
401 /** Token literal values. */ |
353 /** Token literal values. */ |
402 public static final String[] jjstrLiteralImages = { |
354 public static final String[] jjstrLiteralImages = { |
403 "", null, null, null, null, null, null, null, null, null, null, null, null, |
355 "", null, null, null, null, null, null, null, null, null, null, null, null, |
404 null, null, "\156\165\154\154", null, "\173", "\72", "\54", "\175", "\133", "\135", }; |
356 null, null, null, "\173", "\72", "\54", "\175", "\133", "\135", }; |
405 |
357 |
406 /** Lexer state names. */ |
358 /** Lexer state names. */ |
407 public static final String[] lexStateNames = { |
359 public static final String[] lexStateNames = { |
408 "DEFAULT", |
360 "DEFAULT", |
409 }; |
361 }; |
410 static final long[] jjtoToken = { |
362 static final long[] jjtoToken = { |
411 0x7fe181L, |
363 0x3fe181L, |
412 }; |
364 }; |
413 static final long[] jjtoSkip = { |
365 static final long[] jjtoSkip = { |
414 0x7eL, |
366 0x7eL, |
415 }; |
367 }; |
416 protected JavaCharStream input_stream; |
368 protected JavaCharStream input_stream; |
417 private final int[] jjrounds = new int[31]; |
369 private final int[] jjrounds = new int[29]; |
418 private final int[] jjstateSet = new int[62]; |
370 private final int[] jjstateSet = new int[58]; |
419 protected char curChar; |
371 protected char curChar; |
420 /** Constructor. */ |
372 /** Constructor. */ |
421 public JSONParserTokenManager(JavaCharStream stream){ |
373 public JSONParserTokenManager(JavaCharStream stream){ |
422 if (JavaCharStream.staticFlag) |
374 if (JavaCharStream.staticFlag) |
423 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); |
375 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer."); |
440 } |
392 } |
441 private void ReInitRounds() |
393 private void ReInitRounds() |
442 { |
394 { |
443 int i; |
395 int i; |
444 jjround = 0x80000001; |
396 jjround = 0x80000001; |
445 for (i = 31; i-- > 0;) |
397 for (i = 29; i-- > 0;) |
446 jjrounds[i] = 0x80000000; |
398 jjrounds[i] = 0x80000000; |
447 } |
399 } |
448 |
400 |
449 /** Reinitialise parser. */ |
401 /** Reinitialise parser. */ |
450 public void ReInit(JavaCharStream stream, int lexState) |
402 public void ReInit(JavaCharStream stream, int lexState) |