1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.seasar.tuigwaa.cms.core.wiki.engine;
18
19 import java.util.List;
20 import java.util.ArrayList;
21
22 import org.apache.commons.logging.Log;
23 import org.apache.commons.logging.LogFactory;
24
25 import org.seasar.tuigwaa.cms.core.wiki.base.WikiHelper;
26
27 /***
28 * @author someda
29 *
30 * NOT TO IMPLMENT: (2005/10)
31 * - Table format ('h','c', at the end of table line)
32 * - Interwiki
33 *
34 * NOTE:
35 * - Token Specification Policy
36 * Token is defined as simple as possible.
37 * As the lexical tips (https://javacc.dev.java.net/doc/lexertips.html) says,
38 * the complex RE in token definition is avoided as much as possible,
39 * otherwise most of such jobs will be done by parser using LOOKAHEAD.
40 * - ParseException Handling Policy
41 * In GenerateTree(),BlockElement() and InlineElement(),
42 * ParseException will be caught, that is 3-level error handling.
43 * The one caught in GenerateTree() is thought as Fatal Exception,
44 * because syntax error should be caught in try-catch clause of
45 * BlockElement() or InlineElement().
46 * In BlockElement(), when exception occurs, it will proceed
47 * TokenManager consumption until next newline token will apear,
48 * as to InlineElement it'll do nothing about TokenManager.
49 * During exception handling in both BlockElement() and InlineElement(),
50 * it pushes WikiErrors node on top of the stack for not losing
51 * error position itself.
52 * NT Errors() is just only for this purpose and will not be generated
53 * during regular parsing.
54 */
55 public class WikiParser
56 protected JJTWikiParserState jjtree = new JJTWikiParserState();
57 private static final int[] BLOCKELEMENT_KIND =
58 {NL,EXCERPT1,EXCERPT2,EXCERPT3,LIST1,LIST2,LIST3,NLIST1,NLIST2,NLIST3,
59 DLIST,PRESHAPED,TABLE,CTABLE,HEADING1,HEADING2,HEADING3,ALIGN1,ALIGN2,ALIGN3,
60 FALIGN1,FALIGN2,HORIZONTAL,BLOCKPLUGIN,EOF};
61
62 private static final int[] EXCERPT_KIND = {EXCERPT1,EXCERPT2,EXCERPT3};
63 private static final int[] LIST_KIND = {LIST1,LIST2,LIST3,NLIST1,NLIST2,NLIST3};
64 private static final int[] PRESHAPED_KIND = {PRESHAPED};
65 private static final int[] HEADING_KIND = {HEADING1,HEADING2,HEADING3};
66 private static final int[] ALIGN_KIND = {ALIGN1,ALIGN2,ALIGN3};
67 private static final int[] FALIGN_KIND = {FALIGN1,FALIGN2};
68 private static final int[] HORIZONTAL_KIND = {HORIZONTAL};
69 private static final int[] BLOCKPLUGIN_KIND = {BLOCKPLUGIN};
70
71 private List toc_ = new ArrayList();
72 private List annotation_ = new ArrayList();
73 private int nParseErrors_ = 0;
74 private int startpos_ = -1;
75
76 private Log log_ = LogFactory.getLog(getClass());
77
78 public WikiParser(){
79 }
80
81 public int addAnnotation(SimpleNode node){
82 annotation_.add(node);
83 return annotation_.size();
84 }
85
86 public int addTOC(SimpleNode node){
87 toc_.add(node);
88 return toc_.size();
89 }
90
91 public int getNParseErrors(){
92 return nParseErrors_;
93 }
94
95 public int getNLexicalErrors(){
96 return token_source.getNLexicalErrors();
97 }
98
99 /***
100 * Setting current buffer position of JavaCharacterStream
101 * for error recovery.
102 * JavaCharacterStream uses ring buffer to store the character
103 * stream inside its instance.
104 */
105
106
107
108
109
110
111
112
113
114
115
116
117 protected void setStartPosition(){
118 this.startpos_ = jj_input_stream.bufpos;
119 }
120
121 protected void initStartPosition(){
122 this.startpos_ = -1;
123 }
124
125 protected String getErrorLine(){
126
127 if(startpos_ == -1) return "";
128
129 int curpos = jj_input_stream.bufpos;
130 log_.error("current position :" + curpos);
131 log_.error("start position :" + startpos_);
132 log_.error("Token Begin :" + jj_input_stream.tokenBegin);
133 log_.error("Token Source Matched Position :" + token_source.jjmatchedPos);
134
135 if(curpos >= startpos_)
136 return new String(jj_input_stream.buffer,startpos_,curpos - startpos_ + 1);
137 else
138 return new String(jj_input_stream.buffer,startpos_,jj_input_stream.bufsize-startpos_)+
139 new String(jj_input_stream.buffer,0,curpos+1);
140 }
141
142
143
144
145 protected boolean isBlankline(){
146 Token t1 = getToken(1);
147 Token t2 = getToken(2);
148 return (t1.kind == NL && (t2.kind == NL || t2.kind == EOF || t2.kind == TABLE || t2.kind == CTABLE || t2.kind == DLIST));
149 }
150
151
152 protected boolean isParagraph(){
153 boolean flag = true;
154 if(isNewline(1)){
155 for(int i=0;i<BLOCKELEMENT_KIND.length;i++){
156 Token t = getToken(2);
157 if(t.kind == BLOCKELEMENT_KIND[i]){
158 flag = false;
159 break;
160 }
161 }
162 }else{
163 flag = false;
164 }
165
166 if(isTable()) flag = false;
167 if(isCSVTable()) flag = false;
168 if(isDefineList()) flag = false;
169 return flag;
170 }
171
172
173 protected boolean isNormalBlockElement(int[] types){
174
175
176 if(getToken(1).kind == NL){
177 Token t = getToken(2);
178 for(int i=0; i < types.length; i++){
179 if(t.kind == types[i]) return true;
180 }
181 }
182 return false;
183 }
184
185
186 protected boolean isChangeStateBlockElement(int type){
187 Token t = getToken(1);
188 return (t.kind == type);
189 }
190
191
192 protected boolean isExcerpt(){
193 return isNormalBlockElement(EXCERPT_KIND);
194 }
195
196
197 protected boolean isList(){
198 return isNormalBlockElement(LIST_KIND);
199 }
200
201
202 protected boolean isDefineList(){
203 return isChangeStateBlockElement(DLIST);
204 }
205
206
207 protected boolean isPreshaped(){
208 return isNormalBlockElement(PRESHAPED_KIND);
209 }
210
211
212 protected boolean isTable(){
213 return isChangeStateBlockElement(TABLE);
214 }
215
216
217 protected boolean isCSVTable(){
218 return isChangeStateBlockElement(CTABLE);
219 }
220
221
222 protected boolean isHeading(){
223 return isNormalBlockElement(HEADING_KIND);
224 }
225
226
227 protected boolean isAlign(){
228 return isNormalBlockElement(ALIGN_KIND);
229 }
230
231 protected boolean isFloatAlign(){
232 return isNormalBlockElement(FALIGN_KIND);
233 }
234
235
236 protected boolean isHorizontalline(){
237 return isNormalBlockElement(HORIZONTAL_KIND);
238 }
239
240
241 protected boolean isBlockPlugin(){
242 return isNormalBlockElement(BLOCKPLUGIN_KIND);
243 }
244
245 protected boolean isNewline(int pos){
246 Token t = getToken(pos);
247 return (t.kind == NL || t.kind == TABLE || t.kind == CTABLE || t.kind == DLIST);
248 }
249
250
251
252
253 private void processError(String msg, boolean inline,ParseException pe){
254 ++nParseErrors_;
255 WikiErrors enode = new WikiErrors(JJTERRORS);
256
257 StringBuffer buf = new StringBuffer();
258 buf.append(getToken(0).image);
259 jjtree.openNodeScope(enode);
260
261
262
263
264
265 if(isNewline(0)) getNextToken();
266
267 if(inline){
268 if(!isNewline(1)) getNextToken();
269 }else{
270 while(!isNewline(1)){
271 buf.append(getNextToken().image);
272 }
273 }
274 enode.letter = buf.toString();
275 jjtree.closeNodeScope(enode,true);
276 log_.error(msg);
277 log_.error(enode.letter);
278 }
279
280 void SyntaxError() throws ParseException {
281 trace_call("SyntaxError");
282 try {
283
284 WikiSyntaxError jjtn000 = new WikiSyntaxError(JJTSYNTAXERROR);
285 boolean jjtc000 = true;
286 jjtree.openNodeScope(jjtn000);
287 try {ParseException e = generateParseException();
288 StringBuffer buf = new StringBuffer();
289 buf.append(getToken(0));
290 Token t;
291 while(!isNewline(1)){
292 t=getNextToken();
293 buf.append(t.image);
294 }
295 jjtn000.letter = buf.toString();
296 throw e;
297 } finally {
298 if (jjtc000) {
299 jjtree.closeNodeScope(jjtn000, true);
300 }
301 }
302 } finally {
303 trace_return("SyntaxError");
304 }
305 }
306
307 void SkipToNewline() throws ParseException {
308 trace_call("SkipToNewline");
309 try {
310
311 WikiSkipToNewline jjtn000 = new WikiSkipToNewline(JJTSKIPTONEWLINE);
312 boolean jjtc000 = true;
313 jjtree.openNodeScope(jjtn000);
314 try {StringBuffer buf = new StringBuffer();
315 while(!isNewline(1)){
316 Token t=getNextToken();
317 buf.append(t.image);
318 }
319 jjtn000.letter = buf.toString();
320 } finally {
321 if (jjtc000) {
322 jjtree.closeNodeScope(jjtn000, true);
323 }
324 }
325 } finally {
326 trace_return("SkipToNewline");
327 }
328 }
329
330
331 final public void GenerateTree() throws ParseException {
332 trace_call("GenerateTree");
333 try {
334
335 WikiGenerateTree jjtn000 = new WikiGenerateTree(JJTGENERATETREE);
336 boolean jjtc000 = true;
337 jjtree.openNodeScope(jjtn000);
338 try {
339 label_1:
340 while (true) {
341 try {
342 if (jj_2_1(1)) {
343 BlockElement();
344 } else {
345 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
346 case 0:
347 jj_consume_token(0);
348 jjtn000.annotation = annotation_;
349 jjtn000.toc = toc_;
350 {if (true) return;}
351 break;
352 default:
353 SyntaxError();
354 }
355 }
356 } catch (ParseException pe) {
357 ++nParseErrors_;
358 processError("critical parsing error at syntax level.",false,pe);
359 }
360 ;
361 }
362 } catch (Throwable jjte000) {
363 if (jjtc000) {
364 jjtree.clearNodeScope(jjtn000);
365 jjtc000 = false;
366 } else {
367 jjtree.popNode();
368 }
369 if (jjte000 instanceof RuntimeException) {
370 {if (true) throw (RuntimeException)jjte000;}
371 }
372 if (jjte000 instanceof ParseException) {
373 {if (true) throw (ParseException)jjte000;}
374 }
375 {if (true) throw (Error)jjte000;}
376 } finally {
377 if (jjtc000) {
378 jjtree.closeNodeScope(jjtn000, true);
379 }
380 }
381 } finally {
382 trace_return("GenerateTree");
383 }
384 }
385
386 final public void BlockElement() throws ParseException {
387 trace_call("BlockElement");
388 try {
389 try {
390 if (isExcerpt()) {
391 Excerpt();
392 } else if (isList()) {
393 List();
394 } else if (isDefineList()) {
395 DefineList();
396 } else if (isPreshaped()) {
397 Preshaped();
398 } else if (isTable()) {
399 Table();
400 } else if (isCSVTable()) {
401 CSVTable();
402 } else if (isHeading()) {
403 Heading();
404 } else if (isAlign()) {
405 Align();
406 } else if (isFloatAlign()) {
407 FloatAlign();
408 } else if (isHorizontalline()) {
409 Horizontalline();
410 } else if (isBlankline()) {
411 Blankline();
412 } else if (isBlockPlugin()) {
413 BlockPlugin();
414 } else if (jj_2_2(1)) {
415 Paragraph();
416 } else {
417 jj_consume_token(-1);
418 throw new ParseException();
419 }
420 } catch (ParseException pe) {
421 processError("parsing error for block element.",false,pe);
422 }
423 } finally {
424 trace_return("BlockElement");
425 }
426 }
427
428 final public void InlineElement() throws ParseException {
429 trace_call("InlineElement");
430 try {
431 try {
432 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
433 case STRONGITALIC:
434 StrongItalic();
435 break;
436 case DELETELINE:
437 Deleteline();
438 break;
439 case 73:
440 Annotation();
441 break;
442 case PAGENAME:
443 case LINK:
444 case INTERWIKI:
445 case ALIASLINK:
446 case ALIAS:
447 Linker();
448 break;
449 case INLINEPLUGIN:
450 InlinePlugin();
451 break;
452 case TILDE:
453 case SEMICOLON:
454 case LPAREN:
455 case RPAREN:
456 case LBRACKET:
457 case RBRACKET:
458 case LBRACE:
459 case RBRACE:
460 case SLASH:
461 case LT:
462 case EXCERPT1:
463 case EXCERPT2:
464 case EXCERPT3:
465 case LIST1:
466 case LIST2:
467 case LIST3:
468 case NLIST1:
469 case NLIST2:
470 case NLIST3:
471 case PRESHAPED:
472 case HEADING1:
473 case HEADING2:
474 case HEADING3:
475 case ALIGN1:
476 case ALIGN2:
477 case ALIGN3:
478 case FALIGN1:
479 case FALIGN2:
480 case HORIZONTAL:
481 case BLOCKPLUGIN:
482 case COLSPAN:
483 case PIPE:
484 case COLON:
485 case COMMA:
486 case WIKINAME:
487 case NATIVELINK:
488 case ANCHOR:
489 case IDENTIFIER:
490 case ARGS:
491 Letters();
492 break;
493 case ANYOTHER:
494 AnyOther();
495 break;
496 default:
497 jj_consume_token(-1);
498 throw new ParseException();
499 }
500 } catch (ParseException pe) {
501 processError("parsing error for inline element.",true,pe);
502 }
503 } finally {
504 trace_return("InlineElement");
505 }
506 }
507
508
509 final public void Paragraph() throws ParseException {
510 trace_call("Paragraph");
511 try {
512
513 WikiParagraph jjtn000 = new WikiParagraph(JJTPARAGRAPH);
514 boolean jjtc000 = true;
515 jjtree.openNodeScope(jjtn000);
516 try {
517 label_2:
518 while (true) {
519 jj_consume_token(NL);
520 if (jj_2_3(2147483647) && (!isNewline(2))) {
521 jj_consume_token(TILDE);
522 } else {
523 ;
524 }
525 label_3:
526 while (true) {
527 InlineElement();
528 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
529 case TILDE:
530 case SEMICOLON:
531 case LPAREN:
532 case RPAREN:
533 case LBRACKET:
534 case RBRACKET:
535 case LBRACE:
536 case RBRACE:
537 case SLASH:
538 case LT:
539 case EXCERPT1:
540 case EXCERPT2:
541 case EXCERPT3:
542 case LIST1:
543 case LIST2:
544 case LIST3:
545 case NLIST1:
546 case NLIST2:
547 case NLIST3:
548 case PRESHAPED:
549 case HEADING1:
550 case HEADING2:
551 case HEADING3:
552 case ALIGN1:
553 case ALIGN2:
554 case ALIGN3:
555 case FALIGN1:
556 case FALIGN2:
557 case HORIZONTAL:
558 case BLOCKPLUGIN:
559 case COLSPAN:
560 case PIPE:
561 case COLON:
562 case COMMA:
563 case DELETELINE:
564 case STRONGITALIC:
565 case WIKINAME:
566 case NATIVELINK:
567 case ANCHOR:
568 case PAGENAME:
569 case LINK:
570 case INTERWIKI:
571 case ALIASLINK:
572 case ALIAS:
573 case IDENTIFIER:
574 case ARGS:
575 case INLINEPLUGIN:
576 case ANYOTHER:
577 case 73:
578 ;
579 break;
580 default:
581 break label_3;
582 }
583 }
584 if (isParagraph()) {
585 ;
586 } else {
587 break label_2;
588 }
589 }
590 } catch (Throwable jjte000) {
591 if (jjtc000) {
592 jjtree.clearNodeScope(jjtn000);
593 jjtc000 = false;
594 } else {
595 jjtree.popNode();
596 }
597 if (jjte000 instanceof RuntimeException) {
598 {if (true) throw (RuntimeException)jjte000;}
599 }
600 if (jjte000 instanceof ParseException) {
601 {if (true) throw (ParseException)jjte000;}
602 }
603 {if (true) throw (Error)jjte000;}
604 } finally {
605 if (jjtc000) {
606 jjtree.closeNodeScope(jjtn000, true);
607 }
608 }
609 } finally {
610 trace_return("Paragraph");
611 }
612 }
613
614 final public void Excerpt() throws ParseException {
615 trace_call("Excerpt");
616 try {
617
618 WikiExcerpt jjtn000 = new WikiExcerpt(JJTEXCERPT);
619 boolean jjtc000 = true;
620 jjtree.openNodeScope(jjtn000);Token t;
621 try {
622 jj_consume_token(NL);
623 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
624 case EXCERPT1:
625 t = jj_consume_token(EXCERPT1);
626 break;
627 case EXCERPT2:
628 t = jj_consume_token(EXCERPT2);
629 break;
630 case EXCERPT3:
631 t = jj_consume_token(EXCERPT3);
632 break;
633 default:
634 jj_consume_token(-1);
635 throw new ParseException();
636 }
637 label_4:
638 while (true) {
639 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
640 case TILDE:
641 case SEMICOLON:
642 case LPAREN:
643 case RPAREN:
644 case LBRACKET:
645 case RBRACKET:
646 case LBRACE:
647 case RBRACE:
648 case SLASH:
649 case LT:
650 case EXCERPT1:
651 case EXCERPT2:
652 case EXCERPT3:
653 case LIST1:
654 case LIST2:
655 case LIST3:
656 case NLIST1:
657 case NLIST2:
658 case NLIST3:
659 case PRESHAPED:
660 case HEADING1:
661 case HEADING2:
662 case HEADING3:
663 case ALIGN1:
664 case ALIGN2:
665 case ALIGN3:
666 case FALIGN1:
667 case FALIGN2:
668 case HORIZONTAL:
669 case BLOCKPLUGIN:
670 case COLSPAN:
671 case PIPE:
672 case COLON:
673 case COMMA:
674 case DELETELINE:
675 case STRONGITALIC:
676 case WIKINAME:
677 case NATIVELINK:
678 case ANCHOR:
679 case PAGENAME:
680 case LINK:
681 case INTERWIKI:
682 case ALIASLINK:
683 case ALIAS:
684 case IDENTIFIER:
685 case ARGS:
686 case INLINEPLUGIN:
687 case ANYOTHER:
688 case 73:
689 ;
690 break;
691 default:
692 break label_4;
693 }
694 InlineElement();
695 }
696 label_5:
697 while (true) {
698 if (jj_2_4(1)) {
699 ;
700 } else {
701 break label_5;
702 }
703 if (isExcerpt()) {
704 Excerpt();
705 } else if (isList()) {
706 List();
707 } else if (isDefineList()) {
708 DefineList();
709 } else if (isPreshaped()) {
710 Preshaped();
711 } else if (isTable()) {
712 Table();
713 } else if (isCSVTable()) {
714 CSVTable();
715 } else if (isAlign()) {
716 Align();
717 } else if (isBlockPlugin()) {
718 BlockPlugin();
719 } else if (isParagraph()) {
720 Paragraph();
721 } else {
722 jj_consume_token(-1);
723 throw new ParseException();
724 }
725 }
726 jjtree.closeNodeScope(jjtn000, true);
727 jjtc000 = false;
728 jjtn000.level = t.image.length();
729 } catch (Throwable jjte000) {
730 if (jjtc000) {
731 jjtree.clearNodeScope(jjtn000);
732 jjtc000 = false;
733 } else {
734 jjtree.popNode();
735 }
736 if (jjte000 instanceof RuntimeException) {
737 {if (true) throw (RuntimeException)jjte000;}
738 }
739 if (jjte000 instanceof ParseException) {
740 {if (true) throw (ParseException)jjte000;}
741 }
742 {if (true) throw (Error)jjte000;}
743 } finally {
744 if (jjtc000) {
745 jjtree.closeNodeScope(jjtn000, true);
746 }
747 }
748 } finally {
749 trace_return("Excerpt");
750 }
751 }
752
753 final public void List() throws ParseException {
754 trace_call("List");
755 try {
756
757 WikiList jjtn000 = new WikiList(JJTLIST);
758 boolean jjtc000 = true;
759 jjtree.openNodeScope(jjtn000);Token t;
760 try {
761 label_6:
762 while (true) {
763 WikiListMember jjtn001 = new WikiListMember(JJTLISTMEMBER);
764 boolean jjtc001 = true;
765 jjtree.openNodeScope(jjtn001);
766 try {
767 if (isList()) {
768
769 } else {
770 jj_consume_token(-1);
771 throw new ParseException();
772 }
773 jj_consume_token(NL);
774 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
775 case LIST1:
776 t = jj_consume_token(LIST1);
777 break;
778 case LIST2:
779 t = jj_consume_token(LIST2);
780 break;
781 case LIST3:
782 t = jj_consume_token(LIST3);
783 break;
784 case NLIST1:
785 t = jj_consume_token(NLIST1);
786 break;
787 case NLIST2:
788 t = jj_consume_token(NLIST2);
789 break;
790 case NLIST3:
791 t = jj_consume_token(NLIST3);
792 break;
793 default:
794 jj_consume_token(-1);
795 throw new ParseException();
796 }
797 label_7:
798 while (true) {
799 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
800 case TILDE:
801 case SEMICOLON:
802 case LPAREN:
803 case RPAREN:
804 case LBRACKET:
805 case RBRACKET:
806 case LBRACE:
807 case RBRACE:
808 case SLASH:
809 case LT:
810 case EXCERPT1:
811 case EXCERPT2:
812 case EXCERPT3:
813 case LIST1:
814 case LIST2:
815 case LIST3:
816 case NLIST1:
817 case NLIST2:
818 case NLIST3:
819 case PRESHAPED:
820 case HEADING1:
821 case HEADING2:
822 case HEADING3:
823 case ALIGN1:
824 case ALIGN2:
825 case ALIGN3:
826 case FALIGN1:
827 case FALIGN2:
828 case HORIZONTAL:
829 case BLOCKPLUGIN:
830 case COLSPAN:
831 case PIPE:
832 case COLON:
833 case COMMA:
834 case DELETELINE:
835 case STRONGITALIC:
836 case WIKINAME:
837 case NATIVELINK:
838 case ANCHOR:
839 case PAGENAME:
840 case LINK:
841 case INTERWIKI:
842 case ALIASLINK:
843 case ALIAS:
844 case IDENTIFIER:
845 case ARGS:
846 case INLINEPLUGIN:
847 case ANYOTHER:
848 case 73:
849 ;
850 break;
851 default:
852 break label_7;
853 }
854 InlineElement();
855 }
856 label_8:
857 while (true) {
858 if (jj_2_5(1)) {
859 ;
860 } else {
861 break label_8;
862 }
863 if (isExcerpt()) {
864 Excerpt();
865 } else if (isDefineList()) {
866 DefineList();
867 } else if (isPreshaped()) {
868 Preshaped();
869 } else if (isTable()) {
870 Table();
871 } else if (isCSVTable()) {
872 CSVTable();
873 } else if (isAlign()) {
874 Align();
875 } else if (isBlockPlugin()) {
876 BlockPlugin();
877 } else if (isParagraph()) {
878 Paragraph();
879 } else {
880 jj_consume_token(-1);
881 throw new ParseException();
882 }
883 }
884 jjtree.closeNodeScope(jjtn001, true);
885 jjtc001 = false;
886 jjtn001.level = t.image.length();
887 jjtn001.type = WikiHelper.getListType(t.image);
888 } catch (Throwable jjte001) {
889 if (jjtc001) {
890 jjtree.clearNodeScope(jjtn001);
891 jjtc001 = false;
892 } else {
893 jjtree.popNode();
894 }
895 if (jjte001 instanceof RuntimeException) {
896 {if (true) throw (RuntimeException)jjte001;}
897 }
898 if (jjte001 instanceof ParseException) {
899 {if (true) throw (ParseException)jjte001;}
900 }
901 {if (true) throw (Error)jjte001;}
902 } finally {
903 if (jjtc001) {
904 jjtree.closeNodeScope(jjtn001, true);
905 }
906 }
907 if (jj_2_6(1)) {
908 ;
909 } else {
910 break label_6;
911 }
912 }
913 } catch (Throwable jjte000) {
914 if (jjtc000) {
915 jjtree.clearNodeScope(jjtn000);
916 jjtc000 = false;
917 } else {
918 jjtree.popNode();
919 }
920 if (jjte000 instanceof RuntimeException) {
921 {if (true) throw (RuntimeException)jjte000;}
922 }
923 if (jjte000 instanceof ParseException) {
924 {if (true) throw (ParseException)jjte000;}
925 }
926 {if (true) throw (Error)jjte000;}
927 } finally {
928 if (jjtc000) {
929 jjtree.closeNodeScope(jjtn000, true);
930 }
931 }
932 } finally {
933 trace_return("List");
934 }
935 }
936
937 final public void DefineList() throws ParseException {
938 trace_call("DefineList");
939 try {
940
941 WikiDefineList jjtn000 = new WikiDefineList(JJTDEFINELIST);
942 boolean jjtc000 = true;
943 jjtree.openNodeScope(jjtn000);
944 try {
945 label_9:
946 while (true) {
947 jj_consume_token(DLIST);
948 setStartPosition();
949 WikiDefinedWord jjtn001 = new WikiDefinedWord(JJTDEFINEDWORD);
950 boolean jjtc001 = true;
951 jjtree.openNodeScope(jjtn001);
952 try {
953 label_10:
954 while (true) {
955 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
956 case TILDE:
957 case SEMICOLON:
958 case LPAREN:
959 case RPAREN:
960 case LBRACKET:
961 case RBRACKET:
962 case LBRACE:
963 case RBRACE:
964 case SLASH:
965 case LT:
966 case EXCERPT1:
967 case EXCERPT2:
968 case EXCERPT3:
969 case LIST1:
970 case LIST2:
971 case LIST3:
972 case NLIST1:
973 case NLIST2:
974 case NLIST3:
975 case PRESHAPED:
976 case HEADING1:
977 case HEADING2:
978 case HEADING3:
979 case ALIGN1:
980 case ALIGN2:
981 case ALIGN3:
982 case FALIGN1:
983 case FALIGN2:
984 case HORIZONTAL:
985 case BLOCKPLUGIN:
986 case COLSPAN:
987 case PIPE:
988 case COLON:
989 case COMMA:
990 case DELETELINE:
991 case STRONGITALIC:
992 case WIKINAME:
993 case NATIVELINK:
994 case ANCHOR:
995 case PAGENAME:
996 case LINK:
997 case INTERWIKI:
998 case ALIASLINK:
999 case ALIAS:
1000 case IDENTIFIER:
1001 case ARGS:
1002 case INLINEPLUGIN:
1003 case ANYOTHER:
1004 case 73:
1005 ;
1006 break;
1007 default:
1008 break label_10;
1009 }
1010 InlineElement();
1011 }
1012 } catch (Throwable jjte001) {
1013 if (jjtc001) {
1014 jjtree.clearNodeScope(jjtn001);
1015 jjtc001 = false;
1016 } else {
1017 jjtree.popNode();
1018 }
1019 if (jjte001 instanceof RuntimeException) {
1020 {if (true) throw (RuntimeException)jjte001;}
1021 }
1022 if (jjte001 instanceof ParseException) {
1023 {if (true) throw (ParseException)jjte001;}
1024 }
1025 {if (true) throw (Error)jjte001;}
1026 } finally {
1027 if (jjtc001) {
1028 jjtree.closeNodeScope(jjtn001, true);
1029 }
1030 }
1031 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1032 case TABLEDEL:
1033 jj_consume_token(TABLEDEL);
1034 break;
1035 case NTABCOLSPAN:
1036 jj_consume_token(NTABCOLSPAN);
1037 break;
1038 case NTABROWSPAN:
1039 jj_consume_token(NTABROWSPAN);
1040 break;
1041 default:
1042 jj_consume_token(-1);
1043 throw new ParseException();
1044 }
1045 WikiExplanationWord jjtn002 = new WikiExplanationWord(JJTEXPLANATIONWORD);
1046 boolean jjtc002 = true;
1047 jjtree.openNodeScope(jjtn002);
1048 try {
1049 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1050 case TILDE:
1051 jj_consume_token(TILDE);
1052 break;
1053 default:
1054 ;
1055 }
1056 label_11:
1057 while (true) {
1058 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1059 case TILDE:
1060 case SEMICOLON:
1061 case LPAREN:
1062 case RPAREN:
1063 case LBRACKET:
1064 case RBRACKET:
1065 case LBRACE:
1066 case RBRACE:
1067 case SLASH:
1068 case LT:
1069 case EXCERPT1:
1070 case EXCERPT2:
1071 case EXCERPT3:
1072 case LIST1:
1073 case LIST2:
1074 case LIST3:
1075 case NLIST1:
1076 case NLIST2:
1077 case NLIST3:
1078 case PRESHAPED:
1079 case HEADING1:
1080 case HEADING2:
1081 case HEADING3:
1082 case ALIGN1:
1083 case ALIGN2:
1084 case ALIGN3:
1085 case FALIGN1:
1086 case FALIGN2:
1087 case HORIZONTAL:
1088 case BLOCKPLUGIN:
1089 case COLSPAN:
1090 case PIPE:
1091 case COLON:
1092 case COMMA:
1093 case DELETELINE:
1094 case STRONGITALIC:
1095 case WIKINAME:
1096 case NATIVELINK:
1097 case ANCHOR:
1098 case PAGENAME:
1099 case LINK:
1100 case INTERWIKI:
1101 case ALIASLINK:
1102 case ALIAS:
1103 case IDENTIFIER:
1104 case ARGS:
1105 case INLINEPLUGIN:
1106 case ANYOTHER:
1107 case 73:
1108 ;
1109 break;
1110 default:
1111 break label_11;
1112 }
1113 InlineElement();
1114 }
1115 label_12:
1116 while (true) {
1117 if (jj_2_7(1)) {
1118 ;
1119 } else {
1120 break label_12;
1121 }
1122 if (isExcerpt()) {
1123 Excerpt();
1124 } else if (isList()) {
1125 List();
1126 } else if (isPreshaped()) {
1127 Preshaped();
1128 } else if (isTable()) {
1129 Table();
1130 } else if (isCSVTable()) {
1131 CSVTable();
1132 } else if (isAlign()) {
1133 Align();
1134 } else if (isBlockPlugin()) {
1135 BlockPlugin();
1136 } else if (isParagraph()) {
1137 Paragraph();
1138 } else {
1139 jj_consume_token(-1);
1140 throw new ParseException();
1141 }
1142 }
1143 } catch (Throwable jjte002) {
1144 if (jjtc002) {
1145 jjtree.clearNodeScope(jjtn002);
1146 jjtc002 = false;
1147 } else {
1148 jjtree.popNode();
1149 }
1150 if (jjte002 instanceof RuntimeException) {
1151 {if (true) throw (RuntimeException)jjte002;}
1152 }
1153 if (jjte002 instanceof ParseException) {
1154 {if (true) throw (ParseException)jjte002;}
1155 }
1156 {if (true) throw (Error)jjte002;}
1157 } finally {
1158 if (jjtc002) {
1159 jjtree.closeNodeScope(jjtn002, true);
1160 }
1161 }
1162 if (isDefineList()) {
1163 ;
1164 } else {
1165 break label_9;
1166 }
1167 }
1168 } catch (Throwable jjte000) {
1169 if (jjtc000) {
1170 jjtree.clearNodeScope(jjtn000);
1171 jjtc000 = false;
1172 } else {
1173 jjtree.popNode();
1174 }
1175 if (jjte000 instanceof RuntimeException) {
1176 {if (true) throw (RuntimeException)jjte000;}
1177 }
1178 if (jjte000 instanceof ParseException) {
1179 {if (true) throw (ParseException)jjte000;}
1180 }
1181 {if (true) throw (Error)jjte000;}
1182 } finally {
1183 if (jjtc000) {
1184 jjtree.closeNodeScope(jjtn000, true);
1185 }
1186 }
1187 } finally {
1188 trace_return("DefineList");
1189 }
1190 }
1191
1192 final public void Preshaped() throws ParseException {
1193 trace_call("Preshaped");
1194 try {
1195
1196 WikiPreshaped jjtn000 = new WikiPreshaped(JJTPRESHAPED);
1197 boolean jjtc000 = true;
1198 jjtree.openNodeScope(jjtn000);
1199 try {
1200 label_13:
1201 while (true) {
1202 jj_consume_token(NL);
1203 jj_consume_token(PRESHAPED);
1204 SkipToNewline();
1205 if (isPreshaped()) {
1206 ;
1207 } else {
1208 break label_13;
1209 }
1210 }
1211 } finally {
1212 if (jjtc000) {
1213 jjtree.closeNodeScope(jjtn000, true);
1214 }
1215 }
1216 } finally {
1217 trace_return("Preshaped");
1218 }
1219 }
1220
1221 final public void Table() throws ParseException {
1222 trace_call("Table");
1223 try {
1224
1225 WikiTable jjtn000 = new WikiTable(JJTTABLE);
1226 boolean jjtc000 = true;
1227 jjtree.openNodeScope(jjtn000);Token t;
1228 try {
1229 label_14:
1230 while (true) {
1231 jj_consume_token(TABLE);
1232 setStartPosition();
1233 try {
1234 WikiTablemember jjtn002 = new WikiTablemember(JJTTABLEMEMBER);
1235 boolean jjtc002 = true;
1236 jjtree.openNodeScope(jjtn002);
1237 try {
1238 label_15:
1239 while (true) {
1240 WikiTablecolumn jjtn001 = new WikiTablecolumn(JJTTABLECOLUMN);
1241 boolean jjtc001 = true;
1242 jjtree.openNodeScope(jjtn001);
1243 try {
1244 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1245 case NTABCOLSPAN:
1246 jj_consume_token(NTABCOLSPAN);
1247 jjtree.closeNodeScope(jjtn001, true);
1248 jjtc001 = false;
1249 jjtn001.iscolspan = true;
1250 break;
1251 case NTABROWSPAN:
1252 jj_consume_token(NTABROWSPAN);
1253 jjtree.closeNodeScope(jjtn001, true);
1254 jjtc001 = false;
1255 jjtn001.isrowspan = true;
1256 break;
1257 default:
1258 if (jj_2_8(1)) {
1259 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1260 case ALIGN1:
1261 case ALIGN2:
1262 case ALIGN3:
1263 case COLORWORD:
1264 case BGCOLORWORD:
1265 case SIZEWORD:
1266 label_16:
1267 while (true) {
1268 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1269 case ALIGN1:
1270 t = jj_consume_token(ALIGN1);
1271 jjtn001.align = t.image.substring(0,t.image.length()-1);
1272 break;
1273 case ALIGN2:
1274 t = jj_consume_token(ALIGN2);
1275 jjtn001.align = t.image.substring(0,t.image.length()-1);
1276 break;
1277 case ALIGN3:
1278 t = jj_consume_token(ALIGN3);
1279 jjtn001.align = t.image.substring(0,t.image.length()-1);
1280 break;
1281 case COLORWORD:
1282 t = jj_consume_token(COLORWORD);
1283 jjtn001.color=WikiHelper.deleteParenthesis(t.image,"(",")");
1284 break;
1285 case BGCOLORWORD:
1286 t = jj_consume_token(BGCOLORWORD);
1287 jjtn001.bgcolor = WikiHelper.deleteParenthesis(t.image,"(",")");
1288 break;
1289 case SIZEWORD:
1290 t = jj_consume_token(SIZEWORD);
1291 jjtn001.size = WikiHelper.deleteParenthesis(t.image,"(",")");
1292 break;
1293 default:
1294 jj_consume_token(-1);
1295 throw new ParseException();
1296 }
1297 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1298 case ALIGN1:
1299 case ALIGN2:
1300 case ALIGN3:
1301 case COLORWORD:
1302 case BGCOLORWORD:
1303 case SIZEWORD:
1304 ;
1305 break;
1306 default:
1307 break label_16;
1308 }
1309 }
1310 break;
1311 default:
1312 ;
1313 }
1314 if (!(getToken(1).kind==IDENTIFIER && isNewline(2))) {
1315
1316 } else {
1317 jj_consume_token(-1);
1318 throw new ParseException();
1319 }
1320 label_17:
1321 while (true) {
1322 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1323 case TILDE:
1324 case SEMICOLON:
1325 case LPAREN:
1326 case RPAREN:
1327 case LBRACKET:
1328 case RBRACKET:
1329 case LBRACE:
1330 case RBRACE:
1331 case SLASH:
1332 case LT:
1333 case EXCERPT1:
1334 case EXCERPT2:
1335 case EXCERPT3:
1336 case LIST1:
1337 case LIST2:
1338 case LIST3:
1339 case NLIST1:
1340 case NLIST2:
1341 case NLIST3:
1342 case PRESHAPED:
1343 case HEADING1:
1344 case HEADING2:
1345 case HEADING3:
1346 case ALIGN1:
1347 case ALIGN2:
1348 case ALIGN3:
1349 case FALIGN1:
1350 case FALIGN2:
1351 case HORIZONTAL:
1352 case BLOCKPLUGIN:
1353 case COLSPAN:
1354 case PIPE:
1355 case COLON:
1356 case COMMA:
1357 case DELETELINE:
1358 case STRONGITALIC:
1359 case WIKINAME:
1360 case NATIVELINK:
1361 case ANCHOR:
1362 case PAGENAME:
1363 case LINK:
1364 case INTERWIKI:
1365 case ALIASLINK:
1366 case ALIAS:
1367 case IDENTIFIER:
1368 case ARGS:
1369 case INLINEPLUGIN:
1370 case ANYOTHER:
1371 case 73:
1372 ;
1373 break;
1374 default:
1375 break label_17;
1376 }
1377 InlineElement();
1378 }
1379 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1380 case TABLEDEL:
1381 jj_consume_token(TABLEDEL);
1382 break;
1383 case NTABCOLSPAN:
1384 jj_consume_token(NTABCOLSPAN);
1385 break;
1386 case NTABROWSPAN:
1387 jj_consume_token(NTABROWSPAN);
1388 break;
1389 default:
1390 jj_consume_token(-1);
1391 throw new ParseException();
1392 }
1393 } else {
1394 jj_consume_token(-1);
1395 throw new ParseException();
1396 }
1397 }
1398 } catch (Throwable jjte001) {
1399 if (jjtc001) {
1400 jjtree.clearNodeScope(jjtn001);
1401 jjtc001 = false;
1402 } else {
1403 jjtree.popNode();
1404 }
1405 if (jjte001 instanceof RuntimeException) {
1406 {if (true) throw (RuntimeException)jjte001;}
1407 }
1408 if (jjte001 instanceof ParseException) {
1409 {if (true) throw (ParseException)jjte001;}
1410 }
1411 {if (true) throw (Error)jjte001;}
1412 } finally {
1413 if (jjtc001) {
1414 jjtree.closeNodeScope(jjtn001, true);
1415 }
1416 }
1417 if (jj_2_9(1)) {
1418 ;
1419 } else {
1420 break label_15;
1421 }
1422 }
1423 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1424 case IDENTIFIER:
1425 t = jj_consume_token(IDENTIFIER);
1426 jjtn002.type=WikiHelper.getTableType(t.image);
1427 break;
1428 default:
1429 ;
1430 }
1431 } catch (Throwable jjte002) {
1432 if (jjtc002) {
1433 jjtree.clearNodeScope(jjtn002);
1434 jjtc002 = false;
1435 } else {
1436 jjtree.popNode();
1437 }
1438 if (jjte002 instanceof RuntimeException) {
1439 {if (true) throw (RuntimeException)jjte002;}
1440 }
1441 if (jjte002 instanceof ParseException) {
1442 {if (true) throw (ParseException)jjte002;}
1443 }
1444 {if (true) throw (Error)jjte002;}
1445 } finally {
1446 if (jjtc002) {
1447 jjtree.closeNodeScope(jjtn002, true);
1448 }
1449 }
1450 } catch (ParseException pe) {
1451 processError("parsing error for table.",false,pe);
1452 }
1453 if (isTable()) {
1454 ;
1455 } else {
1456 break label_14;
1457 }
1458 }
1459 } catch (Throwable jjte000) {
1460 if (jjtc000) {
1461 jjtree.clearNodeScope(jjtn000);
1462 jjtc000 = false;
1463 } else {
1464 jjtree.popNode();
1465 }
1466 if (jjte000 instanceof RuntimeException) {
1467 {if (true) throw (RuntimeException)jjte000;}
1468 }
1469 if (jjte000 instanceof ParseException) {
1470 {if (true) throw (ParseException)jjte000;}
1471 }
1472 {if (true) throw (Error)jjte000;}
1473 } finally {
1474 if (jjtc000) {
1475 jjtree.closeNodeScope(jjtn000, true);
1476 }
1477 }
1478 } finally {
1479 trace_return("Table");
1480 }
1481 }
1482
1483 final public void CSVTable() throws ParseException {
1484 trace_call("CSVTable");
1485 try {
1486
1487 WikiCSVTable jjtn000 = new WikiCSVTable(JJTCSVTABLE);
1488 boolean jjtc000 = true;
1489 jjtree.openNodeScope(jjtn000);
1490 try {
1491 label_18:
1492 while (true) {
1493 jj_consume_token(CTABLE);
1494 setStartPosition();
1495 try {
1496 WikiTablemember jjtn002 = new WikiTablemember(JJTTABLEMEMBER);
1497 boolean jjtc002 = true;
1498 jjtree.openNodeScope(jjtn002);
1499 try {
1500 label_19:
1501 while (true) {
1502 WikiTablecolumn jjtn001 = new WikiTablecolumn(JJTTABLECOLUMN);
1503 boolean jjtc001 = true;
1504 jjtree.openNodeScope(jjtn001);
1505 try {
1506 if (jj_2_10(2)) {
1507 jj_consume_token(COLSPAN);
1508 jj_consume_token(CTABLEDEL);
1509 jjtree.closeNodeScope(jjtn001, true);
1510 jjtc001 = false;
1511 jjtn001.iscolspan=true;
1512 } else {
1513 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1514 case TILDE:
1515 case SEMICOLON:
1516 case LPAREN:
1517 case RPAREN:
1518 case LBRACKET:
1519 case RBRACKET:
1520 case LBRACE:
1521 case RBRACE:
1522 case SLASH:
1523 case LT:
1524 case EXCERPT1:
1525 case EXCERPT2:
1526 case EXCERPT3:
1527 case LIST1:
1528 case LIST2:
1529 case LIST3:
1530 case NLIST1:
1531 case NLIST2:
1532 case NLIST3:
1533 case PRESHAPED:
1534 case HEADING1:
1535 case HEADING2:
1536 case HEADING3:
1537 case ALIGN1:
1538 case ALIGN2:
1539 case ALIGN3:
1540 case FALIGN1:
1541 case FALIGN2:
1542 case HORIZONTAL:
1543 case BLOCKPLUGIN:
1544 case COLSPAN:
1545 case PIPE:
1546 case COLON:
1547 case COMMA:
1548 case CTABLEDEL:
1549 case DELETELINE:
1550 case STRONGITALIC:
1551 case WIKINAME:
1552 case NATIVELINK:
1553 case ANCHOR:
1554 case PAGENAME:
1555 case LINK:
1556 case INTERWIKI:
1557 case ALIASLINK:
1558 case ALIAS:
1559 case IDENTIFIER:
1560 case ARGS:
1561 case INLINEPLUGIN:
1562 case ANYOTHER:
1563 case 73:
1564 label_20:
1565 while (true) {
1566 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1567 case TILDE:
1568 case SEMICOLON:
1569 case LPAREN:
1570 case RPAREN:
1571 case LBRACKET:
1572 case RBRACKET:
1573 case LBRACE:
1574 case RBRACE:
1575 case SLASH:
1576 case LT:
1577 case EXCERPT1:
1578 case EXCERPT2:
1579 case EXCERPT3:
1580 case LIST1:
1581 case LIST2:
1582 case LIST3:
1583 case NLIST1:
1584 case NLIST2:
1585 case NLIST3:
1586 case PRESHAPED:
1587 case HEADING1:
1588 case HEADING2:
1589 case HEADING3:
1590 case ALIGN1:
1591 case ALIGN2:
1592 case ALIGN3:
1593 case FALIGN1:
1594 case FALIGN2:
1595 case HORIZONTAL:
1596 case BLOCKPLUGIN:
1597 case COLSPAN:
1598 case PIPE:
1599 case COLON:
1600 case COMMA:
1601 case DELETELINE:
1602 case STRONGITALIC:
1603 case WIKINAME:
1604 case NATIVELINK:
1605 case ANCHOR:
1606 case PAGENAME:
1607 case LINK:
1608 case INTERWIKI:
1609 case ALIASLINK:
1610 case ALIAS:
1611 case IDENTIFIER:
1612 case ARGS:
1613 case INLINEPLUGIN:
1614 case ANYOTHER:
1615 case 73:
1616 ;
1617 break;
1618 default:
1619 break label_20;
1620 }
1621 InlineElement();
1622 }
1623 jj_consume_token(CTABLEDEL);
1624 break;
1625 default:
1626 jj_consume_token(-1);
1627 throw new ParseException();
1628 }
1629 }
1630 } catch (Throwable jjte001) {
1631 if (jjtc001) {
1632 jjtree.clearNodeScope(jjtn001);
1633 jjtc001 = false;
1634 } else {
1635 jjtree.popNode();
1636 }
1637 if (jjte001 instanceof RuntimeException) {
1638 {if (true) throw (RuntimeException)jjte001;}
1639 }
1640 if (jjte001 instanceof ParseException) {
1641 {if (true) throw (ParseException)jjte001;}
1642 }
1643 {if (true) throw (Error)jjte001;}
1644 } finally {
1645 if (jjtc001) {
1646 jjtree.closeNodeScope(jjtn001, true);
1647 }
1648 }
1649 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1650 case TILDE:
1651 case SEMICOLON:
1652 case LPAREN:
1653 case RPAREN:
1654 case LBRACKET:
1655 case RBRACKET:
1656 case LBRACE:
1657 case RBRACE:
1658 case SLASH:
1659 case LT:
1660 case EXCERPT1:
1661 case EXCERPT2:
1662 case EXCERPT3:
1663 case LIST1:
1664 case LIST2:
1665 case LIST3:
1666 case NLIST1:
1667 case NLIST2:
1668 case NLIST3:
1669 case PRESHAPED:
1670 case HEADING1:
1671 case HEADING2:
1672 case HEADING3:
1673 case ALIGN1:
1674 case ALIGN2:
1675 case ALIGN3:
1676 case FALIGN1:
1677 case FALIGN2:
1678 case HORIZONTAL:
1679 case BLOCKPLUGIN:
1680 case COLSPAN:
1681 case PIPE:
1682 case COLON:
1683 case COMMA:
1684 case CTABLEDEL:
1685 case DELETELINE:
1686 case STRONGITALIC:
1687 case WIKINAME:
1688 case NATIVELINK:
1689 case ANCHOR:
1690 case PAGENAME:
1691 case LINK:
1692 case INTERWIKI:
1693 case ALIASLINK:
1694 case ALIAS:
1695 case IDENTIFIER:
1696 case ARGS:
1697 case INLINEPLUGIN:
1698 case ANYOTHER:
1699 case 73:
1700 ;
1701 break;
1702 default:
1703 break label_19;
1704 }
1705 }
1706 } catch (Throwable jjte002) {
1707 if (jjtc002) {
1708 jjtree.clearNodeScope(jjtn002);
1709 jjtc002 = false;
1710 } else {
1711 jjtree.popNode();
1712 }
1713 if (jjte002 instanceof RuntimeException) {
1714 {if (true) throw (RuntimeException)jjte002;}
1715 }
1716 if (jjte002 instanceof ParseException) {
1717 {if (true) throw (ParseException)jjte002;}
1718 }
1719 {if (true) throw (Error)jjte002;}
1720 } finally {
1721 if (jjtc002) {
1722 jjtree.closeNodeScope(jjtn002, true);
1723 }
1724 }
1725 } catch (ParseException pe) {
1726 processError("parsing error for table.",false,pe);
1727 }
1728 if (isCSVTable()) {
1729 ;
1730 } else {
1731 break label_18;
1732 }
1733 }
1734 } catch (Throwable jjte000) {
1735 if (jjtc000) {
1736 jjtree.clearNodeScope(jjtn000);
1737 jjtc000 = false;
1738 } else {
1739 jjtree.popNode();
1740 }
1741 if (jjte000 instanceof RuntimeException) {
1742 {if (true) throw (RuntimeException)jjte000;}
1743 }
1744 if (jjte000 instanceof ParseException) {
1745 {if (true) throw (ParseException)jjte000;}
1746 }
1747 {if (true) throw (Error)jjte000;}
1748 } finally {
1749 if (jjtc000) {
1750 jjtree.closeNodeScope(jjtn000, true);
1751 }
1752 }
1753 } finally {
1754 trace_return("CSVTable");
1755 }
1756 }
1757
1758 final public void Heading() throws ParseException {
1759 trace_call("Heading");
1760 try {
1761
1762 WikiHeading jjtn000 = new WikiHeading(JJTHEADING);
1763 boolean jjtc000 = true;
1764 jjtree.openNodeScope(jjtn000);Token t;
1765 try {
1766 jj_consume_token(NL);
1767 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1768 case HEADING1:
1769 t = jj_consume_token(HEADING1);
1770 break;
1771 case HEADING2:
1772 t = jj_consume_token(HEADING2);
1773 break;
1774 case HEADING3:
1775 t = jj_consume_token(HEADING3);
1776 break;
1777 default:
1778 jj_consume_token(-1);
1779 throw new ParseException();
1780 }
1781 label_21:
1782 while (true) {
1783 InlineElement();
1784 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1785 case TILDE:
1786 case SEMICOLON:
1787 case LPAREN:
1788 case RPAREN:
1789 case LBRACKET:
1790 case RBRACKET:
1791 case LBRACE:
1792 case RBRACE:
1793 case SLASH:
1794 case LT:
1795 case EXCERPT1:
1796 case EXCERPT2:
1797 case EXCERPT3:
1798 case LIST1:
1799 case LIST2:
1800 case LIST3:
1801 case NLIST1:
1802 case NLIST2:
1803 case NLIST3:
1804 case PRESHAPED:
1805 case HEADING1:
1806 case HEADING2:
1807 case HEADING3:
1808 case ALIGN1:
1809 case ALIGN2:
1810 case ALIGN3:
1811 case FALIGN1:
1812 case FALIGN2:
1813 case HORIZONTAL:
1814 case BLOCKPLUGIN:
1815 case COLSPAN:
1816 case PIPE:
1817 case COLON:
1818 case COMMA:
1819 case DELETELINE:
1820 case STRONGITALIC:
1821 case WIKINAME:
1822 case NATIVELINK:
1823 case ANCHOR:
1824 case PAGENAME:
1825 case LINK:
1826 case INTERWIKI:
1827 case ALIASLINK:
1828 case ALIAS:
1829 case IDENTIFIER:
1830 case ARGS:
1831 case INLINEPLUGIN:
1832 case ANYOTHER:
1833 case 73:
1834 ;
1835 break;
1836 default:
1837 break label_21;
1838 }
1839 }
1840 jjtree.closeNodeScope(jjtn000, true);
1841 jjtc000 = false;
1842 jjtn000.level=t.image.length();
1843 jjtn000.num=addTOC(jjtn000);
1844 } catch (Throwable jjte000) {
1845 if (jjtc000) {
1846 jjtree.clearNodeScope(jjtn000);
1847 jjtc000 = false;
1848 } else {
1849 jjtree.popNode();
1850 }
1851 if (jjte000 instanceof RuntimeException) {
1852 {if (true) throw (RuntimeException)jjte000;}
1853 }
1854 if (jjte000 instanceof ParseException) {
1855 {if (true) throw (ParseException)jjte000;}
1856 }
1857 {if (true) throw (Error)jjte000;}
1858 } finally {
1859 if (jjtc000) {
1860 jjtree.closeNodeScope(jjtn000, true);
1861 }
1862 }
1863 } finally {
1864 trace_return("Heading");
1865 }
1866 }
1867
1868 final public void Align() throws ParseException {
1869 trace_call("Align");
1870 try {
1871
1872 WikiAlign jjtn000 = new WikiAlign(JJTALIGN);
1873 boolean jjtc000 = true;
1874 jjtree.openNodeScope(jjtn000);Token t;
1875 try {
1876 jj_consume_token(NL);
1877 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1878 case ALIGN1:
1879 t = jj_consume_token(ALIGN1);
1880 break;
1881 case ALIGN2:
1882 t = jj_consume_token(ALIGN2);
1883 break;
1884 case ALIGN3:
1885 t = jj_consume_token(ALIGN3);
1886 break;
1887 default:
1888 jj_consume_token(-1);
1889 throw new ParseException();
1890 }
1891 label_22:
1892 while (true) {
1893 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1894 case TILDE:
1895 case SEMICOLON:
1896 case LPAREN:
1897 case RPAREN:
1898 case LBRACKET:
1899 case RBRACKET:
1900 case LBRACE:
1901 case RBRACE:
1902 case SLASH:
1903 case LT:
1904 case EXCERPT1:
1905 case EXCERPT2:
1906 case EXCERPT3:
1907 case LIST1:
1908 case LIST2:
1909 case LIST3:
1910 case NLIST1:
1911 case NLIST2:
1912 case NLIST3:
1913 case PRESHAPED:
1914 case HEADING1:
1915 case HEADING2:
1916 case HEADING3:
1917 case ALIGN1:
1918 case ALIGN2:
1919 case ALIGN3:
1920 case FALIGN1:
1921 case FALIGN2:
1922 case HORIZONTAL:
1923 case BLOCKPLUGIN:
1924 case COLSPAN:
1925 case PIPE:
1926 case COLON:
1927 case COMMA:
1928 case DELETELINE:
1929 case STRONGITALIC:
1930 case WIKINAME:
1931 case NATIVELINK:
1932 case ANCHOR:
1933 case PAGENAME:
1934 case LINK:
1935 case INTERWIKI:
1936 case ALIASLINK:
1937 case ALIAS:
1938 case IDENTIFIER:
1939 case ARGS:
1940 case INLINEPLUGIN:
1941 case ANYOTHER:
1942 case 73:
1943 ;
1944 break;
1945 default:
1946 break label_22;
1947 }
1948 InlineElement();
1949 }
1950 label_23:
1951 while (true) {
1952 if (!isBlankline()) {
1953 ;
1954 } else {
1955 break label_23;
1956 }
1957 jj_consume_token(NL);
1958 label_24:
1959 while (true) {
1960 InlineElement();
1961 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
1962 case TILDE:
1963 case SEMICOLON:
1964 case LPAREN:
1965 case RPAREN:
1966 case LBRACKET:
1967 case RBRACKET:
1968 case LBRACE:
1969 case RBRACE:
1970 case SLASH:
1971 case LT:
1972 case EXCERPT1:
1973 case EXCERPT2:
1974 case EXCERPT3:
1975 case LIST1:
1976 case LIST2:
1977 case LIST3:
1978 case NLIST1:
1979 case NLIST2:
1980 case NLIST3:
1981 case PRESHAPED:
1982 case HEADING1:
1983 case HEADING2:
1984 case HEADING3:
1985 case ALIGN1:
1986 case ALIGN2:
1987 case ALIGN3:
1988 case FALIGN1:
1989 case FALIGN2:
1990 case HORIZONTAL:
1991 case BLOCKPLUGIN:
1992 case COLSPAN:
1993 case PIPE:
1994 case COLON:
1995 case COMMA:
1996 case DELETELINE:
1997 case STRONGITALIC:
1998 case WIKINAME:
1999 case NATIVELINK:
2000 case ANCHOR:
2001 case PAGENAME:
2002 case LINK:
2003 case INTERWIKI:
2004 case ALIASLINK:
2005 case ALIAS:
2006 case IDENTIFIER:
2007 case ARGS:
2008 case INLINEPLUGIN:
2009 case ANYOTHER:
2010 case 73:
2011 ;
2012 break;
2013 default:
2014 break label_24;
2015 }
2016 }
2017 }
2018 jjtree.closeNodeScope(jjtn000, true);
2019 jjtc000 = false;
2020 jjtn000.image = t.image;
2021 } catch (Throwable jjte000) {
2022 if (jjtc000) {
2023 jjtree.clearNodeScope(jjtn000);
2024 jjtc000 = false;
2025 } else {
2026 jjtree.popNode();
2027 }
2028 if (jjte000 instanceof RuntimeException) {
2029 {if (true) throw (RuntimeException)jjte000;}
2030 }
2031 if (jjte000 instanceof ParseException) {
2032 {if (true) throw (ParseException)jjte000;}
2033 }
2034 {if (true) throw (Error)jjte000;}
2035 } finally {
2036 if (jjtc000) {
2037 jjtree.closeNodeScope(jjtn000, true);
2038 }
2039 }
2040 } finally {
2041 trace_return("Align");
2042 }
2043 }
2044
2045 final public void FloatAlign() throws ParseException {
2046 trace_call("FloatAlign");
2047 try {
2048
2049 WikiFloatAlign jjtn000 = new WikiFloatAlign(JJTFLOATALIGN);
2050 boolean jjtc000 = true;
2051 jjtree.openNodeScope(jjtn000);Token t;
2052 try {
2053 jj_consume_token(NL);
2054 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2055 case FALIGN1:
2056 t = jj_consume_token(FALIGN1);
2057 break;
2058 case FALIGN2:
2059 t = jj_consume_token(FALIGN2);
2060 break;
2061 default:
2062 jj_consume_token(-1);
2063 throw new ParseException();
2064 }
2065 label_25:
2066 while (true) {
2067 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2068 case TILDE:
2069 case SEMICOLON:
2070 case LPAREN:
2071 case RPAREN:
2072 case LBRACKET:
2073 case RBRACKET:
2074 case LBRACE:
2075 case RBRACE:
2076 case SLASH:
2077 case LT:
2078 case EXCERPT1:
2079 case EXCERPT2:
2080 case EXCERPT3:
2081 case LIST1:
2082 case LIST2:
2083 case LIST3:
2084 case NLIST1:
2085 case NLIST2:
2086 case NLIST3:
2087 case PRESHAPED:
2088 case HEADING1:
2089 case HEADING2:
2090 case HEADING3:
2091 case ALIGN1:
2092 case ALIGN2:
2093 case ALIGN3:
2094 case FALIGN1:
2095 case FALIGN2:
2096 case HORIZONTAL:
2097 case BLOCKPLUGIN:
2098 case COLSPAN:
2099 case PIPE:
2100 case COLON:
2101 case COMMA:
2102 case DELETELINE:
2103 case STRONGITALIC:
2104 case WIKINAME:
2105 case NATIVELINK:
2106 case ANCHOR:
2107 case PAGENAME:
2108 case LINK:
2109 case INTERWIKI:
2110 case ALIASLINK:
2111 case ALIAS:
2112 case IDENTIFIER:
2113 case ARGS:
2114 case INLINEPLUGIN:
2115 case ANYOTHER:
2116 case 73:
2117 ;
2118 break;
2119 default:
2120 break label_25;
2121 }
2122 InlineElement();
2123 }
2124 label_26:
2125 while (true) {
2126 if (jj_2_11(1)) {
2127 ;
2128 } else {
2129 break label_26;
2130 }
2131 if (isExcerpt()) {
2132 Excerpt();
2133 } else if (isList()) {
2134 List();
2135 } else if (isDefineList()) {
2136 DefineList();
2137 } else if (isPreshaped()) {
2138 Preshaped();
2139 } else if (isTable()) {
2140 Table();
2141 } else if (isCSVTable()) {
2142 CSVTable();
2143 } else if (isBlockPlugin()) {
2144 BlockPlugin();
2145 } else if (isParagraph()) {
2146 Paragraph();
2147 } else {
2148 jj_consume_token(-1);
2149 throw new ParseException();
2150 }
2151 }
2152 jjtree.closeNodeScope(jjtn000, true);
2153 jjtc000 = false;
2154 jjtn000.image = t.image;
2155 } catch (Throwable jjte000) {
2156 if (jjtc000) {
2157 jjtree.clearNodeScope(jjtn000);
2158 jjtc000 = false;
2159 } else {
2160 jjtree.popNode();
2161 }
2162 if (jjte000 instanceof RuntimeException) {
2163 {if (true) throw (RuntimeException)jjte000;}
2164 }
2165 if (jjte000 instanceof ParseException) {
2166 {if (true) throw (ParseException)jjte000;}
2167 }
2168 {if (true) throw (Error)jjte000;}
2169 } finally {
2170 if (jjtc000) {
2171 jjtree.closeNodeScope(jjtn000, true);
2172 }
2173 }
2174 } finally {
2175 trace_return("FloatAlign");
2176 }
2177 }
2178
2179 final public void Horizontalline() throws ParseException {
2180 trace_call("Horizontalline");
2181 try {
2182
2183 WikiHorizontalline jjtn000 = new WikiHorizontalline(JJTHORIZONTALLINE);
2184 boolean jjtc000 = true;
2185 jjtree.openNodeScope(jjtn000);
2186 try {
2187 jj_consume_token(NL);
2188 jj_consume_token(HORIZONTAL);
2189 SkipToNewline();
2190 } finally {
2191 if (jjtc000) {
2192 jjtree.closeNodeScope(jjtn000, true);
2193 }
2194 }
2195 } finally {
2196 trace_return("Horizontalline");
2197 }
2198 }
2199
2200 final public void Blankline() throws ParseException {
2201 trace_call("Blankline");
2202 try {
2203 jj_consume_token(NL);
2204 } finally {
2205 trace_return("Blankline");
2206 }
2207 }
2208
2209 final public void BlockPlugin() throws ParseException {
2210 trace_call("BlockPlugin");
2211 try {
2212
2213 WikiBlockPlugin jjtn000 = new WikiBlockPlugin(JJTBLOCKPLUGIN);
2214 boolean jjtc000 = true;
2215 jjtree.openNodeScope(jjtn000);Token t;
2216 try {
2217 jj_consume_token(NL);
2218 t = jj_consume_token(BLOCKPLUGIN);
2219 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2220 case ARGS:
2221 Args();
2222 break;
2223 default:
2224 ;
2225 }
2226 SkipToNewline();
2227 jjtree.closeNodeScope(jjtn000, true);
2228 jjtc000 = false;
2229 jjtn000.name = t.image.substring(1);
2230 } catch (Throwable jjte000) {
2231 if (jjtc000) {
2232 jjtree.clearNodeScope(jjtn000);
2233 jjtc000 = false;
2234 } else {
2235 jjtree.popNode();
2236 }
2237 if (jjte000 instanceof RuntimeException) {
2238 {if (true) throw (RuntimeException)jjte000;}
2239 }
2240 if (jjte000 instanceof ParseException) {
2241 {if (true) throw (ParseException)jjte000;}
2242 }
2243 {if (true) throw (Error)jjte000;}
2244 } finally {
2245 if (jjtc000) {
2246 jjtree.closeNodeScope(jjtn000, true);
2247 }
2248 }
2249 } finally {
2250 trace_return("BlockPlugin");
2251 }
2252 }
2253
2254
2255
2256 /***
2257 *
2258 */
2259 final public void Letters() throws ParseException {
2260 trace_call("Letters");
2261 try {
2262
2263 WikiLetters jjtn000 = new WikiLetters(JJTLETTERS);
2264 boolean jjtc000 = true;
2265 jjtree.openNodeScope(jjtn000);Token t;
2266 try {
2267 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2268 case NATIVELINK:
2269 t = jj_consume_token(NATIVELINK);
2270 if(WikiHelper.isEmail(t.image)){
2271 jjtn000.isEmail = true;
2272 }else{
2273 jjtn000.isURL = true;
2274 }
2275 break;
2276 case WIKINAME:
2277 t = jj_consume_token(WIKINAME);
2278 jjtn000.isWikiname = true;
2279 break;
2280 case ANCHOR:
2281 t = jj_consume_token(ANCHOR);
2282 jjtn000.isAnchor = true;
2283 jjtn000.letter = WikiHelper.deleteParenthesis(t.image,"[","]");
2284 break;
2285 case IDENTIFIER:
2286 t = jj_consume_token(IDENTIFIER);
2287 break;
2288 case TILDE:
2289 t = jj_consume_token(TILDE);
2290
2291
2292
2293
2294 if(isNewline(1)) jjtn000.isNewline = true;
2295 break;
2296 case SEMICOLON:
2297 t = jj_consume_token(SEMICOLON);
2298 break;
2299 case LPAREN:
2300 t = jj_consume_token(LPAREN);
2301 break;
2302 case RPAREN:
2303 t = jj_consume_token(RPAREN);
2304 break;
2305 case LBRACKET:
2306 t = jj_consume_token(LBRACKET);
2307 break;
2308 case RBRACKET:
2309 t = jj_consume_token(RBRACKET);
2310 break;
2311 case LBRACE:
2312 t = jj_consume_token(LBRACE);
2313 break;
2314 case RBRACE:
2315 t = jj_consume_token(RBRACE);
2316 break;
2317 case SLASH:
2318 t = jj_consume_token(SLASH);
2319 break;
2320 case EXCERPT1:
2321 t = jj_consume_token(EXCERPT1);
2322 jjtn000.isHTMLescape = true;
2323 break;
2324 case EXCERPT2:
2325 t = jj_consume_token(EXCERPT2);
2326 jjtn000.isHTMLescape = true;
2327 break;
2328 case EXCERPT3:
2329 t = jj_consume_token(EXCERPT3);
2330 jjtn000.isHTMLescape = true;
2331 break;
2332 case LT:
2333 t = jj_consume_token(LT);
2334 jjtn000.isHTMLescape = true;
2335 break;
2336 case LIST1:
2337 t = jj_consume_token(LIST1);
2338 break;
2339 case LIST2:
2340 t = jj_consume_token(LIST2);
2341 break;
2342 case LIST3:
2343 t = jj_consume_token(LIST3);
2344 break;
2345 case NLIST1:
2346 t = jj_consume_token(NLIST1);
2347 break;
2348 case NLIST2:
2349 t = jj_consume_token(NLIST2);
2350 break;
2351 case NLIST3:
2352 t = jj_consume_token(NLIST3);
2353 break;
2354 case ALIGN1:
2355 t = jj_consume_token(ALIGN1);
2356 break;
2357 case ALIGN2:
2358 t = jj_consume_token(ALIGN2);
2359 break;
2360 case ALIGN3:
2361 t = jj_consume_token(ALIGN3);
2362 break;
2363 case FALIGN1:
2364 t = jj_consume_token(FALIGN1);
2365 break;
2366 case FALIGN2:
2367 t = jj_consume_token(FALIGN2);
2368 break;
2369 case COLON:
2370 t = jj_consume_token(COLON);
2371 break;
2372 case PRESHAPED:
2373 t = jj_consume_token(PRESHAPED);
2374 break;
2375 case HEADING1:
2376 t = jj_consume_token(HEADING1);
2377 break;
2378 case HEADING2:
2379 t = jj_consume_token(HEADING2);
2380 break;
2381 case HEADING3:
2382 t = jj_consume_token(HEADING3);
2383 break;
2384 case HORIZONTAL:
2385 t = jj_consume_token(HORIZONTAL);
2386 break;
2387 case PIPE:
2388 t = jj_consume_token(PIPE);
2389 break;
2390 case COMMA:
2391 t = jj_consume_token(COMMA);
2392 break;
2393 case COLSPAN:
2394 t = jj_consume_token(COLSPAN);
2395 break;
2396 case ARGS:
2397 t = jj_consume_token(ARGS);
2398 break;
2399 case BLOCKPLUGIN:
2400 t = jj_consume_token(BLOCKPLUGIN);
2401 break;
2402 default:
2403 jj_consume_token(-1);
2404 throw new ParseException();
2405 }
2406 jjtree.closeNodeScope(jjtn000, true);
2407 jjtc000 = false;
2408 if(!jjtn000.isAnchor) jjtn000.letter = t.image;
2409 } finally {
2410 if (jjtc000) {
2411 jjtree.closeNodeScope(jjtn000, true);
2412 }
2413 }
2414 } finally {
2415 trace_return("Letters");
2416 }
2417 }
2418
2419 final public void AnyOther() throws ParseException {
2420 trace_call("AnyOther");
2421 try {
2422
2423 WikiAnyOther jjtn000 = new WikiAnyOther(JJTANYOTHER);
2424 boolean jjtc000 = true;
2425 jjtree.openNodeScope(jjtn000);Token t;
2426 try {
2427 t = jj_consume_token(ANYOTHER);
2428 jjtree.closeNodeScope(jjtn000, true);
2429 jjtc000 = false;
2430 jjtn000.letter = t.image;
2431 log_.warn("AnyOther token : " + t.image);
2432 } finally {
2433 if (jjtc000) {
2434 jjtree.closeNodeScope(jjtn000, true);
2435 }
2436 }
2437 } finally {
2438 trace_return("AnyOther");
2439 }
2440 }
2441
2442 final public void StrongItalic() throws ParseException {
2443 trace_call("StrongItalic");
2444 try {
2445
2446 WikiStrongItalic jjtn000 = new WikiStrongItalic(JJTSTRONGITALIC);
2447 boolean jjtc000 = true;
2448 jjtree.openNodeScope(jjtn000);Token t;
2449 try {
2450 t = jj_consume_token(STRONGITALIC);
2451 jjtn000.prelevel = t.image.length();
2452 label_27:
2453 while (true) {
2454 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2455 case DELETELINE:
2456 Deleteline();
2457 break;
2458 case 73:
2459 Annotation();
2460 break;
2461 case PAGENAME:
2462 case LINK:
2463 case INTERWIKI:
2464 case ALIASLINK:
2465 case ALIAS:
2466 Linker();
2467 break;
2468 case INLINEPLUGIN:
2469 InlinePlugin();
2470 break;
2471 case TILDE:
2472 case SEMICOLON:
2473 case LPAREN:
2474 case RPAREN:
2475 case LBRACKET:
2476 case RBRACKET:
2477 case LBRACE:
2478 case RBRACE:
2479 case SLASH:
2480 case LT:
2481 case EXCERPT1:
2482 case EXCERPT2:
2483 case EXCERPT3:
2484 case LIST1:
2485 case LIST2:
2486 case LIST3:
2487 case NLIST1:
2488 case NLIST2:
2489 case NLIST3:
2490 case PRESHAPED:
2491 case HEADING1:
2492 case HEADING2:
2493 case HEADING3:
2494 case ALIGN1:
2495 case ALIGN2:
2496 case ALIGN3:
2497 case FALIGN1:
2498 case FALIGN2:
2499 case HORIZONTAL:
2500 case BLOCKPLUGIN:
2501 case COLSPAN:
2502 case PIPE:
2503 case COLON:
2504 case COMMA:
2505 case WIKINAME:
2506 case NATIVELINK:
2507 case ANCHOR:
2508 case IDENTIFIER:
2509 case ARGS:
2510 Letters();
2511 break;
2512 case ANYOTHER:
2513 AnyOther();
2514 break;
2515 default:
2516 jj_consume_token(-1);
2517 throw new ParseException();
2518 }
2519 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2520 case TILDE:
2521 case SEMICOLON:
2522 case LPAREN:
2523 case RPAREN:
2524 case LBRACKET:
2525 case RBRACKET:
2526 case LBRACE:
2527 case RBRACE:
2528 case SLASH:
2529 case LT:
2530 case EXCERPT1:
2531 case EXCERPT2:
2532 case EXCERPT3:
2533 case LIST1:
2534 case LIST2:
2535 case LIST3:
2536 case NLIST1:
2537 case NLIST2:
2538 case NLIST3:
2539 case PRESHAPED:
2540 case HEADING1:
2541 case HEADING2:
2542 case HEADING3:
2543 case ALIGN1:
2544 case ALIGN2:
2545 case ALIGN3:
2546 case FALIGN1:
2547 case FALIGN2:
2548 case HORIZONTAL:
2549 case BLOCKPLUGIN:
2550 case COLSPAN:
2551 case PIPE:
2552 case COLON:
2553 case COMMA:
2554 case DELETELINE:
2555 case WIKINAME:
2556 case NATIVELINK:
2557 case ANCHOR:
2558 case PAGENAME:
2559 case LINK:
2560 case INTERWIKI:
2561 case ALIASLINK:
2562 case ALIAS:
2563 case IDENTIFIER:
2564 case ARGS:
2565 case INLINEPLUGIN:
2566 case ANYOTHER:
2567 case 73:
2568 ;
2569 break;
2570 default:
2571 break label_27;
2572 }
2573 }
2574 t = jj_consume_token(STRONGITALIC);
2575 jjtree.closeNodeScope(jjtn000, true);
2576 jjtc000 = false;
2577 jjtn000.postlevel = t.image.length();
2578 } catch (Throwable jjte000) {
2579 if (jjtc000) {
2580 jjtree.clearNodeScope(jjtn000);
2581 jjtc000 = false;
2582 } else {
2583 jjtree.popNode();
2584 }
2585 if (jjte000 instanceof RuntimeException) {
2586 {if (true) throw (RuntimeException)jjte000;}
2587 }
2588 if (jjte000 instanceof ParseException) {
2589 {if (true) throw (ParseException)jjte000;}
2590 }
2591 {if (true) throw (Error)jjte000;}
2592 } finally {
2593 if (jjtc000) {
2594 jjtree.closeNodeScope(jjtn000, true);
2595 }
2596 }
2597 } finally {
2598 trace_return("StrongItalic");
2599 }
2600 }
2601
2602 final public void Deleteline() throws ParseException {
2603 trace_call("Deleteline");
2604 try {
2605
2606 WikiDeleteline jjtn000 = new WikiDeleteline(JJTDELETELINE);
2607 boolean jjtc000 = true;
2608 jjtree.openNodeScope(jjtn000);
2609 try {
2610 jj_consume_token(DELETELINE);
2611 label_28:
2612 while (true) {
2613 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2614 case STRONGITALIC:
2615 StrongItalic();
2616 break;
2617 case 73:
2618 Annotation();
2619 break;
2620 case PAGENAME:
2621 case LINK:
2622 case INTERWIKI:
2623 case ALIASLINK:
2624 case ALIAS:
2625 Linker();
2626 break;
2627 case INLINEPLUGIN:
2628 InlinePlugin();
2629 break;
2630 case TILDE:
2631 case SEMICOLON:
2632 case LPAREN:
2633 case RPAREN:
2634 case LBRACKET:
2635 case RBRACKET:
2636 case LBRACE:
2637 case RBRACE:
2638 case SLASH:
2639 case LT:
2640 case EXCERPT1:
2641 case EXCERPT2:
2642 case EXCERPT3:
2643 case LIST1:
2644 case LIST2:
2645 case LIST3:
2646 case NLIST1:
2647 case NLIST2:
2648 case NLIST3:
2649 case PRESHAPED:
2650 case HEADING1:
2651 case HEADING2:
2652 case HEADING3:
2653 case ALIGN1:
2654 case ALIGN2:
2655 case ALIGN3:
2656 case FALIGN1:
2657 case FALIGN2:
2658 case HORIZONTAL:
2659 case BLOCKPLUGIN:
2660 case COLSPAN:
2661 case PIPE:
2662 case COLON:
2663 case COMMA:
2664 case WIKINAME:
2665 case NATIVELINK:
2666 case ANCHOR:
2667 case IDENTIFIER:
2668 case ARGS:
2669 Letters();
2670 break;
2671 case ANYOTHER:
2672 AnyOther();
2673 break;
2674 default:
2675 jj_consume_token(-1);
2676 throw new ParseException();
2677 }
2678 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2679 case TILDE:
2680 case SEMICOLON:
2681 case LPAREN:
2682 case RPAREN:
2683 case LBRACKET:
2684 case RBRACKET:
2685 case LBRACE:
2686 case RBRACE:
2687 case SLASH:
2688 case LT:
2689 case EXCERPT1:
2690 case EXCERPT2:
2691 case EXCERPT3:
2692 case LIST1:
2693 case LIST2:
2694 case LIST3:
2695 case NLIST1:
2696 case NLIST2:
2697 case NLIST3:
2698 case PRESHAPED:
2699 case HEADING1:
2700 case HEADING2:
2701 case HEADING3:
2702 case ALIGN1:
2703 case ALIGN2:
2704 case ALIGN3:
2705 case FALIGN1:
2706 case FALIGN2:
2707 case HORIZONTAL:
2708 case BLOCKPLUGIN:
2709 case COLSPAN:
2710 case PIPE:
2711 case COLON:
2712 case COMMA:
2713 case STRONGITALIC:
2714 case WIKINAME:
2715 case NATIVELINK:
2716 case ANCHOR:
2717 case PAGENAME:
2718 case LINK:
2719 case INTERWIKI:
2720 case ALIASLINK:
2721 case ALIAS:
2722 case IDENTIFIER:
2723 case ARGS:
2724 case INLINEPLUGIN:
2725 case ANYOTHER:
2726 case 73:
2727 ;
2728 break;
2729 default:
2730 break label_28;
2731 }
2732 }
2733 jj_consume_token(DELETELINE);
2734 } catch (Throwable jjte000) {
2735 if (jjtc000) {
2736 jjtree.clearNodeScope(jjtn000);
2737 jjtc000 = false;
2738 } else {
2739 jjtree.popNode();
2740 }
2741 if (jjte000 instanceof RuntimeException) {
2742 {if (true) throw (RuntimeException)jjte000;}
2743 }
2744 if (jjte000 instanceof ParseException) {
2745 {if (true) throw (ParseException)jjte000;}
2746 }
2747 {if (true) throw (Error)jjte000;}
2748 } finally {
2749 if (jjtc000) {
2750 jjtree.closeNodeScope(jjtn000, true);
2751 }
2752 }
2753 } finally {
2754 trace_return("Deleteline");
2755 }
2756 }
2757
2758 final public void Annotation() throws ParseException {
2759 trace_call("Annotation");
2760 try {
2761
2762 WikiAnnotation jjtn000 = new WikiAnnotation(JJTANNOTATION);
2763 boolean jjtc000 = true;
2764 jjtree.openNodeScope(jjtn000);
2765 try {
2766 jj_consume_token(73);
2767 label_29:
2768 while (true) {
2769 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2770 case STRONGITALIC:
2771 StrongItalic();
2772 break;
2773 case DELETELINE:
2774 Deleteline();
2775 break;
2776 case PAGENAME:
2777 case LINK:
2778 case INTERWIKI:
2779 case ALIASLINK:
2780 case ALIAS:
2781 Linker();
2782 break;
2783 case INLINEPLUGIN:
2784 InlinePlugin();
2785 break;
2786 case TILDE:
2787 case SEMICOLON:
2788 case LPAREN:
2789 case RPAREN:
2790 case LBRACKET:
2791 case RBRACKET:
2792 case LBRACE:
2793 case RBRACE:
2794 case SLASH:
2795 case LT:
2796 case EXCERPT1:
2797 case EXCERPT2:
2798 case EXCERPT3:
2799 case LIST1:
2800 case LIST2:
2801 case LIST3:
2802 case NLIST1:
2803 case NLIST2:
2804 case NLIST3:
2805 case PRESHAPED:
2806 case HEADING1:
2807 case HEADING2:
2808 case HEADING3:
2809 case ALIGN1:
2810 case ALIGN2:
2811 case ALIGN3:
2812 case FALIGN1:
2813 case FALIGN2:
2814 case HORIZONTAL:
2815 case BLOCKPLUGIN:
2816 case COLSPAN:
2817 case PIPE:
2818 case COLON:
2819 case COMMA:
2820 case WIKINAME:
2821 case NATIVELINK:
2822 case ANCHOR:
2823 case IDENTIFIER:
2824 case ARGS:
2825 Letters();
2826 break;
2827 case ANYOTHER:
2828 AnyOther();
2829 break;
2830 default:
2831 jj_consume_token(-1);
2832 throw new ParseException();
2833 }
2834 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2835 case TILDE:
2836 case SEMICOLON:
2837 case LPAREN:
2838 case RPAREN:
2839 case LBRACKET:
2840 case RBRACKET:
2841 case LBRACE:
2842 case RBRACE:
2843 case SLASH:
2844 case LT:
2845 case EXCERPT1:
2846 case EXCERPT2:
2847 case EXCERPT3:
2848 case LIST1:
2849 case LIST2:
2850 case LIST3:
2851 case NLIST1:
2852 case NLIST2:
2853 case NLIST3:
2854 case PRESHAPED:
2855 case HEADING1:
2856 case HEADING2:
2857 case HEADING3:
2858 case ALIGN1:
2859 case ALIGN2:
2860 case ALIGN3:
2861 case FALIGN1:
2862 case FALIGN2:
2863 case HORIZONTAL:
2864 case BLOCKPLUGIN:
2865 case COLSPAN:
2866 case PIPE:
2867 case COLON:
2868 case COMMA:
2869 case DELETELINE:
2870 case STRONGITALIC:
2871 case WIKINAME:
2872 case NATIVELINK:
2873 case ANCHOR:
2874 case PAGENAME:
2875 case LINK:
2876 case INTERWIKI:
2877 case ALIASLINK:
2878 case ALIAS:
2879 case IDENTIFIER:
2880 case ARGS:
2881 case INLINEPLUGIN:
2882 case ANYOTHER:
2883 ;
2884 break;
2885 default:
2886 break label_29;
2887 }
2888 }
2889 jj_consume_token(74);
2890 jjtree.closeNodeScope(jjtn000, true);
2891 jjtc000 = false;
2892 int i = addAnnotation(jjtn000);
2893 jjtn000.num = i;
2894 } catch (Throwable jjte000) {
2895 if (jjtc000) {
2896 jjtree.clearNodeScope(jjtn000);
2897 jjtc000 = false;
2898 } else {
2899 jjtree.popNode();
2900 }
2901 if (jjte000 instanceof RuntimeException) {
2902 {if (true) throw (RuntimeException)jjte000;}
2903 }
2904 if (jjte000 instanceof ParseException) {
2905 {if (true) throw (ParseException)jjte000;}
2906 }
2907 {if (true) throw (Error)jjte000;}
2908 } finally {
2909 if (jjtc000) {
2910 jjtree.closeNodeScope(jjtn000, true);
2911 }
2912 }
2913 } finally {
2914 trace_return("Annotation");
2915 }
2916 }
2917
2918 final public void Linker() throws ParseException {
2919 trace_call("Linker");
2920 try {
2921 Token t;
2922 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2923 case INTERWIKI:
2924 WikiInterwiki jjtn001 = new WikiInterwiki(JJTINTERWIKI);
2925 boolean jjtc001 = true;
2926 jjtree.openNodeScope(jjtn001);
2927 try {
2928 t = jj_consume_token(INTERWIKI);
2929 jjtree.closeNodeScope(jjtn001, true);
2930 jjtc001 = false;
2931 jjtn001.image = t.image.substring(2,t.image.length()-2);
2932 } finally {
2933 if (jjtc001) {
2934 jjtree.closeNodeScope(jjtn001, true);
2935 }
2936 }
2937 break;
2938 case LINK:
2939 WikiLink jjtn002 = new WikiLink(JJTLINK);
2940 boolean jjtc002 = true;
2941 jjtree.openNodeScope(jjtn002);
2942 try {
2943 t = jj_consume_token(LINK);
2944 jjtree.closeNodeScope(jjtn002, true);
2945 jjtc002 = false;
2946 jjtn002.image=t.image.substring(2,t.image.length()-2);
2947 } finally {
2948 if (jjtc002) {
2949 jjtree.closeNodeScope(jjtn002, true);
2950 }
2951 }
2952 break;
2953 case ALIASLINK:
2954 case ALIAS:
2955 WikiAlias jjtn003 = new WikiAlias(JJTALIAS);
2956 boolean jjtc003 = true;
2957 jjtree.openNodeScope(jjtn003);
2958 try {
2959 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
2960 case ALIAS:
2961 t = jj_consume_token(ALIAS);
2962 break;
2963 case ALIASLINK:
2964 t = jj_consume_token(ALIASLINK);
2965 jjtn003.islink=true;
2966 break;
2967 default:
2968 jj_consume_token(-1);
2969 throw new ParseException();
2970 }
2971 jjtree.closeNodeScope(jjtn003, true);
2972 jjtc003 = false;
2973 jjtn003.image=t.image.substring(2,t.image.length()-2);
2974 } finally {
2975 if (jjtc003) {
2976 jjtree.closeNodeScope(jjtn003, true);
2977 }
2978 }
2979 break;
2980 case PAGENAME:
2981 WikiPagename jjtn004 = new WikiPagename(JJTPAGENAME);
2982 boolean jjtc004 = true;
2983 jjtree.openNodeScope(jjtn004);
2984 try {
2985 t = jj_consume_token(PAGENAME);
2986 jjtree.closeNodeScope(jjtn004, true);
2987 jjtc004 = false;
2988 jjtn004.image = t.image.substring(2,t.image.length()-2);
2989 } finally {
2990 if (jjtc004) {
2991 jjtree.closeNodeScope(jjtn004, true);
2992 }
2993 }
2994 break;
2995 default:
2996 jj_consume_token(-1);
2997 throw new ParseException();
2998 }
2999 } finally {
3000 trace_return("Linker");
3001 }
3002 }
3003
3004 final public void InlinePlugin() throws ParseException {
3005 trace_call("InlinePlugin");
3006 try {
3007
3008 WikiInlinePlugin jjtn000 = new WikiInlinePlugin(JJTINLINEPLUGIN);
3009 boolean jjtc000 = true;
3010 jjtree.openNodeScope(jjtn000);Token t;
3011 try {
3012 t = jj_consume_token(INLINEPLUGIN);
3013 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3014 case ARGS:
3015 Args();
3016 break;
3017 default:
3018 ;
3019 }
3020 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3021 case LBRACE:
3022 jj_consume_token(LBRACE);
3023 label_30:
3024 while (true) {
3025 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
3026 case STRONGITALIC:
3027 StrongItalic();
3028 break;
3029 case DELETELINE:
3030 Deleteline();
3031 break;
3032 case 73:
3033 Annotation();
3034 break;
3035 case PAGENAME:
3036 case LINK:
3037 case INTERWIKI:
3038 case ALIASLINK:
3039 case ALIAS:
3040 Linker();
3041 break;
3042 case INLINEPLUGIN:
3043 InlinePlugin();
3044 break;
3045 default:
3046 if (!(getToken(1).kind==RBRACE && getToken(2).kind == SEMICOLON)) {
3047 Letters();
3048 } else {
3049 jj_consume_token(-1);
3050 throw new ParseException();
3051 }
3052 }
3053 if (jj_2_12(1)) {
3054 ;
3055 } else {
3056 break label_30;
3057 }
3058 }
3059 jj_consume_token(RBRACE);
3060 break;
3061 default:
3062 ;
3063 }
3064 jj_consume_token(SEMICOLON);
3065 jjtree.closeNodeScope(jjtn000, true);
3066 jjtc000 = false;
3067 jjtn000.name = t.image.substring(1);
3068 } catch (Throwable jjte000) {
3069 if (jjtc000) {
3070 jjtree.clearNodeScope(jjtn000);
3071 jjtc000 = false;
3072 } else {
3073 jjtree.popNode();
3074 }
3075 if (jjte000 instanceof RuntimeException) {
3076 {if (true) throw (RuntimeException)jjte000;}
3077 }
3078 if (jjte000 instanceof ParseException) {
3079 {if (true) throw (ParseException)jjte000;}
3080 }
3081 {if (true) throw (Error)jjte000;}
3082 } finally {
3083 if (jjtc000) {
3084 jjtree.closeNodeScope(jjtn000, true);
3085 }
3086 }
3087 } finally {
3088 trace_return("InlinePlugin");
3089 }
3090 }
3091
3092
3093 final public void Args() throws ParseException {
3094 trace_call("Args");
3095 try {
3096
3097 WikiArgs jjtn000 = new WikiArgs(JJTARGS);
3098 boolean jjtc000 = true;
3099 jjtree.openNodeScope(jjtn000);Token t;
3100 try {
3101 t = jj_consume_token(ARGS);
3102 jjtree.closeNodeScope(jjtn000, true);
3103 jjtc000 = false;
3104 jjtn000.args = WikiHelper.splitArgs(t.image);
3105 } finally {
3106 if (jjtc000) {
3107 jjtree.closeNodeScope(jjtn000, true);
3108 }
3109 }
3110 } finally {
3111 trace_return("Args");
3112 }
3113 }
3114
3115 final public void Errors() throws ParseException {
3116 trace_call("Errors");
3117 try {
3118
3119 WikiErrors jjtn000 = new WikiErrors(JJTERRORS);
3120 boolean jjtc000 = true;
3121 jjtree.openNodeScope(jjtn000);
3122 try {
3123 jjtree.closeNodeScope(jjtn000, true);
3124 jjtc000 = false;
3125
3126 } finally {
3127 if (jjtc000) {
3128 jjtree.closeNodeScope(jjtn000, true);
3129 }
3130 }
3131 } finally {
3132 trace_return("Errors");
3133 }
3134 }
3135
3136 final private boolean jj_2_1(int xla) {
3137 jj_la = xla; jj_lastpos = jj_scanpos = token;
3138 try { return !jj_3_1(); }
3139 catch(LookaheadSuccess ls) { return true; }
3140 }
3141
3142 final private boolean jj_2_2(int xla) {
3143 jj_la = xla; jj_lastpos = jj_scanpos = token;
3144 try { return !jj_3_2(); }
3145 catch(LookaheadSuccess ls) { return true; }
3146 }
3147
3148 final private boolean jj_2_3(int xla) {
3149 jj_la = xla; jj_lastpos = jj_scanpos = token;
3150 try { return !jj_3_3(); }
3151 catch(LookaheadSuccess ls) { return true; }
3152 }
3153
3154 final private boolean jj_2_4(int xla) {
3155 jj_la = xla; jj_lastpos = jj_scanpos = token;
3156 try { return !jj_3_4(); }
3157 catch(LookaheadSuccess ls) { return true; }
3158 }
3159
3160 final private boolean jj_2_5(int xla) {
3161 jj_la = xla; jj_lastpos = jj_scanpos = token;
3162 try { return !jj_3_5(); }
3163 catch(LookaheadSuccess ls) { return true; }
3164 }
3165
3166 final private boolean jj_2_6(int xla) {
3167 jj_la = xla; jj_lastpos = jj_scanpos = token;
3168 try { return !jj_3_6(); }
3169 catch(LookaheadSuccess ls) { return true; }
3170 }
3171
3172 final private boolean jj_2_7(int xla) {
3173 jj_la = xla; jj_lastpos = jj_scanpos = token;
3174 try { return !jj_3_7(); }
3175 catch(LookaheadSuccess ls) { return true; }
3176 }
3177
3178 final private boolean jj_2_8(int xla) {
3179 jj_la = xla; jj_lastpos = jj_scanpos = token;
3180 try { return !jj_3_8(); }
3181 catch(LookaheadSuccess ls) { return true; }
3182 }
3183
3184 final private boolean jj_2_9(int xla) {
3185 jj_la = xla; jj_lastpos = jj_scanpos = token;
3186 try { return !jj_3_9(); }
3187 catch(LookaheadSuccess ls) { return true; }
3188 }
3189
3190 final private boolean jj_2_10(int xla) {
3191 jj_la = xla; jj_lastpos = jj_scanpos = token;
3192 try { return !jj_3_10(); }
3193 catch(LookaheadSuccess ls) { return true; }
3194 }
3195
3196 final private boolean jj_2_11(int xla) {
3197 jj_la = xla; jj_lastpos = jj_scanpos = token;
3198 try { return !jj_3_11(); }
3199 catch(LookaheadSuccess ls) { return true; }
3200 }
3201
3202 final private boolean jj_2_12(int xla) {
3203 jj_la = xla; jj_lastpos = jj_scanpos = token;
3204 try { return !jj_3_12(); }
3205 catch(LookaheadSuccess ls) { return true; }
3206 }
3207
3208 final private boolean jj_3R_127() {
3209 if (jj_scan_token(LINK)) return true;
3210 return false;
3211 }
3212
3213 final private boolean jj_3R_78() {
3214 if (jj_3R_90()) return true;
3215 return false;
3216 }
3217
3218 final private boolean jj_3R_107() {
3219 if (jj_scan_token(NL)) return true;
3220 return false;
3221 }
3222
3223 final private boolean jj_3R_126() {
3224 if (jj_scan_token(INTERWIKI)) return true;
3225 return false;
3226 }
3227
3228 final private boolean jj_3_10() {
3229 if (jj_scan_token(COLSPAN)) return true;
3230 if (jj_scan_token(CTABLEDEL)) return true;
3231 return false;
3232 }
3233
3234 final private boolean jj_3R_118() {
3235 if (jj_scan_token(SIZEWORD)) return true;
3236 return false;
3237 }
3238
3239 final private boolean jj_3R_117() {
3240 if (jj_scan_token(BGCOLORWORD)) return true;
3241 return false;
3242 }
3243
3244 final private boolean jj_3R_103() {
3245 Token xsp;
3246 xsp = jj_scanpos;
3247 if (jj_3R_126()) {
3248 jj_scanpos = xsp;
3249 if (jj_3R_127()) {
3250 jj_scanpos = xsp;
3251 if (jj_3R_128()) {
3252 jj_scanpos = xsp;
3253 if (jj_3R_129()) return true;
3254 }
3255 }
3256 }
3257 return false;
3258 }
3259
3260 final private boolean jj_3R_116() {
3261 if (jj_scan_token(COLORWORD)) return true;
3262 return false;
3263 }
3264
3265 final private boolean jj_3R_96() {
3266 if (jj_scan_token(NL)) return true;
3267 return false;
3268 }
3269
3270 final private boolean jj_3R_115() {
3271 if (jj_scan_token(ALIGN3)) return true;
3272 return false;
3273 }
3274
3275 final private boolean jj_3R_114() {
3276 if (jj_scan_token(ALIGN2)) return true;
3277 return false;
3278 }
3279
3280 final private boolean jj_3R_113() {
3281 if (jj_scan_token(ALIGN1)) return true;
3282 return false;
3283 }
3284
3285 final private boolean jj_3R_98() {
3286 Token xsp;
3287 xsp = jj_scanpos;
3288 if (jj_3R_113()) {
3289 jj_scanpos = xsp;
3290 if (jj_3R_114()) {
3291 jj_scanpos = xsp;
3292 if (jj_3R_115()) {
3293 jj_scanpos = xsp;
3294 if (jj_3R_116()) {
3295 jj_scanpos = xsp;
3296 if (jj_3R_117()) {
3297 jj_scanpos = xsp;
3298 if (jj_3R_118()) return true;
3299 }
3300 }
3301 }
3302 }
3303 }
3304 return false;
3305 }
3306
3307 final private boolean jj_3R_31() {
3308 Token xsp;
3309 xsp = jj_scanpos;
3310 lookingAhead = true;
3311 jj_semLA = isExcerpt();
3312 lookingAhead = false;
3313 if (!jj_semLA || jj_3R_78()) {
3314 jj_scanpos = xsp;
3315 lookingAhead = true;
3316 jj_semLA = isList();
3317 lookingAhead = false;
3318 if (!jj_semLA || jj_3R_79()) {
3319 jj_scanpos = xsp;
3320 lookingAhead = true;
3321 jj_semLA = isDefineList();
3322 lookingAhead = false;
3323 if (!jj_semLA || jj_3R_80()) {
3324 jj_scanpos = xsp;
3325 lookingAhead = true;
3326 jj_semLA = isPreshaped();
3327 lookingAhead = false;
3328 if (!jj_semLA || jj_3R_81()) {
3329 jj_scanpos = xsp;
3330 lookingAhead = true;
3331 jj_semLA = isTable();
3332 lookingAhead = false;
3333 if (!jj_semLA || jj_3R_82()) {
3334 jj_scanpos = xsp;
3335 lookingAhead = true;
3336 jj_semLA = isCSVTable();
3337 lookingAhead = false;
3338 if (!jj_semLA || jj_3R_83()) {
3339 jj_scanpos = xsp;
3340 lookingAhead = true;
3341 jj_semLA = isHeading();
3342 lookingAhead = false;
3343 if (!jj_semLA || jj_3R_84()) {
3344 jj_scanpos = xsp;
3345 lookingAhead = true;
3346 jj_semLA = isAlign();
3347 lookingAhead = false;
3348 if (!jj_semLA || jj_3R_85()) {
3349 jj_scanpos = xsp;
3350 lookingAhead = true;
3351 jj_semLA = isFloatAlign();
3352 lookingAhead = false;
3353 if (!jj_semLA || jj_3R_86()) {
3354 jj_scanpos = xsp;
3355 lookingAhead = true;
3356 jj_semLA = isHorizontalline();
3357 lookingAhead = false;
3358 if (!jj_semLA || jj_3R_87()) {
3359 jj_scanpos = xsp;
3360 lookingAhead = true;
3361 jj_semLA = isBlankline();
3362 lookingAhead = false;
3363 if (!jj_semLA || jj_scan_token(9)) {
3364 jj_scanpos = xsp;
3365 lookingAhead = true;
3366 jj_semLA = isBlockPlugin();
3367 lookingAhead = false;
3368 if (!jj_semLA || jj_3R_88()) {
3369 jj_scanpos = xsp;
3370 if (jj_3_2()) return true;
3371 }
3372 }
3373 }
3374 }
3375 }
3376 }
3377 }
3378 }
3379 }
3380 }
3381 }
3382 }
3383 return false;
3384 }
3385
3386 final private boolean jj_3_1() {
3387 if (jj_3R_31()) return true;
3388 return false;
3389 }
3390
3391 final private boolean jj_3R_60() {
3392 return false;
3393 }
3394
3395 final private boolean jj_3R_61() {
3396 if (jj_3R_99()) return true;
3397 return false;
3398 }
3399
3400 final private boolean jj_3R_106() {
3401 if (jj_scan_token(NL)) return true;
3402 return false;
3403 }
3404
3405 final private boolean jj_3R_59() {
3406 Token xsp;
3407 if (jj_3R_98()) return true;
3408 while (true) {
3409 xsp = jj_scanpos;
3410 if (jj_3R_98()) { jj_scanpos = xsp; break; }
3411 }
3412 return false;
3413 }
3414
3415 final private boolean jj_3R_102() {
3416 if (jj_scan_token(73)) return true;
3417 return false;
3418 }
3419
3420 final private boolean jj_3_8() {
3421 Token xsp;
3422 xsp = jj_scanpos;
3423 if (jj_3R_59()) jj_scanpos = xsp;
3424 xsp = jj_scanpos;
3425 lookingAhead = true;
3426 jj_semLA = !(getToken(1).kind==IDENTIFIER && isNewline(2));
3427 lookingAhead = false;
3428 if (!jj_semLA || jj_3R_60()) return true;
3429 while (true) {
3430 xsp = jj_scanpos;
3431 if (jj_3R_61()) { jj_scanpos = xsp; break; }
3432 }
3433 xsp = jj_scanpos;
3434 if (jj_scan_token(50)) {
3435 jj_scanpos = xsp;
3436 if (jj_scan_token(51)) {
3437 jj_scanpos = xsp;
3438 if (jj_scan_token(52)) return true;
3439 }
3440 }
3441 return false;
3442 }
3443
3444 final private boolean jj_3R_63() {
3445 if (jj_scan_token(NTABROWSPAN)) return true;
3446 return false;
3447 }
3448
3449 final private boolean jj_3R_112() {
3450 if (jj_scan_token(CTABLE)) return true;
3451 return false;
3452 }
3453
3454 final private boolean jj_3R_62() {
3455 if (jj_scan_token(NTABCOLSPAN)) return true;
3456 return false;
3457 }
3458
3459 final private boolean jj_3R_95() {
3460 Token xsp;
3461 if (jj_3R_112()) return true;
3462 while (true) {
3463 xsp = jj_scanpos;
3464 if (jj_3R_112()) { jj_scanpos = xsp; break; }
3465 }
3466 return false;
3467 }
3468
3469 final private boolean jj_3_9() {
3470 Token xsp;
3471 xsp = jj_scanpos;
3472 if (jj_3R_62()) {
3473 jj_scanpos = xsp;
3474 if (jj_3R_63()) {
3475 jj_scanpos = xsp;
3476 if (jj_3_8()) return true;
3477 }
3478 }
3479 return false;
3480 }
3481
3482 final private boolean jj_3R_101() {
3483 if (jj_scan_token(DELETELINE)) return true;
3484 return false;
3485 }
3486
3487 final private boolean jj_3R_111() {
3488 if (jj_scan_token(TABLE)) return true;
3489 return false;
3490 }
3491
3492 final private boolean jj_3R_100() {
3493 if (jj_scan_token(STRONGITALIC)) return true;
3494 return false;
3495 }
3496
3497 final private boolean jj_3R_58() {
3498 if (jj_3R_32()) return true;
3499 return false;
3500 }
3501
3502 final private boolean jj_3R_57() {
3503 if (jj_3R_97()) return true;
3504 return false;
3505 }
3506
3507 final private boolean jj_3R_56() {
3508 if (jj_3R_96()) return true;
3509 return false;
3510 }
3511
3512 final private boolean jj_3R_55() {
3513 if (jj_3R_95()) return true;
3514 return false;
3515 }
3516
3517 final private boolean jj_3R_54() {
3518 if (jj_3R_94()) return true;
3519 return false;
3520 }
3521
3522 final private boolean jj_3R_53() {
3523 if (jj_3R_93()) return true;
3524 return false;
3525 }
3526
3527 final private boolean jj_3R_52() {
3528 if (jj_3R_91()) return true;
3529 return false;
3530 }
3531
3532 final private boolean jj_3R_94() {
3533 Token xsp;
3534 if (jj_3R_111()) return true;
3535 while (true) {
3536 xsp = jj_scanpos;
3537 if (jj_3R_111()) { jj_scanpos = xsp; break; }
3538 }
3539 return false;
3540 }
3541
3542 final private boolean jj_3R_51() {
3543 if (jj_3R_90()) return true;
3544 return false;
3545 }
3546
3547 final private boolean jj_3_7() {
3548 Token xsp;
3549 xsp = jj_scanpos;
3550 lookingAhead = true;
3551 jj_semLA = isExcerpt();
3552 lookingAhead = false;
3553 if (!jj_semLA || jj_3R_51()) {
3554 jj_scanpos = xsp;
3555 lookingAhead = true;
3556 jj_semLA = isList();
3557 lookingAhead = false;
3558 if (!jj_semLA || jj_3R_52()) {
3559 jj_scanpos = xsp;
3560 lookingAhead = true;
3561 jj_semLA = isPreshaped();
3562 lookingAhead = false;
3563 if (!jj_semLA || jj_3R_53()) {
3564 jj_scanpos = xsp;
3565 lookingAhead = true;
3566 jj_semLA = isTable();
3567 lookingAhead = false;
3568 if (!jj_semLA || jj_3R_54()) {
3569 jj_scanpos = xsp;
3570 lookingAhead = true;
3571 jj_semLA = isCSVTable();
3572 lookingAhead = false;
3573 if (!jj_semLA || jj_3R_55()) {
3574 jj_scanpos = xsp;
3575 lookingAhead = true;
3576 jj_semLA = isAlign();
3577 lookingAhead = false;
3578 if (!jj_semLA || jj_3R_56()) {
3579 jj_scanpos = xsp;
3580 lookingAhead = true;
3581 jj_semLA = isBlockPlugin();
3582 lookingAhead = false;
3583 if (!jj_semLA || jj_3R_57()) {
3584 jj_scanpos = xsp;
3585 lookingAhead = true;
3586 jj_semLA = isParagraph();
3587 lookingAhead = false;
3588 if (!jj_semLA || jj_3R_58()) return true;
3589 }
3590 }
3591 }
3592 }
3593 }
3594 }
3595 }
3596 return false;
3597 }
3598
3599 final private boolean jj_3R_138() {
3600 if (jj_scan_token(ANYOTHER)) return true;
3601 return false;
3602 }
3603
3604 final private boolean jj_3R_110() {
3605 if (jj_scan_token(NL)) return true;
3606 return false;
3607 }
3608
3609 final private boolean jj_3R_93() {
3610 Token xsp;
3611 if (jj_3R_110()) return true;
3612 while (true) {
3613 xsp = jj_scanpos;
3614 if (jj_3R_110()) { jj_scanpos = xsp; break; }
3615 }
3616 return false;
3617 }
3618
3619 final private boolean jj_3R_49() {
3620 if (jj_3R_32()) return true;
3621 return false;
3622 }
3623
3624 final private boolean jj_3R_48() {
3625 if (jj_3R_97()) return true;
3626 return false;
3627 }
3628
3629 final private boolean jj_3R_47() {
3630 if (jj_3R_96()) return true;
3631 return false;
3632 }
3633
3634 final private boolean jj_3R_109() {
3635 if (jj_scan_token(DLIST)) return true;
3636 return false;
3637 }
3638
3639 final private boolean jj_3R_46() {
3640 if (jj_3R_95()) return true;
3641 return false;
3642 }
3643
3644 final private boolean jj_3R_45() {
3645 if (jj_3R_94()) return true;
3646 return false;
3647 }
3648
3649 final private boolean jj_3R_44() {
3650 if (jj_3R_93()) return true;
3651 return false;
3652 }
3653
3654 final private boolean jj_3R_43() {
3655 if (jj_3R_92()) return true;
3656 return false;
3657 }
3658
3659 final private boolean jj_3R_50() {
3660 return false;
3661 }
3662
3663 final private boolean jj_3R_42() {
3664 if (jj_3R_90()) return true;
3665 return false;
3666 }
3667
3668 final private boolean jj_3_5() {
3669 Token xsp;
3670 xsp = jj_scanpos;
3671 lookingAhead = true;
3672 jj_semLA = isExcerpt();
3673 lookingAhead = false;
3674 if (!jj_semLA || jj_3R_42()) {
3675 jj_scanpos = xsp;
3676 lookingAhead = true;
3677 jj_semLA = isDefineList();
3678 lookingAhead = false;
3679 if (!jj_semLA || jj_3R_43()) {
3680 jj_scanpos = xsp;
3681 lookingAhead = true;
3682 jj_semLA = isPreshaped();
3683 lookingAhead = false;
3684 if (!jj_semLA || jj_3R_44()) {
3685 jj_scanpos = xsp;
3686 lookingAhead = true;
3687 jj_semLA = isTable();
3688 lookingAhead = false;
3689 if (!jj_semLA || jj_3R_45()) {
3690 jj_scanpos = xsp;
3691 lookingAhead = true;
3692 jj_semLA = isCSVTable();
3693 lookingAhead = false;
3694 if (!jj_semLA || jj_3R_46()) {
3695 jj_scanpos = xsp;
3696 lookingAhead = true;
3697 jj_semLA = isAlign();
3698 lookingAhead = false;
3699 if (!jj_semLA || jj_3R_47()) {
3700 jj_scanpos = xsp;
3701 lookingAhead = true;
3702 jj_semLA = isBlockPlugin();
3703 lookingAhead = false;
3704 if (!jj_semLA || jj_3R_48()) {
3705 jj_scanpos = xsp;
3706 lookingAhead = true;
3707 jj_semLA = isParagraph();
3708 lookingAhead = false;
3709 if (!jj_semLA || jj_3R_49()) return true;
3710 }
3711 }
3712 }
3713 }
3714 }
3715 }
3716 }
3717 return false;
3718 }
3719
3720 final private boolean jj_3R_92() {
3721 Token xsp;
3722 if (jj_3R_109()) return true;
3723 while (true) {
3724 xsp = jj_scanpos;
3725 if (jj_3R_109()) { jj_scanpos = xsp; break; }
3726 }
3727 return false;
3728 }
3729
3730 final private boolean jj_3R_137() {
3731 if (jj_scan_token(LT)) return true;
3732 return false;
3733 }
3734
3735 final private boolean jj_3R_136() {
3736 if (jj_scan_token(EXCERPT3)) return true;
3737 return false;
3738 }
3739
3740 final private boolean jj_3R_135() {
3741 if (jj_scan_token(EXCERPT2)) return true;
3742 return false;
3743 }
3744
3745 final private boolean jj_3_3() {
3746 if (jj_scan_token(TILDE)) return true;
3747 return false;
3748 }
3749
3750 final private boolean jj_3R_134() {
3751 if (jj_scan_token(EXCERPT1)) return true;
3752 return false;
3753 }
3754
3755 final private boolean jj_3_6() {
3756 Token xsp;
3757 xsp = jj_scanpos;
3758 lookingAhead = true;
3759 jj_semLA = isList();
3760 lookingAhead = false;
3761 if (!jj_semLA || jj_3R_50()) return true;
3762 if (jj_scan_token(NL)) return true;
3763 return false;
3764 }
3765
3766 final private boolean jj_3R_133() {
3767 if (jj_scan_token(TILDE)) return true;
3768 return false;
3769 }
3770
3771 final private boolean jj_3R_91() {
3772 Token xsp;
3773 if (jj_3_6()) return true;
3774 while (true) {
3775 xsp = jj_scanpos;
3776 if (jj_3_6()) { jj_scanpos = xsp; break; }
3777 }
3778 return false;
3779 }
3780
3781 final private boolean jj_3R_41() {
3782 if (jj_3R_32()) return true;
3783 return false;
3784 }
3785
3786 final private boolean jj_3R_132() {
3787 if (jj_scan_token(ANCHOR)) return true;
3788 return false;
3789 }
3790
3791 final private boolean jj_3R_40() {
3792 if (jj_3R_97()) return true;
3793 return false;
3794 }
3795
3796 final private boolean jj_3R_131() {
3797 if (jj_scan_token(WIKINAME)) return true;
3798 return false;
3799 }
3800
3801 final private boolean jj_3R_39() {
3802 if (jj_3R_96()) return true;
3803 return false;
3804 }
3805
3806 final private boolean jj_3R_38() {
3807 if (jj_3R_95()) return true;
3808 return false;
3809 }
3810
3811 final private boolean jj_3R_37() {
3812 if (jj_3R_94()) return true;
3813 return false;
3814 }
3815
3816 final private boolean jj_3R_36() {
3817 if (jj_3R_93()) return true;
3818 return false;
3819 }
3820
3821 final private boolean jj_3R_35() {
3822 if (jj_3R_92()) return true;
3823 return false;
3824 }
3825
3826 final private boolean jj_3R_34() {
3827 if (jj_3R_91()) return true;
3828 return false;
3829 }
3830
3831 final private boolean jj_3_4() {
3832 Token xsp;
3833 xsp = jj_scanpos;
3834 lookingAhead = true;
3835 jj_semLA = isExcerpt();
3836 lookingAhead = false;
3837 if (!jj_semLA || jj_3R_33()) {
3838 jj_scanpos = xsp;
3839 lookingAhead = true;
3840 jj_semLA = isList();
3841 lookingAhead = false;
3842 if (!jj_semLA || jj_3R_34()) {
3843 jj_scanpos = xsp;
3844 lookingAhead = true;
3845 jj_semLA = isDefineList();
3846 lookingAhead = false;
3847 if (!jj_semLA || jj_3R_35()) {
3848 jj_scanpos = xsp;
3849 lookingAhead = true;
3850 jj_semLA = isPreshaped();
3851 lookingAhead = false;
3852 if (!jj_semLA || jj_3R_36()) {
3853 jj_scanpos = xsp;
3854 lookingAhead = true;
3855 jj_semLA = isTable();
3856 lookingAhead = false;
3857 if (!jj_semLA || jj_3R_37()) {
3858 jj_scanpos = xsp;
3859 lookingAhead = true;
3860 jj_semLA = isCSVTable();
3861 lookingAhead = false;
3862 if (!jj_semLA || jj_3R_38()) {
3863 jj_scanpos = xsp;
3864 lookingAhead = true;
3865 jj_semLA = isAlign();
3866 lookingAhead = false;
3867 if (!jj_semLA || jj_3R_39()) {
3868 jj_scanpos = xsp;
3869 lookingAhead = true;
3870 jj_semLA = isBlockPlugin();
3871 lookingAhead = false;
3872 if (!jj_semLA || jj_3R_40()) {
3873 jj_scanpos = xsp;
3874 lookingAhead = true;
3875 jj_semLA = isParagraph();
3876 lookingAhead = false;
3877 if (!jj_semLA || jj_3R_41()) return true;
3878 }
3879 }
3880 }
3881 }
3882 }
3883 }
3884 }
3885 }
3886 return false;
3887 }
3888
3889 final private boolean jj_3R_33() {
3890 if (jj_3R_90()) return true;
3891 return false;
3892 }
3893
3894 final private boolean jj_3R_130() {
3895 if (jj_scan_token(NATIVELINK)) return true;
3896 return false;
3897 }
3898
3899 final private boolean jj_3R_105() {
3900 Token xsp;
3901 xsp = jj_scanpos;
3902 if (jj_3R_130()) {
3903 jj_scanpos = xsp;
3904 if (jj_3R_131()) {
3905 jj_scanpos = xsp;
3906 if (jj_3R_132()) {
3907 jj_scanpos = xsp;
3908 if (jj_scan_token(69)) {
3909 jj_scanpos = xsp;
3910 if (jj_3R_133()) {
3911 jj_scanpos = xsp;
3912 if (jj_scan_token(11)) {
3913 jj_scanpos = xsp;
3914 if (jj_scan_token(12)) {
3915 jj_scanpos = xsp;
3916 if (jj_scan_token(13)) {
3917 jj_scanpos = xsp;
3918 if (jj_scan_token(14)) {
3919 jj_scanpos = xsp;
3920 if (jj_scan_token(15)) {
3921 jj_scanpos = xsp;
3922 if (jj_scan_token(16)) {
3923 jj_scanpos = xsp;
3924 if (jj_scan_token(17)) {
3925 jj_scanpos = xsp;
3926 if (jj_scan_token(18)) {
3927 jj_scanpos = xsp;
3928 if (jj_3R_134()) {
3929 jj_scanpos = xsp;
3930 if (jj_3R_135()) {
3931 jj_scanpos = xsp;
3932 if (jj_3R_136()) {
3933 jj_scanpos = xsp;
3934 if (jj_3R_137()) {
3935 jj_scanpos = xsp;
3936 if (jj_scan_token(23)) {
3937 jj_scanpos = xsp;
3938 if (jj_scan_token(24)) {
3939 jj_scanpos = xsp;
3940 if (jj_scan_token(25)) {
3941 jj_scanpos = xsp;
3942 if (jj_scan_token(26)) {
3943 jj_scanpos = xsp;
3944 if (jj_scan_token(27)) {
3945 jj_scanpos = xsp;
3946 if (jj_scan_token(28)) {
3947 jj_scanpos = xsp;
3948 if (jj_scan_token(33)) {
3949 jj_scanpos = xsp;
3950 if (jj_scan_token(34)) {
3951 jj_scanpos = xsp;
3952 if (jj_scan_token(35)) {
3953 jj_scanpos = xsp;
3954 if (jj_scan_token(36)) {
3955 jj_scanpos = xsp;
3956 if (jj_scan_token(37)) {
3957 jj_scanpos = xsp;
3958 if (jj_scan_token(48)) {
3959 jj_scanpos = xsp;
3960 if (jj_scan_token(29)) {
3961 jj_scanpos = xsp;
3962 if (jj_scan_token(30)) {
3963 jj_scanpos = xsp;
3964 if (jj_scan_token(31)) {
3965 jj_scanpos = xsp;
3966 if (jj_scan_token(32)) {
3967 jj_scanpos = xsp;
3968 if (jj_scan_token(38)) {
3969 jj_scanpos = xsp;
3970 if (jj_scan_token(47)) {
3971 jj_scanpos = xsp;
3972 if (jj_scan_token(49)) {
3973 jj_scanpos = xsp;
3974 if (jj_scan_token(43)) {
3975 jj_scanpos = xsp;
3976 if (jj_scan_token(70)) {
3977 jj_scanpos = xsp;
3978 if (jj_scan_token(39)) return true;
3979 }
3980 }
3981 }
3982 }
3983 }
3984 }
3985 }
3986 }
3987 }
3988 }
3989 }
3990 }
3991 }
3992 }
3993 }
3994 }
3995 }
3996 }
3997 }
3998 }
3999 }
4000 }
4001 }
4002 }
4003 }
4004 }
4005 }
4006 }
4007 }
4008 }
4009 }
4010 }
4011 }
4012 }
4013 }
4014 }
4015 }
4016 }
4017 return false;
4018 }
4019
4020 final private boolean jj_3R_90() {
4021 if (jj_scan_token(NL)) return true;
4022 return false;
4023 }
4024
4025 final private boolean jj_3R_89() {
4026 if (jj_scan_token(NL)) return true;
4027 return false;
4028 }
4029
4030 final private boolean jj_3R_125() {
4031 if (jj_3R_138()) return true;
4032 return false;
4033 }
4034
4035 final private boolean jj_3R_124() {
4036 if (jj_3R_105()) return true;
4037 return false;
4038 }
4039
4040 final private boolean jj_3R_97() {
4041 if (jj_scan_token(NL)) return true;
4042 return false;
4043 }
4044
4045 final private boolean jj_3R_123() {
4046 if (jj_3R_104()) return true;
4047 return false;
4048 }
4049
4050 final private boolean jj_3R_122() {
4051 if (jj_3R_103()) return true;
4052 return false;
4053 }
4054
4055 final private boolean jj_3R_121() {
4056 if (jj_3R_102()) return true;
4057 return false;
4058 }
4059
4060 final private boolean jj_3R_77() {
4061 if (jj_3R_105()) return true;
4062 return false;
4063 }
4064
4065 final private boolean jj_3R_120() {
4066 if (jj_3R_101()) return true;
4067 return false;
4068 }
4069
4070 final private boolean jj_3R_76() {
4071 if (jj_3R_104()) return true;
4072 return false;
4073 }
4074
4075 final private boolean jj_3R_32() {
4076 Token xsp;
4077 if (jj_3R_89()) return true;
4078 while (true) {
4079 xsp = jj_scanpos;
4080 if (jj_3R_89()) { jj_scanpos = xsp; break; }
4081 }
4082 return false;
4083 }
4084
4085 final private boolean jj_3R_75() {
4086 if (jj_3R_103()) return true;
4087 return false;
4088 }
4089
4090 final private boolean jj_3R_74() {
4091 if (jj_3R_102()) return true;
4092 return false;
4093 }
4094
4095 final private boolean jj_3R_119() {
4096 if (jj_3R_100()) return true;
4097 return false;
4098 }
4099
4100 final private boolean jj_3R_73() {
4101 if (jj_3R_101()) return true;
4102 return false;
4103 }
4104
4105 final private boolean jj_3_12() {
4106 Token xsp;
4107 xsp = jj_scanpos;
4108 if (jj_3R_72()) {
4109 jj_scanpos = xsp;
4110 if (jj_3R_73()) {
4111 jj_scanpos = xsp;
4112 if (jj_3R_74()) {
4113 jj_scanpos = xsp;
4114 if (jj_3R_75()) {
4115 jj_scanpos = xsp;
4116 if (jj_3R_76()) {
4117 jj_scanpos = xsp;
4118 lookingAhead = true;
4119 jj_semLA = !(getToken(1).kind==RBRACE && getToken(2).kind == SEMICOLON);
4120 lookingAhead = false;
4121 if (!jj_semLA || jj_3R_77()) return true;
4122 }
4123 }
4124 }
4125 }
4126 }
4127 return false;
4128 }
4129
4130 final private boolean jj_3R_72() {
4131 if (jj_3R_100()) return true;
4132 return false;
4133 }
4134
4135 final private boolean jj_3R_71() {
4136 if (jj_3R_32()) return true;
4137 return false;
4138 }
4139
4140 final private boolean jj_3R_108() {
4141 if (jj_scan_token(NL)) return true;
4142 return false;
4143 }
4144
4145 final private boolean jj_3R_70() {
4146 if (jj_3R_97()) return true;
4147 return false;
4148 }
4149
4150 final private boolean jj_3R_69() {
4151 if (jj_3R_95()) return true;
4152 return false;
4153 }
4154
4155 final private boolean jj_3R_68() {
4156 if (jj_3R_94()) return true;
4157 return false;
4158 }
4159
4160 final private boolean jj_3_2() {
4161 if (jj_3R_32()) return true;
4162 return false;
4163 }
4164
4165 final private boolean jj_3R_67() {
4166 if (jj_3R_93()) return true;
4167 return false;
4168 }
4169
4170 final private boolean jj_3R_88() {
4171 if (jj_3R_97()) return true;
4172 return false;
4173 }
4174
4175 final private boolean jj_3R_66() {
4176 if (jj_3R_92()) return true;
4177 return false;
4178 }
4179
4180 final private boolean jj_3R_65() {
4181 if (jj_3R_91()) return true;
4182 return false;
4183 }
4184
4185 final private boolean jj_3R_87() {
4186 if (jj_3R_108()) return true;
4187 return false;
4188 }
4189
4190 final private boolean jj_3R_86() {
4191 if (jj_3R_107()) return true;
4192 return false;
4193 }
4194
4195 final private boolean jj_3R_85() {
4196 if (jj_3R_96()) return true;
4197 return false;
4198 }
4199
4200 final private boolean jj_3_11() {
4201 Token xsp;
4202 xsp = jj_scanpos;
4203 lookingAhead = true;
4204 jj_semLA = isExcerpt();
4205 lookingAhead = false;
4206 if (!jj_semLA || jj_3R_64()) {
4207 jj_scanpos = xsp;
4208 lookingAhead = true;
4209 jj_semLA = isList();
4210 lookingAhead = false;
4211 if (!jj_semLA || jj_3R_65()) {
4212 jj_scanpos = xsp;
4213 lookingAhead = true;
4214 jj_semLA = isDefineList();
4215 lookingAhead = false;
4216 if (!jj_semLA || jj_3R_66()) {
4217 jj_scanpos = xsp;
4218 lookingAhead = true;
4219 jj_semLA = isPreshaped();
4220 lookingAhead = false;
4221 if (!jj_semLA || jj_3R_67()) {
4222 jj_scanpos = xsp;
4223 lookingAhead = true;
4224 jj_semLA = isTable();
4225 lookingAhead = false;
4226 if (!jj_semLA || jj_3R_68()) {
4227 jj_scanpos = xsp;
4228 lookingAhead = true;
4229 jj_semLA = isCSVTable();
4230 lookingAhead = false;
4231 if (!jj_semLA || jj_3R_69()) {
4232 jj_scanpos = xsp;
4233 lookingAhead = true;
4234 jj_semLA = isBlockPlugin();
4235 lookingAhead = false;
4236 if (!jj_semLA || jj_3R_70()) {
4237 jj_scanpos = xsp;
4238 lookingAhead = true;
4239 jj_semLA = isParagraph();
4240 lookingAhead = false;
4241 if (!jj_semLA || jj_3R_71()) return true;
4242 }
4243 }
4244 }
4245 }
4246 }
4247 }
4248 }
4249 return false;
4250 }
4251
4252 final private boolean jj_3R_64() {
4253 if (jj_3R_90()) return true;
4254 return false;
4255 }
4256
4257 final private boolean jj_3R_84() {
4258 if (jj_3R_106()) return true;
4259 return false;
4260 }
4261
4262 final private boolean jj_3R_99() {
4263 Token xsp;
4264 xsp = jj_scanpos;
4265 if (jj_3R_119()) {
4266 jj_scanpos = xsp;
4267 if (jj_3R_120()) {
4268 jj_scanpos = xsp;
4269 if (jj_3R_121()) {
4270 jj_scanpos = xsp;
4271 if (jj_3R_122()) {
4272 jj_scanpos = xsp;
4273 if (jj_3R_123()) {
4274 jj_scanpos = xsp;
4275 if (jj_3R_124()) {
4276 jj_scanpos = xsp;
4277 if (jj_3R_125()) return true;
4278 }
4279 }
4280 }
4281 }
4282 }
4283 }
4284 return false;
4285 }
4286
4287 final private boolean jj_3R_83() {
4288 if (jj_3R_95()) return true;
4289 return false;
4290 }
4291
4292 final private boolean jj_3R_82() {
4293 if (jj_3R_94()) return true;
4294 return false;
4295 }
4296
4297 final private boolean jj_3R_81() {
4298 if (jj_3R_93()) return true;
4299 return false;
4300 }
4301
4302 final private boolean jj_3R_129() {
4303 if (jj_scan_token(PAGENAME)) return true;
4304 return false;
4305 }
4306
4307 final private boolean jj_3R_80() {
4308 if (jj_3R_92()) return true;
4309 return false;
4310 }
4311
4312 final private boolean jj_3R_139() {
4313 if (jj_scan_token(ALIASLINK)) return true;
4314 return false;
4315 }
4316
4317 final private boolean jj_3R_79() {
4318 if (jj_3R_91()) return true;
4319 return false;
4320 }
4321
4322 final private boolean jj_3R_128() {
4323 Token xsp;
4324 xsp = jj_scanpos;
4325 if (jj_scan_token(68)) {
4326 jj_scanpos = xsp;
4327 if (jj_3R_139()) return true;
4328 }
4329 return false;
4330 }
4331
4332 final private boolean jj_3R_104() {
4333 if (jj_scan_token(INLINEPLUGIN)) return true;
4334 return false;
4335 }
4336
4337 public WikiParserTokenManager token_source;
4338 JavaCharStream jj_input_stream;
4339 public Token token, jj_nt;
4340 private int jj_ntk;
4341 private Token jj_scanpos, jj_lastpos;
4342 private int jj_la;
4343 public boolean lookingAhead = false;
4344 private boolean jj_semLA;
4345
4346 public WikiParser(java.io.InputStream stream) {
4347 jj_input_stream = new JavaCharStream(stream, 1, 1);
4348 token_source = new WikiParserTokenManager(jj_input_stream);
4349 token = new Token();
4350 jj_ntk = -1;
4351 }
4352
4353 public void ReInit(java.io.InputStream stream) {
4354 jj_input_stream.ReInit(stream, 1, 1);
4355 token_source.ReInit(jj_input_stream);
4356 token = new Token();
4357 jj_ntk = -1;
4358 jjtree.reset();
4359 }
4360
4361 public WikiParser(java.io.Reader stream) {
4362 jj_input_stream = new JavaCharStream(stream, 1, 1);
4363 token_source = new WikiParserTokenManager(jj_input_stream);
4364 token = new Token();
4365 jj_ntk = -1;
4366 }
4367
4368 public void ReInit(java.io.Reader stream) {
4369 jj_input_stream.ReInit(stream, 1, 1);
4370 token_source.ReInit(jj_input_stream);
4371 token = new Token();
4372 jj_ntk = -1;
4373 jjtree.reset();
4374 }
4375
4376 public WikiParser(WikiParserTokenManager tm) {
4377 token_source = tm;
4378 token = new Token();
4379 jj_ntk = -1;
4380 }
4381
4382 public void ReInit(WikiParserTokenManager tm) {
4383 token_source = tm;
4384 token = new Token();
4385 jj_ntk = -1;
4386 jjtree.reset();
4387 }
4388
4389 final private Token jj_consume_token(int kind) throws ParseException {
4390 Token oldToken;
4391 if ((oldToken = token).next != null) token = token.next;
4392 else token = token.next = token_source.getNextToken();
4393 jj_ntk = -1;
4394 if (token.kind == kind) {
4395 trace_token(token, "");
4396 return token;
4397 }
4398 token = oldToken;
4399 throw generateParseException();
4400 }
4401
4402 static private final class LookaheadSuccess extends java.lang.Error { }
4403 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
4404 final private boolean jj_scan_token(int kind) {
4405 if (jj_scanpos == jj_lastpos) {
4406 jj_la--;
4407 if (jj_scanpos.next == null) {
4408 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
4409 } else {
4410 jj_lastpos = jj_scanpos = jj_scanpos.next;
4411 }
4412 } else {
4413 jj_scanpos = jj_scanpos.next;
4414 }
4415 if (jj_scanpos.kind != kind) return true;
4416 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
4417 return false;
4418 }
4419
4420 final public Token getNextToken() {
4421 if (token.next != null) token = token.next;
4422 else token = token.next = token_source.getNextToken();
4423 jj_ntk = -1;
4424 trace_token(token, " (in getNextToken)");
4425 return token;
4426 }
4427
4428 final public Token getToken(int index) {
4429 Token t = lookingAhead ? jj_scanpos : token;
4430 for (int i = 0; i < index; i++) {
4431 if (t.next != null) t = t.next;
4432 else t = t.next = token_source.getNextToken();
4433 }
4434 return t;
4435 }
4436
4437 final private int jj_ntk() {
4438 if ((jj_nt=token.next) == null)
4439 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
4440 else
4441 return (jj_ntk = jj_nt.kind);
4442 }
4443
4444 public ParseException generateParseException() {
4445 Token errortok = token.next;
4446 int line = errortok.beginLine, column = errortok.beginColumn;
4447 String mess = (errortok.kind == 0) ? tokenImage[0] : errortok.image;
4448 return new ParseException("Parse error at line " + line + ", column " + column + ". Encountered: " + mess);
4449 }
4450
4451 private int trace_indent = 0;
4452 private boolean trace_enabled = true;
4453
4454 final public void enable_tracing() {
4455 trace_enabled = true;
4456 }
4457
4458 final public void disable_tracing() {
4459 trace_enabled = false;
4460 }
4461
4462 final private void trace_call(String s) {
4463 if (trace_enabled) {
4464 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
4465 System.out.println("Call: " + s);
4466 }
4467 trace_indent = trace_indent + 2;
4468 }
4469
4470 final private void trace_return(String s) {
4471 trace_indent = trace_indent - 2;
4472 if (trace_enabled) {
4473 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
4474 System.out.println("Return: " + s);
4475 }
4476 }
4477
4478 final private void trace_token(Token t, String where) {
4479 if (trace_enabled) {
4480 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
4481 System.out.print("Consumed token: <" + tokenImage[t.kind]);
4482 if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
4483 System.out.print(": \"" + t.image + "\"");
4484 }
4485 System.out.println(">" + where);
4486 }
4487 }
4488
4489 final private void trace_scan(Token t1, int t2) {
4490 if (trace_enabled) {
4491 for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
4492 System.out.print("Visited token: <" + tokenImage[t1.kind]);
4493 if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
4494 System.out.print(": \"" + t1.image + "\"");
4495 }
4496 System.out.println(">; Expected token: <" + tokenImage[t2] + ">");
4497 }
4498 }
4499
4500 }