lucene-java-3.5.0/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/surround/parser/QueryParser.java

   1 /* Generated By:JavaCC: Do not edit this line. QueryParser.java */
   2 package org.apache.lucene.queryParser.surround.parser;
   3
   4 import java.util.ArrayList;
   5 import java.util.List;
   6 import java.io.StringReader;
   7
   8
   9 import org.apache.lucene.analysis.TokenStream;
  10
  11 import org.apache.lucene.queryParser.surround.query.SrndQuery;
  12 import org.apache.lucene.queryParser.surround.query.FieldsQuery;
  13 import org.apache.lucene.queryParser.surround.query.OrQuery;
  14 import org.apache.lucene.queryParser.surround.query.AndQuery;
  15 import org.apache.lucene.queryParser.surround.query.NotQuery;
  16 import org.apache.lucene.queryParser.surround.query.DistanceQuery;
  17 import org.apache.lucene.queryParser.surround.query.SrndTermQuery;
  18 import org.apache.lucene.queryParser.surround.query.SrndPrefixQuery;
  19 import org.apache.lucene.queryParser.surround.query.SrndTruncQuery;
  20
  21 /**
  22  * This class is generated by JavaCC.  The only method that clients should need
  23  * to call is <a href="#parse">parse()</a>.
  24  */
  25
  26 public class QueryParser implements QueryParserConstants {
  27   final int minimumPrefixLength = 3;
  28   final int minimumCharsInTrunc = 3;
  29   final String truncationErrorMessage = "Too unrestrictive truncation: ";
  30   final String boostErrorMessage = "Cannot handle boost value: ";
  31
  32   /* CHECKME: These should be the same as for the tokenizer. How? */
  33   final char truncator = '*';
  34   final char anyChar = '?';
  35   final char quote = '\"';
  36   final char fieldOperator = ':';
  37   final char comma = ','; /* prefix list separator */
  38   final char carat = '^'; /* weight operator */
  39
  40   static public SrndQuery parse(String query) throws ParseException {
  41     QueryParser parser = new QueryParser();
  42     return parser.parse2(query);
  43   }
  44
  45   public QueryParser() {
  46     this(new FastCharStream(new StringReader("")));
  47   }
  48
  49   public SrndQuery parse2(String query) throws ParseException {
  50     ReInit(new FastCharStream(new StringReader(query)));
  51     try {
  52       return TopSrndQuery();
  53     } catch (TokenMgrError tme) {
  54       throw new ParseException(tme.getMessage());
  55     }
  56   }
  57
  58   protected SrndQuery getFieldsQuery(
  59       SrndQuery q, ArrayList<String> fieldNames) {
  60     /* FIXME: check acceptable subquery: at least one subquery should not be
  61      * a fields query.
  62      */
  63     return new FieldsQuery(q, fieldNames, fieldOperator);
  64   }
  65
  66   protected SrndQuery getOrQuery(List<SrndQuery> queries, boolean infix, Token orToken) {
  67     return new OrQuery(queries, infix, orToken.image);
  68   }
  69
  70   protected SrndQuery getAndQuery(List<SrndQuery> queries, boolean infix, Token andToken) {
  71     return new AndQuery( queries, infix, andToken.image);
  72   }
  73
  74   protected SrndQuery getNotQuery(List<SrndQuery> queries, Token notToken) {
  75     return new NotQuery( queries, notToken.image);
  76   }
  77
  78   protected static int getOpDistance(String distanceOp) {
  79     /* W, 2W, 3W etc -> 1, 2 3, etc. Same for N, 2N ... */
  80     return distanceOp.length() == 1
  81       ? 1
  82       : Integer.parseInt( distanceOp.substring( 0, distanceOp.length() - 1));
  83   }
  84
  85   protected static void checkDistanceSubQueries(DistanceQuery distq, String opName)
  86   throws ParseException {
  87     String m = distq.distanceSubQueryNotAllowed();
  88     if (m != null) {
  89       throw new ParseException("Operator " + opName + ": " + m);
  90     }
  91   }
  92
  93   protected SrndQuery getDistanceQuery(
  94         List<SrndQuery> queries,
  95         boolean infix,
  96         Token dToken,
  97         boolean ordered) throws ParseException {
  98     DistanceQuery dq = new DistanceQuery(queries,
  99                                         infix,
 100                                         getOpDistance(dToken.image),
 101                                         dToken.image,
 102                                         ordered);
 103     checkDistanceSubQueries(dq, dToken.image);
 104     return dq;
 105   }
 106
 107   protected SrndQuery getTermQuery(
 108         String term, boolean quoted) {
 109     return new SrndTermQuery(term, quoted);
 110   }
 111
 112   protected boolean allowedSuffix(String suffixed) {
 113     return (suffixed.length() - 1) >= minimumPrefixLength;
 114   }
 115
 116   protected SrndQuery getPrefixQuery(
 117       String prefix, boolean quoted) {
 118     return new SrndPrefixQuery(prefix, quoted, truncator);
 119   }
 120
 121   protected boolean allowedTruncation(String truncated) {
 122     /* At least 3 normal characters needed. */
 123     int nrNormalChars = 0;
 124     for (int i = 0; i < truncated.length(); i++) {
 125       char c = truncated.charAt(i);
 126       if ((c != truncator) && (c != anyChar)) {
 127         nrNormalChars++;
 128       }
 129     }
 130     return nrNormalChars >= minimumCharsInTrunc;
 131   }
 132
 133   protected SrndQuery getTruncQuery(String truncated) {
 134     return new SrndTruncQuery(truncated, truncator, anyChar);
 135   }
 136
 137   final public SrndQuery TopSrndQuery() throws ParseException {
 138   SrndQuery q;
 139     q = FieldsQuery();
 140     jj_consume_token(0);
 141    {if (true) return q;}
 142     throw new Error("Missing return statement in function");
 143   }
 144
 145   final public SrndQuery FieldsQuery() throws ParseException {
 146   SrndQuery q;
 147   ArrayList<String> fieldNames;
 148     fieldNames = OptionalFields();
 149     q = OrQuery();
 150    {if (true) return (fieldNames == null) ? q : getFieldsQuery(q, fieldNames);}
 151     throw new Error("Missing return statement in function");
 152   }
 153
 154   final public ArrayList<String> OptionalFields() throws ParseException {
 155   Token fieldName;
 156   ArrayList<String> fieldNames = null;
 157     label_1:
 158     while (true) {
 159       if (jj_2_1(2)) {
 160         ;
 161       } else {
 162         break label_1;
 163       }
 164       // to the colon
 165           fieldName = jj_consume_token(TERM);
 166       jj_consume_token(COLON);
 167       if (fieldNames == null) {
 168         fieldNames = new ArrayList<String>();
 169       }
 170       fieldNames.add(fieldName.image);
 171     }
 172    {if (true) return fieldNames;}
 173     throw new Error("Missing return statement in function");
 174   }
 175
 176   final public SrndQuery OrQuery() throws ParseException {
 177   SrndQuery q;
 178   ArrayList<SrndQuery> queries = null;
 179   Token oprt = null;
 180     q = AndQuery();
 181     label_2:
 182     while (true) {
 183       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 184       case OR:
 185         ;
 186         break;
 187       default:
 188         jj_la1[0] = jj_gen;
 189         break label_2;
 190       }
 191       oprt = jj_consume_token(OR);
 192                   /* keep only last used operator */
 193       if (queries == null) {
 194         queries = new ArrayList<SrndQuery>();
 195         queries.add(q);
 196       }
 197       q = AndQuery();
 198       queries.add(q);
 199     }
 200    {if (true) return (queries == null) ? q : getOrQuery(queries, true /* infix */, oprt);}
 201     throw new Error("Missing return statement in function");
 202   }
 203
 204   final public SrndQuery AndQuery() throws ParseException {
 205   SrndQuery q;
 206   ArrayList<SrndQuery> queries = null;
 207   Token oprt = null;
 208     q = NotQuery();
 209     label_3:
 210     while (true) {
 211       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 212       case AND:
 213         ;
 214         break;
 215       default:
 216         jj_la1[1] = jj_gen;
 217         break label_3;
 218       }
 219       oprt = jj_consume_token(AND);
 220                    /* keep only last used operator */
 221       if (queries == null) {
 222         queries = new ArrayList<SrndQuery>();
 223         queries.add(q);
 224       }
 225       q = NotQuery();
 226       queries.add(q);
 227     }
 228    {if (true) return (queries == null) ? q : getAndQuery(queries, true /* infix */, oprt);}
 229     throw new Error("Missing return statement in function");
 230   }
 231
 232   final public SrndQuery NotQuery() throws ParseException {
 233   SrndQuery q;
 234   ArrayList<SrndQuery> queries = null;
 235   Token oprt = null;
 236     q = NQuery();
 237     label_4:
 238     while (true) {
 239       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 240       case NOT:
 241         ;
 242         break;
 243       default:
 244         jj_la1[2] = jj_gen;
 245         break label_4;
 246       }
 247       oprt = jj_consume_token(NOT);
 248                     /* keep only last used operator */
 249       if (queries == null) {
 250         queries = new ArrayList<SrndQuery>();
 251         queries.add(q);
 252       }
 253       q = NQuery();
 254       queries.add(q);
 255     }
 256    {if (true) return (queries == null) ? q : getNotQuery(queries, oprt);}
 257     throw new Error("Missing return statement in function");
 258   }
 259
 260   final public SrndQuery NQuery() throws ParseException {
 261   SrndQuery q;
 262   ArrayList<SrndQuery> queries;
 263   Token dt;
 264     q = WQuery();
 265     label_5:
 266     while (true) {
 267       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 268       case N:
 269         ;
 270         break;
 271       default:
 272         jj_la1[3] = jj_gen;
 273         break label_5;
 274       }
 275       dt = jj_consume_token(N);
 276       queries = new ArrayList<SrndQuery>();
 277       queries.add(q); /* left associative */
 278
 279       q = WQuery();
 280       queries.add(q);
 281       q = getDistanceQuery(queries, true /* infix */, dt, false /* not ordered */);
 282     }
 283    {if (true) return q;}
 284     throw new Error("Missing return statement in function");
 285   }
 286
 287   final public SrndQuery WQuery() throws ParseException {
 288   SrndQuery q;
 289   ArrayList<SrndQuery> queries;
 290   Token wt;
 291     q = PrimaryQuery();
 292     label_6:
 293     while (true) {
 294       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 295       case W:
 296         ;
 297         break;
 298       default:
 299         jj_la1[4] = jj_gen;
 300         break label_6;
 301       }
 302       wt = jj_consume_token(W);
 303       queries = new ArrayList<SrndQuery>();
 304       queries.add(q); /* left associative */
 305
 306       q = PrimaryQuery();
 307       queries.add(q);
 308       q = getDistanceQuery(queries, true /* infix */, wt, true /* ordered */);
 309     }
 310    {if (true) return q;}
 311     throw new Error("Missing return statement in function");
 312   }
 313
 314   final public SrndQuery PrimaryQuery() throws ParseException {
 315                              /* bracketed weighted query or weighted term */
 316   SrndQuery q;
 317     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 318     case LPAREN:
 319       jj_consume_token(LPAREN);
 320       q = FieldsQuery();
 321       jj_consume_token(RPAREN);
 322       break;
 323     case OR:
 324     case AND:
 325     case W:
 326     case N:
 327       q = PrefixOperatorQuery();
 328       break;
 329     case TRUNCQUOTED:
 330     case QUOTED:
 331     case SUFFIXTERM:
 332     case TRUNCTERM:
 333     case TERM:
 334       q = SimpleTerm();
 335       break;
 336     default:
 337       jj_la1[5] = jj_gen;
 338       jj_consume_token(-1);
 339       throw new ParseException();
 340     }
 341     OptionalWeights(q);
 342    {if (true) return q;}
 343     throw new Error("Missing return statement in function");
 344   }
 345
 346   final public SrndQuery PrefixOperatorQuery() throws ParseException {
 347   Token oprt;
 348   List<SrndQuery> queries;
 349     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 350     case OR:
 351       oprt = jj_consume_token(OR);
 352       /* prefix OR */
 353           queries = FieldsQueryList();
 354      {if (true) return getOrQuery(queries, false /* not infix */, oprt);}
 355       break;
 356     case AND:
 357       oprt = jj_consume_token(AND);
 358       /* prefix AND */
 359           queries = FieldsQueryList();
 360      {if (true) return getAndQuery(queries, false /* not infix */, oprt);}
 361       break;
 362     case N:
 363       oprt = jj_consume_token(N);
 364       /* prefix N */
 365           queries = FieldsQueryList();
 366      {if (true) return getDistanceQuery(queries, false /* not infix */, oprt, false /* not ordered */);}
 367       break;
 368     case W:
 369       oprt = jj_consume_token(W);
 370       /* prefix W */
 371           queries = FieldsQueryList();
 372      {if (true) return getDistanceQuery(queries, false  /* not infix */, oprt, true /* ordered */);}
 373       break;
 374     default:
 375       jj_la1[6] = jj_gen;
 376       jj_consume_token(-1);
 377       throw new ParseException();
 378     }
 379     throw new Error("Missing return statement in function");
 380   }
 381
 382   final public List<SrndQuery> FieldsQueryList() throws ParseException {
 383   SrndQuery q;
 384   ArrayList<SrndQuery> queries = new ArrayList<SrndQuery>();
 385     jj_consume_token(LPAREN);
 386     q = FieldsQuery();
 387                      queries.add(q);
 388     label_7:
 389     while (true) {
 390       jj_consume_token(COMMA);
 391       q = FieldsQuery();
 392                               queries.add(q);
 393       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 394       case COMMA:
 395         ;
 396         break;
 397       default:
 398         jj_la1[7] = jj_gen;
 399         break label_7;
 400       }
 401     }
 402     jj_consume_token(RPAREN);
 403    {if (true) return queries;}
 404     throw new Error("Missing return statement in function");
 405   }
 406
 407   final public SrndQuery SimpleTerm() throws ParseException {
 408   Token term;
 409     switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 410     case TERM:
 411       term = jj_consume_token(TERM);
 412      {if (true) return getTermQuery(term.image, false /* not quoted */);}
 413       break;
 414     case QUOTED:
 415       term = jj_consume_token(QUOTED);
 416      {if (true) return getTermQuery(term.image.substring(1, term.image.length()-1), true /* quoted */);}
 417       break;
 418     case SUFFIXTERM:
 419       term = jj_consume_token(SUFFIXTERM);
 420                         /* ending in * */
 421       if (! allowedSuffix(term.image)) {
 422         {if (true) throw new ParseException(truncationErrorMessage + term.image);}
 423       }
 424       {if (true) return getPrefixQuery(term.image.substring(0, term.image.length()-1), false /* not quoted */);}
 425       break;
 426     case TRUNCTERM:
 427       term = jj_consume_token(TRUNCTERM);
 428                        /* with at least one * or ? */
 429       if (! allowedTruncation(term.image)) {
 430         {if (true) throw new ParseException(truncationErrorMessage + term.image);}
 431       }
 432       {if (true) return getTruncQuery(term.image);}
 433       break;
 434     case TRUNCQUOTED:
 435       term = jj_consume_token(TRUNCQUOTED);
 436                          /* eg. "9b-b,m"* */
 437       if ((term.image.length() - 3) < minimumPrefixLength) {
 438         {if (true) throw new ParseException(truncationErrorMessage + term.image);}
 439       }
 440       {if (true) return getPrefixQuery(term.image.substring(1, term.image.length()-2), true /* quoted */);}
 441       break;
 442     default:
 443       jj_la1[8] = jj_gen;
 444       jj_consume_token(-1);
 445       throw new ParseException();
 446     }
 447     throw new Error("Missing return statement in function");
 448   }
 449
 450   final public void OptionalWeights(SrndQuery q) throws ParseException {
 451   Token weight=null;
 452     label_8:
 453     while (true) {
 454       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
 455       case CARAT:
 456         ;
 457         break;
 458       default:
 459         jj_la1[9] = jj_gen;
 460         break label_8;
 461       }
 462       jj_consume_token(CARAT);
 463       weight = jj_consume_token(NUMBER);
 464       float f;
 465       try {
 466         f = Float.valueOf(weight.image).floatValue();
 467       } catch (Exception floatExc) {
 468         {if (true) throw new ParseException(boostErrorMessage + weight.image + " (" + floatExc + ")");}
 469       }
 470       if (f <= 0.0) {
 471         {if (true) throw new ParseException(boostErrorMessage + weight.image);}
 472       }
 473       q.setWeight(f * q.getWeight()); /* left associative, fwiw */
 474
 475     }
 476   }
 477
 478   private boolean jj_2_1(int xla) {
 479     jj_la = xla; jj_lastpos = jj_scanpos = token;
 480     try { return !jj_3_1(); }
 481     catch(LookaheadSuccess ls) { return true; }
 482     finally { jj_save(0, xla); }
 483   }
 484
 485   private boolean jj_3_1() {
 486     if (jj_scan_token(TERM)) return true;
 487     if (jj_scan_token(COLON)) return true;
 488     return false;
 489   }
 490
 491   /** Generated Token Manager. */
 492   public QueryParserTokenManager token_source;
 493   /** Current token. */
 494   public Token token;
 495   /** Next token. */
 496   public Token jj_nt;
 497   private int jj_ntk;
 498   private Token jj_scanpos, jj_lastpos;
 499   private int jj_la;
 500   private int jj_gen;
 501   final private int[] jj_la1 = new int[10];
 502   static private int[] jj_la1_0;
 503   static {
 504       jj_la1_init_0();
 505    }
 506    private static void jj_la1_init_0() {
 507       jj_la1_0 = new int[] {0x100,0x200,0x400,0x1000,0x800,0x7c3b00,0x1b00,0x8000,0x7c0000,0x20000,};
 508    }
 509   final private JJCalls[] jj_2_rtns = new JJCalls[1];
 510   private boolean jj_rescan = false;
 511   private int jj_gc = 0;
 512
 513   /** Constructor with user supplied CharStream. */
 514   public QueryParser(CharStream stream) {
 515     token_source = new QueryParserTokenManager(stream);
 516     token = new Token();
 517     jj_ntk = -1;
 518     jj_gen = 0;
 519     for (int i = 0; i < 10; i++) jj_la1[i] = -1;
 520     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 521   }
 522
 523   /** Reinitialise. */
 524   public void ReInit(CharStream stream) {
 525     token_source.ReInit(stream);
 526     token = new Token();
 527     jj_ntk = -1;
 528     jj_gen = 0;
 529     for (int i = 0; i < 10; i++) jj_la1[i] = -1;
 530     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 531   }
 532
 533   /** Constructor with generated Token Manager. */
 534   public QueryParser(QueryParserTokenManager tm) {
 535     token_source = tm;
 536     token = new Token();
 537     jj_ntk = -1;
 538     jj_gen = 0;
 539     for (int i = 0; i < 10; i++) jj_la1[i] = -1;
 540     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 541   }
 542
 543   /** Reinitialise. */
 544   public void ReInit(QueryParserTokenManager tm) {
 545     token_source = tm;
 546     token = new Token();
 547     jj_ntk = -1;
 548     jj_gen = 0;
 549     for (int i = 0; i < 10; i++) jj_la1[i] = -1;
 550     for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
 551   }
 552
 553   private Token jj_consume_token(int kind) throws ParseException {
 554     Token oldToken;
 555     if ((oldToken = token).next != null) token = token.next;
 556     else token = token.next = token_source.getNextToken();
 557     jj_ntk = -1;
 558     if (token.kind == kind) {
 559       jj_gen++;
 560       if (++jj_gc > 100) {
 561         jj_gc = 0;
 562         for (int i = 0; i < jj_2_rtns.length; i++) {
 563           JJCalls c = jj_2_rtns[i];
 564           while (c != null) {
 565             if (c.gen < jj_gen) c.first = null;
 566             c = c.next;
 567           }
 568         }
 569       }
 570       return token;
 571     }
 572     token = oldToken;
 573     jj_kind = kind;
 574     throw generateParseException();
 575   }
 576
 577   static private final class LookaheadSuccess extends java.lang.Error { }
 578   final private LookaheadSuccess jj_ls = new LookaheadSuccess();
 579   private boolean jj_scan_token(int kind) {
 580     if (jj_scanpos == jj_lastpos) {
 581       jj_la--;
 582       if (jj_scanpos.next == null) {
 583         jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
 584       } else {
 585         jj_lastpos = jj_scanpos = jj_scanpos.next;
 586       }
 587     } else {
 588       jj_scanpos = jj_scanpos.next;
 589     }
 590     if (jj_rescan) {
 591       int i = 0; Token tok = token;
 592       while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
 593       if (tok != null) jj_add_error_token(kind, i);
 594     }
 595     if (jj_scanpos.kind != kind) return true;
 596     if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
 597     return false;
 598   }
 599
 600
 601 /** Get the next Token. */
 602   final public Token getNextToken() {
 603     if (token.next != null) token = token.next;
 604     else token = token.next = token_source.getNextToken();
 605     jj_ntk = -1;
 606     jj_gen++;
 607     return token;
 608   }
 609
 610 /** Get the specific Token. */
 611   final public Token getToken(int index) {
 612     Token t = token;
 613     for (int i = 0; i < index; i++) {
 614       if (t.next != null) t = t.next;
 615       else t = t.next = token_source.getNextToken();
 616     }
 617     return t;
 618   }
 619
 620   private int jj_ntk() {
 621     if ((jj_nt=token.next) == null)
 622       return (jj_ntk = (token.next=token_source.getNextToken()).kind);
 623     else
 624       return (jj_ntk = jj_nt.kind);
 625   }
 626
 627   private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
 628   private int[] jj_expentry;
 629   private int jj_kind = -1;
 630   private int[] jj_lasttokens = new int[100];
 631   private int jj_endpos;
 632
 633   private void jj_add_error_token(int kind, int pos) {
 634     if (pos >= 100) return;
 635     if (pos == jj_endpos + 1) {
 636       jj_lasttokens[jj_endpos++] = kind;
 637     } else if (jj_endpos != 0) {
 638       jj_expentry = new int[jj_endpos];
 639       for (int i = 0; i < jj_endpos; i++) {
 640         jj_expentry[i] = jj_lasttokens[i];
 641       }
 642       jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
 643         int[] oldentry = (int[])(it.next());
 644         if (oldentry.length == jj_expentry.length) {
 645           for (int i = 0; i < jj_expentry.length; i++) {
 646             if (oldentry[i] != jj_expentry[i]) {
 647               continue jj_entries_loop;
 648             }
 649           }
 650           jj_expentries.add(jj_expentry);
 651           break jj_entries_loop;
 652         }
 653       }
 654       if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
 655     }
 656   }
 657
 658   /** Generate ParseException. */
 659   public ParseException generateParseException() {
 660     jj_expentries.clear();
 661     boolean[] la1tokens = new boolean[24];
 662     if (jj_kind >= 0) {
 663       la1tokens[jj_kind] = true;
 664       jj_kind = -1;
 665     }
 666     for (int i = 0; i < 10; i++) {
 667       if (jj_la1[i] == jj_gen) {
 668         for (int j = 0; j < 32; j++) {
 669           if ((jj_la1_0[i] & (1<<j)) != 0) {
 670             la1tokens[j] = true;
 671           }
 672         }
 673       }
 674     }
 675     for (int i = 0; i < 24; i++) {
 676       if (la1tokens[i]) {
 677         jj_expentry = new int[1];
 678         jj_expentry[0] = i;
 679         jj_expentries.add(jj_expentry);
 680       }
 681     }
 682     jj_endpos = 0;
 683     jj_rescan_token();
 684     jj_add_error_token(0, 0);
 685     int[][] exptokseq = new int[jj_expentries.size()][];
 686     for (int i = 0; i < jj_expentries.size(); i++) {
 687       exptokseq[i] = jj_expentries.get(i);
 688     }
 689     return new ParseException(token, exptokseq, tokenImage);
 690   }
 691
 692   /** Enable tracing. */
 693   final public void enable_tracing() {
 694   }
 695
 696   /** Disable tracing. */
 697   final public void disable_tracing() {
 698   }
 699
 700   private void jj_rescan_token() {
 701     jj_rescan = true;
 702     for (int i = 0; i < 1; i++) {
 703     try {
 704       JJCalls p = jj_2_rtns[i];
 705       do {
 706         if (p.gen > jj_gen) {
 707           jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
 708           switch (i) {
 709             case 0: jj_3_1(); break;
 710           }
 711         }
 712         p = p.next;
 713       } while (p != null);
 714       } catch(LookaheadSuccess ls) { }
 715     }
 716     jj_rescan = false;
 717   }
 718
 719   private void jj_save(int index, int xla) {
 720     JJCalls p = jj_2_rtns[index];
 721     while (p.gen > jj_gen) {
 722       if (p.next == null) { p = p.next = new JJCalls(); break; }
 723       p = p.next;
 724     }
 725     p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
 726   }
 727
 728   static final class JJCalls {
 729     int gen;
 730     Token first;
 731     int arg;
 732     JJCalls next;
 733   }
 734
 735 }