|
1
2 package de.gulden.util.javasource.jjt;
3
4 import de.gulden.util.javasource.SourceParser;
5 import java.io.*;
6
7 public class JavadocParserimplements JavadocParserTreeConstants, JavadocParserConstants {
8 protected JJTJavadocParserState jjtree = new JJTJavadocParserState();
9
13 public static Node parse(String  s) throws ParseException {
14 return parse(new ByteArrayInputStream(s.getBytes()));
15 }
16
17
21 public static Node parse(java.io.InputStream in) throws ParseException {
22 Node node;
23 JavadocParser parser=new JavadocParser(in);
24 parser.CompilationUnit();
25 node=parser.jjtree.rootNode();
26 return node;
28 }
29
30
33
34
37 final public void CompilationUnit() throws ParseException {
38
39 SimpleNode jjtn000 = new SimpleNode(JJTCOMPILATIONUNIT);
40 boolean jjtc000 = true;
41 jjtree.openNodeScope(jjtn000);
42 try {
43 DocStart();
44 Description();
45 Tags();
46 DocEnd();
47 jj_consume_token(0);
48 } catch (Throwable jjte000) {
49 if (jjtc000) {
50 jjtree.clearNodeScope(jjtn000);
51 jjtc000 = false;
52 } else {
53 jjtree.popNode();
54 }
55 if (jjte000 instanceof RuntimeException ) {
56 {if (true) throw (RuntimeException )jjte000;}
57 }
58 if (jjte000 instanceof ParseException) {
59 {if (true) throw (ParseException)jjte000;}
60 }
61 {if (true) throw (Error )jjte000;}
62 } finally {
63 if (jjtc000) {
64 jjtree.closeNodeScope(jjtn000, true);
65 }
66 }
67 }
68
69 final public void DocStart() throws ParseException {
70 jj_consume_token(DOCSTART);
71 }
72
73 final public void DocEnd() throws ParseException {
74 if (jj_2_1(2147483647)) {
75 jj_consume_token(EOL);
76 } else {
77 ;
78 }
79 label_1:
80 while (true) {
81 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
82 case STAR:
83 ;
84 break;
85 default:
86 jj_la1[0] = jj_gen;
87 break label_1;
88 }
89 jj_consume_token(STAR);
90 }
91 jj_consume_token(DOCEND);
92 }
93
94 final public void Description() throws ParseException {
95
96 SimpleNode jjtn000 = new SimpleNode(JJTDESCRIPTION);
97 boolean jjtc000 = true;
98 jjtree.openNodeScope(jjtn000);
99 try {
100 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
101 case WORD:
102 FirstLine();
103 break;
104 default:
105 jj_la1[1] = jj_gen;
106 ;
107 }
108 MoreLines();
109 } catch (Throwable jjte000) {
110 if (jjtc000) {
111 jjtree.clearNodeScope(jjtn000);
112 jjtc000 = false;
113 } else {
114 jjtree.popNode();
115 }
116 if (jjte000 instanceof RuntimeException ) {
117 {if (true) throw (RuntimeException )jjte000;}
118 }
119 if (jjte000 instanceof ParseException) {
120 {if (true) throw (ParseException)jjte000;}
121 }
122 {if (true) throw (Error )jjte000;}
123 } finally {
124 if (jjtc000) {
125 jjtree.closeNodeScope(jjtn000, true);
126 }
127 }
128 }
129
130 final public void Tags() throws ParseException {
131 label_2:
132 while (true) {
133 if (jj_2_2(2147483647)) {
134 ;
135 } else {
136 break label_2;
137 }
138 Tag();
139 }
140 }
141
142 final public void Line() throws ParseException {
143
144 SimpleNode jjtn000 = new SimpleNode(JJTLINE);
145 boolean jjtc000 = true;
146 jjtree.openNodeScope(jjtn000);
147 try {
148 label_3:
149 while (true) {
150 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
151 case WORD:
152 ;
153 break;
154 default:
155 jj_la1[2] = jj_gen;
156 break label_3;
157 }
158 Word();
159 }
160 } catch (Throwable jjte000) {
161 if (jjtc000) {
162 jjtree.clearNodeScope(jjtn000);
163 jjtc000 = false;
164 } else {
165 jjtree.popNode();
166 }
167 if (jjte000 instanceof RuntimeException ) {
168 {if (true) throw (RuntimeException )jjte000;}
169 }
170 if (jjte000 instanceof ParseException) {
171 {if (true) throw (ParseException)jjte000;}
172 }
173 {if (true) throw (Error )jjte000;}
174 } finally {
175 if (jjtc000) {
176 jjtree.closeNodeScope(jjtn000, true);
177 }
178 }
179 }
180
181 final public void FirstLine() throws ParseException {
182
183 SimpleNode jjtn000 = new SimpleNode(JJTLINE);
184 boolean jjtc000 = true;
185 jjtree.openNodeScope(jjtn000);
186 try {
187 label_4:
188 while (true) {
189 Word();
190 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
191 case WORD:
192 ;
193 break;
194 default:
195 jj_la1[3] = jj_gen;
196 break label_4;
197 }
198 }
199 } catch (Throwable jjte000) {
200 if (jjtc000) {
201 jjtree.clearNodeScope(jjtn000);
202 jjtc000 = false;
203 } else {
204 jjtree.popNode();
205 }
206 if (jjte000 instanceof RuntimeException ) {
207 {if (true) throw (RuntimeException )jjte000;}
208 }
209 if (jjte000 instanceof ParseException) {
210 {if (true) throw (ParseException)jjte000;}
211 }
212 {if (true) throw (Error )jjte000;}
213 } finally {
214 if (jjtc000) {
215 jjtree.closeNodeScope(jjtn000, true);
216 }
217 }
218 }
219
220 final public void MoreLines() throws ParseException {
221 label_5:
222 while (true) {
223 if (jj_2_3(2147483647)) {
224 ;
225 } else {
226 break label_5;
227 }
228 NextLine();
229 }
230 }
231
232 final public void NextLine() throws ParseException {
233 jj_consume_token(EOL);
234 label_6:
235 while (true) {
236 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
237 case STAR:
238 ;
239 break;
240 default:
241 jj_la1[4] = jj_gen;
242 break label_6;
243 }
244 jj_consume_token(STAR);
245 }
246 Line();
247 }
248
249 final public void Word() throws ParseException {
250
251 SimpleNode jjtn000 = new SimpleNode(JJTWORD);
252 boolean jjtc000 = true;
253 jjtree.openNodeScope(jjtn000);Token t;
254 try {
255 t = jj_consume_token(WORD);
256 jjtree.closeNodeScope(jjtn000, true);
257 jjtc000 = false;
258 jjtn000.setValue(t.toString());
259 } finally {
260 if (jjtc000) {
261 jjtree.closeNodeScope(jjtn000, true);
262 }
263 }
264 }
265
266 final public void Tag() throws ParseException {
267
268 SimpleNode jjtn000 = new SimpleNode(JJTTAG);
269 boolean jjtc000 = true;
270 jjtree.openNodeScope(jjtn000);Token t;
271 try {
272 jj_consume_token(EOL);
273 label_7:
274 while (true) {
275 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
276 case STAR:
277 ;
278 break;
279 default:
280 jj_la1[5] = jj_gen;
281 break label_7;
282 }
283 jj_consume_token(STAR);
284 }
285 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
286 case TAG_AUTHOR:
287 t = jj_consume_token(TAG_AUTHOR);
288 break;
289 case TAG_DEPRECATED:
290 t = jj_consume_token(TAG_DEPRECATED);
291 break;
292 case TAG_EXCEPTION:
293 t = jj_consume_token(TAG_EXCEPTION);
294 TagItem();
295 break;
296 case TAG_THROWS:
297 t = jj_consume_token(TAG_THROWS);
298 TagItem();
299 break;
300 case TAG_PARAM:
301 t = jj_consume_token(TAG_PARAM);
302 TagItem();
303 break;
304 case TAG_RETURN:
305 t = jj_consume_token(TAG_RETURN);
306 break;
307 case TAG_SINCE:
308 t = jj_consume_token(TAG_SINCE);
309 break;
310 case TAG_SEE:
311 t = jj_consume_token(TAG_SEE);
312 break;
313 case TAG_VERSION:
314 t = jj_consume_token(TAG_VERSION);
315 break;
316 case TAG_ID:
317 t = jj_consume_token(TAG_ID);
318 break;
319 default:
320 jj_la1[6] = jj_gen;
321 jj_consume_token(-1);
322 throw new ParseException();
323 }
324 jjtn000.setValue(t.toString());
325 Line();
326 MoreLines();
327 } catch (Throwable jjte000) {
328 if (jjtc000) {
329 jjtree.clearNodeScope(jjtn000);
330 jjtc000 = false;
331 } else {
332 jjtree.popNode();
333 }
334 if (jjte000 instanceof RuntimeException ) {
335 {if (true) throw (RuntimeException )jjte000;}
336 }
337 if (jjte000 instanceof ParseException) {
338 {if (true) throw (ParseException)jjte000;}
339 }
340 {if (true) throw (Error )jjte000;}
341 } finally {
342 if (jjtc000) {
343 jjtree.closeNodeScope(jjtn000, true);
344 }
345 }
346 }
347
348 final public void TagItem() throws ParseException {
349
350 SimpleNode jjtn000 = new SimpleNode(JJTTAGITEM);
351 boolean jjtc000 = true;
352 jjtree.openNodeScope(jjtn000);
353 try {
354 Word();
355 } catch (Throwable jjte000) {
356 if (jjtc000) {
357 jjtree.clearNodeScope(jjtn000);
358 jjtc000 = false;
359 } else {
360 jjtree.popNode();
361 }
362 if (jjte000 instanceof RuntimeException ) {
363 {if (true) throw (RuntimeException )jjte000;}
364 }
365 if (jjte000 instanceof ParseException) {
366 {if (true) throw (ParseException)jjte000;}
367 }
368 {if (true) throw (Error )jjte000;}
369 } finally {
370 if (jjtc000) {
371 jjtree.closeNodeScope(jjtn000, true);
372 }
373 }
374 }
375
376 final private boolean jj_2_1(int xla) {
377 jj_la = xla; jj_lastpos = jj_scanpos = token;
378 try { return !jj_3_1(); }
379 catch(LookaheadSuccess ls) { return true; }
380 finally { jj_save(0, xla); }
381 }
382
383 final private boolean jj_2_2(int xla) {
384 jj_la = xla; jj_lastpos = jj_scanpos = token;
385 try { return !jj_3_2(); }
386 catch(LookaheadSuccess ls) { return true; }
387 finally { jj_save(1, xla); }
388 }
389
390 final private boolean jj_2_3(int xla) {
391 jj_la = xla; jj_lastpos = jj_scanpos = token;
392 try { return !jj_3_3(); }
393 catch(LookaheadSuccess ls) { return true; }
394 finally { jj_save(2, xla); }
395 }
396
397 final private boolean jj_3_1() {
398 if (jj_scan_token(EOL)) return true;
399 Token xsp;
400 while (true) {
401 xsp = jj_scanpos;
402 if (jj_scan_token(7)) { jj_scanpos = xsp; break; }
403 }
404 if (jj_scan_token(DOCEND)) return true;
405 return false;
406 }
407
408 final private boolean jj_3_2() {
409 if (jj_scan_token(EOL)) return true;
410 Token xsp;
411 while (true) {
412 xsp = jj_scanpos;
413 if (jj_scan_token(7)) { jj_scanpos = xsp; break; }
414 }
415 xsp = jj_scanpos;
416 if (jj_scan_token(8)) {
417 jj_scanpos = xsp;
418 if (jj_scan_token(9)) {
419 jj_scanpos = xsp;
420 if (jj_scan_token(10)) {
421 jj_scanpos = xsp;
422 if (jj_scan_token(15)) {
423 jj_scanpos = xsp;
424 if (jj_scan_token(11)) {
425 jj_scanpos = xsp;
426 if (jj_scan_token(12)) {
427 jj_scanpos = xsp;
428 if (jj_scan_token(14)) {
429 jj_scanpos = xsp;
430 if (jj_scan_token(13)) {
431 jj_scanpos = xsp;
432 if (jj_scan_token(16)) {
433 jj_scanpos = xsp;
434 if (jj_scan_token(17)) return true;
435 }
436 }
437 }
438 }
439 }
440 }
441 }
442 }
443 }
444 return false;
445 }
446
447 final private boolean jj_3_3() {
448 if (jj_scan_token(EOL)) return true;
449 Token xsp;
450 while (true) {
451 xsp = jj_scanpos;
452 if (jj_scan_token(7)) { jj_scanpos = xsp; break; }
453 }
454 xsp = jj_scanpos;
455 if (jj_scan_token(18)) {
456 jj_scanpos = xsp;
457 if (jj_scan_token(4)) return true;
458 }
459 return false;
460 }
461
462 public JavadocParserTokenManager token_source;
463 JavaCharStream jj_input_stream;
464 public Token token, jj_nt;
465 private int jj_ntk;
466 private Token jj_scanpos, jj_lastpos;
467 private int jj_la;
468 public boolean lookingAhead = false;
469 private boolean jj_semLA;
470 private int jj_gen;
471 final private int[] jj_la1 = new int[7];
472 static private int[] jj_la1_0;
473 static {
474 jj_la1_0();
475 }
476 private static void jj_la1_0() {
477 jj_la1_0 = new int[] {0x80,0x40000,0x40000,0x40000,0x80,0x80,0x3ff00,};
478 }
479 final private JJCalls[] jj_2_rtns = new JJCalls[3];
480 private boolean jj_rescan = false;
481 private int jj_gc = 0;
482
483 public JavadocParser(java.io.InputStream stream) {
484 jj_input_stream = new JavaCharStream(stream, 1, 1);
485 token_source = new JavadocParserTokenManager(jj_input_stream);
486 token = new Token();
487 jj_ntk = -1;
488 jj_gen = 0;
489 for (int i = 0; i < 7; i++) jj_la1[i] = -1;
490 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
491 }
492
493 public void ReInit(java.io.InputStream stream) {
494 jj_input_stream.ReInit(stream, 1, 1);
495 token_source.ReInit(jj_input_stream);
496 token = new Token();
497 jj_ntk = -1;
498 jjtree.reset();
499 jj_gen = 0;
500 for (int i = 0; i < 7; i++) jj_la1[i] = -1;
501 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
502 }
503
504 public JavadocParser(java.io.Reader stream) {
505 jj_input_stream = new JavaCharStream(stream, 1, 1);
506 token_source = new JavadocParserTokenManager(jj_input_stream);
507 token = new Token();
508 jj_ntk = -1;
509 jj_gen = 0;
510 for (int i = 0; i < 7; i++) jj_la1[i] = -1;
511 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
512 }
513
514 public void ReInit(java.io.Reader stream) {
515 jj_input_stream.ReInit(stream, 1, 1);
516 token_source.ReInit(jj_input_stream);
517 token = new Token();
518 jj_ntk = -1;
519 jjtree.reset();
520 jj_gen = 0;
521 for (int i = 0; i < 7; i++) jj_la1[i] = -1;
522 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
523 }
524
525 public JavadocParser(JavadocParserTokenManager tm) {
526 token_source = tm;
527 token = new Token();
528 jj_ntk = -1;
529 jj_gen = 0;
530 for (int i = 0; i < 7; i++) jj_la1[i] = -1;
531 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
532 }
533
534 public void ReInit(JavadocParserTokenManager tm) {
535 token_source = tm;
536 token = new Token();
537 jj_ntk = -1;
538 jjtree.reset();
539 jj_gen = 0;
540 for (int i = 0; i < 7; i++) jj_la1[i] = -1;
541 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
542 }
543
544 final private Token jj_consume_token(int kind) throws ParseException {
545 Token oldToken;
546 if ((oldToken = token).next != null) token = token.next;
547 else token = token.next = token_source.getNextToken();
548 jj_ntk = -1;
549 if (token.kind == kind) {
550 jj_gen++;
551 if (++jj_gc > 100) {
552 jj_gc = 0;
553 for (int i = 0; i < jj_2_rtns.length; i++) {
554 JJCalls c = jj_2_rtns[i];
555 while (c != null) {
556 if (c.gen < jj_gen) c.first = null;
557 c = c.next;
558 }
559 }
560 }
561 return token;
562 }
563 token = oldToken;
564 jj_kind = kind;
565 throw generateParseException();
566 }
567
568 static private final class LookaheadSuccess extends java.lang.Error { }
569 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
570 final private boolean jj_scan_token(int kind) {
571 if (jj_scanpos == jj_lastpos) {
572 jj_la--;
573 if (jj_scanpos.next == null) {
574 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
575 } else {
576 jj_lastpos = jj_scanpos = jj_scanpos.next;
577 }
578 } else {
579 jj_scanpos = jj_scanpos.next;
580 }
581 if (jj_rescan) {
582 int i = 0; Token tok = token;
583 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
584 if (tok != null) jj_add_error_token(kind, i);
585 }
586 if (jj_scanpos.kind != kind) return true;
587 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
588 return false;
589 }
590
591 final public Token getNextToken() {
592 if (token.next != null) token = token.next;
593 else token = token.next = token_source.getNextToken();
594 jj_ntk = -1;
595 jj_gen++;
596 return token;
597 }
598
599 final public Token getToken(int index) {
600 Token t = lookingAhead ? jj_scanpos : token;
601 for (int i = 0; i < index; i++) {
602 if (t.next != null) t = t.next;
603 else t = t.next = token_source.getNextToken();
604 }
605 return t;
606 }
607
608 final private int jj_ntk() {
609 if ((jj_nt=token.next) == null)
610 return (jj_ntk = (token.next=token_source.getNextToken()).kind);
611 else
612 return (jj_ntk = jj_nt.kind);
613 }
614
615 private java.util.Vector jj_expentries = new java.util.Vector ();
616 private int[] jj_expentry;
617 private int jj_kind = -1;
618 private int[] jj_lasttokens = new int[100];
619 private int jj_endpos;
620
621 private void jj_add_error_token(int kind, int pos) {
622 if (pos >= 100) return;
623 if (pos == jj_endpos + 1) {
624 jj_lasttokens[jj_endpos++] = kind;
625 } else if (jj_endpos != 0) {
626 jj_expentry = new int[jj_endpos];
627 for (int i = 0; i < jj_endpos; i++) {
628 jj_expentry[i] = jj_lasttokens[i];
629 }
630 boolean exists = false;
631 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {
632 int[] oldentry = (int[])(e.nextElement());
633 if (oldentry.length == jj_expentry.length) {
634 exists = true;
635 for (int i = 0; i < jj_expentry.length; i++) {
636 if (oldentry[i] != jj_expentry[i]) {
637 exists = false;
638 break;
639 }
640 }
641 if (exists) break;
642 }
643 }
644 if (!exists) jj_expentries.addElement(jj_expentry);
645 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
646 }
647 }
648
649 public ParseException generateParseException() {
650 jj_expentries.removeAllElements();
651 boolean[] la1tokens = new boolean[19];
652 for (int i = 0; i < 19; i++) {
653 la1tokens[i] = false;
654 }
655 if (jj_kind >= 0) {
656 la1tokens[jj_kind] = true;
657 jj_kind = -1;
658 }
659 for (int i = 0; i < 7; i++) {
660 if (jj_la1[i] == jj_gen) {
661 for (int j = 0; j < 32; j++) {
662 if ((jj_la1_0[i] & (1<<j)) != 0) {
663 la1tokens[j] = true;
664 }
665 }
666 }
667 }
668 for (int i = 0; i < 19; i++) {
669 if (la1tokens[i]) {
670 jj_expentry = new int[1];
671 jj_expentry[0] = i;
672 jj_expentries.addElement(jj_expentry);
673 }
674 }
675 jj_endpos = 0;
676 jj_rescan_token();
677 jj_add_error_token(0, 0);
678 int[][] exptokseq = new int[jj_expentries.size()][];
679 for (int i = 0; i < jj_expentries.size(); i++) {
680 exptokseq[i] = (int[])jj_expentries.elementAt(i);
681 }
682 return new ParseException(token, exptokseq, tokenImage);
683 }
684
685 final public void enable_tracing() {
686 }
687
688 final public void disable_tracing() {
689 }
690
691 final private void jj_rescan_token() {
692 jj_rescan = true;
693 for (int i = 0; i < 3; i++) {
694 JJCalls p = jj_2_rtns[i];
695 do {
696 if (p.gen > jj_gen) {
697 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
698 switch (i) {
699 case 0: jj_3_1(); break;
700 case 1: jj_3_2(); break;
701 case 2: jj_3_3(); break;
702 }
703 }
704 p = p.next;
705 } while (p != null);
706 }
707 jj_rescan = false;
708 }
709
710 final private void jj_save(int index, int xla) {
711 JJCalls p = jj_2_rtns[index];
712 while (p.gen > jj_gen) {
713 if (p.next == null) { p = p.next = new JJCalls(); break; }
714 p = p.next;
715 }
716 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
717 }
718
719 static final class JJCalls {
720 int gen;
721 Token first;
722 int arg;
723 JJCalls next;
724 }
725
726
739
748 }
749 |
Popular Tags |
Java API By Example, From Geeks To Geeks.