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     ****************************************************************/
020    package org.apache.james.mime4j.field.address;
021    
022    public 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    }