private void mOR () { this.Enter_OR (); this.EnterRule ("OR", 1); this.TraceIn ("OR", 1); try { int _type = OR; int _channel = DefaultTokenChannel; // D:\\Compilers\\Verification\\LTLParser.g:46:4: ( '||' | 'or' ) int alt1 = 2; try { this.DebugEnterDecision (1, decisionCanBacktrack [1]); int LA1_0 = this.input.LA (1); if ((LA1_0 == '|')) alt1 = 1; else if ((LA1_0 == 'o')) alt1 = 2; else { NoViableAltException nvae = new NoViableAltException ("", 1, 0, this.input); this.DebugRecognitionException (nvae); throw nvae; } } finally { this.DebugExitDecision (1); } switch (alt1) { case 1 : this.DebugEnterAlt (1); // D:\\Compilers\\Verification\\LTLParser.g:46:6: '||' { this.DebugLocation (46, 6); this.Match ("||"); } break; case 2 : this.DebugEnterAlt (2); // D:\\Compilers\\Verification\\LTLParser.g:46:13: 'or' { this.DebugLocation (46, 13); this.Match ("or"); } break; } this.state.type = _type; this.state.channel = _channel; } finally { this.TraceOut ("OR", 1); this.LeaveRule ("OR", 1); this.Leave_OR (); } }
protected virtual void NoViableAlt(int s, IIntStream input) { if (this.recognizer.state.backtracking > 0) { this.recognizer.state.failed = true; } else { NoViableAltException nvae = new NoViableAltException(this.Description, this.decisionNumber, s, input); this.Error(nvae); throw nvae; } }
protected virtual void NoViableAlt(int s, IIntStream input) { if (this.recognizer.state.backtracking > 0) { this.recognizer.state.failed = true; } else { NoViableAltException nvae = new NoViableAltException(this.Description, this.decisionNumber, s, input); this.Error(nvae); throw nvae; } }
protected virtual void NoViableAlt(int s, IIntStream input) { if (recognizer.state.backtracking > 0) { recognizer.state.failed = true; return; } NoViableAltException nvae = new NoViableAltException(Description, decisionNumber, s, input); Error(nvae); throw nvae; }
public override string GetErrorMessage(RecognitionException e, string[] tokenNames) { string msg = null; if (e is MismatchedTokenException) { MismatchedTokenException mte = (MismatchedTokenException)e; msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting " + GetCharErrorDisplay(mte.Expecting); } else if (e is NoViableAltException) { NoViableAltException nvae = (NoViableAltException)e; // for development, can add "decision=<<"+nvae.grammarDecisionDescription+">>" // and "(decision="+nvae.decisionNumber+") and // "state "+nvae.stateNumber msg = "no viable alternative at character " + GetCharErrorDisplay(e.Character); } else if (e is EarlyExitException) { EarlyExitException eee = (EarlyExitException)e; // for development, can add "(decision="+eee.decisionNumber+")" msg = "required (...)+ loop did not match anything at character " + GetCharErrorDisplay(e.Character); } else if (e is MismatchedNotSetException) { MismatchedNotSetException mse = (MismatchedNotSetException)e; msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + mse.Expecting; } else if (e is MismatchedSetException) { MismatchedSetException mse = (MismatchedSetException)e; msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + mse.Expecting; } else if (e is MismatchedRangeException) { MismatchedRangeException mre = (MismatchedRangeException)e; msg = "mismatched character " + GetCharErrorDisplay(e.Character) + " expecting set " + GetCharErrorDisplay(mre.A) + ".." + GetCharErrorDisplay(mre.B); } else { msg = base.GetErrorMessage(e, tokenNames); } return(msg); }
// $ANTLR start "entityChain" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:232:1: entityChain : ( thisKeyword | filteredEntity ) ( '.' filteredEntity )* ; public entityChain_return entityChain() // throws RecognitionException [1] { var retval = new entityChain_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken char_literal77 = null; thisKeyword_return thisKeyword75 = default( thisKeyword_return ); filteredEntity_return filteredEntity76 = default( filteredEntity_return ); filteredEntity_return filteredEntity78 = default( filteredEntity_return ); CommonTree char_literal77_tree = null; try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:2: ( ( thisKeyword | filteredEntity ) ( '.' filteredEntity )* ) // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:5: ( thisKeyword | filteredEntity ) ( '.' filteredEntity )* { root_0 = (CommonTree)adaptor.GetNilNode(); // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:5: ( thisKeyword | filteredEntity ) int alt28 = 2; int LA28_0 = input.LA( 1 ); if ( ( LA28_0 == 91 ) ) alt28 = 1; else if ( ( LA28_0 == ID ) ) alt28 = 2; else { var nvae_d28s0 = new NoViableAltException( "", 28, 0, input ); throw nvae_d28s0; } switch ( alt28 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:7: thisKeyword { PushFollow( FOLLOW_thisKeyword_in_entityChain1224 ); thisKeyword75 = thisKeyword(); state.followingStackPointer--; adaptor.AddChild( root_0, thisKeyword75.Tree ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:21: filteredEntity { PushFollow( FOLLOW_filteredEntity_in_entityChain1228 ); filteredEntity76 = filteredEntity(); state.followingStackPointer--; adaptor.AddChild( root_0, filteredEntity76.Tree ); } break; } // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:38: ( '.' filteredEntity )* do { int alt29 = 2; int LA29_0 = input.LA( 1 ); if ( ( LA29_0 == 90 ) ) alt29 = 1; switch ( alt29 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:233:40: '.' filteredEntity { char_literal77 = (IToken)Match( input, 90, FOLLOW_90_in_entityChain1234 ); char_literal77_tree = (CommonTree)adaptor.Create( char_literal77 ); root_0 = (CommonTree)adaptor.BecomeRoot( char_literal77_tree, root_0 ); PushFollow( FOLLOW_filteredEntity_in_entityChain1237 ); filteredEntity78 = filteredEntity(); state.followingStackPointer--; adaptor.AddChild( root_0, filteredEntity78.Tree ); } break; default: goto loop29; } } while ( true ); loop29: ; // Stops C# compiler whining that label 'loop29' has no statements } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "rootLevelStatement" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:71:1: rootLevelStatement : ( formulaDeclaration | classDeclaration ); public rootLevelStatement_return rootLevelStatement() // throws RecognitionException [1] { var retval = new rootLevelStatement_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; formulaDeclaration_return formulaDeclaration2 = default( formulaDeclaration_return ); classDeclaration_return classDeclaration3 = default( classDeclaration_return ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:72:2: ( formulaDeclaration | classDeclaration ) int alt2 = 2; int LA2_0 = input.LA( 1 ); if ( ( LA2_0 == ID ) ) alt2 = 1; else if ( ( LA2_0 == 57 ) ) alt2 = 2; else { var nvae_d2s0 = new NoViableAltException( "", 2, 0, input ); throw nvae_d2s0; } switch ( alt2 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:72:4: formulaDeclaration { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_formulaDeclaration_in_rootLevelStatement242 ); formulaDeclaration2 = formulaDeclaration(); state.followingStackPointer--; adaptor.AddChild( root_0, formulaDeclaration2.Tree ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:73:4: classDeclaration { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_classDeclaration_in_rootLevelStatement248 ); classDeclaration3 = classDeclaration(); state.followingStackPointer--; adaptor.AddChild( root_0, classDeclaration3.Tree ); } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "modulusOp" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:185:1: modulusOp : (x= 'mod' -> OP_MODULUS[$x] | x= '%' -> OP_MODULUS[$x] ); public modulusOp_return modulusOp() // throws RecognitionException [1] { var retval = new modulusOp_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken x = null; CommonTree x_tree = null; var stream_78 = new RewriteRuleTokenStream( adaptor, "token 78" ); var stream_77 = new RewriteRuleTokenStream( adaptor, "token 77" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:186:2: (x= 'mod' -> OP_MODULUS[$x] | x= '%' -> OP_MODULUS[$x] ) int alt25 = 2; int LA25_0 = input.LA( 1 ); if ( ( LA25_0 == 77 ) ) alt25 = 1; else if ( ( LA25_0 == 78 ) ) alt25 = 2; else { var nvae_d25s0 = new NoViableAltException( "", 25, 0, input ); throw nvae_d25s0; } switch ( alt25 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:186:4: x= 'mod' { x = (IToken)Match( input, 77, FOLLOW_77_in_modulusOp957 ); stream_77.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 186:12: -> OP_MODULUS[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_MODULUS, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:187:4: x= '%' { x = (IToken)Match( input, 78, FOLLOW_78_in_modulusOp969 ); stream_78.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 187:12: -> OP_MODULUS[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_MODULUS, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "orOp" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:177:1: orOp : (x= 'or' -> OP_OR[$x] | x= '||' -> OP_OR[$x] ); public orOp_return orOp() // throws RecognitionException [1] { var retval = new orOp_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken x = null; CommonTree x_tree = null; var stream_73 = new RewriteRuleTokenStream( adaptor, "token 73" ); var stream_74 = new RewriteRuleTokenStream( adaptor, "token 74" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:178:2: (x= 'or' -> OP_OR[$x] | x= '||' -> OP_OR[$x] ) int alt23 = 2; int LA23_0 = input.LA( 1 ); if ( ( LA23_0 == 73 ) ) alt23 = 1; else if ( ( LA23_0 == 74 ) ) alt23 = 2; else { var nvae_d23s0 = new NoViableAltException( "", 23, 0, input ); throw nvae_d23s0; } switch ( alt23 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:178:4: x= 'or' { x = (IToken)Match( input, 73, FOLLOW_73_in_orOp898 ); stream_73.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 178:11: -> OP_OR[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_OR, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:179:4: x= '||' { x = (IToken)Match( input, 74, FOLLOW_74_in_orOp910 ); stream_74.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 179:11: -> OP_OR[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_OR, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "multiplicativeExpr" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:150:1: multiplicativeExpr : unaryExpr ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )* ; public multiplicativeExpr_return multiplicativeExpr() // throws RecognitionException [1] { var retval = new multiplicativeExpr_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; unaryExpr_return unaryExpr58 = default( unaryExpr_return ); multiplyOp_return multiplyOp59 = default( multiplyOp_return ); divideOp_return divideOp60 = default( divideOp_return ); modulusOp_return modulusOp61 = default( modulusOp_return ); unaryExpr_return unaryExpr62 = default( unaryExpr_return ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:2: ( unaryExpr ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )* ) // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:4: unaryExpr ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )* { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_unaryExpr_in_multiplicativeExpr749 ); unaryExpr58 = unaryExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, unaryExpr58.Tree ); // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:14: ( ( multiplyOp | divideOp | modulusOp ) unaryExpr )* do { int alt18 = 2; int LA18_0 = input.LA( 1 ); if ( ( ( LA18_0 >= 77 && LA18_0 <= 78 ) || ( LA18_0 >= 88 && LA18_0 <= 89 ) ) ) alt18 = 1; switch ( alt18 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:16: ( multiplyOp | divideOp | modulusOp ) unaryExpr { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:16: ( multiplyOp | divideOp | modulusOp ) int alt17 = 3; switch ( input.LA( 1 ) ) { case 88: { alt17 = 1; } break; case 89: { alt17 = 2; } break; case 77: case 78: { alt17 = 3; } break; default: var nvae_d17s0 = new NoViableAltException( "", 17, 0, input ); throw nvae_d17s0; } switch ( alt17 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:18: multiplyOp { PushFollow( FOLLOW_multiplyOp_in_multiplicativeExpr755 ); multiplyOp59 = multiplyOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( multiplyOp59.Tree, root_0 ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:32: divideOp { PushFollow( FOLLOW_divideOp_in_multiplicativeExpr760 ); divideOp60 = divideOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( divideOp60.Tree, root_0 ); } break; case 3: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:151:44: modulusOp { PushFollow( FOLLOW_modulusOp_in_multiplicativeExpr765 ); modulusOp61 = modulusOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( modulusOp61.Tree, root_0 ); } break; } PushFollow( FOLLOW_unaryExpr_in_multiplicativeExpr770 ); unaryExpr62 = unaryExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, unaryExpr62.Tree ); } break; default: goto loop18; } } while ( true ); loop18: ; // Stops C# compiler whining that label 'loop18' has no statements } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "relationalExpr" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:144:1: relationalExpr : additiveExpr ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )* ; public relationalExpr_return relationalExpr() // throws RecognitionException [1] { var retval = new relationalExpr_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; additiveExpr_return additiveExpr48 = default( additiveExpr_return ); ltOp_return ltOp49 = default( ltOp_return ); gtOp_return gtOp50 = default( gtOp_return ); lteOp_return lteOp51 = default( lteOp_return ); gteOp_return gteOp52 = default( gteOp_return ); additiveExpr_return additiveExpr53 = default( additiveExpr_return ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:2: ( additiveExpr ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )* ) // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:4: additiveExpr ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )* { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_additiveExpr_in_relationalExpr679 ); additiveExpr48 = additiveExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, additiveExpr48.Tree ); // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:17: ( ( ltOp | gtOp | lteOp | gteOp ) additiveExpr )* do { int alt14 = 2; int LA14_0 = input.LA( 1 ); if ( ( ( LA14_0 >= 82 && LA14_0 <= 85 ) ) ) alt14 = 1; switch ( alt14 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:19: ( ltOp | gtOp | lteOp | gteOp ) additiveExpr { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:19: ( ltOp | gtOp | lteOp | gteOp ) int alt13 = 4; switch ( input.LA( 1 ) ) { case 82: { alt13 = 1; } break; case 83: { alt13 = 2; } break; case 84: { alt13 = 3; } break; case 85: { alt13 = 4; } break; default: var nvae_d13s0 = new NoViableAltException( "", 13, 0, input ); throw nvae_d13s0; } switch ( alt13 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:21: ltOp { PushFollow( FOLLOW_ltOp_in_relationalExpr685 ); ltOp49 = ltOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( ltOp49.Tree, root_0 ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:29: gtOp { PushFollow( FOLLOW_gtOp_in_relationalExpr690 ); gtOp50 = gtOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( gtOp50.Tree, root_0 ); } break; case 3: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:37: lteOp { PushFollow( FOLLOW_lteOp_in_relationalExpr695 ); lteOp51 = lteOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( lteOp51.Tree, root_0 ); } break; case 4: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:145:46: gteOp { PushFollow( FOLLOW_gteOp_in_relationalExpr700 ); gteOp52 = gteOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( gteOp52.Tree, root_0 ); } break; } PushFollow( FOLLOW_additiveExpr_in_relationalExpr705 ); additiveExpr53 = additiveExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, additiveExpr53.Tree ); } break; default: goto loop14; } } while ( true ); loop14: ; // Stops C# compiler whining that label 'loop14' has no statements } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
private int SpecialStateTransition20(DFA dfa, int s, IIntStream _input) { ITokenStream input = (ITokenStream)_input; int _s = s; s = -1; int LA20_1 = input.LA(1); int index20_1 = input.Index; switch (_s) { case 0: { input.Rewind(); if ((EvaluatePredicate(synpred12_AS3_fragment))) {s = 62;} else if ((true)) {s = 2;} input.Seek(index20_1); break; } default: break; } if (s >= 0) return s; if (state.backtracking > 0) {state.failed=true; return -1;} NoViableAltException nvae = new NoViableAltException(dfa.Description, 20, _s, input); dfa.Error(nvae); throw nvae; }
/** <summary>A hook for debugging interface</summary> */ public virtual void Error(NoViableAltException nvae) { }
/// <summary> /// What error message should be generated for the various exception types? /// /// Not very object-oriented code, but I like having all error message generation /// within one method rather than spread among all of the exception classes. This /// also makes it much easier for the exception handling because the exception /// classes do not have to have pointers back to this object to access utility /// routines and so on. Also, changing the message for an exception type would be /// difficult because you would have to subclassing exception, but then somehow get /// ANTLR to make those kinds of exception objects instead of the default. /// /// This looks weird, but trust me--it makes the most sense in terms of flexibility. /// /// For grammar debugging, you will want to override this to add more information /// such as the stack frame with GetRuleInvocationStack(e, this.GetType().Fullname) /// and, for no viable alts, the decision description and state etc... /// /// Override this to change the message generated for one or more exception types. /// </summary> public virtual string GetErrorMessage(RecognitionException e, string[] tokenNames) { string msg = e.Message; if (e is UnwantedTokenException) { UnwantedTokenException ute = (UnwantedTokenException)e; string tokenName = "<unknown>"; if (ute.Expecting == Token.EOF) { tokenName = "EOF"; } else { tokenName = tokenNames[ute.Expecting]; } msg = "extraneous input " + GetTokenErrorDisplay(ute.UnexpectedToken) + " expecting " + tokenName; } else if (e is MissingTokenException) { MissingTokenException mte = (MissingTokenException)e; string tokenName = "<unknown>"; if (mte.Expecting == Token.EOF) { tokenName = "EOF"; } else { tokenName = tokenNames[mte.Expecting]; } msg = "missing " + tokenName + " at " + GetTokenErrorDisplay(e.Token); } else if (e is MismatchedTokenException) { MismatchedTokenException mte = (MismatchedTokenException)e; string tokenName = "<unknown>"; if (mte.Expecting == Token.EOF) { tokenName = "EOF"; } else { tokenName = tokenNames[mte.Expecting]; } msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting " + tokenName; } else if (e is MismatchedTreeNodeException) { MismatchedTreeNodeException mtne = (MismatchedTreeNodeException)e; string tokenName = "<unknown>"; if (mtne.expecting == Token.EOF) { tokenName = "EOF"; } else { tokenName = tokenNames[mtne.expecting]; } // The ternary operator is only necessary because of a bug in the .NET framework msg = "mismatched tree node: " + ((mtne.Node != null && mtne.Node.ToString() != null) ? mtne.Node : string.Empty) + " expecting " + tokenName; } else if (e is NoViableAltException) { NoViableAltException nvae = (NoViableAltException)e; // for development, can add "decision=<<"+nvae.grammarDecisionDescription+">>" // and "(decision="+nvae.decisionNumber+") and // "state "+nvae.stateNumber msg = "no viable alternative at input " + GetTokenErrorDisplay(e.Token); } else if (e is EarlyExitException) { EarlyExitException eee = (EarlyExitException)e; // for development, can add "(decision="+eee.decisionNumber+")" msg = "required (...)+ loop did not match anything at input " + GetTokenErrorDisplay(e.Token); } else if (e is MismatchedSetException) { MismatchedSetException mse = (MismatchedSetException)e; msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting set " + mse.expecting; } else if (e is MismatchedNotSetException) { MismatchedNotSetException mse = (MismatchedNotSetException)e; msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + " expecting set " + mse.expecting; } else if (e is FailedPredicateException) { FailedPredicateException fpe = (FailedPredicateException)e; msg = "rule " + fpe.ruleName + " failed predicate: {" + fpe.predicateText + "}?"; } return(msg); }
// $ANTLR start "classLevelStatement" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:88:1: classLevelStatement : ( propertyDeclaration | relationshipDeclaration ); public classLevelStatement_return classLevelStatement() // throws RecognitionException [1] { var retval = new classLevelStatement_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; propertyDeclaration_return propertyDeclaration15 = default( propertyDeclaration_return ); relationshipDeclaration_return relationshipDeclaration16 = default( relationshipDeclaration_return ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:89:2: ( propertyDeclaration | relationshipDeclaration ) int alt5 = 2; int LA5_0 = input.LA( 1 ); if ( ( LA5_0 == 62 ) ) alt5 = 1; else if ( ( LA5_0 == 67 ) ) alt5 = 2; else { var nvae_d5s0 = new NoViableAltException( "", 5, 0, input ); throw nvae_d5s0; } switch ( alt5 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:89:4: propertyDeclaration { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_propertyDeclaration_in_classLevelStatement354 ); propertyDeclaration15 = propertyDeclaration(); state.followingStackPointer--; adaptor.AddChild( root_0, propertyDeclaration15.Tree ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:90:4: relationshipDeclaration { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_relationshipDeclaration_in_classLevelStatement359 ); relationshipDeclaration16 = relationshipDeclaration(); state.followingStackPointer--; adaptor.AddChild( root_0, relationshipDeclaration16.Tree ); } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
public override void Error(NoViableAltException nvae) { DebugRecognitionException(nvae); }
public AstParserRuleReturnScope<CommonTree, IToken> compilationUnit() { EnterRule_compilationUnit(); EnterRule("compilationUnit", 1); TraceIn("compilationUnit", 1); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> as2CompilationUnit1 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> as3CompilationUnit2 = default(AstParserRuleReturnScope<CommonTree, IToken>); RewriteRuleSubtreeStream stream_as2CompilationUnit=new RewriteRuleSubtreeStream(adaptor,"rule as2CompilationUnit"); RewriteRuleSubtreeStream stream_as3CompilationUnit=new RewriteRuleSubtreeStream(adaptor,"rule as3CompilationUnit"); try { DebugEnterRule(GrammarFileName, "compilationUnit"); DebugLocation(114, 1); try { // AS3.g:115:2: ( ( as2CompilationUnit | as3CompilationUnit ) -> ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? ) ) DebugEnterAlt(1); // AS3.g:115:4: ( as2CompilationUnit | as3CompilationUnit ) { DebugLocation(115, 4); // AS3.g:115:4: ( as2CompilationUnit | as3CompilationUnit ) int alt1=2; try { DebugEnterSubRule(1); try { DebugEnterDecision(1, false); int LA1_1 = input.LA(1); if ((LA1_1==CLASS||LA1_1==DYNAMIC||LA1_1==IDENT||LA1_1==IMPORT||(LA1_1>=INCLUDE_DIRECTIVE && LA1_1<=INTERFACE)||LA1_1==INTERNAL||LA1_1==PRIVATE||(LA1_1>=PROTECTED && LA1_1<=PUBLIC)||LA1_1==STATIC||(LA1_1>=244 && LA1_1<=246)||LA1_1==250||LA1_1==252)) { alt1 = 1; } else if ((LA1_1==PACKAGE)) { alt1 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 1, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(1); } switch (alt1) { case 1: DebugEnterAlt(1); // AS3.g:115:6: as2CompilationUnit { DebugLocation(115, 6); PushFollow(Follow._as2CompilationUnit_in_compilationUnit476); as2CompilationUnit1=as2CompilationUnit(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_as2CompilationUnit.Add(as2CompilationUnit1.Tree); } break; case 2: DebugEnterAlt(2); // AS3.g:116:5: as3CompilationUnit { DebugLocation(116, 5); PushFollow(Follow._as3CompilationUnit_in_compilationUnit482); as3CompilationUnit2=as3CompilationUnit(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_as3CompilationUnit.Add(as3CompilationUnit2.Tree); } break; } } finally { DebugExitSubRule(1); } { // AST REWRITE // elements: as2CompilationUnit, as3CompilationUnit // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 117:5: -> ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? ) { DebugLocation(117, 8); // AS3.g:117:8: ^( COMPILATION_UNIT ( as2CompilationUnit )? ( as3CompilationUnit )? ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(117, 10); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(COMPILATION_UNIT, "COMPILATION_UNIT"), root_1); DebugLocation(117, 27); // AS3.g:117:27: ( as2CompilationUnit )? if (stream_as2CompilationUnit.HasNext) { DebugLocation(117, 27); adaptor.AddChild(root_1, stream_as2CompilationUnit.NextTree()); } stream_as2CompilationUnit.Reset(); DebugLocation(117, 47); // AS3.g:117:47: ( as3CompilationUnit )? if (stream_as3CompilationUnit.HasNext) { DebugLocation(117, 47); adaptor.AddChild(root_1, stream_as3CompilationUnit.NextTree()); } stream_as3CompilationUnit.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)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 { TraceOut("compilationUnit", 1); LeaveRule("compilationUnit", 1); LeaveRule_compilationUnit(); } DebugLocation(118, 1); } finally { DebugExitRule(GrammarFileName, "compilationUnit"); } return retval; }
// $ANTLR start "equalityExpr" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:141:1: equalityExpr : relationalExpr ( ( equalsOp | notEqualsOp ) relationalExpr )* ; public equalityExpr_return equalityExpr() // throws RecognitionException [1] { var retval = new equalityExpr_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; relationalExpr_return relationalExpr44 = default( relationalExpr_return ); equalsOp_return equalsOp45 = default( equalsOp_return ); notEqualsOp_return notEqualsOp46 = default( notEqualsOp_return ); relationalExpr_return relationalExpr47 = default( relationalExpr_return ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:2: ( relationalExpr ( ( equalsOp | notEqualsOp ) relationalExpr )* ) // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:4: relationalExpr ( ( equalsOp | notEqualsOp ) relationalExpr )* { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_relationalExpr_in_equalityExpr650 ); relationalExpr44 = relationalExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, relationalExpr44.Tree ); // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:19: ( ( equalsOp | notEqualsOp ) relationalExpr )* do { int alt12 = 2; int LA12_0 = input.LA( 1 ); if ( ( LA12_0 == 68 || ( LA12_0 >= 79 && LA12_0 <= 81 ) ) ) alt12 = 1; switch ( alt12 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:21: ( equalsOp | notEqualsOp ) relationalExpr { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:21: ( equalsOp | notEqualsOp ) int alt11 = 2; int LA11_0 = input.LA( 1 ); if ( ( LA11_0 == 68 || LA11_0 == 79 ) ) alt11 = 1; else if ( ( ( LA11_0 >= 80 && LA11_0 <= 81 ) ) ) alt11 = 2; else { var nvae_d11s0 = new NoViableAltException( "", 11, 0, input ); throw nvae_d11s0; } switch ( alt11 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:23: equalsOp { PushFollow( FOLLOW_equalsOp_in_equalityExpr656 ); equalsOp45 = equalsOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( equalsOp45.Tree, root_0 ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:142:35: notEqualsOp { PushFollow( FOLLOW_notEqualsOp_in_equalityExpr661 ); notEqualsOp46 = notEqualsOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( notEqualsOp46.Tree, root_0 ); } break; } PushFollow( FOLLOW_relationalExpr_in_equalityExpr666 ); relationalExpr47 = relationalExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, relationalExpr47.Tree ); } break; default: goto loop12; } } while ( true ); loop12: ; // Stops C# compiler whining that label 'loop12' has no statements } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> parameterDeclaration() { EnterRule_parameterDeclaration(); EnterRule("parameterDeclaration", 34); TraceIn("parameterDeclaration", 34); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> basicParameterDeclaration112 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> parameterRestDeclaration113 = default(AstParserRuleReturnScope<CommonTree, IToken>); try { DebugEnterRule(GrammarFileName, "parameterDeclaration"); DebugLocation(339, 1); try { // AS3.g:340:2: ( basicParameterDeclaration | parameterRestDeclaration ) int alt27=2; try { DebugEnterDecision(27, false); int LA27_1 = input.LA(1); if ((LA27_1==AS||LA27_1==CONST||LA27_1==DYNAMIC||LA27_1==GET||LA27_1==IDENT||LA27_1==IS||LA27_1==NAMESPACE||LA27_1==SET||LA27_1==SUPER||LA27_1==USE||LA27_1==XML)) { alt27 = 1; } else if ((LA27_1==REST)) { alt27 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 27, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(27); } switch (alt27) { case 1: DebugEnterAlt(1); // AS3.g:340:4: basicParameterDeclaration { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(340, 4); PushFollow(Follow._basicParameterDeclaration_in_parameterDeclaration1862); basicParameterDeclaration112=basicParameterDeclaration(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, basicParameterDeclaration112.Tree); } break; case 2: DebugEnterAlt(2); // AS3.g:340:32: parameterRestDeclaration { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(340, 32); PushFollow(Follow._parameterRestDeclaration_in_parameterDeclaration1866); parameterRestDeclaration113=parameterRestDeclaration(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, parameterRestDeclaration113.Tree); } break; } retval.Stop = (IToken)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 { TraceOut("parameterDeclaration", 34); LeaveRule("parameterDeclaration", 34); LeaveRule_parameterDeclaration(); } DebugLocation(341, 1); } finally { DebugExitRule(GrammarFileName, "parameterDeclaration"); } return retval; }
// $ANTLR start "additiveExpr" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:147:1: additiveExpr : multiplicativeExpr ( ( addOp | subtractOp ) multiplicativeExpr )* ; public additiveExpr_return additiveExpr() // throws RecognitionException [1] { var retval = new additiveExpr_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; multiplicativeExpr_return multiplicativeExpr54 = default( multiplicativeExpr_return ); addOp_return addOp55 = default( addOp_return ); subtractOp_return subtractOp56 = default( subtractOp_return ); multiplicativeExpr_return multiplicativeExpr57 = default( multiplicativeExpr_return ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:2: ( multiplicativeExpr ( ( addOp | subtractOp ) multiplicativeExpr )* ) // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:4: multiplicativeExpr ( ( addOp | subtractOp ) multiplicativeExpr )* { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_multiplicativeExpr_in_additiveExpr719 ); multiplicativeExpr54 = multiplicativeExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, multiplicativeExpr54.Tree ); // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:23: ( ( addOp | subtractOp ) multiplicativeExpr )* do { int alt16 = 2; int LA16_0 = input.LA( 1 ); if ( ( ( LA16_0 >= 86 && LA16_0 <= 87 ) ) ) alt16 = 1; switch ( alt16 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:25: ( addOp | subtractOp ) multiplicativeExpr { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:25: ( addOp | subtractOp ) int alt15 = 2; int LA15_0 = input.LA( 1 ); if ( ( LA15_0 == 86 ) ) alt15 = 1; else if ( ( LA15_0 == 87 ) ) alt15 = 2; else { var nvae_d15s0 = new NoViableAltException( "", 15, 0, input ); throw nvae_d15s0; } switch ( alt15 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:27: addOp { PushFollow( FOLLOW_addOp_in_additiveExpr725 ); addOp55 = addOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( addOp55.Tree, root_0 ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:148:36: subtractOp { PushFollow( FOLLOW_subtractOp_in_additiveExpr730 ); subtractOp56 = subtractOp(); state.followingStackPointer--; root_0 = (CommonTree)adaptor.BecomeRoot( subtractOp56.Tree, root_0 ); } break; } PushFollow( FOLLOW_multiplicativeExpr_in_additiveExpr735 ); multiplicativeExpr57 = multiplicativeExpr(); state.followingStackPointer--; adaptor.AddChild( root_0, multiplicativeExpr57.Tree ); } break; default: goto loop16; } } while ( true ); loop16: ; // Stops C# compiler whining that label 'loop16' has no statements } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> statement() { EnterRule_statement(); EnterRule("statement", 41); TraceIn("statement", 41); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> block130 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> declarationStatement131 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> expressionStatement132 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> ifStatement133 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> forEachStatement134 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> whileStatement135 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> doWhileStatement136 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> withStatement137 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> switchStatement138 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> breakStatement139 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> continueStatement140 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> returnStatement141 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> throwStatement142 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> tryStatement143 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> defaultXMLNamespaceStatement144 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> semi145 = default(AstParserRuleReturnScope<CommonTree, IToken>); try { DebugEnterRule(GrammarFileName, "statement"); DebugLocation(371, 1); try { // AS3.g:372:2: ( ( LCURLY )=> block | declarationStatement | expressionStatement | ifStatement | forEachStatement | whileStatement | doWhileStatement | withStatement | switchStatement | breakStatement | continueStatement | returnStatement | throwStatement | tryStatement | defaultXMLNamespaceStatement | semi ) int alt34=16; try { DebugEnterDecision(34, false); switch (input.LA(1)) { case LCURLY: { int LA34_2 = input.LA(2); if ((EvaluatePredicate(synpred13_AS3_fragment))) { alt34 = 1; } else if ((true)) { alt34 = 3; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 34, 1, input, 2); DebugRecognitionException(nvae); throw nvae; } } break; case CONST: case VAR: { alt34 = 2; } break; case AS: case BNOT: case DEC: case DECIMAL_LITERAL: case DYNAMIC: case E4X_ATTRI: case FALSE: case FLOAT_LITERAL: case FUNCTION: case GET: case HEX_LITERAL: case IDENT: case INC: case INTERNAL: case IS: case LBRACK: case LNOT: case LPAREN: case MINUS: case NAMESPACE: case NEW: case NULL: case OCTAL_LITERAL: case PLUS: case PRIVATE: case PROTECTED: case PUBLIC: case REGEX_LITERAL: case SET: case STRING_LITERAL_DOUBLE: case STRING_LITERAL_SINGLE: case SUPER: case TRUE: case USE: case XML: case XML_LITERAL: case 243: case 255: case 256: case 257: { alt34 = 3; } break; case IF: { alt34 = 4; } break; case FOR: { alt34 = 5; } break; case WHILE: { alt34 = 6; } break; case DO: { alt34 = 7; } break; case WITH: { alt34 = 8; } break; case SWITCH: { alt34 = 9; } break; case BREAK: { alt34 = 10; } break; case CONTINUE: { alt34 = 11; } break; case RETURN: { alt34 = 12; } break; case 253: { alt34 = 13; } break; case 254: { alt34 = 14; } break; case DEFAULT: { alt34 = 15; } break; case SEMI: { alt34 = 16; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 34, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(34); } switch (alt34) { case 1: DebugEnterAlt(1); // AS3.g:372:4: ( LCURLY )=> block { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(372, 16); PushFollow(Follow._block_in_statement2037); block130=block(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, block130.Tree); } break; case 2: DebugEnterAlt(2); // AS3.g:374:4: declarationStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(374, 4); PushFollow(Follow._declarationStatement_in_statement2043); declarationStatement131=declarationStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, declarationStatement131.Tree); } break; case 3: DebugEnterAlt(3); // AS3.g:376:4: expressionStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(376, 4); PushFollow(Follow._expressionStatement_in_statement2050); expressionStatement132=expressionStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, expressionStatement132.Tree); } break; case 4: DebugEnterAlt(4); // AS3.g:378:4: ifStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(378, 4); PushFollow(Follow._ifStatement_in_statement2056); ifStatement133=ifStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, ifStatement133.Tree); } break; case 5: DebugEnterAlt(5); // AS3.g:380:4: forEachStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(380, 4); PushFollow(Follow._forEachStatement_in_statement2062); forEachStatement134=forEachStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, forEachStatement134.Tree); } break; case 6: DebugEnterAlt(6); // AS3.g:382:4: whileStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(382, 4); PushFollow(Follow._whileStatement_in_statement2068); whileStatement135=whileStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, whileStatement135.Tree); } break; case 7: DebugEnterAlt(7); // AS3.g:384:4: doWhileStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(384, 4); PushFollow(Follow._doWhileStatement_in_statement2074); doWhileStatement136=doWhileStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, doWhileStatement136.Tree); } break; case 8: DebugEnterAlt(8); // AS3.g:386:4: withStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(386, 4); PushFollow(Follow._withStatement_in_statement2081); withStatement137=withStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, withStatement137.Tree); } break; case 9: DebugEnterAlt(9); // AS3.g:388:4: switchStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(388, 4); PushFollow(Follow._switchStatement_in_statement2088); switchStatement138=switchStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, switchStatement138.Tree); } break; case 10: DebugEnterAlt(10); // AS3.g:390:4: breakStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(390, 4); PushFollow(Follow._breakStatement_in_statement2095); breakStatement139=breakStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, breakStatement139.Tree); } break; case 11: DebugEnterAlt(11); // AS3.g:392:4: continueStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(392, 4); PushFollow(Follow._continueStatement_in_statement2101); continueStatement140=continueStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, continueStatement140.Tree); } break; case 12: DebugEnterAlt(12); // AS3.g:394:4: returnStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(394, 4); PushFollow(Follow._returnStatement_in_statement2107); returnStatement141=returnStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, returnStatement141.Tree); } break; case 13: DebugEnterAlt(13); // AS3.g:396:4: throwStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(396, 4); PushFollow(Follow._throwStatement_in_statement2113); throwStatement142=throwStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, throwStatement142.Tree); } break; case 14: DebugEnterAlt(14); // AS3.g:398:4: tryStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(398, 4); PushFollow(Follow._tryStatement_in_statement2120); tryStatement143=tryStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, tryStatement143.Tree); } break; case 15: DebugEnterAlt(15); // AS3.g:400:4: defaultXMLNamespaceStatement { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(400, 4); PushFollow(Follow._defaultXMLNamespaceStatement_in_statement2127); defaultXMLNamespaceStatement144=defaultXMLNamespaceStatement(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, defaultXMLNamespaceStatement144.Tree); } break; case 16: DebugEnterAlt(16); // AS3.g:402:9: semi { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(402, 9); PushFollow(Follow._semi_in_statement2142); semi145=semi(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, semi145.Tree); } break; } retval.Stop = (IToken)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 { TraceOut("statement", 41); LeaveRule("statement", 41); LeaveRule_statement(); } DebugLocation(404, 1); } finally { DebugExitRule(GrammarFileName, "statement"); } return retval; }
// $ANTLR start "primaryExpr" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:159:1: primaryExpr : ( '(' expression ')' | number | booleanValue | LITERAL | functionCall | entityChain ); public primaryExpr_return primaryExpr() // throws RecognitionException [1] { var retval = new primaryExpr_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken char_literal67 = null; IToken char_literal69 = null; IToken LITERAL72 = null; expression_return expression68 = default( expression_return ); number_return number70 = default( number_return ); booleanValue_return booleanValue71 = default( booleanValue_return ); functionCall_return functionCall73 = default( functionCall_return ); entityChain_return entityChain74 = default( entityChain_return ); CommonTree char_literal67_tree = null; CommonTree char_literal69_tree = null; CommonTree LITERAL72_tree = null; try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:160:2: ( '(' expression ')' | number | booleanValue | LITERAL | functionCall | entityChain ) int alt21 = 6; switch ( input.LA( 1 ) ) { case 69: { alt21 = 1; } break; case INT: case FLOAT: { alt21 = 2; } break; case 95: case 96: { alt21 = 3; } break; case LITERAL: { alt21 = 4; } break; case ID: { int LA21_5 = input.LA( 2 ); if ( ( LA21_5 == 69 ) ) alt21 = 5; else if ( ( LA21_5 == 60 || LA21_5 == 63 || LA21_5 == 68 || LA21_5 == 70 || ( LA21_5 >= 73 && LA21_5 <= 90 ) || ( LA21_5 >= 92 && LA21_5 <= 94 ) ) ) alt21 = 6; else { var nvae_d21s5 = new NoViableAltException( "", 21, 5, input ); throw nvae_d21s5; } } break; case 91: { alt21 = 6; } break; default: var nvae_d21s0 = new NoViableAltException( "", 21, 0, input ); throw nvae_d21s0; } switch ( alt21 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:160:4: '(' expression ')' { root_0 = (CommonTree)adaptor.GetNilNode(); char_literal67 = (IToken)Match( input, 69, FOLLOW_69_in_primaryExpr819 ); PushFollow( FOLLOW_expression_in_primaryExpr822 ); expression68 = expression(); state.followingStackPointer--; adaptor.AddChild( root_0, expression68.Tree ); char_literal69 = (IToken)Match( input, 70, FOLLOW_70_in_primaryExpr824 ); } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:161:4: number { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_number_in_primaryExpr830 ); number70 = number(); state.followingStackPointer--; adaptor.AddChild( root_0, number70.Tree ); } break; case 3: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:162:4: booleanValue { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_booleanValue_in_primaryExpr835 ); booleanValue71 = booleanValue(); state.followingStackPointer--; adaptor.AddChild( root_0, booleanValue71.Tree ); } break; case 4: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:163:4: LITERAL { root_0 = (CommonTree)adaptor.GetNilNode(); LITERAL72 = (IToken)Match( input, LITERAL, FOLLOW_LITERAL_in_primaryExpr840 ); LITERAL72_tree = (CommonTree)adaptor.Create( LITERAL72 ); adaptor.AddChild( root_0, LITERAL72_tree ); } break; case 5: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:164:4: functionCall { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_functionCall_in_primaryExpr845 ); functionCall73 = functionCall(); state.followingStackPointer--; adaptor.AddChild( root_0, functionCall73.Tree ); } break; case 6: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:165:4: entityChain { root_0 = (CommonTree)adaptor.GetNilNode(); PushFollow( FOLLOW_entityChain_in_primaryExpr850 ); entityChain74 = entityChain(); state.followingStackPointer--; adaptor.AddChild( root_0, entityChain74.Tree ); } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> forInClauseDecl() { EnterRule_forInClauseDecl(); EnterRule("forInClauseDecl", 62); TraceIn("forInClauseDecl", 62); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); AstParserRuleReturnScope<CommonTree, IToken> varOrConst206 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> ident207 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> typeExpression208 = default(AstParserRuleReturnScope<CommonTree, IToken>); AstParserRuleReturnScope<CommonTree, IToken> ident209 = default(AstParserRuleReturnScope<CommonTree, IToken>); try { DebugEnterRule(GrammarFileName, "forInClauseDecl"); DebugLocation(522, 1); try { // AS3.g:523:2: ( varOrConst ident ( typeExpression )? | ident ) int alt45=2; try { DebugEnterDecision(45, false); int LA45_1 = input.LA(1); if ((LA45_1==CONST||LA45_1==VAR)) { alt45 = 1; } else if ((LA45_1==AS||LA45_1==DYNAMIC||LA45_1==GET||LA45_1==IDENT||LA45_1==IS||LA45_1==NAMESPACE||LA45_1==SET||LA45_1==SUPER||LA45_1==USE||LA45_1==XML)) { alt45 = 2; } else { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 45, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } finally { DebugExitDecision(45); } switch (alt45) { case 1: DebugEnterAlt(1); // AS3.g:523:4: varOrConst ident ( typeExpression )? { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(523, 4); PushFollow(Follow._varOrConst_in_forInClauseDecl2840); varOrConst206=varOrConst(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, varOrConst206.Tree); DebugLocation(523, 15); PushFollow(Follow._ident_in_forInClauseDecl2842); ident207=ident(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, ident207.Tree); DebugLocation(523, 21); // AS3.g:523:21: ( typeExpression )? int alt44=2; try { DebugEnterSubRule(44); try { DebugEnterDecision(44, false); int LA44_1 = input.LA(1); if ((LA44_1==COLON)) { alt44 = 1; } } finally { DebugExitDecision(44); } switch (alt44) { case 1: DebugEnterAlt(1); // AS3.g:523:21: typeExpression { DebugLocation(523, 21); PushFollow(Follow._typeExpression_in_forInClauseDecl2844); typeExpression208=typeExpression(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, typeExpression208.Tree); } break; } } finally { DebugExitSubRule(44); } } break; case 2: DebugEnterAlt(2); // AS3.g:524:11: ident { root_0 = (CommonTree)adaptor.Nil(); DebugLocation(524, 11); PushFollow(Follow._ident_in_forInClauseDecl2858); ident209=ident(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) adaptor.AddChild(root_0, ident209.Tree); } break; } retval.Stop = (IToken)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 { TraceOut("forInClauseDecl", 62); LeaveRule("forInClauseDecl", 62); LeaveRule_forInClauseDecl(); } DebugLocation(525, 1); } finally { DebugExitRule(GrammarFileName, "forInClauseDecl"); } return retval; }
// $ANTLR start "andOp" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:181:1: andOp : (x= 'and' -> OP_AND[$x] | x= '&&' -> OP_AND[$x] ); public andOp_return andOp() // throws RecognitionException [1] { var retval = new andOp_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken x = null; CommonTree x_tree = null; var stream_75 = new RewriteRuleTokenStream( adaptor, "token 75" ); var stream_76 = new RewriteRuleTokenStream( adaptor, "token 76" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:182:2: (x= 'and' -> OP_AND[$x] | x= '&&' -> OP_AND[$x] ) int alt24 = 2; int LA24_0 = input.LA( 1 ); if ( ( LA24_0 == 75 ) ) alt24 = 1; else if ( ( LA24_0 == 76 ) ) alt24 = 2; else { var nvae_d24s0 = new NoViableAltException( "", 24, 0, input ); throw nvae_d24s0; } switch ( alt24 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:182:4: x= 'and' { x = (IToken)Match( input, 75, FOLLOW_75_in_andOp927 ); stream_75.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 182:12: -> OP_AND[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_AND, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:183:4: x= '&&' { x = (IToken)Match( input, 76, FOLLOW_76_in_andOp939 ); stream_76.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 183:12: -> OP_AND[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_AND, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
private AstParserRuleReturnScope<CommonTree, IToken> typeExpression() { EnterRule_typeExpression(); EnterRule("typeExpression", 71); TraceIn("typeExpression", 71); AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>(); retval.Start = (IToken)input.LT(1); CommonTree root_0 = default(CommonTree); IToken COLON232 = default(IToken); IToken string_literal234 = default(IToken); IToken STAR235 = default(IToken); AstParserRuleReturnScope<CommonTree, IToken> typeIdentifier233 = default(AstParserRuleReturnScope<CommonTree, IToken>); CommonTree COLON232_tree = default(CommonTree); CommonTree string_literal234_tree = default(CommonTree); CommonTree STAR235_tree = default(CommonTree); RewriteRuleITokenStream stream_COLON=new RewriteRuleITokenStream(adaptor,"token COLON"); RewriteRuleITokenStream stream_257=new RewriteRuleITokenStream(adaptor,"token 257"); RewriteRuleITokenStream stream_STAR=new RewriteRuleITokenStream(adaptor,"token STAR"); RewriteRuleSubtreeStream stream_typeIdentifier=new RewriteRuleSubtreeStream(adaptor,"rule typeIdentifier"); try { DebugEnterRule(GrammarFileName, "typeExpression"); DebugLocation(567, 4); try { // AS3.g:568:2: ( COLON ( typeIdentifier | 'void' | STAR ) -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? ) ) DebugEnterAlt(1); // AS3.g:569:3: COLON ( typeIdentifier | 'void' | STAR ) { DebugLocation(569, 3); COLON232=(IToken)Match(input,COLON,Follow._COLON_in_typeExpression3075); if (state.failed) return retval; if (state.backtracking == 0) stream_COLON.Add(COLON232); DebugLocation(569, 9); // AS3.g:569:9: ( typeIdentifier | 'void' | STAR ) int alt49=3; try { DebugEnterSubRule(49); try { DebugEnterDecision(49, false); switch (input.LA(1)) { case AS: case DYNAMIC: case GET: case IDENT: case IS: case NAMESPACE: case SET: case SUPER: case USE: case XML: { alt49 = 1; } break; case 257: { alt49 = 2; } break; case STAR: { alt49 = 3; } break; default: { if (state.backtracking>0) {state.failed=true; return retval;} NoViableAltException nvae = new NoViableAltException("", 49, 0, input, 1); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(49); } switch (alt49) { case 1: DebugEnterAlt(1); // AS3.g:569:10: typeIdentifier { DebugLocation(569, 10); PushFollow(Follow._typeIdentifier_in_typeExpression3078); typeIdentifier233=typeIdentifier(); PopFollow(); if (state.failed) return retval; if (state.backtracking == 0) stream_typeIdentifier.Add(typeIdentifier233.Tree); } break; case 2: DebugEnterAlt(2); // AS3.g:569:27: 'void' { DebugLocation(569, 27); string_literal234=(IToken)Match(input,257,Follow._257_in_typeExpression3082); if (state.failed) return retval; if (state.backtracking == 0) stream_257.Add(string_literal234); } break; case 3: DebugEnterAlt(3); // AS3.g:569:36: STAR { DebugLocation(569, 36); STAR235=(IToken)Match(input,STAR,Follow._STAR_in_typeExpression3086); if (state.failed) return retval; if (state.backtracking == 0) stream_STAR.Add(STAR235); } break; } } finally { DebugExitSubRule(49); } { // AST REWRITE // elements: COLON, typeIdentifier, 257, STAR // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: if (state.backtracking == 0) { retval.Tree = root_0; RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.Tree:null); root_0 = (CommonTree)adaptor.Nil(); // 570:3: -> ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? ) { DebugLocation(570, 6); // AS3.g:570:6: ^( TYPE_SPEC COLON ( typeIdentifier )? ( 'void' )? ( STAR )? ) { CommonTree root_1 = (CommonTree)adaptor.Nil(); DebugLocation(570, 8); root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(TYPE_SPEC, "TYPE_SPEC"), root_1); DebugLocation(570, 18); adaptor.AddChild(root_1, stream_COLON.NextNode()); DebugLocation(570, 24); // AS3.g:570:24: ( typeIdentifier )? if (stream_typeIdentifier.HasNext) { DebugLocation(570, 24); adaptor.AddChild(root_1, stream_typeIdentifier.NextTree()); } stream_typeIdentifier.Reset(); DebugLocation(570, 40); // AS3.g:570:40: ( 'void' )? if (stream_257.HasNext) { DebugLocation(570, 40); adaptor.AddChild(root_1, stream_257.NextNode()); } stream_257.Reset(); DebugLocation(570, 48); // AS3.g:570:48: ( STAR )? if (stream_STAR.HasNext) { DebugLocation(570, 48); adaptor.AddChild(root_1, stream_STAR.NextNode()); } stream_STAR.Reset(); adaptor.AddChild(root_0, root_1); } } retval.Tree = root_0; } } } retval.Stop = (IToken)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 { TraceOut("typeExpression", 71); LeaveRule("typeExpression", 71); LeaveRule_typeExpression(); } DebugLocation(571, 4); } finally { DebugExitRule(GrammarFileName, "typeExpression"); } return retval; }
// $ANTLR start "equalsOp" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:189:1: equalsOp : (x= '==' -> OP_EQ[$x] | x= '=' -> OP_EQ[$x] ); public equalsOp_return equalsOp() // throws RecognitionException [1] { var retval = new equalsOp_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken x = null; CommonTree x_tree = null; var stream_79 = new RewriteRuleTokenStream( adaptor, "token 79" ); var stream_68 = new RewriteRuleTokenStream( adaptor, "token 68" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:190:2: (x= '==' -> OP_EQ[$x] | x= '=' -> OP_EQ[$x] ) int alt26 = 2; int LA26_0 = input.LA( 1 ); if ( ( LA26_0 == 79 ) ) alt26 = 1; else if ( ( LA26_0 == 68 ) ) alt26 = 2; else { var nvae_d26s0 = new NoViableAltException( "", 26, 0, input ); throw nvae_d26s0; } switch ( alt26 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:190:4: x= '==' { x = (IToken)Match( input, 79, FOLLOW_79_in_equalsOp988 ); stream_79.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 190:11: -> OP_EQ[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_EQ, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:191:4: x= '=' { x = (IToken)Match( input, 68, FOLLOW_68_in_equalsOp1001 ); stream_68.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 191:11: -> OP_EQ[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_EQ, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "expr" // Interp.g:34:1: expr returns [Element ret] : ( assignment | structdec | structobjdec | print ); public InterpParser.expr_return expr() // throws RecognitionException [1] { InterpParser.expr_return retval = new InterpParser.expr_return(); retval.Start = input.LT(1); object root_0 = null; InterpParser.assignment_return assignment2 = null; InterpParser.structdec_return structdec3 = null; InterpParser.structobjdec_return structobjdec4 = null; InterpParser.print_return print5 = null; try { // Interp.g:35:3: ( assignment | structdec | structobjdec | print ) int alt2 = 4; switch ( input.LA(1) ) { case VARIABLE: { int LA2_1 = input.LA(2); if ( (LA2_1 == ASSIGNMENT || LA2_1 == 19) ) { alt2 = 1; } else if ( (LA2_1 == VARIABLE) ) { alt2 = 3; } else { NoViableAltException nvae_d2s1 = new NoViableAltException("", 2, 1, input); throw nvae_d2s1; } } break; case 16: { alt2 = 2; } break; case 20: { alt2 = 4; } break; default: NoViableAltException nvae_d2s0 = new NoViableAltException("", 2, 0, input); throw nvae_d2s0; } switch (alt2) { case 1 : // Interp.g:35:5: assignment { root_0 = (object)adaptor.GetNilNode(); PushFollow(FOLLOW_assignment_in_expr92); assignment2 = assignment(); state.followingStackPointer--; adaptor.AddChild(root_0, assignment2.Tree); retval.ret = ((assignment2 != null) ? assignment2.ret : null); } break; case 2 : // Interp.g:36:5: structdec { root_0 = (object)adaptor.GetNilNode(); PushFollow(FOLLOW_structdec_in_expr100); structdec3 = structdec(); state.followingStackPointer--; adaptor.AddChild(root_0, structdec3.Tree); retval.ret = ((structdec3 != null) ? structdec3.ret : null); } break; case 3 : // Interp.g:37:5: structobjdec { root_0 = (object)adaptor.GetNilNode(); PushFollow(FOLLOW_structobjdec_in_expr108); structobjdec4 = structobjdec(); state.followingStackPointer--; adaptor.AddChild(root_0, structobjdec4.Tree); retval.ret = ((structobjdec4 != null) ? structobjdec4.ret : null); } break; case 4 : // Interp.g:38:5: print { root_0 = (object)adaptor.GetNilNode(); PushFollow(FOLLOW_print_in_expr116); print5 = print(); state.followingStackPointer--; adaptor.AddChild(root_0, print5.Tree); retval.ret = ((print5 != null) ? print5.ret : null); } break; } retval.Stop = input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input,re); // Conversion of the second argument necessary, but harmless retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re); } finally { } return retval; }
// $ANTLR start "notEqualsOp" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:193:1: notEqualsOp : (x= '!=' -> OP_NE[$x] | x= '<>' -> OP_NE[$x] ); public notEqualsOp_return notEqualsOp() // throws RecognitionException [1] { var retval = new notEqualsOp_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken x = null; CommonTree x_tree = null; var stream_80 = new RewriteRuleTokenStream( adaptor, "token 80" ); var stream_81 = new RewriteRuleTokenStream( adaptor, "token 81" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:194:2: (x= '!=' -> OP_NE[$x] | x= '<>' -> OP_NE[$x] ) int alt27 = 2; int LA27_0 = input.LA( 1 ); if ( ( LA27_0 == 80 ) ) alt27 = 1; else if ( ( LA27_0 == 81 ) ) alt27 = 2; else { var nvae_d27s0 = new NoViableAltException( "", 27, 0, input ); throw nvae_d27s0; } switch ( alt27 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:194:4: x= '!=' { x = (IToken)Match( input, 80, FOLLOW_80_in_notEqualsOp1019 ); stream_80.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 194:11: -> OP_NE[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_NE, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:195:4: x= '<>' { x = (IToken)Match( input, 81, FOLLOW_81_in_notEqualsOp1031 ); stream_81.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 195:11: -> OP_NE[$x] { adaptor.AddChild( root_0, adaptor.Create( OP_NE, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "assignment" // Interp.g:40:1: assignment returns [AssignmentOperationElement ret] : ( variable | structassign ) ASSIGNMENT ( var_or_int_literal | matrixoperation | addition | multiplication ) END_OF_STATEMENT ; public InterpParser.assignment_return assignment() // throws RecognitionException [1] { InterpParser.assignment_return retval = new InterpParser.assignment_return(); retval.Start = input.LT(1); object root_0 = null; IToken ASSIGNMENT8 = null; IToken END_OF_STATEMENT13 = null; InterpParser.variable_return variable6 = null; InterpParser.structassign_return structassign7 = null; InterpParser.var_or_int_literal_return var_or_int_literal9 = null; InterpParser.matrixoperation_return matrixoperation10 = null; InterpParser.addition_return addition11 = null; InterpParser.multiplication_return multiplication12 = null; object ASSIGNMENT8_tree=null; object END_OF_STATEMENT13_tree=null; retval.ret = new AssignmentOperationElement(); try { // Interp.g:44:3: ( ( variable | structassign ) ASSIGNMENT ( var_or_int_literal | matrixoperation | addition | multiplication ) END_OF_STATEMENT ) // Interp.g:44:5: ( variable | structassign ) ASSIGNMENT ( var_or_int_literal | matrixoperation | addition | multiplication ) END_OF_STATEMENT { root_0 = (object)adaptor.GetNilNode(); // Interp.g:44:5: ( variable | structassign ) int alt3 = 2; int LA3_0 = input.LA(1); if ( (LA3_0 == VARIABLE) ) { int LA3_1 = input.LA(2); if ( (LA3_1 == ASSIGNMENT) ) { alt3 = 1; } else if ( (LA3_1 == 19) ) { alt3 = 2; } else { NoViableAltException nvae_d3s1 = new NoViableAltException("", 3, 1, input); throw nvae_d3s1; } } else { NoViableAltException nvae_d3s0 = new NoViableAltException("", 3, 0, input); throw nvae_d3s0; } switch (alt3) { case 1 : // Interp.g:44:6: variable { PushFollow(FOLLOW_variable_in_assignment138); variable6 = variable(); state.followingStackPointer--; adaptor.AddChild(root_0, variable6.Tree); retval.ret.setLhs(((variable6 != null) ? variable6.ret : null)); } break; case 2 : // Interp.g:45:5: structassign { PushFollow(FOLLOW_structassign_in_assignment146); structassign7 = structassign(); state.followingStackPointer--; adaptor.AddChild(root_0, structassign7.Tree); retval.ret.setStructLhs(((structassign7 != null) ? structassign7.ret : null)); } break; } ASSIGNMENT8=(IToken)Match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_assignment153); ASSIGNMENT8_tree = (object)adaptor.Create(ASSIGNMENT8); adaptor.AddChild(root_0, ASSIGNMENT8_tree); // Interp.g:47:5: ( var_or_int_literal | matrixoperation | addition | multiplication ) int alt4 = 4; switch ( input.LA(1) ) { case VARIABLE: { switch ( input.LA(2) ) { case END_OF_STATEMENT: { alt4 = 1; } break; case MULTIPLY: { alt4 = 4; } break; case PLUS: { alt4 = 3; } break; default: NoViableAltException nvae_d4s1 = new NoViableAltException("", 4, 1, input); throw nvae_d4s1; } } break; case INT_LITERAL: { switch ( input.LA(2) ) { case END_OF_STATEMENT: { alt4 = 1; } break; case MULTIPLY: { alt4 = 4; } break; case PLUS: { alt4 = 3; } break; default: NoViableAltException nvae_d4s2 = new NoViableAltException("", 4, 2, input); throw nvae_d4s2; } } break; case 12: { alt4 = 2; } break; default: NoViableAltException nvae_d4s0 = new NoViableAltException("", 4, 0, input); throw nvae_d4s0; } switch (alt4) { case 1 : // Interp.g:47:6: var_or_int_literal { PushFollow(FOLLOW_var_or_int_literal_in_assignment161); var_or_int_literal9 = var_or_int_literal(); state.followingStackPointer--; adaptor.AddChild(root_0, var_or_int_literal9.Tree); retval.ret.setRhs(((var_or_int_literal9 != null) ? var_or_int_literal9.ret : null)); } break; case 2 : // Interp.g:48:7: matrixoperation { PushFollow(FOLLOW_matrixoperation_in_assignment171); matrixoperation10 = matrixoperation(); state.followingStackPointer--; adaptor.AddChild(root_0, matrixoperation10.Tree); retval.ret.setRhs(((matrixoperation10 != null) ? matrixoperation10.ret : null)); } break; case 3 : // Interp.g:49:7: addition { PushFollow(FOLLOW_addition_in_assignment182); addition11 = addition(); state.followingStackPointer--; adaptor.AddChild(root_0, addition11.Tree); retval.ret.setRhs(((addition11 != null) ? addition11.ret : null)); } break; case 4 : // Interp.g:50:7: multiplication { PushFollow(FOLLOW_multiplication_in_assignment192); multiplication12 = multiplication(); state.followingStackPointer--; adaptor.AddChild(root_0, multiplication12.Tree); retval.ret.setRhs(((multiplication12 != null) ? multiplication12.ret : null)); } break; } END_OF_STATEMENT13=(IToken)Match(input,END_OF_STATEMENT,FOLLOW_END_OF_STATEMENT_in_assignment202); END_OF_STATEMENT13_tree = (object)adaptor.Create(END_OF_STATEMENT13); adaptor.AddChild(root_0, END_OF_STATEMENT13_tree); } retval.Stop = input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input,re); // Conversion of the second argument necessary, but harmless retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re); } finally { } return retval; }
// $ANTLR start "booleanValue" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:269:1: booleanValue : (x= 'true' -> TRUE[$x] | x= 'false' -> FALSE[$x] ); public booleanValue_return booleanValue() // throws RecognitionException [1] { var retval = new booleanValue_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; IToken x = null; CommonTree x_tree = null; var stream_96 = new RewriteRuleTokenStream( adaptor, "token 96" ); var stream_95 = new RewriteRuleTokenStream( adaptor, "token 95" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:270:2: (x= 'true' -> TRUE[$x] | x= 'false' -> FALSE[$x] ) int alt34 = 2; int LA34_0 = input.LA( 1 ); if ( ( LA34_0 == 95 ) ) alt34 = 1; else if ( ( LA34_0 == 96 ) ) alt34 = 2; else { var nvae_d34s0 = new NoViableAltException( "", 34, 0, input ); throw nvae_d34s0; } switch ( alt34 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:270:4: x= 'true' { x = (IToken)Match( input, 95, FOLLOW_95_in_booleanValue1440 ); stream_95.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 270:13: -> TRUE[$x] { adaptor.AddChild( root_0, adaptor.Create( TRUE, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:271:4: x= 'false' { x = (IToken)Match( input, 96, FOLLOW_96_in_booleanValue1452 ); stream_96.Add( x ); // AST REWRITE // elements: // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 271:14: -> FALSE[$x] { adaptor.AddChild( root_0, adaptor.Create( FALSE, x ) ); } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }
// $ANTLR start "var_or_int_literal" // Interp.g:53:1: var_or_int_literal returns [Element ret] : ( variable | int_literal ) ; public InterpParser.var_or_int_literal_return var_or_int_literal() // throws RecognitionException [1] { InterpParser.var_or_int_literal_return retval = new InterpParser.var_or_int_literal_return(); retval.Start = input.LT(1); object root_0 = null; InterpParser.variable_return variable14 = null; InterpParser.int_literal_return int_literal15 = null; try { // Interp.g:54:3: ( ( variable | int_literal ) ) // Interp.g:54:6: ( variable | int_literal ) { root_0 = (object)adaptor.GetNilNode(); // Interp.g:54:6: ( variable | int_literal ) int alt5 = 2; int LA5_0 = input.LA(1); if ( (LA5_0 == VARIABLE) ) { alt5 = 1; } else if ( (LA5_0 == INT_LITERAL) ) { alt5 = 2; } else { NoViableAltException nvae_d5s0 = new NoViableAltException("", 5, 0, input); throw nvae_d5s0; } switch (alt5) { case 1 : // Interp.g:54:7: variable { PushFollow(FOLLOW_variable_in_var_or_int_literal218); variable14 = variable(); state.followingStackPointer--; adaptor.AddChild(root_0, variable14.Tree); retval.ret = ((variable14 != null) ? variable14.ret : null); } break; case 2 : // Interp.g:55:7: int_literal { PushFollow(FOLLOW_int_literal_in_var_or_int_literal229); int_literal15 = int_literal(); state.followingStackPointer--; adaptor.AddChild(root_0, int_literal15.Tree); retval.ret = ((int_literal15 != null) ? int_literal15.ret : null); } break; } } retval.Stop = input.LT(-1); retval.Tree = (object)adaptor.RulePostProcessing(root_0); adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop); } catch (RecognitionException re) { ReportError(re); Recover(input,re); // Conversion of the second argument necessary, but harmless retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re); } finally { } return retval; }
protected internal int DFA8_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException { IIntStream input = _input; int _s = s; switch ( s ) { case 0 : int LA8_6 = input.LA(1); s = -1; if ( ((LA8_6 >= '\u0000' && LA8_6 <= '\uFFFF')) ) { s = 40; } else s = 39; if ( s >= 0 ) return s; break; case 1 : int LA8_7 = input.LA(1); s = -1; if ( ((LA8_7 >= '\u0000' && LA8_7 <= '\uFFFF')) ) { s = 42; } else s = 41; if ( s >= 0 ) return s; break; case 2 : int LA8_0 = input.LA(1); s = -1; if ( (LA8_0 == 'G') ) { s = 1; } else if ( (LA8_0 == 'S') ) { s = 2; } else if ( (LA8_0 == '[') ) { s = 3; } else if ( ((LA8_0 >= '\t' && LA8_0 <= '\n') || LA8_0 == '\r' || LA8_0 == ' ') ) { s = 4; } else if ( (LA8_0 == '%') ) { s = 5; } else if ( (LA8_0 == '\"') ) { s = 6; } else if ( (LA8_0 == '\'') ) { s = 7; } else if ( (LA8_0 == 'C') ) { s = 8; } else if ( (LA8_0 == 'D') ) { s = 9; } else if ( (LA8_0 == 'I') ) { s = 10; } else if ( (LA8_0 == 'P') ) { s = 11; } else if ( (LA8_0 == 'W') ) { s = 12; } else if ( (LA8_0 == 'B') ) { s = 13; } else if ( (LA8_0 == 'F') ) { s = 14; } else if ( (LA8_0 == 'U') ) { s = 15; } else if ( (LA8_0 == 'E') ) { s = 16; } else if ( (LA8_0 == 'M') ) { s = 17; } else if ( (LA8_0 == 'R') ) { s = 18; } else if ( (LA8_0 == 'T') ) { s = 19; } else if ( (LA8_0 == 'N') ) { s = 20; } else if ( (LA8_0 == 'L') ) { s = 21; } else if ( (LA8_0 == 'A' || LA8_0 == 'H' || (LA8_0 >= 'J' && LA8_0 <= 'K') || LA8_0 == 'O' || LA8_0 == 'Q' || LA8_0 == 'V' || (LA8_0 >= 'X' && LA8_0 <= 'Z') || LA8_0 == '_' || (LA8_0 >= 'a' && LA8_0 <= 'z')) ) { s = 22; } else if ( ((LA8_0 >= '0' && LA8_0 <= '9')) ) { s = 23; } else if ( (LA8_0 == '+') ) { s = 24; } else if ( (LA8_0 == '-') ) { s = 25; } else if ( (LA8_0 == '*') ) { s = 26; } else if ( (LA8_0 == '/') ) { s = 27; } else if ( (LA8_0 == '=') ) { s = 28; } else if ( ((LA8_0 >= '\u0000' && LA8_0 <= '\b') || (LA8_0 >= '\u000B' && LA8_0 <= '\f') || (LA8_0 >= '\u000E' && LA8_0 <= '\u001F') || LA8_0 == '!' || (LA8_0 >= '#' && LA8_0 <= '$') || LA8_0 == '&' || (LA8_0 >= '(' && LA8_0 <= ')') || LA8_0 == ',' || LA8_0 == '.' || (LA8_0 >= ':' && LA8_0 <= '<') || (LA8_0 >= '>' && LA8_0 <= '@') || (LA8_0 >= '\\' && LA8_0 <= '^') || LA8_0 == '`' || (LA8_0 >= '{' && LA8_0 <= '\uFFFF')) ) { s = 29; } if ( s >= 0 ) return s; break; } NoViableAltException nvae8 = new NoViableAltException(dfa.Description, 8, _s, input); dfa.Error(nvae8); throw nvae8; }
private void mTYPE() { EnterRule_TYPE(); EnterRule("TYPE", 5); TraceIn("TYPE", 5); try { int _type = TYPE; int _channel = DefaultTokenChannel; // FuncProtoToShim.g:35:6: ( ( 'integer' | 'float' | 'key' | 'vector' | 'rotation' | 'string' | 'list' ) ) DebugEnterAlt(1); // FuncProtoToShim.g:35:8: ( 'integer' | 'float' | 'key' | 'vector' | 'rotation' | 'string' | 'list' ) { DebugLocation(35, 8); // FuncProtoToShim.g:35:8: ( 'integer' | 'float' | 'key' | 'vector' | 'rotation' | 'string' | 'list' ) int alt2=7; try { DebugEnterSubRule(2); try { DebugEnterDecision(2, false); switch (input.LA(1)) { case 'i': { alt2 = 1; } break; case 'f': { alt2 = 2; } break; case 'k': { alt2 = 3; } break; case 'v': { alt2 = 4; } break; case 'r': { alt2 = 5; } break; case 's': { alt2 = 6; } break; case 'l': { alt2 = 7; } break; default: { NoViableAltException nvae = new NoViableAltException("", 2, 0, input); DebugRecognitionException(nvae); throw nvae; } } } finally { DebugExitDecision(2); } switch (alt2) { case 1: DebugEnterAlt(1); // FuncProtoToShim.g:35:9: 'integer' { DebugLocation(35, 9); Match("integer"); } break; case 2: DebugEnterAlt(2); // FuncProtoToShim.g:35:19: 'float' { DebugLocation(35, 19); Match("float"); } break; case 3: DebugEnterAlt(3); // FuncProtoToShim.g:35:27: 'key' { DebugLocation(35, 27); Match("key"); } break; case 4: DebugEnterAlt(4); // FuncProtoToShim.g:35:33: 'vector' { DebugLocation(35, 33); Match("vector"); } break; case 5: DebugEnterAlt(5); // FuncProtoToShim.g:35:42: 'rotation' { DebugLocation(35, 42); Match("rotation"); } break; case 6: DebugEnterAlt(6); // FuncProtoToShim.g:35:53: 'string' { DebugLocation(35, 53); Match("string"); } break; case 7: DebugEnterAlt(7); // FuncProtoToShim.g:35:62: 'list' { DebugLocation(35, 62); Match("list"); } break; } } finally { DebugExitSubRule(2); } } state.type = _type; state.channel = _channel; } finally { TraceOut("TYPE", 5); LeaveRule("TYPE", 5); LeaveRule_TYPE(); } }
private int SpecialStateTransition5(DFA dfa, int s, IIntStream _input) { IIntStream input = _input; int _s = s; switch (s) { case 0: int LA5_31 = input.LA(1); s = -1; if ( ((LA5_31>='\u0000' && LA5_31<='\uFFFF')) ) {s = 63;} else s = 62; if ( s>=0 ) return s; break; } NoViableAltException nvae = new NoViableAltException(dfa.Description, 5, _s, input); dfa.Error(nvae); throw nvae; }
// $ANTLR start "propertyModifiers" // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:100:1: propertyModifiers : ( exclusivePropertyModifier -> ^( MODIFIERS exclusivePropertyModifier ) | ( propertyModifier )+ -> ^( MODIFIERS ( propertyModifier )+ ) ); public propertyModifiers_return propertyModifiers() // throws RecognitionException [1] { var retval = new propertyModifiers_return(); retval.Start = input.LT( 1 ); CommonTree root_0 = null; exclusivePropertyModifier_return exclusivePropertyModifier21 = default( exclusivePropertyModifier_return ); propertyModifier_return propertyModifier22 = default( propertyModifier_return ); var stream_propertyModifier = new RewriteRuleSubtreeStream( adaptor, "rule propertyModifier" ); var stream_exclusivePropertyModifier = new RewriteRuleSubtreeStream( adaptor, "rule exclusivePropertyModifier" ); try { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:2: ( exclusivePropertyModifier -> ^( MODIFIERS exclusivePropertyModifier ) | ( propertyModifier )+ -> ^( MODIFIERS ( propertyModifier )+ ) ) int alt8 = 2; int LA8_0 = input.LA( 1 ); if ( ( LA8_0 == 64 ) ) alt8 = 1; else if ( ( ( LA8_0 >= 65 && LA8_0 <= 66 ) ) ) alt8 = 2; else { var nvae_d8s0 = new NoViableAltException( "", 8, 0, input ); throw nvae_d8s0; } switch ( alt8 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:4: exclusivePropertyModifier { PushFollow( FOLLOW_exclusivePropertyModifier_in_propertyModifiers419 ); exclusivePropertyModifier21 = exclusivePropertyModifier(); state.followingStackPointer--; stream_exclusivePropertyModifier.Add( exclusivePropertyModifier21.Tree ); // AST REWRITE // elements: exclusivePropertyModifier // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 101:30: -> ^( MODIFIERS exclusivePropertyModifier ) { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:101:33: ^( MODIFIERS exclusivePropertyModifier ) { var root_1 = (CommonTree)adaptor.GetNilNode(); root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( MODIFIERS, "MODIFIERS" ), root_1 ); adaptor.AddChild( root_1, stream_exclusivePropertyModifier.NextTree() ); adaptor.AddChild( root_0, root_1 ); } } retval.Tree = root_0; retval.Tree = root_0; } break; case 2: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: ( propertyModifier )+ { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: ( propertyModifier )+ int cnt7 = 0; do { int alt7 = 2; int LA7_0 = input.LA( 1 ); if ( ( ( LA7_0 >= 65 && LA7_0 <= 66 ) ) ) alt7 = 1; switch ( alt7 ) { case 1: // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:4: propertyModifier { PushFollow( FOLLOW_propertyModifier_in_propertyModifiers434 ); propertyModifier22 = propertyModifier(); state.followingStackPointer--; stream_propertyModifier.Add( propertyModifier22.Tree ); } break; default: if ( cnt7 >= 1 ) goto loop7; var eee7 = new EarlyExitException( 7, input ); throw eee7; } cnt7++; } while ( true ); loop7: ; // Stops C# compiler whining that label 'loop7' has no statements // AST REWRITE // elements: propertyModifier // token labels: // rule labels: retval // token list labels: // rule list labels: // wildcard labels: retval.Tree = root_0; var stream_retval = new RewriteRuleSubtreeStream( adaptor, "rule retval", retval != null ? retval.Tree : null ); root_0 = (CommonTree)adaptor.GetNilNode(); // 102:22: -> ^( MODIFIERS ( propertyModifier )+ ) { // C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:102:25: ^( MODIFIERS ( propertyModifier )+ ) { var root_1 = (CommonTree)adaptor.GetNilNode(); root_1 = (CommonTree)adaptor.BecomeRoot( adaptor.Create( MODIFIERS, "MODIFIERS" ), root_1 ); if ( !( stream_propertyModifier.HasNext() ) ) throw new RewriteEarlyExitException(); while ( stream_propertyModifier.HasNext() ) adaptor.AddChild( root_1, stream_propertyModifier.NextTree() ); stream_propertyModifier.Reset(); adaptor.AddChild( root_0, root_1 ); } } retval.Tree = root_0; retval.Tree = root_0; } break; } retval.Stop = input.LT( -1 ); retval.Tree = adaptor.RulePostProcessing( root_0 ); adaptor.SetTokenBoundaries( retval.Tree, (IToken)retval.Start, (IToken)retval.Stop ); } catch ( RecognitionException re ) { ReportError( re ); Recover( input, re ); // Conversion of the second argument necessary, but harmless retval.Tree = adaptor.ErrorNode( input, (IToken)retval.Start, input.LT( -1 ), re ); } finally {} return retval; }