/* Generated By:JavaCC: Do not edit this line. QueryParser.java */
package org.apache.lucene.queryparser.surround.parser;

import java.util.ArrayList;
import java.util.List;
import java.io.StringReader;


import org.apache.lucene.queryparser.surround.query.SrndQuery;
import org.apache.lucene.queryparser.surround.query.FieldsQuery;
import org.apache.lucene.queryparser.surround.query.OrQuery;
import org.apache.lucene.queryparser.surround.query.AndQuery;
import org.apache.lucene.queryparser.surround.query.NotQuery;
import org.apache.lucene.queryparser.surround.query.DistanceQuery;
import org.apache.lucene.queryparser.surround.query.SrndTermQuery;
import org.apache.lucene.queryparser.surround.query.SrndPrefixQuery;
import org.apache.lucene.queryparser.surround.query.SrndTruncQuery;

This class is generated by JavaCC. The only method that clients should need to call is parse(). 
This parser generates queries that make use of position information
  (Span queries). It provides positional operators (w and
  n) that accept a numeric distance, as well as boolean
  operators (and, or, and not,
  wildcards (* and ?), quoting (with
  "), and boosting (via ^).
 
The operators (W, N, AND, OR, NOT) can be expressed lower-cased or
  upper-cased, and the non-unary operators (everything but NOT) support
  both infix (a AND b AND c) and prefix AND(a, b,
  c) notation. 
 
The W and N operators express a positional relationship among their
 operands.  W is ordered, and N is unordered.  The distance is 1 by
 default, meaning the operands are adjacent, or may be provided as a
 prefix from 2-99.  So, for example, 3W(a, b) means that terms a and b
 must appear within three positions of each other, or in other words, up
 to two terms may appear between a and b.  
/**
 * This class is generated by JavaCC.  The only method that clients should need
 * to call is {@link #parse parse()}.
 *

 * <p>This parser generates queries that make use of position information
 *   (Span queries). It provides positional operators (<code>w</code> and
 *   <code>n</code>) that accept a numeric distance, as well as boolean
 *   operators (<code>and</code>, <code>or</code>, and <code>not</code>,
 *   wildcards (<code>*</code> and <code>?</code>), quoting (with
 *   <code>"</code>), and boosting (via <code>^</code>).</p>

 *  <p>The operators (W, N, AND, OR, NOT) can be expressed lower-cased or
 *   upper-cased, and the non-unary operators (everything but NOT) support
 *   both infix <code>(a AND b AND c)</code> and prefix <code>AND(a, b,
 *   c)</code> notation. </p>
 
 *  <p>The W and N operators express a positional relationship among their
 *  operands.  W is ordered, and N is unordered.  The distance is 1 by
 *  default, meaning the operands are adjacent, or may be provided as a
 *  prefix from 2-99.  So, for example, 3W(a, b) means that terms a and b
 *  must appear within three positions of each other, or in other words, up
 *  to two terms may appear between a and b.  </p>
 */

public class QueryParser implements QueryParserConstants {
  static final int MINIMUM_PREFIX_LENGTH = 3;
  static final int MINIMUM_CHARS_IN_TRUNC = 3;
  static final String TRUNCATION_ERROR_MESSAGE = "Too unrestrictive truncation: ";
  static final String BOOST_ERROR_MESSAGE = "Cannot handle boost value: ";

  /* CHECKME: These should be the same as for the tokenizer. How? */
  static final char TRUNCATOR = '*';
  static final char ANY_CHAR = '?';
  static final char FIELD_OPERATOR = ':';

  static public SrndQuery parse(String query) throws ParseException {
    QueryParser parser = new QueryParser();
    return parser.parse2(query);
  }

  public QueryParser() {
    this(new FastCharStream(new StringReader("")));
  }

  public SrndQuery parse2(String query) throws ParseException {
    ReInit(new FastCharStream(new StringReader(query)));
    try {
      return TopSrndQuery();
    } catch (TokenMgrError tme) {
      throw new ParseException(tme.getMessage());
    }
  }

  protected SrndQuery getFieldsQuery(
      SrndQuery q, ArrayList<String> fieldNames) {
    /* FIXME: check acceptable subquery: at least one subquery should not be
     * a fields query.
     */
    return new FieldsQuery(q, fieldNames, FIELD_OPERATOR);
  }

  protected SrndQuery getOrQuery(List<SrndQuery> queries, boolean infix, Token orToken) {
    return new OrQuery(queries, infix, orToken.image);
  }

  protected SrndQuery getAndQuery(List<SrndQuery> queries, boolean infix, Token andToken) {
    return new AndQuery( queries, infix, andToken.image);
  }

  protected SrndQuery getNotQuery(List<SrndQuery> queries, Token notToken) {
    return new NotQuery( queries, notToken.image);
  }

  protected static int getOpDistance(String distanceOp) {
    /* W, 2W, 3W etc -> 1, 2 3, etc. Same for N, 2N ... */
    return distanceOp.length() == 1
      ? 1
      : Integer.parseInt( distanceOp.substring( 0, distanceOp.length() - 1));
  }

  protected static void checkDistanceSubQueries(DistanceQuery distq, String opName)
  throws ParseException {
    String m = distq.distanceSubQueryNotAllowed();
    if (m != null) {
      throw new ParseException("Operator " + opName + ": " + m);
    }
  }

  protected SrndQuery getDistanceQuery(
        List<SrndQuery> queries,
        boolean infix,
        Token dToken,
        boolean ordered) throws ParseException {
    DistanceQuery dq = new DistanceQuery(queries,
                                        infix,
                                        getOpDistance(dToken.image),
                                        dToken.image,
                                        ordered);
    checkDistanceSubQueries(dq, dToken.image);
    return dq;
  }

  protected SrndQuery getTermQuery(
        String term, boolean quoted) {
    return new SrndTermQuery(term, quoted);
  }

  protected boolean allowedSuffix(String suffixed) {
    return (suffixed.length() - 1) >= MINIMUM_PREFIX_LENGTH;
  }

  protected SrndQuery getPrefixQuery(
      String prefix, boolean quoted) {
    return new SrndPrefixQuery(prefix, quoted, TRUNCATOR);
  }

  protected boolean allowedTruncation(String truncated) {
    /* At least 3 normal characters needed. */
    int nrNormalChars = 0;
    for (int i = 0; i < truncated.length(); i++) {
      char c = truncated.charAt(i);
      if ((c != TRUNCATOR) && (c != ANY_CHAR)) {
        nrNormalChars++;
      }
    }
    return nrNormalChars >= MINIMUM_CHARS_IN_TRUNC;
  }

  protected SrndQuery getTruncQuery(String truncated) {
    return new SrndTruncQuery(truncated, TRUNCATOR, ANY_CHAR);
  }

  final public SrndQuery TopSrndQuery() throws ParseException {
  SrndQuery q;
    q = FieldsQuery();
    jj_consume_token(0);
   {if (true) return q;}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery FieldsQuery() throws ParseException {
  SrndQuery q;
  ArrayList<String> fieldNames;
    fieldNames = OptionalFields();
    q = OrQuery();
   {if (true) return (fieldNames == null) ? q : getFieldsQuery(q, fieldNames);}
    throw new Error("Missing return statement in function");
  }

  final public ArrayList<String> OptionalFields() throws ParseException {
  Token fieldName;
  ArrayList<String> fieldNames = null;
    label_1:
    while (true) {
      if (jj_2_1(2)) {
        ;
      } else {
        break label_1;
      }
      // to the colon
          fieldName = jj_consume_token(TERM);
      jj_consume_token(COLON);
      if (fieldNames == null) {
        fieldNames = new ArrayList<String>();
      }
      fieldNames.add(fieldName.image);
    }
   {if (true) return fieldNames;}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery OrQuery() throws ParseException {
  SrndQuery q;
  ArrayList<SrndQuery> queries = null;
  Token oprt = null;
    q = AndQuery();
    label_2:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case OR:
        ;
        break;
      default:
        jj_la1[0] = jj_gen;
        break label_2;
      }
      oprt = jj_consume_token(OR);
                  /* keep only last used operator */
      if (queries == null) {
        queries = new ArrayList<SrndQuery>();
        queries.add(q);
      }
      q = AndQuery();
      queries.add(q);
    }
   {if (true) return (queries == null) ? q : getOrQuery(queries, true /* infix */, oprt);}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery AndQuery() throws ParseException {
  SrndQuery q;
  ArrayList<SrndQuery> queries = null;
  Token oprt = null;
    q = NotQuery();
    label_3:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AND:
        ;
        break;
      default:
        jj_la1[1] = jj_gen;
        break label_3;
      }
      oprt = jj_consume_token(AND);
                   /* keep only last used operator */
      if (queries == null) {
        queries = new ArrayList<SrndQuery>();
        queries.add(q);
      }
      q = NotQuery();
      queries.add(q);
    }
   {if (true) return (queries == null) ? q : getAndQuery(queries, true /* infix */, oprt);}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery NotQuery() throws ParseException {
  SrndQuery q;
  ArrayList<SrndQuery> queries = null;
  Token oprt = null;
    q = NQuery();
    label_4:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NOT:
        ;
        break;
      default:
        jj_la1[2] = jj_gen;
        break label_4;
      }
      oprt = jj_consume_token(NOT);
                    /* keep only last used operator */
      if (queries == null) {
        queries = new ArrayList<SrndQuery>();
        queries.add(q);
      }
      q = NQuery();
      queries.add(q);
    }
   {if (true) return (queries == null) ? q : getNotQuery(queries, oprt);}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery NQuery() throws ParseException {
  SrndQuery q;
  ArrayList<SrndQuery> queries;
  Token dt;
    q = WQuery();
    label_5:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case N:
        ;
        break;
      default:
        jj_la1[3] = jj_gen;
        break label_5;
      }
      dt = jj_consume_token(N);
      queries = new ArrayList<SrndQuery>();
      queries.add(q); /* left associative */

      q = WQuery();
      queries.add(q);
      q = getDistanceQuery(queries, true /* infix */, dt, false /* not ordered */);
    }
   {if (true) return q;}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery WQuery() throws ParseException {
  SrndQuery q;
  ArrayList<SrndQuery> queries;
  Token wt;
    q = PrimaryQuery();
    label_6:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case W:
        ;
        break;
      default:
        jj_la1[4] = jj_gen;
        break label_6;
      }
      wt = jj_consume_token(W);
      queries = new ArrayList<SrndQuery>();
      queries.add(q); /* left associative */

      q = PrimaryQuery();
      queries.add(q);
      q = getDistanceQuery(queries, true /* infix */, wt, true /* ordered */);
    }
   {if (true) return q;}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery PrimaryQuery() throws ParseException {
                             /* bracketed weighted query or weighted term */
  SrndQuery q;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case LPAREN:
      jj_consume_token(LPAREN);
      q = FieldsQuery();
      jj_consume_token(RPAREN);
      break;
    case OR:
    case AND:
    case W:
    case N:
      q = PrefixOperatorQuery();
      break;
    case TRUNCQUOTED:
    case QUOTED:
    case SUFFIXTERM:
    case TRUNCTERM:
    case TERM:
      q = SimpleTerm();
      break;
    default:
      jj_la1[5] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    OptionalWeights(q);
   {if (true) return q;}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery PrefixOperatorQuery() throws ParseException {
  Token oprt;
  List<SrndQuery> queries;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case OR:
      oprt = jj_consume_token(OR);
      /* prefix OR */
          queries = FieldsQueryList();
     {if (true) return getOrQuery(queries, false /* not infix */, oprt);}
      break;
    case AND:
      oprt = jj_consume_token(AND);
      /* prefix AND */
          queries = FieldsQueryList();
     {if (true) return getAndQuery(queries, false /* not infix */, oprt);}
      break;
    case N:
      oprt = jj_consume_token(N);
      /* prefix N */
          queries = FieldsQueryList();
     {if (true) return getDistanceQuery(queries, false /* not infix */, oprt, false /* not ordered */);}
      break;
    case W:
      oprt = jj_consume_token(W);
      /* prefix W */
          queries = FieldsQueryList();
     {if (true) return getDistanceQuery(queries, false  /* not infix */, oprt, true /* ordered */);}
      break;
    default:
      jj_la1[6] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public List<SrndQuery> FieldsQueryList() throws ParseException {
  SrndQuery q;
  ArrayList<SrndQuery> queries = new ArrayList<SrndQuery>();
    jj_consume_token(LPAREN);
    q = FieldsQuery();
                     queries.add(q);
    label_7:
    while (true) {
      jj_consume_token(COMMA);
      q = FieldsQuery();
                              queries.add(q);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COMMA:
        ;
        break;
      default:
        jj_la1[7] = jj_gen;
        break label_7;
      }
    }
    jj_consume_token(RPAREN);
   {if (true) return queries;}
    throw new Error("Missing return statement in function");
  }

  final public SrndQuery SimpleTerm() throws ParseException {
  Token term;
    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
    case TERM:
      term = jj_consume_token(TERM);
     {if (true) return getTermQuery(term.image, false /* not quoted */);}
      break;
    case QUOTED:
      term = jj_consume_token(QUOTED);
     {if (true) return getTermQuery(term.image.substring(1, term.image.length()-1), true /* quoted */);}
      break;
    case SUFFIXTERM:
      term = jj_consume_token(SUFFIXTERM);
                        /* ending in * */
      if (! allowedSuffix(term.image)) {
        {if (true) throw new ParseException(TRUNCATION_ERROR_MESSAGE + term.image);}
      }
      {if (true) return getPrefixQuery(term.image.substring(0, term.image.length()-1), false /* not quoted */);}
      break;
    case TRUNCTERM:
      term = jj_consume_token(TRUNCTERM);
                       /* with at least one * or ? */
      if (! allowedTruncation(term.image)) {
        {if (true) throw new ParseException(TRUNCATION_ERROR_MESSAGE + term.image);}
      }
      {if (true) return getTruncQuery(term.image);}
      break;
    case TRUNCQUOTED:
      term = jj_consume_token(TRUNCQUOTED);
                         /* eg. "9b-b,m"* */
      if ((term.image.length() - 3) < MINIMUM_PREFIX_LENGTH) {
        {if (true) throw new ParseException(TRUNCATION_ERROR_MESSAGE + term.image);}
      }
      {if (true) return getPrefixQuery(term.image.substring(1, term.image.length()-2), true /* quoted */);}
      break;
    default:
      jj_la1[8] = jj_gen;
      jj_consume_token(-1);
      throw new ParseException();
    }
    throw new Error("Missing return statement in function");
  }

  final public void OptionalWeights(SrndQuery q) throws ParseException {
  Token weight=null;
    label_8:
    while (true) {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CARAT:
        ;
        break;
      default:
        jj_la1[9] = jj_gen;
        break label_8;
      }
      jj_consume_token(CARAT);
      weight = jj_consume_token(NUMBER);
      float f;
      try {
        f = Float.parseFloat(weight.image);
      } catch (Exception floatExc) {
        {if (true) throw new ParseException(BOOST_ERROR_MESSAGE + weight.image + " (" + floatExc + ")");}
      }
      if (f <= 0.0) {
        {if (true) throw new ParseException(BOOST_ERROR_MESSAGE + weight.image);}
      }
      q.setWeight(f * q.getWeight()); /* left associative, fwiw */

    }
  }

  private boolean jj_2_1(int xla) {
    jj_la = xla; jj_lastpos = jj_scanpos = token;
    try { return !jj_3_1(); }
    catch(LookaheadSuccess ls) { return true; }
    finally { jj_save(0, xla); }
  }

  private boolean jj_3_1() {
    if (jj_scan_token(TERM)) return true;
    if (jj_scan_token(COLON)) return true;
    return false;
  }

  
Generated Token Manager. /** Generated Token Manager. */
  public QueryParserTokenManager token_source;
  
Current token. /** Current token. */
  public Token token;
  
Next token. /** Next token. */
  public Token jj_nt;
  private int jj_ntk;
  private Token jj_scanpos, jj_lastpos;
  private int jj_la;
  private int jj_gen;
  final private int[] jj_la1 = new int[10];
  static private int[] jj_la1_0;
  static {
      jj_la1_init_0();
   }
   private static void jj_la1_init_0() {
      jj_la1_0 = new int[] {0x100,0x200,0x400,0x1000,0x800,0x7c3b00,0x1b00,0x8000,0x7c0000,0x20000,};
   }
  final private JJCalls[] jj_2_rtns = new JJCalls[1];
  private boolean jj_rescan = false;
  private int jj_gc = 0;

  
Constructor with user supplied CharStream. /** Constructor with user supplied CharStream. */
  public QueryParser(CharStream stream) {
    token_source = new QueryParserTokenManager(stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  
Reinitialise. /** Reinitialise. */
  public void ReInit(CharStream stream) {
    token_source.ReInit(stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  
Constructor with generated Token Manager. /** Constructor with generated Token Manager. */
  public QueryParser(QueryParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  
Reinitialise. /** Reinitialise. */
  public void ReInit(QueryParserTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 10; i++) jj_la1[i] = -1;
    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
  }

  private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      if (++jj_gc > 100) {
        jj_gc = 0;
        for (int i = 0; i < jj_2_rtns.length; i++) {
          JJCalls c = jj_2_rtns[i];
          while (c != null) {
            if (c.gen < jj_gen) c.first = null;
            c = c.next;
          }
        }
      }
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }

  static private final class LookaheadSuccess extends java.lang.Error { }
  final private LookaheadSuccess jj_ls = new LookaheadSuccess();
  private boolean jj_scan_token(int kind) {
    if (jj_scanpos == jj_lastpos) {
      jj_la--;
      if (jj_scanpos.next == null) {
        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
      } else {
        jj_lastpos = jj_scanpos = jj_scanpos.next;
      }
    } else {
      jj_scanpos = jj_scanpos.next;
    }
    if (jj_rescan) {
      int i = 0; Token tok = token;
      while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
      if (tok != null) jj_add_error_token(kind, i);
    }
    if (jj_scanpos.kind != kind) return true;
    if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
    return false;
  }


Get the next Token. /** Get the next Token. */
  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

Get the specific Token. /** Get the specific Token. */
  final public Token getToken(int index) {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;
  private int[] jj_lasttokens = new int[100];
  private int jj_endpos;

  private void jj_add_error_token(int kind, int pos) {
    if (pos >= 100) return;
    if (pos == jj_endpos + 1) {
      jj_lasttokens[jj_endpos++] = kind;
    } else if (jj_endpos != 0) {
      jj_expentry = new int[jj_endpos];
      for (int i = 0; i < jj_endpos; i++) {
        jj_expentry[i] = jj_lasttokens[i];
      }
      jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
        int[] oldentry = (int[])(it.next());
        if (oldentry.length == jj_expentry.length) {
          for (int i = 0; i < jj_expentry.length; i++) {
            if (oldentry[i] != jj_expentry[i]) {
              continue jj_entries_loop;
            }
          }
          jj_expentries.add(jj_expentry);
          break jj_entries_loop;
        }
      }
      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
    }
  }

  
Generate ParseException. /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[24];
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 10; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 24; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.add(jj_expentry);
      }
    }
    jj_endpos = 0;
    jj_rescan_token();
    jj_add_error_token(0, 0);
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = jj_expentries.get(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  
Enable tracing. /** Enable tracing. */
  final public void enable_tracing() {
  }

  
Disable tracing. /** Disable tracing. */
  final public void disable_tracing() {
  }

  private void jj_rescan_token() {
    jj_rescan = true;
    for (int i = 0; i < 1; i++) {
    try {
      JJCalls p = jj_2_rtns[i];
      do {
        if (p.gen > jj_gen) {
          jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
          switch (i) {
            case 0: jj_3_1(); break;
          }
        }
        p = p.next;
      } while (p != null);
      } catch(LookaheadSuccess ls) { }
    }
    jj_rescan = false;
  }

  private void jj_save(int index, int xla) {
    JJCalls p = jj_2_rtns[index];
    while (p.gen > jj_gen) {
      if (p.next == null) { p = p.next = new JJCalls(); break; }
      p = p.next;
    }
    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
  }

  static final class JJCalls {
    int gen;
    Token first;
    int arg;
    JJCalls next;
  }

}