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}