source: josm/trunk/src/org/openstreetmap/josm/gui/mappaint/mapcss/parser/MapCSSParserTokenManager.java@ 3856

Last change on this file since 3856 was 3856, checked in by bastiK, 13 years ago

improve mapcss support
  • Property svn:eol-style set to native
File size: 16.7 KB
Line 
1/* Generated By:JavaCC: Do not edit this line. MapCSSParserTokenManager.java */
2package org.openstreetmap.josm.gui.mappaint.mapcss.parser;
3import java.awt.Color;
4import java.util.ArrayList;
5import java.util.List;
6import org.openstreetmap.josm.gui.mappaint.mapcss.Condition;
7import org.openstreetmap.josm.gui.mappaint.mapcss.Expression;
8import org.openstreetmap.josm.gui.mappaint.mapcss.Instruction;
9import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSRule;
10import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
11import org.openstreetmap.josm.gui.mappaint.mapcss.Selector;
12import org.openstreetmap.josm.gui.mappaint.mapcss.Expression.FunctionExpression;
13import org.openstreetmap.josm.gui.mappaint.mapcss.Expression.LiteralExpression;
14import org.openstreetmap.josm.tools.Pair;
15
16/** Token Manager. */
17public class MapCSSParserTokenManager implements MapCSSParserConstants
18{
19
20 /** Debug output. */
21 public java.io.PrintStream debugStream = System.out;
22 /** Set debug output. */
23 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
24private final int jjStopStringLiteralDfa_0(int pos, long active0)
25{
26 switch (pos)
27 {
28 default :
29 return -1;
30 }
31}
32private final int jjStartNfa_0(int pos, long active0)
33{
34 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
35}
36private int jjStopAtPos(int pos, int kind)
37{
38 jjmatchedKind = kind;
39 jjmatchedPos = pos;
40 return pos + 1;
41}
42private int jjMoveStringLiteralDfa0_0()
43{
44 switch(curChar)
45 {
46 case 33:
47 jjmatchedKind = 17;
48 return jjMoveStringLiteralDfa1_0(0x40000L);
49 case 38:
50 return jjStopAtPos(0, 27);
51 case 40:
52 return jjStopAtPos(0, 14);
53 case 41:
54 return jjStopAtPos(0, 15);
55 case 42:
56 return jjStopAtPos(0, 8);
57 case 43:
58 return jjStopAtPos(0, 25);
59 case 44:
60 return jjStopAtPos(0, 22);
61 case 45:
62 return jjStopAtPos(0, 26);
63 case 47:
64 jjmatchedKind = 9;
65 return jjMoveStringLiteralDfa1_0(0x20000000L);
66 case 58:
67 jjmatchedKind = 19;
68 return jjMoveStringLiteralDfa1_0(0x100000L);
69 case 59:
70 return jjStopAtPos(0, 21);
71 case 61:
72 return jjStopAtPos(0, 16);
73 case 63:
74 return jjStopAtPos(0, 28);
75 case 91:
76 return jjStopAtPos(0, 12);
77 case 93:
78 return jjStopAtPos(0, 13);
79 case 123:
80 return jjStopAtPos(0, 10);
81 case 124:
82 jjmatchedKind = 23;
83 return jjMoveStringLiteralDfa1_0(0x1000000L);
84 case 125:
85 return jjStopAtPos(0, 11);
86 default :
87 return jjMoveNfa_0(0, 0);
88 }
89}
90private int jjMoveStringLiteralDfa1_0(long active0)
91{
92 try { curChar = input_stream.readChar(); }
93 catch(java.io.IOException e) {
94 jjStopStringLiteralDfa_0(0, active0);
95 return 1;
96 }
97 switch(curChar)
98 {
99 case 42:
100 if ((active0 & 0x20000000L) != 0L)
101 return jjStopAtPos(1, 29);
102 break;
103 case 58:
104 if ((active0 & 0x100000L) != 0L)
105 return jjStopAtPos(1, 20);
106 break;
107 case 61:
108 if ((active0 & 0x40000L) != 0L)
109 return jjStopAtPos(1, 18);
110 break;
111 case 122:
112 if ((active0 & 0x1000000L) != 0L)
113 return jjStopAtPos(1, 24);
114 break;
115 default :
116 break;
117 }
118 return jjStartNfa_0(0, active0);
119}
120static final long[] jjbitVec0 = {
121 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
122};
123static final long[] jjbitVec2 = {
124 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
125};
126private int jjMoveNfa_0(int startState, int curPos)
127{
128 int startsAt = 0;
129 jjnewStateCnt = 22;
130 int i = 1;
131 jjstateSet[0] = startState;
132 int kind = 0x7fffffff;
133 for (;;)
134 {
135 if (++jjround == 0x7fffffff)
136 ReInitRounds();
137 if (curChar < 64)
138 {
139 long l = 1L << curChar;
140 do
141 {
142 switch(jjstateSet[--i])
143 {
144 case 0:
145 if ((0x3ff000000000000L & l) != 0L)
146 {
147 if (kind > 3)
148 kind = 3;
149 jjCheckNAddTwoStates(4, 5);
150 }
151 else if ((0x100003600L & l) != 0L)
152 {
153 if (kind > 7)
154 kind = 7;
155 jjCheckNAdd(21);
156 }
157 else if (curChar == 35)
158 jjstateSet[jjnewStateCnt++] = 14;
159 else if (curChar == 34)
160 jjCheckNAddStates(0, 2);
161 if ((0x3fe000000000000L & l) != 0L)
162 {
163 if (kind > 2)
164 kind = 2;
165 jjCheckNAdd(3);
166 }
167 break;
168 case 1:
169 if ((0x3ff200000000000L & l) == 0L)
170 break;
171 if (kind > 1)
172 kind = 1;
173 jjstateSet[jjnewStateCnt++] = 1;
174 break;
175 case 2:
176 if ((0x3fe000000000000L & l) == 0L)
177 break;
178 if (kind > 2)
179 kind = 2;
180 jjCheckNAdd(3);
181 break;
182 case 3:
183 if ((0x3ff000000000000L & l) == 0L)
184 break;
185 if (kind > 2)
186 kind = 2;
187 jjCheckNAdd(3);
188 break;
189 case 4:
190 if ((0x3ff000000000000L & l) == 0L)
191 break;
192 if (kind > 3)
193 kind = 3;
194 jjCheckNAddTwoStates(4, 5);
195 break;
196 case 5:
197 if (curChar == 46)
198 jjCheckNAdd(6);
199 break;
200 case 6:
201 if ((0x3ff000000000000L & l) == 0L)
202 break;
203 if (kind > 3)
204 kind = 3;
205 jjCheckNAdd(6);
206 break;
207 case 7:
208 case 11:
209 if (curChar == 34)
210 jjCheckNAddStates(0, 2);
211 break;
212 case 8:
213 if ((0xffffff7b00000000L & l) != 0L)
214 jjCheckNAddStates(0, 2);
215 break;
216 case 9:
217 if (curChar == 34 && kind > 4)
218 kind = 4;
219 break;
220 case 13:
221 if (curChar == 35)
222 jjstateSet[jjnewStateCnt++] = 14;
223 break;
224 case 14:
225 if ((0x3ff000000000000L & l) != 0L)
226 jjAddStates(3, 4);
227 break;
228 case 15:
229 if ((0x3ff000000000000L & l) != 0L)
230 jjstateSet[jjnewStateCnt++] = 16;
231 break;
232 case 16:
233 if ((0x3ff000000000000L & l) != 0L)
234 jjstateSet[jjnewStateCnt++] = 17;
235 break;
236 case 17:
237 if ((0x3ff000000000000L & l) != 0L)
238 jjstateSet[jjnewStateCnt++] = 18;
239 break;
240 case 18:
241 case 20:
242 if ((0x3ff000000000000L & l) != 0L)
243 jjCheckNAdd(19);
244 break;
245 case 19:
246 if ((0x3ff000000000000L & l) != 0L && kind > 6)
247 kind = 6;
248 break;
249 case 21:
250 if ((0x100003600L & l) == 0L)
251 break;
252 if (kind > 7)
253 kind = 7;
254 jjCheckNAdd(21);
255 break;
256 default : break;
257 }
258 } while(i != startsAt);
259 }
260 else if (curChar < 128)
261 {
262 long l = 1L << (curChar & 077);
263 do
264 {
265 switch(jjstateSet[--i])
266 {
267 case 0:
268 case 1:
269 if ((0x7fffffe87fffffeL & l) == 0L)
270 break;
271 if (kind > 1)
272 kind = 1;
273 jjCheckNAdd(1);
274 break;
275 case 8:
276 if ((0x7fffffffefffffffL & l) != 0L)
277 jjCheckNAddStates(0, 2);
278 break;
279 case 10:
280 if (curChar == 92)
281 jjAddStates(5, 6);
282 break;
283 case 12:
284 if (curChar == 92)
285 jjCheckNAddStates(0, 2);
286 break;
287 case 14:
288 if ((0x7e0000007eL & l) != 0L)
289 jjAddStates(3, 4);
290 break;
291 case 15:
292 if ((0x7e0000007eL & l) != 0L)
293 jjstateSet[jjnewStateCnt++] = 16;
294 break;
295 case 16:
296 if ((0x7e0000007eL & l) != 0L)
297 jjstateSet[jjnewStateCnt++] = 17;
298 break;
299 case 17:
300 if ((0x7e0000007eL & l) != 0L)
301 jjstateSet[jjnewStateCnt++] = 18;
302 break;
303 case 18:
304 case 20:
305 if ((0x7e0000007eL & l) != 0L)
306 jjCheckNAdd(19);
307 break;
308 case 19:
309 if ((0x7e0000007eL & l) != 0L && kind > 6)
310 kind = 6;
311 break;
312 default : break;
313 }
314 } while(i != startsAt);
315 }
316 else
317 {
318 int hiByte = (int)(curChar >> 8);
319 int i1 = hiByte >> 6;
320 long l1 = 1L << (hiByte & 077);
321 int i2 = (curChar & 0xff) >> 6;
322 long l2 = 1L << (curChar & 077);
323 do
324 {
325 switch(jjstateSet[--i])
326 {
327 case 8:
328 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
329 jjAddStates(0, 2);
330 break;
331 default : break;
332 }
333 } while(i != startsAt);
334 }
335 if (kind != 0x7fffffff)
336 {
337 jjmatchedKind = kind;
338 jjmatchedPos = curPos;
339 kind = 0x7fffffff;
340 }
341 ++curPos;
342 if ((i = jjnewStateCnt) == (startsAt = 22 - (jjnewStateCnt = startsAt)))
343 return curPos;
344 try { curChar = input_stream.readChar(); }
345 catch(java.io.IOException e) { return curPos; }
346 }
347}
348private int jjMoveStringLiteralDfa0_1()
349{
350 switch(curChar)
351 {
352 case 42:
353 return jjMoveStringLiteralDfa1_1(0x80000000L);
354 default :
355 return 1;
356 }
357}
358private int jjMoveStringLiteralDfa1_1(long active0)
359{
360 try { curChar = input_stream.readChar(); }
361 catch(java.io.IOException e) {
362 return 1;
363 }
364 switch(curChar)
365 {
366 case 47:
367 if ((active0 & 0x80000000L) != 0L)
368 return jjStopAtPos(1, 31);
369 break;
370 default :
371 return 2;
372 }
373 return 2;
374}
375static final int[] jjnextStates = {
376 8, 9, 10, 15, 20, 11, 12,
377};
378private static final boolean jjCanMove_0(int hiByte, int i1, int i2, long l1, long l2)
379{
380 switch(hiByte)
381 {
382 case 0:
383 return ((jjbitVec2[i2] & l2) != 0L);
384 default :
385 if ((jjbitVec0[i1] & l1) != 0L)
386 return true;
387 return false;
388 }
389}
390
391/** Token literal values. */
392public static final String[] jjstrLiteralImages = {
393"", null, null, null, null, null, null, null, "\52", "\57", "\173", "\175",
394"\133", "\135", "\50", "\51", "\75", "\41", "\41\75", "\72", "\72\72", "\73", "\54",
395"\174", "\174\172", "\53", "\55", "\46", "\77", "\57\52", null, "\52\57", null, };
396
397/** Lexer state names. */
398public static final String[] lexStateNames = {
399 "DEFAULT",
400 "COMMENT",
401};
402
403/** Lex State array. */
404public static final int[] jjnewLexState = {
405 -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,
406 -1, -1, -1, -1, 1, -1, 0, -1,
407};
408static final long[] jjtoToken = {
409 0xffffffdfL,
410};
411static final long[] jjtoSkip = {
412 0x100000000L,
413};
414protected SimpleCharStream input_stream;
415private final int[] jjrounds = new int[22];
416private final int[] jjstateSet = new int[44];
417protected char curChar;
418/** Constructor. */
419public MapCSSParserTokenManager(SimpleCharStream stream){
420 if (SimpleCharStream.staticFlag)
421 throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
422 input_stream = stream;
423}
424
425/** Constructor. */
426public MapCSSParserTokenManager(SimpleCharStream stream, int lexState){
427 this(stream);
428 SwitchTo(lexState);
429}
430
431/** Reinitialise parser. */
432public void ReInit(SimpleCharStream stream)
433{
434 jjmatchedPos = jjnewStateCnt = 0;
435 curLexState = defaultLexState;
436 input_stream = stream;
437 ReInitRounds();
438}
439private void ReInitRounds()
440{
441 int i;
442 jjround = 0x80000001;
443 for (i = 22; i-- > 0;)
444 jjrounds[i] = 0x80000000;
445}
446
447/** Reinitialise parser. */
448public void ReInit(SimpleCharStream stream, int lexState)
449{
450 ReInit(stream);
451 SwitchTo(lexState);
452}
453
454/** Switch to specified lex state. */
455public void SwitchTo(int lexState)
456{
457 if (lexState >= 2 || lexState < 0)
458 throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
459 else
460 curLexState = lexState;
461}
462
463protected Token jjFillToken()
464{
465 final Token t;
466 final String curTokenImage;
467 final int beginLine;
468 final int endLine;
469 final int beginColumn;
470 final int endColumn;
471 String im = jjstrLiteralImages[jjmatchedKind];
472 curTokenImage = (im == null) ? input_stream.GetImage() : im;
473 beginLine = input_stream.getBeginLine();
474 beginColumn = input_stream.getBeginColumn();
475 endLine = input_stream.getEndLine();
476 endColumn = input_stream.getEndColumn();
477 t = Token.newToken(jjmatchedKind, curTokenImage);
478
479 t.beginLine = beginLine;
480 t.endLine = endLine;
481 t.beginColumn = beginColumn;
482 t.endColumn = endColumn;
483
484 return t;
485}
486
487int curLexState = 0;
488int defaultLexState = 0;
489int jjnewStateCnt;
490int jjround;
491int jjmatchedPos;
492int jjmatchedKind;
493
494/** Get the next Token. */
495public Token getNextToken()
496{
497 Token matchedToken;
498 int curPos = 0;
499
500 EOFLoop :
501 for (;;)
502 {
503 try
504 {
505 curChar = input_stream.BeginToken();
506 }
507 catch(java.io.IOException e)
508 {
509 jjmatchedKind = 0;
510 matchedToken = jjFillToken();
511 return matchedToken;
512 }
513
514 switch(curLexState)
515 {
516 case 0:
517 jjmatchedKind = 0x7fffffff;
518 jjmatchedPos = 0;
519 curPos = jjMoveStringLiteralDfa0_0();
520 if (jjmatchedPos == 0 && jjmatchedKind > 30)
521 {
522 jjmatchedKind = 30;
523 }
524 break;
525 case 1:
526 jjmatchedKind = 0x7fffffff;
527 jjmatchedPos = 0;
528 curPos = jjMoveStringLiteralDfa0_1();
529 if (jjmatchedPos == 0 && jjmatchedKind > 32)
530 {
531 jjmatchedKind = 32;
532 }
533 break;
534 }
535 if (jjmatchedKind != 0x7fffffff)
536 {
537 if (jjmatchedPos + 1 < curPos)
538 input_stream.backup(curPos - jjmatchedPos - 1);
539 if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
540 {
541 matchedToken = jjFillToken();
542 if (jjnewLexState[jjmatchedKind] != -1)
543 curLexState = jjnewLexState[jjmatchedKind];
544 return matchedToken;
545 }
546 else
547 {
548 if (jjnewLexState[jjmatchedKind] != -1)
549 curLexState = jjnewLexState[jjmatchedKind];
550 continue EOFLoop;
551 }
552 }
553 int error_line = input_stream.getEndLine();
554 int error_column = input_stream.getEndColumn();
555 String error_after = null;
556 boolean EOFSeen = false;
557 try { input_stream.readChar(); input_stream.backup(1); }
558 catch (java.io.IOException e1) {
559 EOFSeen = true;
560 error_after = curPos <= 1 ? "" : input_stream.GetImage();
561 if (curChar == '\n' || curChar == '\r') {
562 error_line++;
563 error_column = 0;
564 }
565 else
566 error_column++;
567 }
568 if (!EOFSeen) {
569 input_stream.backup(1);
570 error_after = curPos <= 1 ? "" : input_stream.GetImage();
571 }
572 throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
573 }
574}
575
576private void jjCheckNAdd(int state)
577{
578 if (jjrounds[state] != jjround)
579 {
580 jjstateSet[jjnewStateCnt++] = state;
581 jjrounds[state] = jjround;
582 }
583}
584private void jjAddStates(int start, int end)
585{
586 do {
587 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
588 } while (start++ != end);
589}
590private void jjCheckNAddTwoStates(int state1, int state2)
591{
592 jjCheckNAdd(state1);
593 jjCheckNAdd(state2);
594}
595
596private void jjCheckNAddStates(int start, int end)
597{
598 do {
599 jjCheckNAdd(jjnextStates[start]);
600 } while (start++ != end);
601}
602
603}
Note: See TracBrowser for help on using the repository browser.