001/* Generated By:JJTree&JavaCC: Do not edit this line. AddressListParser.java */ 002/**************************************************************** 003 * Licensed to the Apache Software Foundation (ASF) under one * 004 * or more contributor license agreements. See the NOTICE file * 005 * distributed with this work for additional information * 006 * regarding copyright ownership. The ASF licenses this file * 007 * to you under the Apache License, Version 2.0 (the * 008 * "License"); you may not use this file except in compliance * 009 * with the License. You may obtain a copy of the License at * 010 * * 011 * http://www.apache.org/licenses/LICENSE-2.0 * 012 * * 013 * Unless required by applicable law or agreed to in writing, * 014 * software distributed under the License is distributed on an * 015 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * 016 * KIND, either express or implied. See the License for the * 017 * specific language governing permissions and limitations * 018 * under the License. * 019 ****************************************************************/ 020package org.apache.james.mime4j.field.address; 021 022public class AddressListParser/*@bgen(jjtree)*/implements AddressListParserTreeConstants, AddressListParserConstants {/*@bgen(jjtree)*/ 023 protected JJTAddressListParserState jjtree = new JJTAddressListParserState();public static void main(String args[]) throws ParseException { 024 while (true) { 025 try { 026 AddressListParser parser = new AddressListParser(System.in); 027 parser.parseLine(); 028 ((SimpleNode) parser.jjtree.rootNode()).dump("> "); 029 } catch (Exception x) { 030 x.printStackTrace(); 031 return; 032 } 033 } 034 } 035 036 public ASTaddress_list parseAddressList() throws ParseException { 037 try { 038 parseAddressList0(); 039 return (ASTaddress_list) jjtree.rootNode(); 040 } catch (TokenMgrError tme) { 041 throw new ParseException(tme.getMessage()); 042 } 043 } 044 045 public ASTaddress parseAddress() throws ParseException { 046 try { 047 parseAddress0(); 048 return (ASTaddress) jjtree.rootNode(); 049 } catch (TokenMgrError tme) { 050 throw new ParseException(tme.getMessage()); 051 } 052 } 053 054 public ASTmailbox parseMailbox() throws ParseException { 055 try { 056 parseMailbox0(); 057 return (ASTmailbox) jjtree.rootNode(); 058 } catch (TokenMgrError tme) { 059 throw new ParseException(tme.getMessage()); 060 } 061 } 062 063 void jjtreeOpenNodeScope(Node n) { 064 ((SimpleNode) n).firstToken = getToken(1); 065 } 066 067 void jjtreeCloseNodeScope(Node n) { 068 ((SimpleNode) n).lastToken = getToken(0); 069 } 070 071 final public void parseLine() throws ParseException { 072 address_list(); 073 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 074 case 1: 075 jj_consume_token(1); 076 break; 077 default: 078 jj_la1[0] = jj_gen; 079 ; 080 } 081 jj_consume_token(2); 082 } 083 084 final public void parseAddressList0() throws ParseException { 085 address_list(); 086 jj_consume_token(0); 087 } 088 089 final public void parseAddress0() throws ParseException { 090 address(); 091 jj_consume_token(0); 092 } 093 094 final public void parseMailbox0() throws ParseException { 095 mailbox(); 096 jj_consume_token(0); 097 } 098 099 final public void address_list() throws ParseException { 100 /*@bgen(jjtree) address_list */ 101 ASTaddress_list jjtn000 = new ASTaddress_list(JJTADDRESS_LIST); 102 boolean jjtc000 = true; 103 jjtree.openNodeScope(jjtn000); 104 jjtreeOpenNodeScope(jjtn000); 105 try { 106 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 107 case 6: 108 case DOTATOM: 109 case QUOTEDSTRING: 110 address(); 111 break; 112 default: 113 jj_la1[1] = jj_gen; 114 ; 115 } 116 label_1: 117 while (true) { 118 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 119 case 3: 120 ; 121 break; 122 default: 123 jj_la1[2] = jj_gen; 124 break label_1; 125 } 126 jj_consume_token(3); 127 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 128 case 6: 129 case DOTATOM: 130 case QUOTEDSTRING: 131 address(); 132 break; 133 default: 134 jj_la1[3] = jj_gen; 135 ; 136 } 137 } 138 } catch (Throwable jjte000) { 139 if (jjtc000) { 140 jjtree.clearNodeScope(jjtn000); 141 jjtc000 = false; 142 } else { 143 jjtree.popNode(); 144 } 145 if (jjte000 instanceof RuntimeException) { 146 {if (true) throw (RuntimeException)jjte000;} 147 } 148 if (jjte000 instanceof ParseException) { 149 {if (true) throw (ParseException)jjte000;} 150 } 151 {if (true) throw (Error)jjte000;} 152 } finally { 153 if (jjtc000) { 154 jjtree.closeNodeScope(jjtn000, true); 155 jjtreeCloseNodeScope(jjtn000); 156 } 157 } 158 } 159 160 final public void address() throws ParseException { 161 /*@bgen(jjtree) address */ 162 ASTaddress jjtn000 = new ASTaddress(JJTADDRESS); 163 boolean jjtc000 = true; 164 jjtree.openNodeScope(jjtn000); 165 jjtreeOpenNodeScope(jjtn000); 166 try { 167 if (jj_2_1(2147483647)) { 168 addr_spec(); 169 } else { 170 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 171 case 6: 172 angle_addr(); 173 break; 174 case DOTATOM: 175 case QUOTEDSTRING: 176 phrase(); 177 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 178 case 4: 179 group_body(); 180 break; 181 case 6: 182 angle_addr(); 183 break; 184 default: 185 jj_la1[4] = jj_gen; 186 jj_consume_token(-1); 187 throw new ParseException(); 188 } 189 break; 190 default: 191 jj_la1[5] = jj_gen; 192 jj_consume_token(-1); 193 throw new ParseException(); 194 } 195 } 196 } catch (Throwable jjte000) { 197 if (jjtc000) { 198 jjtree.clearNodeScope(jjtn000); 199 jjtc000 = false; 200 } else { 201 jjtree.popNode(); 202 } 203 if (jjte000 instanceof RuntimeException) { 204 {if (true) throw (RuntimeException)jjte000;} 205 } 206 if (jjte000 instanceof ParseException) { 207 {if (true) throw (ParseException)jjte000;} 208 } 209 {if (true) throw (Error)jjte000;} 210 } finally { 211 if (jjtc000) { 212 jjtree.closeNodeScope(jjtn000, true); 213 jjtreeCloseNodeScope(jjtn000); 214 } 215 } 216 } 217 218 final public void mailbox() throws ParseException { 219 /*@bgen(jjtree) mailbox */ 220 ASTmailbox jjtn000 = new ASTmailbox(JJTMAILBOX); 221 boolean jjtc000 = true; 222 jjtree.openNodeScope(jjtn000); 223 jjtreeOpenNodeScope(jjtn000); 224 try { 225 if (jj_2_2(2147483647)) { 226 addr_spec(); 227 } else { 228 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 229 case 6: 230 angle_addr(); 231 break; 232 case DOTATOM: 233 case QUOTEDSTRING: 234 name_addr(); 235 break; 236 default: 237 jj_la1[6] = jj_gen; 238 jj_consume_token(-1); 239 throw new ParseException(); 240 } 241 } 242 } catch (Throwable jjte000) { 243 if (jjtc000) { 244 jjtree.clearNodeScope(jjtn000); 245 jjtc000 = false; 246 } else { 247 jjtree.popNode(); 248 } 249 if (jjte000 instanceof RuntimeException) { 250 {if (true) throw (RuntimeException)jjte000;} 251 } 252 if (jjte000 instanceof ParseException) { 253 {if (true) throw (ParseException)jjte000;} 254 } 255 {if (true) throw (Error)jjte000;} 256 } finally { 257 if (jjtc000) { 258 jjtree.closeNodeScope(jjtn000, true); 259 jjtreeCloseNodeScope(jjtn000); 260 } 261 } 262 } 263 264 final public void name_addr() throws ParseException { 265 /*@bgen(jjtree) name_addr */ 266 ASTname_addr jjtn000 = new ASTname_addr(JJTNAME_ADDR); 267 boolean jjtc000 = true; 268 jjtree.openNodeScope(jjtn000); 269 jjtreeOpenNodeScope(jjtn000); 270 try { 271 phrase(); 272 angle_addr(); 273 } catch (Throwable jjte000) { 274 if (jjtc000) { 275 jjtree.clearNodeScope(jjtn000); 276 jjtc000 = false; 277 } else { 278 jjtree.popNode(); 279 } 280 if (jjte000 instanceof RuntimeException) { 281 {if (true) throw (RuntimeException)jjte000;} 282 } 283 if (jjte000 instanceof ParseException) { 284 {if (true) throw (ParseException)jjte000;} 285 } 286 {if (true) throw (Error)jjte000;} 287 } finally { 288 if (jjtc000) { 289 jjtree.closeNodeScope(jjtn000, true); 290 jjtreeCloseNodeScope(jjtn000); 291 } 292 } 293 } 294 295 final public void group_body() throws ParseException { 296 /*@bgen(jjtree) group_body */ 297 ASTgroup_body jjtn000 = new ASTgroup_body(JJTGROUP_BODY); 298 boolean jjtc000 = true; 299 jjtree.openNodeScope(jjtn000); 300 jjtreeOpenNodeScope(jjtn000); 301 try { 302 jj_consume_token(4); 303 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 304 case 6: 305 case DOTATOM: 306 case QUOTEDSTRING: 307 mailbox(); 308 break; 309 default: 310 jj_la1[7] = jj_gen; 311 ; 312 } 313 label_2: 314 while (true) { 315 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 316 case 3: 317 ; 318 break; 319 default: 320 jj_la1[8] = jj_gen; 321 break label_2; 322 } 323 jj_consume_token(3); 324 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 325 case 6: 326 case DOTATOM: 327 case QUOTEDSTRING: 328 mailbox(); 329 break; 330 default: 331 jj_la1[9] = jj_gen; 332 ; 333 } 334 } 335 jj_consume_token(5); 336 } catch (Throwable jjte000) { 337 if (jjtc000) { 338 jjtree.clearNodeScope(jjtn000); 339 jjtc000 = false; 340 } else { 341 jjtree.popNode(); 342 } 343 if (jjte000 instanceof RuntimeException) { 344 {if (true) throw (RuntimeException)jjte000;} 345 } 346 if (jjte000 instanceof ParseException) { 347 {if (true) throw (ParseException)jjte000;} 348 } 349 {if (true) throw (Error)jjte000;} 350 } finally { 351 if (jjtc000) { 352 jjtree.closeNodeScope(jjtn000, true); 353 jjtreeCloseNodeScope(jjtn000); 354 } 355 } 356 } 357 358 final public void angle_addr() throws ParseException { 359 /*@bgen(jjtree) angle_addr */ 360 ASTangle_addr jjtn000 = new ASTangle_addr(JJTANGLE_ADDR); 361 boolean jjtc000 = true; 362 jjtree.openNodeScope(jjtn000); 363 jjtreeOpenNodeScope(jjtn000); 364 try { 365 jj_consume_token(6); 366 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 367 case 8: 368 route(); 369 break; 370 default: 371 jj_la1[10] = jj_gen; 372 ; 373 } 374 addr_spec(); 375 jj_consume_token(7); 376 } catch (Throwable jjte000) { 377 if (jjtc000) { 378 jjtree.clearNodeScope(jjtn000); 379 jjtc000 = false; 380 } else { 381 jjtree.popNode(); 382 } 383 if (jjte000 instanceof RuntimeException) { 384 {if (true) throw (RuntimeException)jjte000;} 385 } 386 if (jjte000 instanceof ParseException) { 387 {if (true) throw (ParseException)jjte000;} 388 } 389 {if (true) throw (Error)jjte000;} 390 } finally { 391 if (jjtc000) { 392 jjtree.closeNodeScope(jjtn000, true); 393 jjtreeCloseNodeScope(jjtn000); 394 } 395 } 396 } 397 398 final public void route() throws ParseException { 399 /*@bgen(jjtree) route */ 400 ASTroute jjtn000 = new ASTroute(JJTROUTE); 401 boolean jjtc000 = true; 402 jjtree.openNodeScope(jjtn000); 403 jjtreeOpenNodeScope(jjtn000); 404 try { 405 jj_consume_token(8); 406 domain(); 407 label_3: 408 while (true) { 409 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 410 case 3: 411 case 8: 412 ; 413 break; 414 default: 415 jj_la1[11] = jj_gen; 416 break label_3; 417 } 418 label_4: 419 while (true) { 420 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 421 case 3: 422 ; 423 break; 424 default: 425 jj_la1[12] = jj_gen; 426 break label_4; 427 } 428 jj_consume_token(3); 429 } 430 jj_consume_token(8); 431 domain(); 432 } 433 jj_consume_token(4); 434 } catch (Throwable jjte000) { 435 if (jjtc000) { 436 jjtree.clearNodeScope(jjtn000); 437 jjtc000 = false; 438 } else { 439 jjtree.popNode(); 440 } 441 if (jjte000 instanceof RuntimeException) { 442 {if (true) throw (RuntimeException)jjte000;} 443 } 444 if (jjte000 instanceof ParseException) { 445 {if (true) throw (ParseException)jjte000;} 446 } 447 {if (true) throw (Error)jjte000;} 448 } finally { 449 if (jjtc000) { 450 jjtree.closeNodeScope(jjtn000, true); 451 jjtreeCloseNodeScope(jjtn000); 452 } 453 } 454 } 455 456 final public void phrase() throws ParseException { 457 /*@bgen(jjtree) phrase */ 458 ASTphrase jjtn000 = new ASTphrase(JJTPHRASE); 459 boolean jjtc000 = true; 460 jjtree.openNodeScope(jjtn000); 461 jjtreeOpenNodeScope(jjtn000); 462 try { 463 label_5: 464 while (true) { 465 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 466 case DOTATOM: 467 jj_consume_token(DOTATOM); 468 break; 469 case QUOTEDSTRING: 470 jj_consume_token(QUOTEDSTRING); 471 break; 472 default: 473 jj_la1[13] = jj_gen; 474 jj_consume_token(-1); 475 throw new ParseException(); 476 } 477 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 478 case DOTATOM: 479 case QUOTEDSTRING: 480 ; 481 break; 482 default: 483 jj_la1[14] = jj_gen; 484 break label_5; 485 } 486 } 487 } finally { 488 if (jjtc000) { 489 jjtree.closeNodeScope(jjtn000, true); 490 jjtreeCloseNodeScope(jjtn000); 491 } 492 } 493 } 494 495 final public void addr_spec() throws ParseException { 496 /*@bgen(jjtree) addr_spec */ 497 ASTaddr_spec jjtn000 = new ASTaddr_spec(JJTADDR_SPEC); 498 boolean jjtc000 = true; 499 jjtree.openNodeScope(jjtn000); 500 jjtreeOpenNodeScope(jjtn000); 501 try { 502 local_part(); 503 jj_consume_token(8); 504 domain(); 505 } catch (Throwable jjte000) { 506 if (jjtc000) { 507 jjtree.clearNodeScope(jjtn000); 508 jjtc000 = false; 509 } else { 510 jjtree.popNode(); 511 } 512 if (jjte000 instanceof RuntimeException) { 513 {if (true) throw (RuntimeException)jjte000;} 514 } 515 if (jjte000 instanceof ParseException) { 516 {if (true) throw (ParseException)jjte000;} 517 } 518 {if (true) throw (Error)jjte000;} 519 } finally { 520 if (jjtc000) { 521 jjtree.closeNodeScope(jjtn000, true); 522 jjtreeCloseNodeScope(jjtn000); 523 } 524 } 525 } 526 527 final public void local_part() throws ParseException { 528 /*@bgen(jjtree) local_part */ 529 ASTlocal_part jjtn000 = new ASTlocal_part(JJTLOCAL_PART); 530 boolean jjtc000 = true; 531 jjtree.openNodeScope(jjtn000); 532 jjtreeOpenNodeScope(jjtn000);Token t; 533 try { 534 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 535 case DOTATOM: 536 t = jj_consume_token(DOTATOM); 537 break; 538 case QUOTEDSTRING: 539 t = jj_consume_token(QUOTEDSTRING); 540 break; 541 default: 542 jj_la1[15] = jj_gen; 543 jj_consume_token(-1); 544 throw new ParseException(); 545 } 546 label_6: 547 while (true) { 548 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 549 case 9: 550 case DOTATOM: 551 case QUOTEDSTRING: 552 ; 553 break; 554 default: 555 jj_la1[16] = jj_gen; 556 break label_6; 557 } 558 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 559 case 9: 560 t = jj_consume_token(9); 561 break; 562 default: 563 jj_la1[17] = jj_gen; 564 ; 565 } 566 if ( t.kind == AddressListParserConstants.QUOTEDSTRING || t.image.charAt(t.image.length() - 1) != '.') 567 {if (true) throw new ParseException("Words in local part must be separated by '.'");} 568 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 569 case DOTATOM: 570 t = jj_consume_token(DOTATOM); 571 break; 572 case QUOTEDSTRING: 573 t = jj_consume_token(QUOTEDSTRING); 574 break; 575 default: 576 jj_la1[18] = jj_gen; 577 jj_consume_token(-1); 578 throw new ParseException(); 579 } 580 } 581 } finally { 582 if (jjtc000) { 583 jjtree.closeNodeScope(jjtn000, true); 584 jjtreeCloseNodeScope(jjtn000); 585 } 586 } 587 } 588 589 final public void domain() throws ParseException { 590 /*@bgen(jjtree) domain */ 591 ASTdomain jjtn000 = new ASTdomain(JJTDOMAIN); 592 boolean jjtc000 = true; 593 jjtree.openNodeScope(jjtn000); 594 jjtreeOpenNodeScope(jjtn000);Token t; 595 try { 596 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 597 case DOTATOM: 598 t = jj_consume_token(DOTATOM); 599 label_7: 600 while (true) { 601 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 602 case 9: 603 case DOTATOM: 604 ; 605 break; 606 default: 607 jj_la1[19] = jj_gen; 608 break label_7; 609 } 610 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 611 case 9: 612 t = jj_consume_token(9); 613 break; 614 default: 615 jj_la1[20] = jj_gen; 616 ; 617 } 618 if (t.image.charAt(t.image.length() - 1) != '.') 619 {if (true) throw new ParseException("Atoms in domain names must be separated by '.'");} 620 t = jj_consume_token(DOTATOM); 621 } 622 break; 623 case DOMAINLITERAL: 624 jj_consume_token(DOMAINLITERAL); 625 break; 626 default: 627 jj_la1[21] = jj_gen; 628 jj_consume_token(-1); 629 throw new ParseException(); 630 } 631 } finally { 632 if (jjtc000) { 633 jjtree.closeNodeScope(jjtn000, true); 634 jjtreeCloseNodeScope(jjtn000); 635 } 636 } 637 } 638 639 private boolean jj_2_1(int xla) { 640 jj_la = xla; jj_lastpos = jj_scanpos = token; 641 try { return !jj_3_1(); } 642 catch(LookaheadSuccess ls) { return true; } 643 finally { jj_save(0, xla); } 644 } 645 646 private boolean jj_2_2(int xla) { 647 jj_la = xla; jj_lastpos = jj_scanpos = token; 648 try { return !jj_3_2(); } 649 catch(LookaheadSuccess ls) { return true; } 650 finally { jj_save(1, xla); } 651 } 652 653 private boolean jj_3R_11() { 654 Token xsp; 655 xsp = jj_scanpos; 656 if (jj_scan_token(9)) jj_scanpos = xsp; 657 xsp = jj_scanpos; 658 if (jj_scan_token(14)) { 659 jj_scanpos = xsp; 660 if (jj_scan_token(31)) return true; 661 } 662 return false; 663 } 664 665 private boolean jj_3R_13() { 666 Token xsp; 667 xsp = jj_scanpos; 668 if (jj_scan_token(9)) jj_scanpos = xsp; 669 if (jj_scan_token(DOTATOM)) return true; 670 return false; 671 } 672 673 private boolean jj_3R_8() { 674 if (jj_3R_9()) return true; 675 if (jj_scan_token(8)) return true; 676 if (jj_3R_10()) return true; 677 return false; 678 } 679 680 private boolean jj_3_1() { 681 if (jj_3R_8()) return true; 682 return false; 683 } 684 685 private boolean jj_3R_12() { 686 if (jj_scan_token(DOTATOM)) return true; 687 Token xsp; 688 while (true) { 689 xsp = jj_scanpos; 690 if (jj_3R_13()) { jj_scanpos = xsp; break; } 691 } 692 return false; 693 } 694 695 private boolean jj_3R_10() { 696 Token xsp; 697 xsp = jj_scanpos; 698 if (jj_3R_12()) { 699 jj_scanpos = xsp; 700 if (jj_scan_token(18)) return true; 701 } 702 return false; 703 } 704 705 private boolean jj_3_2() { 706 if (jj_3R_8()) return true; 707 return false; 708 } 709 710 private boolean jj_3R_9() { 711 Token xsp; 712 xsp = jj_scanpos; 713 if (jj_scan_token(14)) { 714 jj_scanpos = xsp; 715 if (jj_scan_token(31)) return true; 716 } 717 while (true) { 718 xsp = jj_scanpos; 719 if (jj_3R_11()) { jj_scanpos = xsp; break; } 720 } 721 return false; 722 } 723 724 /** Generated Token Manager. */ 725 public AddressListParserTokenManager token_source; 726 SimpleCharStream jj_input_stream; 727 /** Current token. */ 728 public Token token; 729 /** Next token. */ 730 public Token jj_nt; 731 private int jj_ntk; 732 private Token jj_scanpos, jj_lastpos; 733 private int jj_la; 734 private int jj_gen; 735 final private int[] jj_la1 = new int[22]; 736 static private int[] jj_la1_0; 737 static private int[] jj_la1_1; 738 static { 739 jj_la1_init_0(); 740 jj_la1_init_1(); 741 } 742 private static void jj_la1_init_0() { 743 jj_la1_0 = new int[] {0x2,0x80004040,0x8,0x80004040,0x50,0x80004040,0x80004040,0x80004040,0x8,0x80004040,0x100,0x108,0x8,0x80004000,0x80004000,0x80004000,0x80004200,0x200,0x80004000,0x4200,0x200,0x44000,}; 744 } 745 private static void jj_la1_init_1() { 746 jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,}; 747 } 748 final private JJCalls[] jj_2_rtns = new JJCalls[2]; 749 private boolean jj_rescan = false; 750 private int jj_gc = 0; 751 752 /** Constructor with InputStream. */ 753 public AddressListParser(java.io.InputStream stream) { 754 this(stream, null); 755 } 756 /** Constructor with InputStream and supplied encoding */ 757 public AddressListParser(java.io.InputStream stream, String encoding) { 758 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 759 token_source = new AddressListParserTokenManager(jj_input_stream); 760 token = new Token(); 761 jj_ntk = -1; 762 jj_gen = 0; 763 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 764 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 765 } 766 767 /** Reinitialise. */ 768 public void ReInit(java.io.InputStream stream) { 769 ReInit(stream, null); 770 } 771 /** Reinitialise. */ 772 public void ReInit(java.io.InputStream stream, String encoding) { 773 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); } 774 token_source.ReInit(jj_input_stream); 775 token = new Token(); 776 jj_ntk = -1; 777 jjtree.reset(); 778 jj_gen = 0; 779 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 780 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 781 } 782 783 /** Constructor. */ 784 public AddressListParser(java.io.Reader stream) { 785 jj_input_stream = new SimpleCharStream(stream, 1, 1); 786 token_source = new AddressListParserTokenManager(jj_input_stream); 787 token = new Token(); 788 jj_ntk = -1; 789 jj_gen = 0; 790 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 791 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 792 } 793 794 /** Reinitialise. */ 795 public void ReInit(java.io.Reader stream) { 796 jj_input_stream.ReInit(stream, 1, 1); 797 token_source.ReInit(jj_input_stream); 798 token = new Token(); 799 jj_ntk = -1; 800 jjtree.reset(); 801 jj_gen = 0; 802 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 803 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 804 } 805 806 /** Constructor with generated Token Manager. */ 807 public AddressListParser(AddressListParserTokenManager tm) { 808 token_source = tm; 809 token = new Token(); 810 jj_ntk = -1; 811 jj_gen = 0; 812 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 813 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 814 } 815 816 /** Reinitialise. */ 817 public void ReInit(AddressListParserTokenManager tm) { 818 token_source = tm; 819 token = new Token(); 820 jj_ntk = -1; 821 jjtree.reset(); 822 jj_gen = 0; 823 for (int i = 0; i < 22; i++) jj_la1[i] = -1; 824 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 825 } 826 827 private Token jj_consume_token(int kind) throws ParseException { 828 Token oldToken; 829 if ((oldToken = token).next != null) token = token.next; 830 else token = token.next = token_source.getNextToken(); 831 jj_ntk = -1; 832 if (token.kind == kind) { 833 jj_gen++; 834 if (++jj_gc > 100) { 835 jj_gc = 0; 836 for (int i = 0; i < jj_2_rtns.length; i++) { 837 JJCalls c = jj_2_rtns[i]; 838 while (c != null) { 839 if (c.gen < jj_gen) c.first = null; 840 c = c.next; 841 } 842 } 843 } 844 return token; 845 } 846 token = oldToken; 847 jj_kind = kind; 848 throw generateParseException(); 849 } 850 851 static private final class LookaheadSuccess extends java.lang.Error { } 852 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 853 private boolean jj_scan_token(int kind) { 854 if (jj_scanpos == jj_lastpos) { 855 jj_la--; 856 if (jj_scanpos.next == null) { 857 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 858 } else { 859 jj_lastpos = jj_scanpos = jj_scanpos.next; 860 } 861 } else { 862 jj_scanpos = jj_scanpos.next; 863 } 864 if (jj_rescan) { 865 int i = 0; Token tok = token; 866 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } 867 if (tok != null) jj_add_error_token(kind, i); 868 } 869 if (jj_scanpos.kind != kind) return true; 870 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; 871 return false; 872 } 873 874 875/** Get the next Token. */ 876 final public Token getNextToken() { 877 if (token.next != null) token = token.next; 878 else token = token.next = token_source.getNextToken(); 879 jj_ntk = -1; 880 jj_gen++; 881 return token; 882 } 883 884/** Get the specific Token. */ 885 final public Token getToken(int index) { 886 Token t = token; 887 for (int i = 0; i < index; i++) { 888 if (t.next != null) t = t.next; 889 else t = t.next = token_source.getNextToken(); 890 } 891 return t; 892 } 893 894 private int jj_ntk() { 895 if ((jj_nt=token.next) == null) 896 return (jj_ntk = (token.next=token_source.getNextToken()).kind); 897 else 898 return (jj_ntk = jj_nt.kind); 899 } 900 901 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>(); 902 private int[] jj_expentry; 903 private int jj_kind = -1; 904 private int[] jj_lasttokens = new int[100]; 905 private int jj_endpos; 906 907 private void jj_add_error_token(int kind, int pos) { 908 if (pos >= 100) return; 909 if (pos == jj_endpos + 1) { 910 jj_lasttokens[jj_endpos++] = kind; 911 } else if (jj_endpos != 0) { 912 jj_expentry = new int[jj_endpos]; 913 for (int i = 0; i < jj_endpos; i++) { 914 jj_expentry[i] = jj_lasttokens[i]; 915 } 916 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) { 917 int[] oldentry = (int[])(it.next()); 918 if (oldentry.length == jj_expentry.length) { 919 for (int i = 0; i < jj_expentry.length; i++) { 920 if (oldentry[i] != jj_expentry[i]) { 921 continue jj_entries_loop; 922 } 923 } 924 jj_expentries.add(jj_expentry); 925 break jj_entries_loop; 926 } 927 } 928 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; 929 } 930 } 931 932 /** Generate ParseException. */ 933 public ParseException generateParseException() { 934 jj_expentries.clear(); 935 boolean[] la1tokens = new boolean[34]; 936 if (jj_kind >= 0) { 937 la1tokens[jj_kind] = true; 938 jj_kind = -1; 939 } 940 for (int i = 0; i < 22; i++) { 941 if (jj_la1[i] == jj_gen) { 942 for (int j = 0; j < 32; j++) { 943 if ((jj_la1_0[i] & (1<<j)) != 0) { 944 la1tokens[j] = true; 945 } 946 if ((jj_la1_1[i] & (1<<j)) != 0) { 947 la1tokens[32+j] = true; 948 } 949 } 950 } 951 } 952 for (int i = 0; i < 34; i++) { 953 if (la1tokens[i]) { 954 jj_expentry = new int[1]; 955 jj_expentry[0] = i; 956 jj_expentries.add(jj_expentry); 957 } 958 } 959 jj_endpos = 0; 960 jj_rescan_token(); 961 jj_add_error_token(0, 0); 962 int[][] exptokseq = new int[jj_expentries.size()][]; 963 for (int i = 0; i < jj_expentries.size(); i++) { 964 exptokseq[i] = jj_expentries.get(i); 965 } 966 return new ParseException(token, exptokseq, tokenImage); 967 } 968 969 /** Enable tracing. */ 970 final public void enable_tracing() { 971 } 972 973 /** Disable tracing. */ 974 final public void disable_tracing() { 975 } 976 977 private void jj_rescan_token() { 978 jj_rescan = true; 979 for (int i = 0; i < 2; i++) { 980 try { 981 JJCalls p = jj_2_rtns[i]; 982 do { 983 if (p.gen > jj_gen) { 984 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; 985 switch (i) { 986 case 0: jj_3_1(); break; 987 case 1: jj_3_2(); break; 988 } 989 } 990 p = p.next; 991 } while (p != null); 992 } catch(LookaheadSuccess ls) { } 993 } 994 jj_rescan = false; 995 } 996 997 private void jj_save(int index, int xla) { 998 JJCalls p = jj_2_rtns[index]; 999 while (p.gen > jj_gen) { 1000 if (p.next == null) { p = p.next = new JJCalls(); break; } 1001 p = p.next; 1002 } 1003 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; 1004 } 1005 1006 static final class JJCalls { 1007 int gen; 1008 Token first; 1009 int arg; 1010 JJCalls next; 1011 } 1012 1013}