{

    /** flag for enabling the "assert" keyword */

    private boolean assertEnabled = true;

    /** flag for enabling the "enum" keyword */

    private boolean enumEnabled = true;

    /** flag for including whitespace tokens (for IDE preparsing) */

    private boolean whitespaceIncluded = false;

    /** Enable the "assert" keyword */

    public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; }

    /** Query the "assert" keyword state */

    public boolean isAssertEnabled() { return assertEnabled; }

    /** Enable the "enum" keyword */

    public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; }

    /** Query the "enum" keyword state */

    public boolean isEnumEnabled() { return enumEnabled; }

    /** Include whitespace tokens.  Note that this breaks the parser.   */

    public void setWhitespaceIncluded(boolean z) { whitespaceIncluded = z; }

    /** Are whitespace tokens included? */

    public boolean isWhitespaceIncluded() { return whitespaceIncluded; }

    {

        // Initialization actions performed on construction.

        setTabSize(1);  // get rid of special tab interpretation, for IDEs and general clarity

    }

    /** Bumped when inside '[x]' or '(x)', reset inside '{x}'.  See ONE_NL.  */

    protected int parenLevel = 0;

    protected int suppressNewline = 0;  // be really mean to newlines inside strings

    protected static final int SCS_TYPE = 3, SCS_VAL = 4, SCS_LIT = 8, SCS_LIMIT = 16;

    protected static final int SCS_SQ_TYPE = 0, SCS_TQ_TYPE = 1, SCS_RE_TYPE = 2, SCS_DRE_TYPE = 3;

    protected int stringCtorState = 0;  // hack string and regexp constructor boundaries

    /** Push parenLevel here and reset whenever inside '{x}'. */

    protected ArrayList parenLevelStack = new ArrayList();

    protected int lastSigTokenType = EOF;  // last returned non-whitespace token

    public void setTokenObjectClass(String name) {/*ignore*/}

    protected Token makeToken(int t) {

        GroovySourceToken tok = new GroovySourceToken(t);

        tok.setColumn(inputState.getTokenStartColumn());

        tok.setLine(inputState.getTokenStartLine());

        tok.setColumnLast(inputState.getColumn());

        tok.setLineLast(inputState.getLine());

        return tok;

    }

    protected void pushParenLevel() {

        parenLevelStack.add(Integer.valueOf(parenLevel*SCS_LIMIT + stringCtorState));

        parenLevel = 0;

        stringCtorState = 0;

    }

    protected void popParenLevel() {

        int npl = parenLevelStack.size();

        if (npl == 0)  return;

        int i = ((Integer) parenLevelStack.remove(--npl)).intValue();

        parenLevel      = i / SCS_LIMIT;

        stringCtorState = i % SCS_LIMIT;

    }

    protected void restartStringCtor(boolean expectLiteral) {

        if (stringCtorState != 0) {

            stringCtorState = (expectLiteral? SCS_LIT: SCS_VAL) + (stringCtorState & SCS_TYPE);

        }

    }

    protected boolean allowRegexpLiteral() {

        return !isExpressionEndingToken(lastSigTokenType);

    }

    /** Return true for an operator or punctuation which can end an expression.

     *  Return true for keywords, identifiers, and literals.

     *  Return true for tokens which can end expressions (right brackets, ++, --).

     *  Return false for EOF and all other operator and punctuation tokens.

     *  Used to suppress the recognition of /foo/ as opposed to the simple division operator '/'.

     */

    // Cf. 'constant' and 'balancedBrackets' rules in the grammar.)

    protected static boolean isExpressionEndingToken(int ttype) {

        switch (ttype) {

        case INC:               // x++ / y

        case DEC:               // x-- / y

        case RPAREN:            // (x) / y

        case RBRACK:            // f[x] / y

        case RCURLY:            // f{x} / y

        case STRING_LITERAL:    // "x" / y

        case STRING_CTOR_END:   // "$x" / y

        case NUM_INT:           // 0 / y

        case NUM_FLOAT:         // 0f / y

        case NUM_LONG:          // 0l / y

        case NUM_DOUBLE:        // 0.0 / y

        case NUM_BIG_INT:       // 0g / y

        case NUM_BIG_DECIMAL:   // 0.0g / y

        case IDENT:             // x / y

        // and a bunch of keywords (all of them; no sense picking and choosing):

        case LITERAL_as:

        case LITERAL_assert:

        case LITERAL_boolean:

        case LITERAL_break:

        case LITERAL_byte:

        case LITERAL_case:

        case LITERAL_catch: