/* Generated By:JJTree&JavaCC: Do not edit this line. ExpressionParser.java */
/**************************************************************************************
 * Copyright (c) Jonas Bonér, Alexandre Vasseur. All rights reserved.                 *
 * http://aspectwerkz.codehaus.org                                                    *
 * ---------------------------------------------------------------------------------- *
 * The software in this package is published under the terms of the LGPL license      *
 * a copy of which has been included with this distribution in the license.txt file.  *
 **************************************************************************************/
package org.codehaus.aspectwerkz.expression.ast;

import java.lang.reflect.Modifier;
import java.io.Reader;
import java.io.StringReader;

/**
 * Usage:
 * 
 * <pre>
 * 
 *      ExpressionParser parser = new ExpressionParser(System.in); // can be only one
 *      ASTRoot root = parser.parse(&quot;call(@RequiresNew public * foo.Bar.*(String, ..) AND withincode(* foo.Baz.within(..)&quot;);
 *      Expression expression = new Expression(root);
 *      ...
 *   
 * </pre>
 * 
 * TODO: the grammar is still fragile
 * 
 * @author <a href="mailto:jboner@codehaus.org">Jonas Bonér </a>
 * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur </a>
 */
public class ExpressionParser/* @bgen(jjtree) */implements ExpressionParserTreeConstants, ExpressionParserConstants {/* @bgen(jjtree) */
    protected static JJTExpressionParserState jjtree = new JJTExpressionParserState();

    public ASTRoot parse(String expression) throws ParseException {
        return parse(new StringReader(expression));
    }

    public ASTRoot parse(Reader reader) throws ParseException {
        ReInit(reader);
        return Root();
    }

    //------------------ Bootstrap ------------------

    /**
     * Entry point.
     */
    static final public ASTRoot Root() throws ParseException {
        /* @bgen(jjtree) Root */
        ASTRoot jjtn000 = new ASTRoot(JJTROOT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            Expression();
            jj_consume_token(0);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            {
                if (true)
                    return jjtn000;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
        throw new Error("Missing return statement in function");
    }

    /**
     * Expression.
     */
    static final public void Expression() throws ParseException {
        /* @bgen(jjtree) Expression */
        ASTExpression jjtn000 = new ASTExpression(JJTEXPRESSION);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            AndExpression();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    //------------------ Logical operators ------------------

    /**
     * AndExpression.
     */
    static final public void AndExpression() throws ParseException {
        ASTAnd jjtn001 = new ASTAnd(JJTAND);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        try {
            OrExpression();
            label_1: while (true) {
                if (jj_2_1(2)) {
                    ;
                } else {
                    break label_1;
                }
                jj_consume_token(AND);
                OrExpression();
            }
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
            }
        }
    }

    /**
     * OrExpression.
     */
    static final public void OrExpression() throws ParseException {
        ASTOr jjtn001 = new ASTOr(JJTOR);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        try {
            UnaryExpression();
            label_2: while (true) {
                if (jj_2_2(2)) {
                    ;
                } else {
                    break label_2;
                }
                jj_consume_token(OR);
                AndExpression();
            }
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, jjtree.nodeArity() > 1);
            }
        }
    }

    /**
     * UnaryExpression.
     */
    static final public void UnaryExpression() throws ParseException {
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case NOT:
                NotExpression();
                break;
            case 80:
                jj_consume_token(80);
                Expression();
                jj_consume_token(81);
                break;
            case EXECUTION:
            case CALL:
            case SET:
            case GET:
            case HANDLER:
            case WITHIN:
            case WITHIN_CODE:
            case STATIC_INITIALIZATION:
            case CFLOW:
            case CFLOW_BELOW:
            case ARGS:
            case POINTCUT_REFERENCE_WITH_ARGS:
            case POINTCUT_REFERENCE:
                Pointcut();
                break;
            default:
                jj_la1[0] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
        }
    }

    /**
     * NotExpression.
     */
    static final public void NotExpression() throws ParseException {
        jj_consume_token(NOT);
        ASTNot jjtn001 = new ASTNot(JJTNOT);
        boolean jjtc001 = true;
        jjtree.openNodeScope(jjtn001);
        try {
            UnaryExpression();
        } catch (Throwable jjte001) {
            if (jjtc001) {
                jjtree.clearNodeScope(jjtn001);
                jjtc001 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte001 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte001;
                }
            }
            if (jjte001 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte001;
                }
            }
            {
                if (true)
                    throw (Error) jjte001;
            }
        } finally {
            if (jjtc001) {
                jjtree.closeNodeScope(jjtn001, true);
            }
        }
    }

    //------------------ Pointcuts ------------------

    /**
     * Pointcut.
     */
    static final public void Pointcut() throws ParseException {
        if (jj_2_3(4)) {
            Call();
        } else if (jj_2_4(4)) {
            Execution();
        } else if (jj_2_5(4)) {
            Set();
        } else if (jj_2_6(4)) {
            Get();
        } else if (jj_2_7(4)) {
            Handler();
        } else if (jj_2_8(4)) {
            Within();
        } else if (jj_2_9(4)) {
            WithinCode();
        } else if (jj_2_10(4)) {
            StaticInitialization();
        } else if (jj_2_11(4)) {
            Cflow();
        } else if (jj_2_12(4)) {
            CflowBelow();
        } else if (jj_2_13(4)) {
            Args();
        } else if (jj_2_14(4)) {
            PointcutReference();
        } else {
            jj_consume_token(-1);
            throw new ParseException();
        }
    }

    /**
     * Pointcut reference.
     */
    static final public void PointcutReference() throws ParseException {
        /* @bgen(jjtree) PointcutReference */
        ASTPointcutReference jjtn000 = new ASTPointcutReference(JJTPOINTCUTREFERENCE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token name;
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case POINTCUT_REFERENCE_WITH_ARGS:
                    name = jj_consume_token(POINTCUT_REFERENCE_WITH_ARGS);
                    break;
                case POINTCUT_REFERENCE:
                    name = jj_consume_token(POINTCUT_REFERENCE);
                    break;
                default:
                    jj_la1[1] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtn000.setName(name.image);
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case EAGER_WILDCARD:
                case ARG_PATTERN:
                case ARG_ARRAY_PATTERN:
                    ArgsParameters();
                    jj_consume_token(ARGS_END);
                    break;
                default:
                    jj_la1[2] = jj_gen;
                    ;
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Execution.
     */
    static final public void Execution() throws ParseException {
        /* @bgen(jjtree) Execution */
        ASTExecution jjtn000 = new ASTExecution(JJTEXECUTION);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(EXECUTION);
            if (jj_2_15(4)) {
                MethodPattern();
            } else {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_PUBLIC:
                    case METHOD_PROTECTED:
                    case METHOD_PRIVATE:
                    case METHOD_SYNCHRONIZED:
                    case METHOD_NOT:
                    case METHOD_ANNOTATION:
                    case METHOD_CLASS_PATTERN:
                        ConstructorPattern();
                        break;
                    default:
                        jj_la1[3] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            }
            jj_consume_token(81);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Call.
     */
    static final public void Call() throws ParseException {
        /* @bgen(jjtree) Call */
        ASTCall jjtn000 = new ASTCall(JJTCALL);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(CALL);
            if (jj_2_16(4)) {
                MethodPattern();
            } else {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_PUBLIC:
                    case METHOD_PROTECTED:
                    case METHOD_PRIVATE:
                    case METHOD_SYNCHRONIZED:
                    case METHOD_NOT:
                    case METHOD_ANNOTATION:
                    case METHOD_CLASS_PATTERN:
                        ConstructorPattern();
                        break;
                    default:
                        jj_la1[4] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            }
            jj_consume_token(81);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Set.
     */
    static final public void Set() throws ParseException {
        /* @bgen(jjtree) Set */
        ASTSet jjtn000 = new ASTSet(JJTSET);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(SET);
            FieldPattern();
            jj_consume_token(FIELD_POINTCUT_END);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Get.
     */
    static final public void Get() throws ParseException {
        /* @bgen(jjtree) Get */
        ASTGet jjtn000 = new ASTGet(JJTGET);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(GET);
            FieldPattern();
            jj_consume_token(FIELD_POINTCUT_END);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Handler.
     */
    static final public void Handler() throws ParseException {
        /* @bgen(jjtree) Handler */
        ASTHandler jjtn000 = new ASTHandler(JJTHANDLER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(HANDLER);
            ClassPattern();
            jj_consume_token(CLASS_POINTCUT_END);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Within.
     */
    static final public void Within() throws ParseException {
        /* @bgen(jjtree) Within */
        ASTWithin jjtn000 = new ASTWithin(JJTWITHIN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(WITHIN);
            ClassPattern();
            jj_consume_token(CLASS_POINTCUT_END);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * WithinCode.
     */
    static final public void WithinCode() throws ParseException {
        /* @bgen(jjtree) WithinCode */
        ASTWithinCode jjtn000 = new ASTWithinCode(JJTWITHINCODE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(WITHIN_CODE);
            MethodPattern();
            jj_consume_token(81);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * StaticInitialization.
     */
    static final public void StaticInitialization() throws ParseException {
        /* @bgen(jjtree) StaticInitialization */
        ASTStaticInitialization jjtn000 = new ASTStaticInitialization(JJTSTATICINITIALIZATION);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(STATIC_INITIALIZATION);
            ClassPattern();
            jj_consume_token(CLASS_POINTCUT_END);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Cflow.
     */
    static final public void Cflow() throws ParseException {
        /* @bgen(jjtree) Cflow */
        ASTCflow jjtn000 = new ASTCflow(JJTCFLOW);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(CFLOW);
            Expression();
            jj_consume_token(81);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * CflowBelow.
     */
    static final public void CflowBelow() throws ParseException {
        /* @bgen(jjtree) CflowBelow */
        ASTCflowBelow jjtn000 = new ASTCflowBelow(JJTCFLOWBELOW);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            jj_consume_token(CFLOW_BELOW);
            Expression();
            jj_consume_token(81);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Args.
     */
    static final public void Args() throws ParseException {
        /* @bgen(jjtree) Args */
        ASTArgs jjtn000 = new ASTArgs(JJTARGS);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            if (jj_2_17(2)) {
                jj_consume_token(ARGS);
                jj_consume_token(ARGS_END);
            } else {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case ARGS:
                        jj_consume_token(ARGS);
                        ArgsParameters();
                        jj_consume_token(ARGS_END);
                        break;
                    default:
                        jj_la1[5] = jj_gen;
                        jj_consume_token(-1);
                        throw new ParseException();
                }
            }
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    //------------------ Patterns ------------------

    /**
     * Class pattern.
     */
    static final public void ClassPattern() throws ParseException {
        /* @bgen(jjtree) ClassPattern */
        ASTClassPattern jjtn000 = new ASTClassPattern(JJTCLASSPATTERN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token pattern;
        try {
            label_3: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case CLASS_ATTRIBUTE:
                        ;
                        break;
                    default:
                        jj_la1[6] = jj_gen;
                        break label_3;
                }
                ClassAttribute();
            }
            label_4: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case CLASS_PRIVATE:
                    case CLASS_PROTECTED:
                    case CLASS_PUBLIC:
                    case CLASS_STATIC:
                    case CLASS_ABSTRACT:
                    case CLASS_FINAL:
                    case CLASS_NOT:
                        ;
                        break;
                    default:
                        jj_la1[7] = jj_gen;
                        break label_4;
                }
                ClassModifier();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case CLASS_PATTERN:
                    pattern = jj_consume_token(CLASS_PATTERN);
                    break;
                case EAGER_WILDCARD:
                    pattern = jj_consume_token(EAGER_WILDCARD);
                    break;
                default:
                    jj_la1[8] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setTypePattern(pattern.image);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Method pattern.
     * 
     * @TODO: split class name and method name.
     * @TODO: handle '+'.
     * @TODO: put method name, return type and declaring class in different nodes.
     */
    static final public void MethodPattern() throws ParseException {
        /* @bgen(jjtree) MethodPattern */
        ASTMethodPattern jjtn000 = new ASTMethodPattern(JJTMETHODPATTERN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token returnType, name;
        try {
            label_5: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_ANNOTATION:
                        ;
                        break;
                    default:
                        jj_la1[9] = jj_gen;
                        break label_5;
                }
                MethodAttribute();
            }
            label_6: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_PUBLIC:
                    case METHOD_PROTECTED:
                    case METHOD_PRIVATE:
                    case METHOD_STATIC:
                    case METHOD_ABSTRACT:
                    case METHOD_FINAL:
                    case METHOD_NATIVE:
                    case METHOD_SYNCHRONIZED:
                    case METHOD_NOT:
                        ;
                        break;
                    default:
                        jj_la1[10] = jj_gen;
                        break label_6;
                }
                MethodModifier();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case METHOD_CLASS_PATTERN:
                    returnType = jj_consume_token(METHOD_CLASS_PATTERN);
                    break;
                case METHOD_ARRAY_CLASS_PATTERN:
                    returnType = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
                    break;
                default:
                    jj_la1[11] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtn000.setReturnTypePattern(returnType.image);
            name = jj_consume_token(METHOD_CLASS_PATTERN);
            jjtn000.setFullNamePattern(name.image);
            Parameters();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Constructor pattern.
     * 
     * @TODO: split class name and constructor name ('new').
     * @TODO: handle '+'.
     * @TODO: put declaring class in a different node.
     */
    static final public void ConstructorPattern() throws ParseException {
        /* @bgen(jjtree) ConstructorPattern */
        ASTConstructorPattern jjtn000 = new ASTConstructorPattern(JJTCONSTRUCTORPATTERN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token name;
        try {
            label_7: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_ANNOTATION:
                        ;
                        break;
                    default:
                        jj_la1[12] = jj_gen;
                        break label_7;
                }
                MethodAttribute();
            }
            label_8: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_PUBLIC:
                    case METHOD_PROTECTED:
                    case METHOD_PRIVATE:
                    case METHOD_SYNCHRONIZED:
                    case METHOD_NOT:
                        ;
                        break;
                    default:
                        jj_la1[13] = jj_gen;
                        break label_8;
                }
                ConstructorModifier();
            }
            name = jj_consume_token(METHOD_CLASS_PATTERN);
            if (!name.image.endsWith("new")) {
                {
                    if (true)
                        throw new RuntimeException("constructor pattern must have 'new' as method name");
                }
            }
            jjtn000.setFullNamePattern(name.image);
            Parameters();
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Field pattern.
     * 
     * @TODO: split class name and field name.
     * @TODO: handle '+'.
     * @TODO: put field name, field type and declaring class in different nodes.
     */
    static final public void FieldPattern() throws ParseException {
        /* @bgen(jjtree) FieldPattern */
        ASTFieldPattern jjtn000 = new ASTFieldPattern(JJTFIELDPATTERN);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token type, name;
        try {
            label_9: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case FIELD_ANNOTATION:
                        ;
                        break;
                    default:
                        jj_la1[14] = jj_gen;
                        break label_9;
                }
                FieldAttribute();
            }
            label_10: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case FIELD_PRIVATE:
                    case FIELD_PROTECTED:
                    case FIELD_PUBLIC:
                    case FIELD_STATIC:
                    case FIELD_ABSTRACT:
                    case FIELD_FINAL:
                    case FIELD_TRANSIENT:
                    case FIELD_NOT:
                        ;
                        break;
                    default:
                        jj_la1[15] = jj_gen;
                        break label_10;
                }
                FieldModifier();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case FIELD_CLASS_PATTERN:
                    type = jj_consume_token(FIELD_CLASS_PATTERN);
                    break;
                case FIELD_ARRAY_CLASS_PATTERN:
                    type = jj_consume_token(FIELD_ARRAY_CLASS_PATTERN);
                    break;
                default:
                    jj_la1[16] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtn000.setFieldTypePattern(type.image);
            name = jj_consume_token(FIELD_CLASS_PATTERN);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setFullNamePattern(name.image);
        } catch (Throwable jjte000) {
            if (jjtc000) {
                jjtree.clearNodeScope(jjtn000);
                jjtc000 = false;
            } else {
                jjtree.popNode();
            }
            if (jjte000 instanceof RuntimeException) {
                {
                    if (true)
                        throw (RuntimeException) jjte000;
                }
            }
            if (jjte000 instanceof ParseException) {
                {
                    if (true)
                        throw (ParseException) jjte000;
                }
            }
            {
                if (true)
                    throw (Error) jjte000;
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Parameters.
     */
    static final public void Parameters() throws ParseException {
        jj_consume_token(PARAMETER_START);
        switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
            case EAGER_WILDCARD:
            case METHOD_CLASS_PATTERN:
            case METHOD_ARRAY_CLASS_PATTERN:
                Parameter();
                label_11: while (true) {
                    switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                        case COMMA:
                            ;
                            break;
                        default:
                            jj_la1[17] = jj_gen;
                            break label_11;
                    }
                    jj_consume_token(COMMA);
                    Parameter();
                }
                break;
            default:
                jj_la1[18] = jj_gen;
                ;
        }
        jj_consume_token(PARAMETER_END);
    }

    /**
     * Parameter pattern.
     */
    static final public void Parameter() throws ParseException {
        /* @bgen(jjtree) Parameter */
        ASTParameter jjtn000 = new ASTParameter(JJTPARAMETER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token parameter;
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case METHOD_CLASS_PATTERN:
                    parameter = jj_consume_token(METHOD_CLASS_PATTERN);
                    break;
                case METHOD_ARRAY_CLASS_PATTERN:
                    parameter = jj_consume_token(METHOD_ARRAY_CLASS_PATTERN);
                    break;
                case EAGER_WILDCARD:
                    parameter = jj_consume_token(EAGER_WILDCARD);
                    break;
                default:
                    jj_la1[19] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setTypePattern(parameter.image);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * ArgsParameters.
     */
    static final public void ArgsParameters() throws ParseException {
        ArgParameter();
        label_12: while (true) {
            if (jj_2_18(2)) {
                ;
            } else {
                break label_12;
            }
            jj_consume_token(COMMA);
            ArgsParameters();
        }
    }

    /**
     * ArgParameter.
     */
    static final public void ArgParameter() throws ParseException {
        /* @bgen(jjtree) ArgParameter */
        ASTArgParameter jjtn000 = new ASTArgParameter(JJTARGPARAMETER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token t;
        try {
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case ARG_PATTERN:
                    t = jj_consume_token(ARG_PATTERN);
                    break;
                case ARG_ARRAY_PATTERN:
                    t = jj_consume_token(ARG_ARRAY_PATTERN);
                    break;
                case EAGER_WILDCARD:
                    t = jj_consume_token(EAGER_WILDCARD);
                    break;
                default:
                    jj_la1[20] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setTypePattern(t.image);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Class annotation.
     */
    static final public void ClassAttribute() throws ParseException {
        /* @bgen(jjtree) Attribute */
        ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token annotation;
        try {
            annotation = jj_consume_token(CLASS_ATTRIBUTE);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setName(annotation.image);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Method annotation.
     */
    static final public void MethodAttribute() throws ParseException {
        /* @bgen(jjtree) Attribute */
        ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token annotation;
        try {
            annotation = jj_consume_token(METHOD_ANNOTATION);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setName(annotation.image);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Field annotation.
     */
    static final public void FieldAttribute() throws ParseException {
        /* @bgen(jjtree) Attribute */
        ASTAttribute jjtn000 = new ASTAttribute(JJTATTRIBUTE);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        Token annotation;
        try {
            annotation = jj_consume_token(FIELD_ANNOTATION);
            jjtree.closeNodeScope(jjtn000, true);
            jjtc000 = false;
            jjtn000.setName(annotation.image);
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Class modifier.
     */
    static final public void ClassModifier() throws ParseException {
        /* @bgen(jjtree) Modifier */
        ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            label_13: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case CLASS_NOT:
                        ;
                        break;
                    default:
                        jj_la1[21] = jj_gen;
                        break label_13;
                }
                jj_consume_token(CLASS_NOT);
                jjtn000.setNot();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case CLASS_PUBLIC:
                    jj_consume_token(CLASS_PUBLIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PUBLIC);
                    break;
                case CLASS_PROTECTED:
                    jj_consume_token(CLASS_PROTECTED);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PROTECTED);
                    break;
                case CLASS_PRIVATE:
                    jj_consume_token(CLASS_PRIVATE);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PRIVATE);
                    break;
                case CLASS_STATIC:
                    jj_consume_token(CLASS_STATIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.STATIC);
                    break;
                case CLASS_ABSTRACT:
                    jj_consume_token(CLASS_ABSTRACT);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.ABSTRACT);
                    break;
                case CLASS_FINAL:
                    jj_consume_token(CLASS_FINAL);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.FINAL);
                    break;
                default:
                    jj_la1[22] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Method modifier.
     */
    static final public void MethodModifier() throws ParseException {
        /* @bgen(jjtree) Modifier */
        ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            label_14: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_NOT:
                        ;
                        break;
                    default:
                        jj_la1[23] = jj_gen;
                        break label_14;
                }
                jj_consume_token(METHOD_NOT);
                jjtn000.setNot();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case METHOD_PUBLIC:
                    jj_consume_token(METHOD_PUBLIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PUBLIC);
                    break;
                case METHOD_PROTECTED:
                    jj_consume_token(METHOD_PROTECTED);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PROTECTED);
                    break;
                case METHOD_PRIVATE:
                    jj_consume_token(METHOD_PRIVATE);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PRIVATE);
                    break;
                case METHOD_STATIC:
                    jj_consume_token(METHOD_STATIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.STATIC);
                    break;
                case METHOD_ABSTRACT:
                    jj_consume_token(METHOD_ABSTRACT);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.ABSTRACT);
                    break;
                case METHOD_FINAL:
                    jj_consume_token(METHOD_FINAL);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.FINAL);
                    break;
                case METHOD_NATIVE:
                    jj_consume_token(METHOD_NATIVE);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.NATIVE);
                    break;
                case METHOD_SYNCHRONIZED:
                    jj_consume_token(METHOD_SYNCHRONIZED);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.SYNCHRONIZED);
                    break;
                default:
                    jj_la1[24] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Constructor modifier.
     */
    static final public void ConstructorModifier() throws ParseException {
        /* @bgen(jjtree) Modifier */
        ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            label_15: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case METHOD_NOT:
                        ;
                        break;
                    default:
                        jj_la1[25] = jj_gen;
                        break label_15;
                }
                jj_consume_token(METHOD_NOT);
                jjtn000.setNot();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case METHOD_PUBLIC:
                    jj_consume_token(METHOD_PUBLIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PUBLIC);
                    break;
                case METHOD_PROTECTED:
                    jj_consume_token(METHOD_PROTECTED);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PROTECTED);
                    break;
                case METHOD_PRIVATE:
                    jj_consume_token(METHOD_PRIVATE);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PRIVATE);
                    break;
                case METHOD_SYNCHRONIZED:
                    jj_consume_token(METHOD_SYNCHRONIZED);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.SYNCHRONIZED);
                    break;
                default:
                    jj_la1[26] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

    /**
     * Field modifier.
     */
    static final public void FieldModifier() throws ParseException {
        /* @bgen(jjtree) Modifier */
        ASTModifier jjtn000 = new ASTModifier(JJTMODIFIER);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        try {
            label_16: while (true) {
                switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                    case FIELD_NOT:
                        ;
                        break;
                    default:
                        jj_la1[27] = jj_gen;
                        break label_16;
                }
                jj_consume_token(FIELD_NOT);
                jjtn000.setNot();
            }
            switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
                case FIELD_PUBLIC:
                    jj_consume_token(FIELD_PUBLIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PUBLIC);
                    break;
                case FIELD_PROTECTED:
                    jj_consume_token(FIELD_PROTECTED);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PROTECTED);
                    break;
                case FIELD_PRIVATE:
                    jj_consume_token(FIELD_PRIVATE);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.PRIVATE);
                    break;
                case FIELD_STATIC:
                    jj_consume_token(FIELD_STATIC);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.STATIC);
                    break;
                case FIELD_ABSTRACT:
                    jj_consume_token(FIELD_ABSTRACT);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.ABSTRACT);
                    break;
                case FIELD_FINAL:
                    jj_consume_token(FIELD_FINAL);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.FINAL);
                    break;
                case FIELD_TRANSIENT:
                    jj_consume_token(FIELD_TRANSIENT);
                    jjtree.closeNodeScope(jjtn000, true);
                    jjtc000 = false;
                    jjtn000.setModifier(Modifier.TRANSIENT);
                    break;
                default:
                    jj_la1[28] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
            }
        } finally {
            if (jjtc000) {
                jjtree.closeNodeScope(jjtn000, true);
            }
        }
    }

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

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

    static final private boolean jj_2_3(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_3();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(2, xla);
        }
    }

    static final private boolean jj_2_4(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_4();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(3, xla);
        }
    }

    static final private boolean jj_2_5(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_5();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(4, xla);
        }
    }

    static final private boolean jj_2_6(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_6();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(5, xla);
        }
    }

    static final private boolean jj_2_7(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_7();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(6, xla);
        }
    }

    static final private boolean jj_2_8(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_8();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(7, xla);
        }
    }

    static final private boolean jj_2_9(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_9();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(8, xla);
        }
    }

    static final private boolean jj_2_10(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_10();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(9, xla);
        }
    }

    static final private boolean jj_2_11(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_11();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(10, xla);
        }
    }

    static final private boolean jj_2_12(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_12();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(11, xla);
        }
    }

    static final private boolean jj_2_13(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_13();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(12, xla);
        }
    }

    static final private boolean jj_2_14(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_14();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(13, xla);
        }
    }

    static final private boolean jj_2_15(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_15();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(14, xla);
        }
    }

    static final private boolean jj_2_16(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_16();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(15, xla);
        }
    }

    static final private boolean jj_2_17(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_17();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(16, xla);
        }
    }

    static final private boolean jj_2_18(int xla) {
        jj_la = xla;
        jj_lastpos = jj_scanpos = token;
        try {
            return !jj_3_18();
        } catch (LookaheadSuccess ls) {
            return true;
        } finally {
            jj_save(17, xla);
        }
    }

    static final private boolean jj_3R_62() {
        if (jj_scan_token(CLASS_ATTRIBUTE))
            return true;
        return false;
    }

    static final private boolean jj_3R_80() {
        if (jj_scan_token(FIELD_ABSTRACT))
            return true;
        return false;
    }

    static final private boolean jj_3R_24() {
        if (jj_scan_token(WITHIN))
            return true;
        if (jj_3R_37())
            return true;
        if (jj_scan_token(CLASS_POINTCUT_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_79() {
        if (jj_scan_token(FIELD_STATIC))
            return true;
        return false;
    }

    static final private boolean jj_3_18() {
        if (jj_scan_token(COMMA))
            return true;
        if (jj_3R_32())
            return true;
        return false;
    }

    static final private boolean jj_3R_23() {
        if (jj_scan_token(HANDLER))
            return true;
        if (jj_3R_37())
            return true;
        if (jj_scan_token(CLASS_POINTCUT_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_78() {
        if (jj_scan_token(FIELD_PRIVATE))
            return true;
        return false;
    }

    static final private boolean jj_3R_44() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_scan_token(76)) {
            jj_scanpos = xsp;
            if (jj_scan_token(77)) {
                jj_scanpos = xsp;
                if (jj_scan_token(7))
                    return true;
            }
        }
        return false;
    }

    static final private boolean jj_3R_77() {
        if (jj_scan_token(FIELD_PROTECTED))
            return true;
        return false;
    }

    static final private boolean jj_3R_22() {
        if (jj_scan_token(GET))
            return true;
        if (jj_3R_36())
            return true;
        if (jj_scan_token(FIELD_POINTCUT_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_76() {
        if (jj_scan_token(FIELD_PUBLIC))
            return true;
        return false;
    }

    static final private boolean jj_3R_32() {
        if (jj_3R_44())
            return true;
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3_18()) {
                jj_scanpos = xsp;
                break;
            }
        }
        return false;
    }

    static final private boolean jj_3R_75() {
        if (jj_scan_token(FIELD_NOT))
            return true;
        return false;
    }

    static final private boolean jj_3R_21() {
        if (jj_scan_token(SET))
            return true;
        if (jj_3R_36())
            return true;
        if (jj_scan_token(FIELD_POINTCUT_END))
            return true;
        return false;
    }

    static final private boolean jj_3_16() {
        if (jj_3R_31())
            return true;
        return false;
    }

    static final private boolean jj_3R_61() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_75()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_3R_76()) {
            jj_scanpos = xsp;
            if (jj_3R_77()) {
                jj_scanpos = xsp;
                if (jj_3R_78()) {
                    jj_scanpos = xsp;
                    if (jj_3R_79()) {
                        jj_scanpos = xsp;
                        if (jj_3R_80()) {
                            jj_scanpos = xsp;
                            if (jj_3R_81()) {
                                jj_scanpos = xsp;
                                if (jj_3R_82())
                                    return true;
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    static final private boolean jj_3R_55() {
        if (jj_3R_73())
            return true;
        return false;
    }

    static final private boolean jj_3_15() {
        if (jj_3R_31())
            return true;
        return false;
    }

    static final private boolean jj_3R_19() {
        if (jj_scan_token(CALL))
            return true;
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_16()) {
            jj_scanpos = xsp;
            if (jj_3R_34())
                return true;
        }
        return false;
    }

    static final private boolean jj_3R_73() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_scan_token(50)) {
            jj_scanpos = xsp;
            if (jj_scan_token(51)) {
                jj_scanpos = xsp;
                if (jj_scan_token(7))
                    return true;
            }
        }
        return false;
    }

    static final private boolean jj_3R_94() {
        if (jj_scan_token(METHOD_SYNCHRONIZED))
            return true;
        return false;
    }

    static final private boolean jj_3R_20() {
        if (jj_scan_token(EXECUTION))
            return true;
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_15()) {
            jj_scanpos = xsp;
            if (jj_3R_35())
                return true;
        }
        return false;
    }

    static final private boolean jj_3R_93() {
        if (jj_scan_token(METHOD_PRIVATE))
            return true;
        return false;
    }

    static final private boolean jj_3R_43() {
        if (jj_scan_token(PARAMETER_START))
            return true;
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_55())
            jj_scanpos = xsp;
        if (jj_scan_token(PARAMETER_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_92() {
        if (jj_scan_token(METHOD_PROTECTED))
            return true;
        return false;
    }

    static final private boolean jj_3R_40() {
        if (jj_3R_32())
            return true;
        if (jj_scan_token(ARGS_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_91() {
        if (jj_scan_token(METHOD_PUBLIC))
            return true;
        return false;
    }

    static final private boolean jj_3R_30() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_scan_token(25)) {
            jj_scanpos = xsp;
            if (jj_scan_token(26))
                return true;
        }
        xsp = jj_scanpos;
        if (jj_3R_40())
            jj_scanpos = xsp;
        return false;
    }

    static final private boolean jj_3R_47() {
        if (jj_3R_57())
            return true;
        return false;
    }

    static final private boolean jj_3R_90() {
        if (jj_scan_token(METHOD_NOT))
            return true;
        return false;
    }

    static final private boolean jj_3R_74() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_90()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_3R_91()) {
            jj_scanpos = xsp;
            if (jj_3R_92()) {
                jj_scanpos = xsp;
                if (jj_3R_93()) {
                    jj_scanpos = xsp;
                    if (jj_3R_94())
                        return true;
                }
            }
        }
        return false;
    }

    static final private boolean jj_3R_50() {
        if (jj_3R_61())
            return true;
        return false;
    }

    static final private boolean jj_3R_49() {
        if (jj_3R_60())
            return true;
        return false;
    }

    static final private boolean jj_3R_36() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_49()) {
                jj_scanpos = xsp;
                break;
            }
        }
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_50()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_scan_token(65)) {
            jj_scanpos = xsp;
            if (jj_scan_token(66))
                return true;
        }
        if (jj_scan_token(FIELD_CLASS_PATTERN))
            return true;
        return false;
    }

    static final private boolean jj_3_14() {
        if (jj_3R_30())
            return true;
        return false;
    }

    static final private boolean jj_3_13() {
        if (jj_3R_29())
            return true;
        return false;
    }

    static final private boolean jj_3_12() {
        if (jj_3R_28())
            return true;
        return false;
    }

    static final private boolean jj_3_11() {
        if (jj_3R_27())
            return true;
        return false;
    }

    static final private boolean jj_3_10() {
        if (jj_3R_26())
            return true;
        return false;
    }

    static final private boolean jj_3R_72() {
        if (jj_scan_token(METHOD_SYNCHRONIZED))
            return true;
        return false;
    }

    static final private boolean jj_3_9() {
        if (jj_3R_25())
            return true;
        return false;
    }

    static final private boolean jj_3_8() {
        if (jj_3R_24())
            return true;
        return false;
    }

    static final private boolean jj_3_7() {
        if (jj_3R_23())
            return true;
        return false;
    }

    static final private boolean jj_3_6() {
        if (jj_3R_22())
            return true;
        return false;
    }

    static final private boolean jj_3_5() {
        if (jj_3R_21())
            return true;
        return false;
    }

    static final private boolean jj_3R_71() {
        if (jj_scan_token(METHOD_NATIVE))
            return true;
        return false;
    }

    static final private boolean jj_3_4() {
        if (jj_3R_20())
            return true;
        return false;
    }

    static final private boolean jj_3_3() {
        if (jj_3R_19())
            return true;
        return false;
    }

    static final private boolean jj_3R_57() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_3()) {
            jj_scanpos = xsp;
            if (jj_3_4()) {
                jj_scanpos = xsp;
                if (jj_3_5()) {
                    jj_scanpos = xsp;
                    if (jj_3_6()) {
                        jj_scanpos = xsp;
                        if (jj_3_7()) {
                            jj_scanpos = xsp;
                            if (jj_3_8()) {
                                jj_scanpos = xsp;
                                if (jj_3_9()) {
                                    jj_scanpos = xsp;
                                    if (jj_3_10()) {
                                        jj_scanpos = xsp;
                                        if (jj_3_11()) {
                                            jj_scanpos = xsp;
                                            if (jj_3_12()) {
                                                jj_scanpos = xsp;
                                                if (jj_3_13()) {
                                                    jj_scanpos = xsp;
                                                    if (jj_3_14())
                                                        return true;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    static final private boolean jj_3R_46() {
        if (jj_scan_token(80))
            return true;
        if (jj_3R_38())
            return true;
        if (jj_scan_token(81))
            return true;
        return false;
    }

    static final private boolean jj_3R_70() {
        if (jj_scan_token(METHOD_FINAL))
            return true;
        return false;
    }

    static final private boolean jj_3_2() {
        if (jj_scan_token(OR))
            return true;
        if (jj_3R_18())
            return true;
        return false;
    }

    static final private boolean jj_3R_59() {
        if (jj_3R_74())
            return true;
        return false;
    }

    static final private boolean jj_3R_69() {
        if (jj_scan_token(METHOD_ABSTRACT))
            return true;
        return false;
    }

    static final private boolean jj_3R_56() {
        if (jj_scan_token(NOT))
            return true;
        if (jj_3R_33())
            return true;
        return false;
    }

    static final private boolean jj_3R_58() {
        if (jj_3R_53())
            return true;
        return false;
    }

    static final private boolean jj_3R_48() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_58()) {
                jj_scanpos = xsp;
                break;
            }
        }
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_59()) {
                jj_scanpos = xsp;
                break;
            }
        }
        if (jj_scan_token(METHOD_CLASS_PATTERN))
            return true;
        if (jj_3R_43())
            return true;
        return false;
    }

    static final private boolean jj_3R_68() {
        if (jj_scan_token(METHOD_STATIC))
            return true;
        return false;
    }

    static final private boolean jj_3_1() {
        if (jj_scan_token(AND))
            return true;
        if (jj_3R_17())
            return true;
        return false;
    }

    static final private boolean jj_3R_33() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3R_45()) {
            jj_scanpos = xsp;
            if (jj_3R_46()) {
                jj_scanpos = xsp;
                if (jj_3R_47())
                    return true;
            }
        }
        return false;
    }

    static final private boolean jj_3R_45() {
        if (jj_3R_56())
            return true;
        return false;
    }

    static final private boolean jj_3R_67() {
        if (jj_scan_token(METHOD_PRIVATE))
            return true;
        return false;
    }

    static final private boolean jj_3R_66() {
        if (jj_scan_token(METHOD_PROTECTED))
            return true;
        return false;
    }

    static final private boolean jj_3R_17() {
        if (jj_3R_33())
            return true;
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3_2()) {
                jj_scanpos = xsp;
                break;
            }
        }
        return false;
    }

    static final private boolean jj_3R_65() {
        if (jj_scan_token(METHOD_PUBLIC))
            return true;
        return false;
    }

    static final private boolean jj_3R_64() {
        if (jj_scan_token(METHOD_NOT))
            return true;
        return false;
    }

    static final private boolean jj_3R_42() {
        if (jj_3R_54())
            return true;
        return false;
    }

    static final private boolean jj_3R_54() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_64()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_3R_65()) {
            jj_scanpos = xsp;
            if (jj_3R_66()) {
                jj_scanpos = xsp;
                if (jj_3R_67()) {
                    jj_scanpos = xsp;
                    if (jj_3R_68()) {
                        jj_scanpos = xsp;
                        if (jj_3R_69()) {
                            jj_scanpos = xsp;
                            if (jj_3R_70()) {
                                jj_scanpos = xsp;
                                if (jj_3R_71()) {
                                    jj_scanpos = xsp;
                                    if (jj_3R_72())
                                        return true;
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }

    static final private boolean jj_3R_18() {
        if (jj_3R_17())
            return true;
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3_1()) {
                jj_scanpos = xsp;
                break;
            }
        }
        return false;
    }

    static final private boolean jj_3R_41() {
        if (jj_3R_53())
            return true;
        return false;
    }

    static final private boolean jj_3R_31() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_41()) {
                jj_scanpos = xsp;
                break;
            }
        }
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_42()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_scan_token(50)) {
            jj_scanpos = xsp;
            if (jj_scan_token(51))
                return true;
        }
        if (jj_scan_token(METHOD_CLASS_PATTERN))
            return true;
        if (jj_3R_43())
            return true;
        return false;
    }

    static final private boolean jj_3R_38() {
        if (jj_3R_18())
            return true;
        return false;
    }

    static final private boolean jj_3R_89() {
        if (jj_scan_token(CLASS_FINAL))
            return true;
        return false;
    }

    static final private boolean jj_3R_88() {
        if (jj_scan_token(CLASS_ABSTRACT))
            return true;
        return false;
    }

    static final private boolean jj_3R_87() {
        if (jj_scan_token(CLASS_STATIC))
            return true;
        return false;
    }

    static final private boolean jj_3R_52() {
        if (jj_3R_63())
            return true;
        return false;
    }

    static final private boolean jj_3R_51() {
        if (jj_3R_62())
            return true;
        return false;
    }

    static final private boolean jj_3R_86() {
        if (jj_scan_token(CLASS_PRIVATE))
            return true;
        return false;
    }

    static final private boolean jj_3R_37() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_51()) {
                jj_scanpos = xsp;
                break;
            }
        }
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_52()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_scan_token(35)) {
            jj_scanpos = xsp;
            if (jj_scan_token(7))
                return true;
        }
        return false;
    }

    static final private boolean jj_3R_85() {
        if (jj_scan_token(CLASS_PROTECTED))
            return true;
        return false;
    }

    static final private boolean jj_3R_84() {
        if (jj_scan_token(CLASS_PUBLIC))
            return true;
        return false;
    }

    static final private boolean jj_3R_39() {
        if (jj_scan_token(ARGS))
            return true;
        if (jj_3R_32())
            return true;
        if (jj_scan_token(ARGS_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_83() {
        if (jj_scan_token(CLASS_NOT))
            return true;
        return false;
    }

    static final private boolean jj_3R_63() {
        Token xsp;
        while (true) {
            xsp = jj_scanpos;
            if (jj_3R_83()) {
                jj_scanpos = xsp;
                break;
            }
        }
        xsp = jj_scanpos;
        if (jj_3R_84()) {
            jj_scanpos = xsp;
            if (jj_3R_85()) {
                jj_scanpos = xsp;
                if (jj_3R_86()) {
                    jj_scanpos = xsp;
                    if (jj_3R_87()) {
                        jj_scanpos = xsp;
                        if (jj_3R_88()) {
                            jj_scanpos = xsp;
                            if (jj_3R_89())
                                return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    static final private boolean jj_3R_29() {
        Token xsp;
        xsp = jj_scanpos;
        if (jj_3_17()) {
            jj_scanpos = xsp;
            if (jj_3R_39())
                return true;
        }
        return false;
    }

    static final private boolean jj_3_17() {
        if (jj_scan_token(ARGS))
            return true;
        if (jj_scan_token(ARGS_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_28() {
        if (jj_scan_token(CFLOW_BELOW))
            return true;
        if (jj_3R_38())
            return true;
        if (jj_scan_token(81))
            return true;
        return false;
    }

    static final private boolean jj_3R_60() {
        if (jj_scan_token(FIELD_ANNOTATION))
            return true;
        return false;
    }

    static final private boolean jj_3R_27() {
        if (jj_scan_token(CFLOW))
            return true;
        if (jj_3R_38())
            return true;
        if (jj_scan_token(81))
            return true;
        return false;
    }

    static final private boolean jj_3R_26() {
        if (jj_scan_token(STATIC_INITIALIZATION))
            return true;
        if (jj_3R_37())
            return true;
        if (jj_scan_token(CLASS_POINTCUT_END))
            return true;
        return false;
    }

    static final private boolean jj_3R_53() {
        if (jj_scan_token(METHOD_ANNOTATION))
            return true;
        return false;
    }

    static final private boolean jj_3R_82() {
        if (jj_scan_token(FIELD_TRANSIENT))
            return true;
        return false;
    }

    static final private boolean jj_3R_25() {
        if (jj_scan_token(WITHIN_CODE))
            return true;
        if (jj_3R_31())
            return true;
        return false;
    }

    static final private boolean jj_3R_34() {
        if (jj_3R_48())
            return true;
        return false;
    }

    static final private boolean jj_3R_81() {
        if (jj_scan_token(FIELD_FINAL))
            return true;
        return false;
    }

    static final private boolean jj_3R_35() {
        if (jj_3R_48())
            return true;
        return false;
    }

    static private boolean jj_initialized_once = false;

    static public ExpressionParserTokenManager token_source;

    static SimpleCharStream jj_input_stream;

    static public Token token, jj_nt;

    static private int jj_ntk;

    static private Token jj_scanpos, jj_lastpos;

    static private int jj_la;

    static public boolean lookingAhead = false;

    static private boolean jj_semLA;

    static private int jj_gen;

    static final private int[] jj_la1 = new int[29];

    static private int[] jj_la1_0;

    static private int[] jj_la1_1;

    static private int[] jj_la1_2;
    static {
        jj_la1_0();
        jj_la1_1();
        jj_la1_2();
    }

    private static void jj_la1_0() {
        jj_la1_0 = new int[] {
            0x63ffc00,
            0x6000000,
            0x80,
            0x0,
            0x0,
            0x200000,
            0x0,
            0xf8000000,
            0x80,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x8,
            0x80,
            0x80,
            0x80,
            0x0,
            0xf8000000,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
        };
    }

    private static void jj_la1_1() {
        jj_la1_1 = new int[] {
            0x0,
            0x0,
            0x0,
            0x5c380,
            0x5c380,
            0x0,
            0x4,
            0x3,
            0x8,
            0x10000,
            0xff80,
            0xc0000,
            0x10000,
            0xc380,
            0x80000000,
            0x7f800000,
            0x0,
            0x0,
            0xc0000,
            0xc0000,
            0x0,
            0x2,
            0x1,
            0x8000,
            0x7f80,
            0x8000,
            0x4380,
            0x40000000,
            0x3f800000,
        };
    }

    private static void jj_la1_2() {
        jj_la1_2 = new int[] {
            0x10000,
            0x0,
            0x3000,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x6,
            0x0,
            0x0,
            0x0,
            0x3000,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
            0x0,
        };
    }

    static final private JJCalls[] jj_2_rtns = new JJCalls[18];

    static private boolean jj_rescan = false;

    static private int jj_gc = 0;

    public ExpressionParser(java.io.InputStream stream) {
        if (jj_initialized_once) {
            System.out.println("ERROR: Second call to constructor of static parser.  You must");
            System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
            System.out.println("       during parser generation.");
            throw new Error();
        }
        jj_initialized_once = true;
        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 < 29; i++)
            jj_la1[i] = -1;
        for (int i = 0; i < jj_2_rtns.length; i++)
            jj_2_rtns[i] = new JJCalls();
    }

    static public void ReInit(java.io.InputStream stream) {
        jj_input_stream.ReInit(stream, 1, 1);
        token_source.ReInit(jj_input_stream);
        token = new Token();
        jj_ntk = -1;
        jjtree.reset();
        jj_gen = 0;
        for (int i = 0; i < 29; 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) {
        if (jj_initialized_once) {
            System.out.println("ERROR: Second call to constructor of static parser.  You must");
            System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
            System.out.println("       during parser generation.");
            throw new Error();
        }
        jj_initialized_once = true;
        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 < 29; i++)
            jj_la1[i] = -1;
        for (int i = 0; i < jj_2_rtns.length; i++)
            jj_2_rtns[i] = new JJCalls();
    }

    static 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;
        jjtree.reset();
        jj_gen = 0;
        for (int i = 0; i < 29; 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) {
        if (jj_initialized_once) {
            System.out.println("ERROR: Second call to constructor of static parser.  You must");
            System.out.println("       either use ReInit() or set the JavaCC option STATIC to false");
            System.out.println("       during parser generation.");
            throw new Error();
        }
        jj_initialized_once = true;
        token_source = tm;
        token = new Token();
        jj_ntk = -1;
        jj_gen = 0;
        for (int i = 0; i < 29; 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;
        jjtree.reset();
        jj_gen = 0;
        for (int i = 0; i < 29; i++)
            jj_la1[i] = -1;
        for (int i = 0; i < jj_2_rtns.length; i++)
            jj_2_rtns[i] = new JJCalls();
    }

    static 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 {
    }

    static final private LookaheadSuccess jj_ls = new LookaheadSuccess();

    static 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;
    }

    static 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;
    }

    static 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;
    }

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

    static private java.util.Vector jj_expentries = new java.util.Vector();

    static private int[] jj_expentry;

    static private int jj_kind = -1;

    static private int[] jj_lasttokens = new int[100];

    static private int jj_endpos;

    static 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;
        }
    }

    static public ParseException generateParseException() {
        jj_expentries.removeAllElements();
        boolean[] la1tokens = new boolean[82];
        for (int i = 0; i < 82; i++) {
            la1tokens[i] = false;
        }
        if (jj_kind >= 0) {
            la1tokens[jj_kind] = true;
            jj_kind = -1;
        }
        for (int i = 0; i < 29; 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;
                    }
                    if ((jj_la1_2[i] & (1 << j)) != 0) {
                        la1tokens[64 + j] = true;
                    }
                }
            }
        }
        for (int i = 0; i < 82; 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);
    }

    static final public void enable_tracing() {
    }

    static final public void disable_tracing() {
    }

    static final private void jj_rescan_token() {
        jj_rescan = true;
        for (int i = 0; i < 18; i++) {
            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;
                        case 2:
                            jj_3_3();
                            break;
                        case 3:
                            jj_3_4();
                            break;
                        case 4:
                            jj_3_5();
                            break;
                        case 5:
                            jj_3_6();
                            break;
                        case 6:
                            jj_3_7();
                            break;
                        case 7:
                            jj_3_8();
                            break;
                        case 8:
                            jj_3_9();
                            break;
                        case 9:
                            jj_3_10();
                            break;
                        case 10:
                            jj_3_11();
                            break;
                        case 11:
                            jj_3_12();
                            break;
                        case 12:
                            jj_3_13();
                            break;
                        case 13:
                            jj_3_14();
                            break;
                        case 14:
                            jj_3_15();
                            break;
                        case 15:
                            jj_3_16();
                            break;
                        case 16:
                            jj_3_17();
                            break;
                        case 17:
                            jj_3_18();
                            break;
                    }
                }
                p = p.next;
            } while (p != null);
        }
        jj_rescan = false;
    }

    static 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;
    }

}