Application: gvSIG desktop

/* Generated By:JavaCC: Do not edit this line. ExpressionParser.java */

/* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib��ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.symbology.fmap.rendering.filter.parser;

import java.util.*;

import java.io.*;

import com.hardcode.gdbms.engine.values.*;

import org.gvsig.symbology.fmap.rendering.filter.operations.*;

/**

 *

 * @author Pepe Vidal Salvador - jose.vidal.salvador@iver.es

 *

 */

public class ExpressionParser implements ExpressionParserConstants {

    private Stack stack = new Stack();

        private static OperatorsFactory operators = OperatorsFactory.getInstance();

        private Hashtable<String, Value> symbols = new Hashtable<String, Value>();

        private ArrayList<String> classNames = new ArrayList<String>();

 public ArrayList<String> getClassNames (){

        return classNames;

 }

  public void addClassName(String name){

         for (int i = 0; i < classNames.size(); i++) {

                if(classNames.get(i).compareTo(name)==0)

                        return;

        }

         classNames.add(name);

 }

    public Expression getExpression(){

    return (Expression)stack.pop();

  }

         public Stack getStack(){

                return this.stack;

        }

  public ExpressionParser(StringReader reader, Hashtable<String, Value> symbolsTable) {

        this(reader);

          this.symbols = symbolsTable;

}

public void putSymbol(String string, Value value){

        this.symbols.put(string,value);

}

  public static void main(String[]args)throws ParseException,ExpressionException{

         ExpressionParser parser = new ExpressionParser(new StringReader("true && true"));

         parser.Expression();

         parser.getStack();

         Expression exp = parser.getExpression();

  }

  final public void Expression() throws ParseException {

    AndExpression();

    label_1:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case OR:

        ;

        break;

      default:

        jj_la1[0] = jj_gen;

        break label_1;

      }

      jj_consume_token(OR);

      AndExpression();

    Expression leftExpression = (Expression)stack.pop();

    Expression rightExpression = (Expression)stack.pop();

        Expression orExpr = new OrOperator(symbols);

        orExpr.addArgument(0, rightExpression);

        orExpr.addArgument(0, leftExpression);

    stack.push(orExpr);

    }

  }

  final public void AndExpression() throws ParseException {

  Token x;

    EqCompExpression();

    label_2:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case AND:

        ;

        break;

      default:

        jj_la1[1] = jj_gen;

        break label_2;

      }

      x = jj_consume_token(AND);

      EqCompExpression();

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = new AndOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

    }

  }

  final public void EqCompExpression() throws ParseException {

  Token x;

    ComparisonExpression();

    label_3:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case EQ:

      case NE:

        ;

        break;

      default:

        jj_la1[2] = jj_gen;

        break label_3;

      }

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case EQ:

        x = jj_consume_token(EQ);

        break;

      case NE:

        x = jj_consume_token(NE);

        break;

      default:

        jj_la1[3] = jj_gen;

        jj_consume_token(-1);

        throw new ParseException();

      }

      ComparisonExpression();

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == EQ)func = new EqOperator(symbols);

    else if (x.kind == NE)func = new NeOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

    }

  }

  final public void ComparisonExpression() throws ParseException {

  Token x;

    AdditiveExpression();

    label_4:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case GT:

      case LT:

      case LE:

      case GE:

        ;

        break;

      default:

        jj_la1[4] = jj_gen;

        break label_4;

      }

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case LT:

        x = jj_consume_token(LT);

        break;

      case LE:

        x = jj_consume_token(LE);

        break;

      case GT:

        x = jj_consume_token(GT);

        break;

      case GE:

        x = jj_consume_token(GE);

        break;

      default:

        jj_la1[5] = jj_gen;

        jj_consume_token(-1);

        throw new ParseException();

      }

      AdditiveExpression();

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == LT)func = new LessThanOperator(symbols);

    else if (x.kind == LE)func = new LessThanOrEqualsOperator(symbols);

    else if (x.kind == GT)func = new GreaterThanOperator(symbols);

    else if (x.kind == GE)func = new GreaterThanOrEqualsOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

    }

  }

  final public void AdditiveExpression() throws ParseException {

  Token x;

    MultiplicativeExpression();

    label_5:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case PLUS:

      case MINUS:

        ;

        break;

      default:

        jj_la1[6] = jj_gen;

        break label_5;

      }

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case PLUS:

        x = jj_consume_token(PLUS);

        break;

      case MINUS:

        x = jj_consume_token(MINUS);

        break;

      default:

        jj_la1[7] = jj_gen;

        jj_consume_token(-1);

        throw new ParseException();

      }

      MultiplicativeExpression();

    Expression rightExpression = (Expression)stack.pop();

    Expression leftExpression = (Expression)stack.pop();

    Expression func = null;

    if (x.kind == PLUS)func = new AddOperator(symbols);

    else func = new MinusOperator(symbols);

    func.addArgument(0, rightExpression);

    func.addArgument(0, leftExpression);

    stack.push(func);

    }

  }

  final public void MultiplicativeExpression() throws ParseException {

  Token x;

    UnaryElement();

    label_6:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case MULTIPLY:

      case DIVIDE:

        ;

        break;

      default:

        jj_la1[8] = jj_gen;

        break label_6;

      }

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case MULTIPLY:

        x = jj_consume_token(MULTIPLY);

        break;

      case DIVIDE:

        x = jj_consume_token(DIVIDE);

        break;

      default:

        jj_la1[9] = jj_gen;

        jj_consume_token(-1);

        throw new ParseException();

      }

      UnaryElement();

        try{

                        Expression A = (Expression) stack.pop();

                        Expression B = (Expression) stack.pop();

                         boolean aInt = (((Expression) A).evaluate() instanceof Integer);

                         boolean bInt = (((Expression) B).evaluate() instanceof Integer);

                        if (aInt &&     bInt) {

                                int a = (Integer) A.evaluate();

                                int b = (Integer) B.evaluate();

                                if (x.kind == MULTIPLY)

                                        stack.push(new NumericalConstant(new Integer(b * a),symbols));

                                else

                                        stack.push(new NumericalConstant(new Integer(b / a),symbols));

                        } else {

                                double a = new Double(((Expression)A).evaluate().toString());

                double b = new Double(((Expression)B).evaluate().toString());

                                if (x.kind == MULTIPLY)

                                        stack.push(new NumericalConstant(new Double(b * a),symbols));

                                else

                                        stack.push(new NumericalConstant(new Double(b / a),symbols));

                        }}catch (ClassCastException ex) {

                  ex.printStackTrace();

            } catch (ExpressionException e) {

                                  e.printStackTrace();

                        }

    }

  }

  final public void UnaryElement() throws ParseException {

  Token x = null;

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case PLUS:

    case MINUS:

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case PLUS:

        x = jj_consume_token(PLUS);

        break;

      case MINUS:

        x = jj_consume_token(MINUS);

        break;

      default:

        jj_la1[10] = jj_gen;

        jj_consume_token(-1);

        throw new ParseException();

      }

      UnaryElement();

              try{

                 Object A = stack.pop();

                         if ((((Expression) A).evaluate() instanceof Integer)) {

                                int a = (Integer) ((Expression) A).evaluate();

                                if (x.kind == PLUS)

                                        stack.push(new NumericalConstant(new Integer(a),symbols));

                                else

                                        stack.push(new NumericalConstant(new Integer(-a),symbols));

                        } else {

                                double a = (Double) ((Expression) A).evaluate();

                                if (x.kind == PLUS)

                                        stack.push(new NumericalConstant(new Double(a),symbols));

                                else

                                        stack.push(new NumericalConstant(new Double(-a),symbols));

                        }

                         } catch (ClassCastException ex) {

               ex.printStackTrace();

             }catch (ExpressionException ex) {

                 ex.printStackTrace();

             }

      break;

    case NOT:

    case OPEN_SQ_BRACKETS:

    case OPEN_PARENTHESIS:

    case BOOLEAN:

    case NULL:

    case IDENTIFIER:

    case INTEGER:

    case FLOATING_POINT:

    case STRING:

      BooleanUnaryElement();

      break;

    default:

      jj_la1[11] = jj_gen;

      jj_consume_token(-1);

      throw new ParseException();

    }

  }

  final public void BooleanUnaryElement() throws ParseException {

        Token t;

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case NOT:

      t = jj_consume_token(NOT);

      UnaryElement();

                Expression rightExpression = (Expression)stack.pop();

                Expression func = new NotOperator(symbols);

                func.addArgument(0, rightExpression);

                stack.push(func);

      break;

    case OPEN_SQ_BRACKETS:

    case OPEN_PARENTHESIS:

    case BOOLEAN:

    case NULL:

    case IDENTIFIER:

    case INTEGER:

    case FLOATING_POINT:

    case STRING:

      Element();

      break;

    default:

      jj_la1[12] = jj_gen;

      jj_consume_token(-1);

      throw new ParseException();

    }

  }

  final public void Element() throws ParseException {

  Token x;

  String y =  "[$,A-Z,_,a-z]([$,A-Z,_,a-z]|[0-9])*";

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case OPEN_SQ_BRACKETS:

      jj_consume_token(OPEN_SQ_BRACKETS);

      x = jj_consume_token(IDENTIFIER);

      jj_consume_token(CLOSE_SQ_BRACKETS);

    ReplaceOperator func = new ReplaceOperator(symbols);

     func.addArgument(x.image);

        stack.push(func);

        addClassName(x.image);

      break;

    case INTEGER:

      x = jj_consume_token(INTEGER);

        NumericalConstant intC = new NumericalConstant(Integer.valueOf(x.image),symbols);

        stack.push(intC);

      break;

    case FLOATING_POINT:

      x = jj_consume_token(FLOATING_POINT);

        NumericalConstant doubleC = new NumericalConstant(Double.valueOf(x.image),symbols);

        stack.push(doubleC);

      break;

    case STRING:

      x = jj_consume_token(STRING);

    StringConstant stringValue = new StringConstant(x.image.substring(1, x.image.length()-1),symbols);

    stack.push(stringValue);

      break;

    case BOOLEAN:

      x = jj_consume_token(BOOLEAN);

    BooleanConstant boolValue = new BooleanConstant(x.image,symbols);

    stack.push(boolValue);

      break;

    case NULL:

      x = jj_consume_token(NULL);

        NullConstant nullValue = new NullConstant(symbols);

    stack.push(nullValue);

      break;

    default:

      jj_la1[13] = jj_gen;

      if (jj_2_1(2)) {

        function();

      } else {

        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

        case OPEN_PARENTHESIS:

          jj_consume_token(OPEN_PARENTHESIS);

          Expression();

          jj_consume_token(CLOSE_PARENTHESIS);

          break;

        default:

          jj_la1[14] = jj_gen;

          jj_consume_token(-1);

          throw new ParseException();

        }

      }

    }

  }

  final public void function() throws ParseException {

  String functionName;

  int argCount = 0;

  Expression function;

  Token x;

    if (jj_2_2(2)) {

      jj_consume_token(IDENTIFIER);

    functionName = token.image;

      argCount = Arguments();

    try {

      function = (Expression) operators.getOperator(functionName);

    }

    catch (Exception e){

      {if (true) throw new ParseException("Problem with function '"+functionName+"': "+e.toString());}

    }

    if (function == null){if (true) throw new ParseException("Nonexisting function name '"+functionName+"'");}

    for (int i = 0;

    i<argCount;

    i++){

      Expression arg = (Expression)stack.pop();

      function.addArgument(0, arg);

    }

    stack.push(function);

    } else {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case IDENTIFIER:

        x = jj_consume_token(IDENTIFIER);

    StringConstant stringValue = new StringConstant(x.image,symbols);

    stack.push(stringValue);

        break;

      default:

        jj_la1[15] = jj_gen;

        jj_consume_token(-1);

        throw new ParseException();

      }

    }

  }

  final public int Arguments() throws ParseException {

  int argCount = 0;

    jj_consume_token(OPEN_PARENTHESIS);

    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

    case PLUS:

    case MINUS:

    case NOT:

    case OPEN_SQ_BRACKETS:

    case OPEN_PARENTHESIS:

    case BOOLEAN:

    case NULL:

    case IDENTIFIER:

    case INTEGER:

    case FLOATING_POINT:

    case STRING:

      argCount = ArgumentList();

      break;

    default:

      jj_la1[16] = jj_gen;

      ;

    }

    jj_consume_token(CLOSE_PARENTHESIS);

    {if (true) return argCount;}

    throw new Error("Missing return statement in function");

  }

  final public int ArgumentList() throws ParseException {

  int argCount = 0;

    Expression();

    argCount++;

    label_7:

    while (true) {

      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {

      case COMMA:

        ;

        break;

      default:

        jj_la1[17] = jj_gen;

        break label_7;

      }

      jj_consume_token(COMMA);

      Expression();

    argCount++;

    }

    {if (true) return argCount;}

    throw new Error("Missing return statement in function");

  }

  final 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); }

  }

  final private boolean jj_2_2(int xla) {

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    try { return !jj_3_2(); }

    catch(LookaheadSuccess ls) { return true; }

    finally { jj_save(1, xla); }

  }

  final private boolean jj_3R_9() {

    if (jj_scan_token(OPEN_PARENTHESIS)) return true;

    return false;

  }

  final private boolean jj_3_1() {

    if (jj_3R_8()) return true;

    return false;

  }

  final private boolean jj_3R_10() {

    if (jj_scan_token(IDENTIFIER)) return true;

    return false;

  }

  final private boolean jj_3R_8() {

    Token xsp;

    xsp = jj_scanpos;

    if (jj_3_2()) {

    jj_scanpos = xsp;

    if (jj_3R_10()) return true;

    }

    return false;

  }

  final private boolean jj_3_2() {

    if (jj_scan_token(IDENTIFIER)) return true;

    if (jj_3R_9()) return true;

    return false;

  }

  public ExpressionParserTokenManager token_source;

  SimpleCharStream jj_input_stream;

  public Token token, jj_nt;

  private int jj_ntk;

  private Token jj_scanpos, jj_lastpos;

  private int jj_la;

  public boolean lookingAhead = false;

  private boolean jj_semLA;

  private int jj_gen;

  final private int[] jj_la1 = new int[18];

  static private int[] jj_la1_0;

  static private int[] jj_la1_1;

  static {

      jj_la1_0();

      jj_la1_1();

   }

   private static void jj_la1_0() {

      jj_la1_0 = new int[] {0x10000,0x20000,0x9000,0x9000,0x6600,0x6600,0x60,0x60,0x180,0x180,0x60,0x38280860,0x38280800,0x18080000,0x200000,0x20000000,0x38280860,0x1000000,};

   }

   private static void jj_la1_1() {

      jj_la1_1 = new int[] {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xb,0xb,0xb,0x0,0x0,0xb,0x0,};

   }

  final private JJCalls[] jj_2_rtns = new JJCalls[2];

  private boolean jj_rescan = false;

  private int jj_gc = 0;

  public ExpressionParser(java.io.InputStream stream) {

     this(stream, null);

  }

  public ExpressionParser(java.io.InputStream stream, String encoding) {

    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }

    token_source = new ExpressionParserTokenManager(jj_input_stream);

    token = new Token();

    jj_ntk = -1;

    jj_gen = 0;

    for (int i = 0; i < 18; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

  public void ReInit(java.io.InputStream stream) {

     ReInit(stream, null);

  }

  public void ReInit(java.io.InputStream stream, String encoding) {

    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }

    token_source.ReInit(jj_input_stream);

    token = new Token();

    jj_ntk = -1;

    jj_gen = 0;

    for (int i = 0; i < 18; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

  public ExpressionParser(java.io.Reader stream) {

    jj_input_stream = new SimpleCharStream(stream, 1, 1);

    token_source = new ExpressionParserTokenManager(jj_input_stream);

    token = new Token();

    jj_ntk = -1;

    jj_gen = 0;

    for (int i = 0; i < 18; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

  public void ReInit(java.io.Reader stream) {

    jj_input_stream.ReInit(stream, 1, 1);

    token_source.ReInit(jj_input_stream);

    token = new Token();

    jj_ntk = -1;

    jj_gen = 0;

    for (int i = 0; i < 18; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

  public ExpressionParser(ExpressionParserTokenManager tm) {

    token_source = tm;

    token = new Token();

    jj_ntk = -1;

    jj_gen = 0;

    for (int i = 0; i < 18; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

  public void ReInit(ExpressionParserTokenManager tm) {

    token_source = tm;

    token = new Token();

    jj_ntk = -1;

    jj_gen = 0;

    for (int i = 0; i < 18; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

  final 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();

  final 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;

  }

  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;

  }

  final public Token getToken(int index) {

    Token t = lookingAhead ? jj_scanpos : token;

    for (int i = 0; i < index; i++) {

      if (t.next != null) t = t.next;

      else t = t.next = token_source.getNextToken();

    }

    return t;

  }

  final 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.Vector jj_expentries = new java.util.Vector();

  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];

      }

      boolean exists = false;

      for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) {

        int[] oldentry = (int[])(e.nextElement());

        if (oldentry.length == jj_expentry.length) {

          exists = true;

          for (int i = 0; i < jj_expentry.length; i++) {

            if (oldentry[i] != jj_expentry[i]) {

              exists = false;

              break;

            }

          }

          if (exists) break;

        }

      }

      if (!exists) jj_expentries.addElement(jj_expentry);

      if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;

    }

  }

  public ParseException generateParseException() {

    jj_expentries.removeAllElements();

    boolean[] la1tokens = new boolean[37];

    for (int i = 0; i < 37; i++) {

      la1tokens[i] = false;

    }

    if (jj_kind >= 0) {

      la1tokens[jj_kind] = true;

      jj_kind = -1;

    }

    for (int i = 0; i < 18; 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;

          }

          if ((jj_la1_1[i] & (1<<j)) != 0) {

            la1tokens[32+j] = true;

          }

        }

      }

    }

    for (int i = 0; i < 37; i++) {

      if (la1tokens[i]) {

        jj_expentry = new int[1];

        jj_expentry[0] = i;

        jj_expentries.addElement(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] = (int[])jj_expentries.elementAt(i);

    }

    return new ParseException(token, exptokseq, tokenImage);

  }

  final public void enable_tracing() {

  }

  final public void disable_tracing() {

  }

  final private void jj_rescan_token() {

    jj_rescan = true;

    for (int i = 0; i < 2; 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;

            case 1: jj_3_2(); break;

          }

        }

        p = p.next;

      } while (p != null);

      } catch(LookaheadSuccess ls) { }

    }

    jj_rescan = false;

  }

  final 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;

  }

}