|
1
2 package org.apache.velocity.runtime.parser;
3 import java.io.*;
4 import java.util.*;
5 import org.apache.velocity.runtime.RuntimeServices;
6 import org.apache.velocity.runtime.parser.node.*;
7 import org.apache.velocity.runtime.directive.Directive;
8 import org.apache.velocity.runtime.directive.Macro;
9 import org.apache.velocity.runtime.directive.MacroParseException;
10 import org.apache.velocity.util.StringUtils;
11
12 public class ParserTokenManager implements ParserConstants
13 {
14 private int fileDepth = 0;
15
16 private int lparen = 0;
17 private int rparen = 0;
18
19 Stack stateStack = new Stack();
20 public boolean debugPrint = false;
21
22 private boolean inReference;
23 public boolean inDirective;
24 private boolean inComment;
25 public boolean inSet;
26
27
35 public boolean stateStackPop()
36 {
37 Hashtable h;
38
39 try
40 {
41 h = (Hashtable) stateStack.pop();
42 }
43 catch( EmptyStackException e)
44 {
45 lparen=0;
46 SwitchTo(DEFAULT);
47 return false;
48 }
49
50 if( debugPrint )
51 System.out.println(
52 " stack pop (" + stateStack.size() + ") : lparen=" +
53 ( (Integer  ) h.get("lparen")).intValue() +
54 " newstate=" + ( (Integer ) h.get("lexstate")).intValue() );
55
56 lparen = ( (Integer ) h.get("lparen")).intValue();
57 rparen = ( (Integer ) h.get("rparen")).intValue();
58
59 SwitchTo( ( (Integer ) h.get("lexstate")).intValue() );
60
61 return true;
62 }
63
64
69 public boolean stateStackPush()
70 {
71 if( debugPrint )
72 System.out.println(" (" + stateStack.size() + ") pushing cur state : " +
73 curLexState );
74
75 Hashtable h = new Hashtable();
76
77 h.put("lexstate", new Integer ( curLexState ) );
78 h.put("lparen", new Integer ( lparen ));
79 h.put("rparen", new Integer ( rparen ));
80
81 lparen = 0;
82
83 stateStack.push( h );
84
85 return true;
86 }
87
88
94 public void clearStateVars()
95 {
96 stateStack.clear();
97
98 lparen = 0;
99 rparen = 0;
100 inReference = false;
101 inDirective = false;
102 inComment = false;
103 inSet = false;
104
105 return;
106 }
107
108
111 private void RPARENHandler()
112 {
113
118
119 boolean closed = false;
120
121 if (inComment)
122 closed = true;
123
124 while( !closed )
125 {
126
131
132 if( lparen > 0)
133 {
134
138
139 if( lparen == rparen + 1)
140 {
141 stateStackPop();
142 }
143 else
144 {
145 rparen++;
146 }
147
148 closed = true;
149 }
150 else
151 {
152
155
156 if(!stateStackPop())
157 break;
158 }
159 }
160 }
161 public java.io.PrintStream debugStream = System.out;
162 public void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
163 private final int jjStopStringLiteralDfa_0(int pos, long active0)
164 {
165 switch (pos)
166 {
167 case 0:
168 if ((active0 & 0x6000000L) != 0L)
169 {
170 jjmatchedKind = 52;
171 return 33;
172 }
173 if ((active0 & 0x10000000L) != 0L)
174 return 31;
175 if ((active0 & 0xd000L) != 0L)
176 return 7;
177 return -1;
178 case 1:
179 if ((active0 & 0x6000000L) != 0L)
180 {
181 jjmatchedKind = 52;
182 jjmatchedPos = 1;
183 return 33;
184 }
185 if ((active0 & 0x4000L) != 0L)
186 return 5;
187 return -1;
188 case 2:
189 if ((active0 & 0x6000000L) != 0L)
190 {
191 jjmatchedKind = 52;
192 jjmatchedPos = 2;
193 return 33;
194 }
195 return -1;
196 case 3:
197 if ((active0 & 0x4000000L) != 0L)
198 {
199 jjmatchedKind = 52;
200 jjmatchedPos = 3;
201 return 33;
202 }
203 if ((active0 & 0x2000000L) != 0L)
204 return 33;
205 return -1;
206 default :
207 return -1;
208 }
209 }
210 private final int jjStartNfa_0(int pos, long active0)
211 {
212 return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
213 }
214 private final int jjStopAtPos(int pos, int kind)
215 {
216 jjmatchedKind = kind;
217 jjmatchedPos = pos;
218 return pos + 1;
219 }
220 private final int jjStartNfaWithStates_0(int pos, int kind, int state)
221 {
222 jjmatchedKind = kind;
223 jjmatchedPos = pos;
224 try { curChar = input_stream.readChar(); }
225 catch(java.io.IOException e) { return pos + 1; }
226 return jjMoveNfa_0(state, pos + 1);
227 }
228 private final int jjMoveStringLiteralDfa0_0()
229 {
230 switch(curChar)
231 {
232 case 33:
233 jjmatchedKind = 41;
234 return jjMoveStringLiteralDfa1_0(0x10000000000L);
235 case 35:
236 jjmatchedKind = 15;
237 return jjMoveStringLiteralDfa1_0(0x5000L);
238 case 37:
239 return jjStopAtPos(0, 32);
240 case 38:
241 return jjMoveStringLiteralDfa1_0(0x200000000L);
242 case 40:
243 return jjStopAtPos(0, 5);
244 case 42:
245 return jjStopAtPos(0, 30);
246 case 43:
247 return jjStopAtPos(0, 29);
248 case 44:
249 return jjStopAtPos(0, 3);
250 case 45:
251 return jjStartNfaWithStates_0(0, 28, 31);
252 case 46:
253 return jjMoveStringLiteralDfa1_0(0x10L);
254 case 47:
255 return jjStopAtPos(0, 31);
256 case 60:
257 jjmatchedKind = 35;
258 return jjMoveStringLiteralDfa1_0(0x1000000000L);
259 case 61:
260 jjmatchedKind = 42;
261 return jjMoveStringLiteralDfa1_0(0x8000000000L);
262 case 62:
263 jjmatchedKind = 37;
264 return jjMoveStringLiteralDfa1_0(0x4000000000L);
265 case 91:
266 return jjStopAtPos(0, 1);
267 case 93:
268 return jjStopAtPos(0, 2);
269 case 102:
270 return jjMoveStringLiteralDfa1_0(0x4000000L);
271 case 116:
272 return jjMoveStringLiteralDfa1_0(0x2000000L);
273 case 124:
274 return jjMoveStringLiteralDfa1_0(0x400000000L);
275 default :
276 return jjMoveNfa_0(0, 0);
277 }
278 }
279 private final int jjMoveStringLiteralDfa1_0(long active0)
280 {
281 try { curChar = input_stream.readChar(); }
282 catch(java.io.IOException e) {
283 jjStopStringLiteralDfa_0(0, active0);
284 return 1;
285 }
286 switch(curChar)
287 {
288 case 35:
289 if ((active0 & 0x1000L) != 0L)
290 return jjStopAtPos(1, 12);
291 break;
292 case 38:
293 if ((active0 & 0x200000000L) != 0L)
294 return jjStopAtPos(1, 33);
295 break;
296 case 42:
297 if ((active0 & 0x4000L) != 0L)
298 return jjStartNfaWithStates_0(1, 14, 5);
299 break;
300 case 46:
301 if ((active0 & 0x10L) != 0L)
302 return jjStopAtPos(1, 4);
303 break;
304 case 61:
305 if ((active0 & 0x1000000000L) != 0L)
306 return jjStopAtPos(1, 36);
307 else if ((active0 & 0x4000000000L) != 0L)
308 return jjStopAtPos(1, 38);
309 else if ((active0 & 0x8000000000L) != 0L)
310 return jjStopAtPos(1, 39);
311 else if ((active0 & 0x10000000000L) != 0L)
312 return jjStopAtPos(1, 40);
313 break;
314 case 97:
315 return jjMoveStringLiteralDfa2_0(active0, 0x4000000L);
316 case 114:
317 return jjMoveStringLiteralDfa2_0(active0, 0x2000000L);
318 case 124:
319 if ((active0 & 0x400000000L) != 0L)
320 return jjStopAtPos(1, 34);
321 break;
322 default :
323 break;
324 }
325 return jjStartNfa_0(0, active0);
326 }
327 private final int jjMoveStringLiteralDfa2_0(long old0, long active0)
328 {
329 if (((active0 &= old0)) == 0L)
330 return jjStartNfa_0(0, old0);
331 try { curChar = input_stream.readChar(); }
332 catch(java.io.IOException e) {
333 jjStopStringLiteralDfa_0(1, active0);
334 return 2;
335 }
336 switch(curChar)
337 {
338 case 108:
339 return jjMoveStringLiteralDfa3_0(active0, 0x4000000L);
340 case 117:
341 return jjMoveStringLiteralDfa3_0(active0, 0x2000000L);
342 default :
343 break;
344 }
345 return jjStartNfa_0(1, active0);
346 }
347 private final int jjMoveStringLiteralDfa3_0(long old0, long active0)
348 {
349 if (((active0 &= old0)) == 0L)
350 return jjStartNfa_0(1, old0);
351 try { curChar = input_stream.readChar(); }
352 catch(java.io.IOException e) {
353 jjStopStringLiteralDfa_0(2, active0);
354 return 3;
355 }
356 switch(curChar)
357 {
358 case 101:
359 if ((active0 & 0x2000000L) != 0L)
360 return jjStartNfaWithStates_0(3, 25, 33);
361 break;
362 case 115:
363 return jjMoveStringLiteralDfa4_0(active0, 0x4000000L);
364 default :
365 break;
366 }
367 return jjStartNfa_0(2, active0);
368 }
369 private final int jjMoveStringLiteralDfa4_0(long old0, long active0)
370 {
371 if (((active0 &= old0)) == 0L)
372 return jjStartNfa_0(2, old0);
373 try { curChar = input_stream.readChar(); }
374 catch(java.io.IOException e) {
375 jjStopStringLiteralDfa_0(3, active0);
376 return 4;
377 }
378 switch(curChar)
379 {
380 case 101:
381 if ((active0 & 0x4000000L) != 0L)
382 return jjStartNfaWithStates_0(4, 26, 33);
383 break;
384 default :
385 break;
386 }
387 return jjStartNfa_0(3, active0);
388 }
389 private final void jjCheckNAdd(int state)
390 {
391 if (jjrounds[state] != jjround)
392 {
393 jjstateSet[jjnewStateCnt++] = state;
394 jjrounds[state] = jjround;
395 }
396 }
397 private final void jjAddStates(int start, int end)
398 {
399 do {
400 jjstateSet[jjnewStateCnt++] = jjnextStates[start];
401 } while (start++ != end);
402 }
403 private final void jjCheckNAddTwoStates(int state1, int state2)
404 {
405 jjCheckNAdd(state1);
406 jjCheckNAdd(state2);
407 }
408 private final void jjCheckNAddStates(int start, int end)
409 {
410 do {
411 jjCheckNAdd(jjnextStates[start]);
412 } while (start++ != end);
413 }
414 private final void jjCheckNAddStates(int start)
415 {
416 jjCheckNAdd(jjnextStates[start]);
417 jjCheckNAdd(jjnextStates[start + 1]);
418 }
419 static final long[] jjbitVec0 = {
420 0xfffffffffffffffeL, 0xffffffffffffffffL, 0xffffffffffffffffL, 0xffffffffffffffffL
421 };
422 static final long[] jjbitVec2 = {
423 0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
424 };
425 private final int jjMoveNfa_0(int startState, int curPos)
426 {
427 int[] nextStates;
428 int startsAt = 0;
429 jjnewStateCnt = 42;
430 int i = 1;
431 jjstateSet[0] = startState;
432 int j, kind = 0x7fffffff;
433 for (;;)
434 {
435 if (++jjround == 0x7fffffff)
436 ReInitRounds();
437 if (curChar < 64)
438 {
439 long l = 1L << curChar;
440 MatchLoop: do
441 {
442 switch(jjstateSet[--i])
443 {
444 case 0:
445 if ((0x3ff000000000000L & l) != 0L)
446 {
447 if (kind > 49)
448 kind = 49;
449 jjCheckNAdd(31);
450 }
451 else if ((0x2400L & l) != 0L)
452 {
453 if (kind > 27)
454 kind = 27;
455 }
456 else if ((0x100000200L & l) != 0L)
457 {
458 if (kind > 23)
459 kind = 23;
460 jjCheckNAdd(9);
461 }
462 else if (curChar == 36)
463 {
464 if (kind > 10)
465 kind = 10;
466 jjCheckNAddTwoStates(39, 40);
467 }
468 else if (curChar == 45)
469 jjCheckNAdd(31);
470 else if (curChar == 39)
471 jjCheckNAddStates(0, 2);
472 else if (curChar == 34)
473 jjCheckNAddStates(3, 5);
474 else if (curChar == 35)
475 jjstateSet[jjnewStateCnt++] = 7;
476 else if (curChar == 41)
477 {
478 if (kind > 6)
479 kind = 6;
480 jjCheckNAddStates(6, 8);
481 }
482 if (curChar == 13)
483 jjstateSet[jjnewStateCnt++] = 28;
484 break;
485 case 1:
486 if ((0x100000200L & l) != 0L)
487 jjCheckNAddStates(6, 8);
488 break;
489 case 2:
490 if ((0x2400L & l) != 0L && kind > 6)
491 kind = 6;
492 break;
493 case 3:
494 if (curChar == 10 && kind > 6)
495 kind = 6;
496 break;
497 case 4:
498 if (curChar == 13)
499 jjstateSet[jjnewStateCnt++] = 3;
500 break;
501 case 5:
502 if (curChar == 42)
503 jjstateSet[jjnewStateCnt++] = 6;
504 break;
505 case 6:
506 if ((0xfffffff7ffffffffL & l) != 0L && kind > 13)
507 kind = 13;
508 break;
509 case 7:
510 if (curChar == 42)
511 jjstateSet[jjnewStateCnt++] = 5;
512 break;
513 case 8:
514 if (curChar == 35)
515 jjstateSet[jjnewStateCnt++] = 7;
516 break;
517 case 9:
518 if ((0x100000200L & l) == 0L)
519 break;
520 if (kind > 23)
521 kind = 23;
522 jjCheckNAdd(9);
523 break;
524 case 10:
525 if (curChar == 34)
526 jjCheckNAddStates(3, 5);
527 break;
528 case 11:
529 if ((0xfffffffbffffdbffL & l) != 0L)
530 jjCheckNAddStates(3, 5);
531 break;
532 case 12:
533 if (curChar == 34 && kind > 24)
534 kind = 24;
535 break;
536 case 14:
537 if ((0x8400000000L & l) != 0L)
538 jjCheckNAddStates(3, 5);
539 break;
540 case 15:
541 if ((0xff000000000000L & l) != 0L)
542 jjCheckNAddStates(9, 12);
543 break;
544 case 16:
545 if ((0xff000000000000L & l) != 0L)
546 jjCheckNAddStates(3, 5);
547 break;
548 case 17:
549 if ((0xf000000000000L & l) != 0L)
550 jjstateSet[jjnewStateCnt++] = 18;
551 break;
552 case 18:
553 if ((0xff000000000000L & l) != 0L)
554 jjCheckNAdd(16);
555 break;
556 case 19:
557 if (curChar == 32)
558 jjAddStates(13, 14);
559 break;
560 case 20:
561 if (curChar == 10)
562 jjCheckNAddStates(3, 5);
563 break;
564 case 21:
565 if (curChar == 39)
566 jjCheckNAddStates(0, 2);
567 break;
568 case 22:
569 if ((0xffffff7fffffdbffL & l) != 0L)
570 jjCheckNAddStates(0, 2);
571 break;
572 case 24:
573 if (curChar == 32)
574 jjAddStates(15, 16);
575 break;
576 case 25:
577 if (curChar == 10)
578 jjCheckNAddStates(0, 2);
579 break;
580 case 26:
581 if (curChar == 39 && kind > 24)
582 kind = 24;
583 break;
584 case 27:
585 if ((0x2400L & l) != 0L && kind > 27)
586 kind = 27;
587 break;
588 case 28:
589 if (curChar == 10 && kind > 27)
590 kind = 27;
591 break;
592 case 29:
593 if (curChar == 13)
594 jjstateSet[jjnewStateCnt++] = 28;
595 break;
596 case 30:
597 if (curChar == 45)
598 jjCheckNAdd(31);
599 break;
600 case 31:
601 if ((0x3ff000000000000L & l) == 0L)
602 break;
603 if (kind > 49)
604 kind = 49;
605 jjCheckNAdd(31);
606 break;
607 case 33:
608 if ((0x3ff000000000000L & l) == 0L)
609 break;
610 if (kind > 52)
611 kind = 52;
612 jjstateSet[jjnewStateCnt++] = 33;
613 break;
614 case 36:
615 if (curChar == 36 && kind > 10)
616 kind = 10;
617 break;
618 case 38:
619 if (curChar == 36)
620 jjCheckNAddTwoStates(39, 40);
621 break;
622 case 40:
623 if (curChar == 33 && kind > 11)
624 kind = 11;
625 break;
626 case 41:
627 if (curChar != 36)
628 break;
629 if (kind > 10)
630 kind = 10;
631 jjCheckNAddTwoStates(39, 40);
632 break;
633 default : break;
634 }
635 } while(i != startsAt);
636 }
637 else if (curChar < 128)
638 {
639 long l = 1L << (curChar & 077);
640 MatchLoop: do
641 {
642 switch(jjstateSet[--i])
643 {
644 case 0:
645 if ((0x7fffffe87fffffeL & l) != 0L)
646 {
647 if (kind > 52)
648 kind = 52;
649 jjCheckNAdd(33);
650 }
651 else if (curChar == 92)
652 jjCheckNAddStates(17, 20);
653 break;
654 case 6:
655 if (kind > 13)
656 kind = 13;
657 break;
658 case 11:
659 if ((0xffffffffefffffffL & l) != 0L)
660 jjCheckNAddStates(3, 5);
661 break;
662 case 13:
663 if (curChar == 92)
664 jjAddStates(21, 25);
665 break;
666 case 14:
667 if ((0x14404410000000L & l) != 0L)
668 jjCheckNAddStates(3, 5);
669 break;
670 case 22:
671 jjAddStates(0, 2);
672 break;
673 case 23:
674 if (curChar == 92)
675 jjAddStates(15, 16);
676 break;
677 case 32:
678 case 33:
679 if ((0x7fffffe87fffffeL & l) == 0L)
680 break;
681 if (kind > 52)
682 kind = 52;
683 jjCheckNAdd(33);
684 break;
685 case 34:
686 if (curChar == 92)
687 jjCheckNAddStates(17, 20);
688 break;
689 case 35:
690 if (curChar == 92)
691 jjCheckNAddTwoStates(35, 36);
692 break;
693 case 37:
694 if (curChar == 92)
695 jjCheckNAddTwoStates(37, 38);
696 break;
697 case 39:
698 if (curChar == 92)
699 jjAddStates(26, 27);
700 break;
701 default : break;
702 }
703 } while(i != startsAt);
704 }
705 else
706 {
707 int hiByte = (int)(curChar >> 8);
708 int i1 = hiByte >> 6;
709 long l1 = 1L << (hiByte & 077);
710 int i2 = (curChar & 0xff) >> 6;
711 long l2 = 1L << (curChar & 077);
712 MatchLoop: do
713 {
714 switch(jjstateSet[--i])
715 {
716 case 6:
717 if (jjCanMove_0(hiByte, i1, i2, l1, l2) && kind > 13)
718 kind = 13;
719 break;
720 case 11:
721 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
722 jjAddStates(3, 5);
723 break;
724 case 22:
725 if (jjCanMove_0(hiByte, i1, i2, l1, l2))
726 jjAddStates(0, 2);
727 break;
728 default : break;
729 }
730 } while(i != startsAt);
731 }
732 if (kind != 0x7fffffff)
733 {
734 jjmatchedKind = kind;
735 jjmatchedPos = curPos;
736 kind = 0x7fffffff;
737 }
738 ++curPos;
739 if ((i = jjnewStateCnt) ==
|
Java API By Example, From Geeks To Geeks.