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