Examples with NoViableAltException org.antlr.runtime.NoViableAltException used on opensource projects

Example 41 with NoViableAltException

use of org.antlr.runtime.NoViableAltException in project freud by LMAX-Exchange.

the class CssParser method selectop.

// $ANTLR start "selectop"
// /home/langera/dev/freud/src/grammar/Css.g:72:1: selectop : ( '>' -> CHILD | '+' -> ADJACENT_SIBLING );
public final CssParser.selectop_return selectop() throws RecognitionException {
    CssParser.selectop_return retval = new CssParser.selectop_return();
    retval.start = input.LT(1);
    CommonTree root_0 = null;
    Token char_literal29 = null;
    Token char_literal30 = null;
    CommonTree char_literal29_tree = null;
    CommonTree char_literal30_tree = null;
    RewriteRuleTokenStream stream_32 = new RewriteRuleTokenStream(adaptor, "token 32");
    RewriteRuleTokenStream stream_33 = new RewriteRuleTokenStream(adaptor, "token 33");
    try {
        // /home/langera/dev/freud/src/grammar/Css.g:73:2: ( '>' -> CHILD | '+' -> ADJACENT_SIBLING )
        int alt14 = 2;
        int LA14_0 = input.LA(1);
        if ((LA14_0 == 32)) {
            alt14 = 1;
        } else if ((LA14_0 == 33)) {
            alt14 = 2;
        } else {
            NoViableAltException nvae = new NoViableAltException("", 14, 0, input);
            throw nvae;
        }
        switch(alt14) {
            case 1:
                // /home/langera/dev/freud/src/grammar/Css.g:73:4: '>'
                {
                    char_literal29 = (Token) match(input, 32, FOLLOW_32_in_selectop363);
                    stream_32.add(char_literal29);
                    // AST REWRITE
                    // elements:
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                    root_0 = (CommonTree) adaptor.nil();
                    // 73:8: -> CHILD
                    {
                        adaptor.addChild(root_0, (CommonTree) adaptor.create(CHILD, "CHILD"));
                    }
                    retval.tree = root_0;
                }
                break;
            case 2:
                // /home/langera/dev/freud/src/grammar/Css.g:74:11: '+'
                {
                    char_literal30 = (Token) match(input, 33, FOLLOW_33_in_selectop379);
                    stream_33.add(char_literal30);
                    // AST REWRITE
                    // elements:
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                    root_0 = (CommonTree) adaptor.nil();
                    // 74:16: -> ADJACENT_SIBLING
                    {
                        adaptor.addChild(root_0, (CommonTree) adaptor.create(ADJACENT_SIBLING, "ADJACENT_SIBLING"));
                    }
                    retval.tree = root_0;
                }
                break;
        }
        retval.stop = input.LT(-1);
        retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
        adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    } catch (RecognitionException re) {
        reportError(re);
        recover(input, re);
        retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);
    } finally {
    }
    return retval;
}

Example 42 with NoViableAltException

use of org.antlr.runtime.NoViableAltException in project freud by LMAX-Exchange.

the class CssParser method attribRelate.

// $ANTLR start "attribRelate"
// /home/langera/dev/freud/src/grammar/Css.g:97:1: attribRelate : ( '=' -> ATTRIBEQUAL | '~=' -> HASVALUE | '|=' -> BEGINSWITH );
public final CssParser.attribRelate_return attribRelate() throws RecognitionException {
    CssParser.attribRelate_return retval = new CssParser.attribRelate_return();
    retval.start = input.LT(1);
    CommonTree root_0 = null;
    Token char_literal51 = null;
    Token string_literal52 = null;
    Token string_literal53 = null;
    CommonTree char_literal51_tree = null;
    CommonTree string_literal52_tree = null;
    CommonTree string_literal53_tree = null;
    RewriteRuleTokenStream stream_43 = new RewriteRuleTokenStream(adaptor, "token 43");
    RewriteRuleTokenStream stream_44 = new RewriteRuleTokenStream(adaptor, "token 44");
    RewriteRuleTokenStream stream_42 = new RewriteRuleTokenStream(adaptor, "token 42");
    try {
        // /home/langera/dev/freud/src/grammar/Css.g:98:2: ( '=' -> ATTRIBEQUAL | '~=' -> HASVALUE | '|=' -> BEGINSWITH )
        int alt22 = 3;
        switch(input.LA(1)) {
            case 42:
                {
                    alt22 = 1;
                }
                break;
            case 43:
                {
                    alt22 = 2;
                }
                break;
            case 44:
                {
                    alt22 = 3;
                }
                break;
            default:
                NoViableAltException nvae = new NoViableAltException("", 22, 0, input);
                throw nvae;
        }
        switch(alt22) {
            case 1:
                // /home/langera/dev/freud/src/grammar/Css.g:98:4: '='
                {
                    char_literal51 = (Token) match(input, 42, FOLLOW_42_in_attribRelate581);
                    stream_42.add(char_literal51);
                    // AST REWRITE
                    // elements:
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                    root_0 = (CommonTree) adaptor.nil();
                    // 98:9: -> ATTRIBEQUAL
                    {
                        adaptor.addChild(root_0, (CommonTree) adaptor.create(ATTRIBEQUAL, "ATTRIBEQUAL"));
                    }
                    retval.tree = root_0;
                }
                break;
            case 2:
                // /home/langera/dev/freud/src/grammar/Css.g:99:4: '~='
                {
                    string_literal52 = (Token) match(input, 43, FOLLOW_43_in_attribRelate591);
                    stream_43.add(string_literal52);
                    // AST REWRITE
                    // elements:
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                    root_0 = (CommonTree) adaptor.nil();
                    // 99:9: -> HASVALUE
                    {
                        adaptor.addChild(root_0, (CommonTree) adaptor.create(HASVALUE, "HASVALUE"));
                    }
                    retval.tree = root_0;
                }
                break;
            case 3:
                // /home/langera/dev/freud/src/grammar/Css.g:100:4: '|='
                {
                    string_literal53 = (Token) match(input, 44, FOLLOW_44_in_attribRelate600);
                    stream_44.add(string_literal53);
                    // AST REWRITE
                    // elements:
                    // token labels:
                    // rule labels: retval
                    // token list labels:
                    // rule list labels:
                    // wildcard labels:
                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval != null ? retval.tree : null);
                    root_0 = (CommonTree) adaptor.nil();
                    // 100:9: -> BEGINSWITH
                    {
                        adaptor.addChild(root_0, (CommonTree) adaptor.create(BEGINSWITH, "BEGINSWITH"));
                    }
                    retval.tree = root_0;
                }
                break;
        }
        retval.stop = input.LT(-1);
        retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
        adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    } catch (RecognitionException re) {
        reportError(re);
        recover(input, re);
        retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);
    } finally {
    }
    return retval;
}

Example 43 with NoViableAltException

use of org.antlr.runtime.NoViableAltException in project freud by LMAX-Exchange.

the class JavaParser method genericTypeListClosing.

// $ANTLR start "genericTypeListClosing"
// /home/langera/dev/freud/trunk/src/grammar/Java.g:469:1: genericTypeListClosing : ( GREATER_THAN | SHIFT_RIGHT | BIT_SHIFT_RIGHT | );
public final JavaParser.genericTypeListClosing_return genericTypeListClosing() throws RecognitionException {
    JavaParser.genericTypeListClosing_return retval = new JavaParser.genericTypeListClosing_return();
    retval.start = input.LT(1);
    int genericTypeListClosing_StartIndex = input.index();
    CommonTree root_0 = null;
    Token GREATER_THAN38 = null;
    Token SHIFT_RIGHT39 = null;
    Token BIT_SHIFT_RIGHT40 = null;
    CommonTree GREATER_THAN38_tree = null;
    CommonTree SHIFT_RIGHT39_tree = null;
    CommonTree BIT_SHIFT_RIGHT40_tree = null;
    try {
        if (state.backtracking > 0 && alreadyParsedRule(input, 12)) {
            return retval;
        }
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:473:5: ( GREATER_THAN | SHIFT_RIGHT | BIT_SHIFT_RIGHT | )
        int alt12 = 4;
        switch(input.LA(1)) {
            case GREATER_THAN:
                {
                    int LA12_1 = input.LA(2);
                    if ((synpred14_Java())) {
                        alt12 = 1;
                    } else if ((true)) {
                        alt12 = 4;
                    } else {
                        if (state.backtracking > 0) {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae = new NoViableAltException("", 12, 1, input);
                        throw nvae;
                    }
                }
                break;
            case SHIFT_RIGHT:
                {
                    int LA12_2 = input.LA(2);
                    if ((synpred15_Java())) {
                        alt12 = 2;
                    } else if ((true)) {
                        alt12 = 4;
                    } else {
                        if (state.backtracking > 0) {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae = new NoViableAltException("", 12, 2, input);
                        throw nvae;
                    }
                }
                break;
            case BIT_SHIFT_RIGHT:
                {
                    int LA12_3 = input.LA(2);
                    if ((synpred16_Java())) {
                        alt12 = 3;
                    } else if ((true)) {
                        alt12 = 4;
                    } else {
                        if (state.backtracking > 0) {
                            state.failed = true;
                            return retval;
                        }
                        NoViableAltException nvae = new NoViableAltException("", 12, 3, input);
                        throw nvae;
                    }
                }
                break;
            case EOF:
            case AND:
            case AND_ASSIGN:
            case ASSIGN:
            case BIT_SHIFT_RIGHT_ASSIGN:
            case COLON:
            case COMMA:
            case DIV_ASSIGN:
            case DOT:
            case ELLIPSIS:
            case EQUAL:
            case LBRACK:
            case LCURLY:
            case LOGICAL_AND:
            case LOGICAL_OR:
            case LPAREN:
            case MINUS_ASSIGN:
            case MOD_ASSIGN:
            case NOT_EQUAL:
            case OR:
            case OR_ASSIGN:
            case PLUS_ASSIGN:
            case QUESTION:
            case RBRACK:
            case RCURLY:
            case RPAREN:
            case SEMI:
            case SHIFT_LEFT_ASSIGN:
            case SHIFT_RIGHT_ASSIGN:
            case STAR_ASSIGN:
            case XOR:
            case XOR_ASSIGN:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case EXTENDS:
            case FLOAT:
            case IMPLEMENTS:
            case INT:
            case LONG:
            case SHORT:
            case SUPER:
            case THIS:
            case VOID:
            case IDENT:
                {
                    alt12 = 4;
                }
                break;
            default:
                if (state.backtracking > 0) {
                    state.failed = true;
                    return retval;
                }
                NoViableAltException nvae = new NoViableAltException("", 12, 0, input);
                throw nvae;
        }
        switch(alt12) {
            case 1:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:473:9: GREATER_THAN
                {
                    root_0 = (CommonTree) adaptor.nil();
                    GREATER_THAN38 = (Token) match(input, GREATER_THAN, FOLLOW_GREATER_THAN_in_genericTypeListClosing5060);
                    if (state.failed) {
                        return retval;
                    }
                    if (state.backtracking == 0) {
                        GREATER_THAN38_tree = (CommonTree) adaptor.create(GREATER_THAN38);
                        adaptor.addChild(root_0, GREATER_THAN38_tree);
                    }
                }
                break;
            case 2:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:474:9: SHIFT_RIGHT
                {
                    root_0 = (CommonTree) adaptor.nil();
                    SHIFT_RIGHT39 = (Token) match(input, SHIFT_RIGHT, FOLLOW_SHIFT_RIGHT_in_genericTypeListClosing5070);
                    if (state.failed) {
                        return retval;
                    }
                    if (state.backtracking == 0) {
                        SHIFT_RIGHT39_tree = (CommonTree) adaptor.create(SHIFT_RIGHT39);
                        adaptor.addChild(root_0, SHIFT_RIGHT39_tree);
                    }
                }
                break;
            case 3:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:475:9: BIT_SHIFT_RIGHT
                {
                    root_0 = (CommonTree) adaptor.nil();
                    BIT_SHIFT_RIGHT40 = (Token) match(input, BIT_SHIFT_RIGHT, FOLLOW_BIT_SHIFT_RIGHT_in_genericTypeListClosing5080);
                    if (state.failed) {
                        return retval;
                    }
                    if (state.backtracking == 0) {
                        BIT_SHIFT_RIGHT40_tree = (CommonTree) adaptor.create(BIT_SHIFT_RIGHT40);
                        adaptor.addChild(root_0, BIT_SHIFT_RIGHT40_tree);
                    }
                }
                break;
            case 4:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:477:5:
                {
                    root_0 = (CommonTree) adaptor.nil();
                }
                break;
        }
        retval.stop = input.LT(-1);
        if (state.backtracking == 0) {
            retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
        }
    } catch (RecognitionException re) {
        reportError(re);
        recover(input, re);
        retval.tree = (CommonTree) adaptor.errorNode(input, retval.start, input.LT(-1), re);
    } finally {
        if (state.backtracking > 0) {
            memoize(input, 12, genericTypeListClosing_StartIndex);
        }
    }
    return retval;
}

Example 44 with NoViableAltException

use of org.antlr.runtime.NoViableAltException in project freud by LMAX-Exchange.

the class JavaLexer method mDECIMAL_LITERAL.

// $ANTLR end "HEX_LITERAL"
// $ANTLR start "DECIMAL_LITERAL"
public final void mDECIMAL_LITERAL() throws RecognitionException {
    try {
        int _type = DECIMAL_LITERAL;
        int _channel = DEFAULT_TOKEN_CHANNEL;
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( INTEGER_TYPE_SUFFIX )? )
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( INTEGER_TYPE_SUFFIX )?
        {
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )
            int alt4 = 2;
            int LA4_0 = input.LA(1);
            if ((LA4_0 == '0')) {
                alt4 = 1;
            } else if (((LA4_0 >= '1' && LA4_0 <= '9'))) {
                alt4 = 2;
            } else {
                NoViableAltException nvae = new NoViableAltException("", 4, 0, input);
                throw nvae;
            }
            switch(alt4) {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:20: '0'
                    {
                        match('0');
                    }
                    break;
                case 2:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:26: '1' .. '9' ( '0' .. '9' )*
                    {
                        matchRange('1', '9');
                        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:35: ( '0' .. '9' )*
                        loop3: do {
                            int alt3 = 2;
                            int LA3_0 = input.LA(1);
                            if (((LA3_0 >= '0' && LA3_0 <= '9'))) {
                                alt3 = 1;
                            }
                            switch(alt3) {
                                case 1:
                                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:35: '0' .. '9'
                                    {
                                        matchRange('0', '9');
                                    }
                                    break;
                                default:
                                    break loop3;
                            }
                        } while (true);
                    }
                    break;
            }
            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:46: ( INTEGER_TYPE_SUFFIX )?
            int alt5 = 2;
            int LA5_0 = input.LA(1);
            if ((LA5_0 == 'L' || LA5_0 == 'l')) {
                alt5 = 1;
            }
            switch(alt5) {
                case 1:
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1172:46: INTEGER_TYPE_SUFFIX
                    {
                        mINTEGER_TYPE_SUFFIX();
                    }
                    break;
            }
        }
        state.type = _type;
        state.channel = _channel;
    } finally {
    }
}

Example 45 with NoViableAltException

use of org.antlr.runtime.NoViableAltException in project freud by LMAX-Exchange.

the class JavaParser method synpred228_Java_fragment.

// $ANTLR end synpred220_Java
// $ANTLR start synpred228_Java
public final void synpred228_Java_fragment() throws RecognitionException {
    Token outerDot = null;
    Token Super = null;
    Token innerDot = null;
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1114:13: (outerDot= DOT ( CLASS | genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments ) | THIS | Super= SUPER arguments | innerNewExpression ) )
    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1114:13: outerDot= DOT ( CLASS | genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments ) | THIS | Super= SUPER arguments | innerNewExpression )
    {
        outerDot = (Token) match(input, DOT, FOLLOW_DOT_in_synpred228_Java13556);
        if (state.failed) {
            return;
        }
        // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:13: ( CLASS | genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments ) | THIS | Super= SUPER arguments | innerNewExpression )
        int alt224 = 5;
        switch(input.LA(1)) {
            case CLASS:
                {
                    alt224 = 1;
                }
                break;
            case LESS_THAN:
                {
                    alt224 = 2;
                }
                break;
            case THIS:
                {
                    alt224 = 3;
                }
                break;
            case SUPER:
                {
                    alt224 = 4;
                }
                break;
            case NEW:
                {
                    alt224 = 5;
                }
                break;
            default:
                if (state.backtracking > 0) {
                    state.failed = true;
                    return;
                }
                NoViableAltException nvae = new NoViableAltException("", 224, 0, input);
                throw nvae;
        }
        switch(alt224) {
            case 1:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1115:17: CLASS
                {
                    match(input, CLASS, FOLLOW_CLASS_in_synpred228_Java13574);
                    if (state.failed) {
                        return;
                    }
                }
                break;
            case 2:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1116:17: genericTypeArgumentListSimplified (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments )
                {
                    pushFollow(FOLLOW_genericTypeArgumentListSimplified_in_synpred228_Java13637);
                    genericTypeArgumentListSimplified();
                    state._fsp--;
                    if (state.failed) {
                        return;
                    }
                    // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:17: (Super= SUPER arguments | SUPER innerDot= DOT IDENT arguments | IDENT arguments )
                    int alt223 = 3;
                    int LA223_0 = input.LA(1);
                    if ((LA223_0 == SUPER)) {
                        int LA223_1 = input.LA(2);
                        if ((LA223_1 == DOT)) {
                            alt223 = 2;
                        } else if ((LA223_1 == LPAREN)) {
                            alt223 = 1;
                        } else {
                            if (state.backtracking > 0) {
                                state.failed = true;
                                return;
                            }
                            NoViableAltException nvae = new NoViableAltException("", 223, 1, input);
                            throw nvae;
                        }
                    } else if ((LA223_0 == IDENT)) {
                        alt223 = 3;
                    } else {
                        if (state.backtracking > 0) {
                            state.failed = true;
                            return;
                        }
                        NoViableAltException nvae = new NoViableAltException("", 223, 0, input);
                        throw nvae;
                    }
                    switch(alt223) {
                        case 1:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1117:21: Super= SUPER arguments
                            {
                                Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_synpred228_Java13661);
                                if (state.failed) {
                                    return;
                                }
                                pushFollow(FOLLOW_arguments_in_synpred228_Java13663);
                                arguments();
                                state._fsp--;
                                if (state.failed) {
                                    return;
                                }
                            }
                            break;
                        case 2:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1118:21: SUPER innerDot= DOT IDENT arguments
                            {
                                match(input, SUPER, FOLLOW_SUPER_in_synpred228_Java13713);
                                if (state.failed) {
                                    return;
                                }
                                innerDot = (Token) match(input, DOT, FOLLOW_DOT_in_synpred228_Java13717);
                                if (state.failed) {
                                    return;
                                }
                                match(input, IDENT, FOLLOW_IDENT_in_synpred228_Java13719);
                                if (state.failed) {
                                    return;
                                }
                                pushFollow(FOLLOW_arguments_in_synpred228_Java13721);
                                arguments();
                                state._fsp--;
                                if (state.failed) {
                                    return;
                                }
                            }
                            break;
                        case 3:
                            // /home/langera/dev/freud/trunk/src/grammar/Java.g:1119:21: IDENT arguments
                            {
                                match(input, IDENT, FOLLOW_IDENT_in_synpred228_Java13771);
                                if (state.failed) {
                                    return;
                                }
                                pushFollow(FOLLOW_arguments_in_synpred228_Java13773);
                                arguments();
                                state._fsp--;
                                if (state.failed) {
                                    return;
                                }
                            }
                            break;
                    }
                }
                break;
            case 3:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1121:17: THIS
                {
                    match(input, THIS, FOLLOW_THIS_in_synpred228_Java13848);
                    if (state.failed) {
                        return;
                    }
                }
                break;
            case 4:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1122:17: Super= SUPER arguments
                {
                    Super = (Token) match(input, SUPER, FOLLOW_SUPER_in_synpred228_Java13914);
                    if (state.failed) {
                        return;
                    }
                    pushFollow(FOLLOW_arguments_in_synpred228_Java13916);
                    arguments();
                    state._fsp--;
                    if (state.failed) {
                        return;
                    }
                }
                break;
            case 5:
                // /home/langera/dev/freud/trunk/src/grammar/Java.g:1123:17: innerNewExpression
                {
                    pushFollow(FOLLOW_innerNewExpression_in_synpred228_Java13964);
                    innerNewExpression();
                    state._fsp--;
                    if (state.failed) {
                        return;
                    }
                }
                break;
        }
    }
}