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