Inheritance: RecognitionException
Example #1
0
        public virtual string GetErrorMessage(RecognitionException e, string[] tokenNames)
        {
            string str1 = e.Message;

            if (e is UnwantedTokenException)
            {
                UnwantedTokenException unwantedTokenException = (UnwantedTokenException)e;
                string str2 = unwantedTokenException.Expecting != -1 ? tokenNames[unwantedTokenException.Expecting] : "EndOfFile";
                str1 = "extraneous input " + this.GetTokenErrorDisplay(unwantedTokenException.UnexpectedToken) + " expecting " + str2;
            }
            else if (e is MissingTokenException)
            {
                MissingTokenException missingTokenException = (MissingTokenException)e;
                str1 = "missing " + (missingTokenException.Expecting != -1 ? tokenNames[missingTokenException.Expecting] : "EndOfFile") + " at " + this.GetTokenErrorDisplay(e.Token);
            }
            else if (e is MismatchedTokenException)
            {
                MismatchedTokenException mismatchedTokenException = (MismatchedTokenException)e;
                string str2 = mismatchedTokenException.Expecting != -1 ? tokenNames[mismatchedTokenException.Expecting] : "EndOfFile";
                str1 = "mismatched input " + this.GetTokenErrorDisplay(e.Token) + " expecting " + str2;
            }
            else if (e is MismatchedTreeNodeException)
            {
                MismatchedTreeNodeException treeNodeException = (MismatchedTreeNodeException)e;
                string str2 = treeNodeException.Expecting != -1 ? tokenNames[treeNodeException.Expecting] : "EndOfFile";
                str1 = "mismatched tree node: " + (treeNodeException.Node != null ? treeNodeException.Node.ToString() ?? string.Empty : string.Empty) + " expecting " + str2;
            }
            else if (e is NoViableAltException)
            {
                str1 = "no viable alternative at input " + this.GetTokenErrorDisplay(e.Token);
            }
            else if (e is EarlyExitException)
            {
                str1 = "required (...)+ loop did not match anything at input " + this.GetTokenErrorDisplay(e.Token);
            }
            else if (e is MismatchedSetException)
            {
                MismatchedSetException mismatchedSetException = (MismatchedSetException)e;
                str1 = "mismatched input " + this.GetTokenErrorDisplay(e.Token) + " expecting set " + (object)mismatchedSetException.Expecting;
            }
            else if (e is MismatchedNotSetException)
            {
                MismatchedNotSetException mismatchedNotSetException = (MismatchedNotSetException)e;
                str1 = "mismatched input " + this.GetTokenErrorDisplay(e.Token) + " expecting set " + (object)mismatchedNotSetException.Expecting;
            }
            else if (e is FailedPredicateException)
            {
                FailedPredicateException predicateException = (FailedPredicateException)e;
                str1 = "rule " + predicateException.RuleName + " failed predicate: {" + predicateException.PredicateText + "}?";
            }
            return(str1);
        }
Example #2
0
        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);
        }
Example #3
0
        public override string GetErrorMessage(RecognitionException e, string[] tokenNames)
        {
            string str;

            if (e is MismatchedTokenException)
            {
                MismatchedTokenException mismatchedTokenException = (MismatchedTokenException)e;
                str = "mismatched character " + this.GetCharErrorDisplay(e.Character) + " expecting " + this.GetCharErrorDisplay(mismatchedTokenException.Expecting);
            }
            else if (e is NoViableAltException)
            {
                str = "no viable alternative at character " + this.GetCharErrorDisplay(e.Character);
            }
            else if (e is EarlyExitException)
            {
                str = "required (...)+ loop did not match anything at character " + this.GetCharErrorDisplay(e.Character);
            }
            else if (e is MismatchedNotSetException)
            {
                MismatchedNotSetException mismatchedNotSetException = (MismatchedNotSetException)e;
                str = "mismatched character " + this.GetCharErrorDisplay(e.Character) + " expecting set " + (object)mismatchedNotSetException.Expecting;
            }
            else if (e is MismatchedSetException)
            {
                MismatchedSetException mismatchedSetException = (MismatchedSetException)e;
                str = "mismatched character " + this.GetCharErrorDisplay(e.Character) + " expecting set " + (object)mismatchedSetException.Expecting;
            }
            else if (e is MismatchedRangeException)
            {
                MismatchedRangeException mismatchedRangeException = (MismatchedRangeException)e;
                str = "mismatched character " + this.GetCharErrorDisplay(e.Character) + " expecting set " + this.GetCharErrorDisplay(mismatchedRangeException.A) + ".." + this.GetCharErrorDisplay(mismatchedRangeException.B);
            }
            else
            {
                str = base.GetErrorMessage(e, tokenNames);
            }
            return(str);
        }
Example #4
0
    // $ANTLR end "TSTOP"

    // $ANTLR start "WS"
    public void mWS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Development\\TT.Net\\TT\\Template.g:23:4: ( ( '\\r' | '\\n' | '\\t' | ' ' )+ )
            // C:\\Development\\TT.Net\\TT\\Template.g:23:6: ( '\\r' | '\\n' | '\\t' | ' ' )+
            {
            	// C:\\Development\\TT.Net\\TT\\Template.g:23:6: ( '\\r' | '\\n' | '\\t' | ' ' )+
            	int cnt3 = 0;
            	do 
            	{
            	    int alt3 = 2;
            	    int LA3_0 = input.LA(1);

            	    if ( ((LA3_0 >= '\t' && LA3_0 <= '\n') || LA3_0 == '\r' || LA3_0 == ' ') )
            	    {
            	        alt3 = 1;
            	    }


            	    switch (alt3) 
            		{
            			case 1 :
            			    // C:\\Development\\TT.Net\\TT\\Template.g:
            			    {
            			    	if ( (input.LA(1) >= '\t' && input.LA(1) <= '\n') || input.LA(1) == '\r' || input.LA(1) == ' ' ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    if ( cnt3 >= 1 ) goto loop3;
            		            EarlyExitException eee3 =
            		                new EarlyExitException(3, input);
            		            throw eee3;
            	    }
            	    cnt3++;
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whining that label 'loop3' has no statements

            	 _channel=HIDDEN; 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
		// $ANTLR start "number"
		// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:265:1: number : ( INT | FLOAT );
		public number_return number() // throws RecognitionException [1]
		{
			var retval = new number_return();
			retval.Start = input.LT( 1 );

			CommonTree root_0 = null;

			IToken set93 = null;

			CommonTree set93_tree = null;

			try
			{
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:266:2: ( INT | FLOAT )
				// C:\\Projects\\CalcEngine\\src\\CalcEngine\\Parsers\\Antlr\\AntlrCalcEngine.g:
				{
					root_0 = (CommonTree)adaptor.GetNilNode();

					set93 = input.LT( 1 );
					if ( ( input.LA( 1 ) >= INT && input.LA( 1 ) <= FLOAT ) )
					{
						input.Consume();
						adaptor.AddChild( root_0, adaptor.Create( set93 ) );
						state.errorRecovery = false;
					}
					else
					{
						var mse = new MismatchedSetException( null, input );
						throw mse;
					}
				}

				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 void mID()
	{
		EnterRule_ID();
		EnterRule("ID", 6);
		TraceIn("ID", 6);
		try
		{
			int _type = ID;
			int _channel = DefaultTokenChannel;
			// FuncProtoToShim.g:38:4: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
			DebugEnterAlt(1);
			// FuncProtoToShim.g:38:6: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
			{
			DebugLocation(38, 6);
			if ((input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z'))
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(38, 30);
			// FuncProtoToShim.g:38:30: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
			try { DebugEnterSubRule(3);
			while (true)
			{
				int alt3=2;
				try { DebugEnterDecision(3, false);
				int LA3_0 = input.LA(1);

				if (((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')))
				{
					alt3 = 1;
				}


				} finally { DebugExitDecision(3); }
				switch ( alt3 )
				{
				case 1:
					DebugEnterAlt(1);
					// FuncProtoToShim.g:
					{
					DebugLocation(38, 30);
					input.Consume();


					}
					break;

				default:
					goto loop3;
				}
			}

			loop3:
				;

			} finally { DebugExitSubRule(3); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("ID", 6);
			LeaveRule("ID", 6);
			LeaveRule_ID();
		}
	}
Example #7
0
	private AstParserRuleReturnScope<CommonTree, IToken> number()
	{
		EnterRule_number();
		EnterRule("number", 129);
		TraceIn("number", 129);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set427 = default(IToken);

		CommonTree set427_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "number");
		DebugLocation(983, 1);
		try
		{
			// AS3.g:983:8: ( HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOAT_LITERAL )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(983, 8);

			set427=(IToken)input.LT(1);
			if (input.LA(1)==DECIMAL_LITERAL||input.LA(1)==FLOAT_LITERAL||input.LA(1)==HEX_LITERAL||input.LA(1)==OCTAL_LITERAL)
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set427));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("number", 129);
			LeaveRule("number", 129);
			LeaveRule_number();
		}
		DebugLocation(987, 1);
		} finally { DebugExitRule(GrammarFileName, "number"); }
		return retval;

	}
Example #8
0
	private AstParserRuleReturnScope<CommonTree, IToken> relationalOperator()
	{
		EnterRule_relationalOperator();
		EnterRule("relationalOperator", 110);
		TraceIn("relationalOperator", 110);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set350 = default(IToken);

		CommonTree set350_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "relationalOperator");
		DebugLocation(828, 1);
		try
		{
			// AS3.g:829:2: ( LT | GT | LE | GE | IS | AS | 'instanceof' )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(829, 2);

			set350=(IToken)input.LT(1);
			if (input.LA(1)==AS||input.LA(1)==GE||input.LA(1)==GT||input.LA(1)==IS||input.LA(1)==LE||input.LA(1)==LT||input.LA(1)==249)
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set350));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("relationalOperator", 110);
			LeaveRule("relationalOperator", 110);
			LeaveRule_relationalOperator();
		}
		DebugLocation(830, 1);
		} finally { DebugExitRule(GrammarFileName, "relationalOperator"); }
		return retval;

	}
Example #9
0
	private AstParserRuleReturnScope<CommonTree, IToken> assignmentOperator()
	{
		EnterRule_assignmentOperator();
		EnterRule("assignmentOperator", 97);
		TraceIn("assignmentOperator", 97);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set319 = default(IToken);

		CommonTree set319_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "assignmentOperator");
		DebugLocation(743, 1);
		try
		{
			// AS3.g:744:2: ( ASSIGN | STAR_ASSIGN | DIV_ASSIGN | MOD_ASSIGN | PLUS_ASSIGN | MINUS_ASSIGN | SL_ASSIGN | SR_ASSIGN | BSR_ASSIGN | BAND_ASSIGN | BXOR_ASSIGN | BOR_ASSIGN | LAND_ASSIGN | LOR_ASSIGN )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(744, 2);

			set319=(IToken)input.LT(1);
			if (input.LA(1)==ASSIGN||input.LA(1)==BAND_ASSIGN||input.LA(1)==BOR_ASSIGN||input.LA(1)==BSR_ASSIGN||input.LA(1)==BXOR_ASSIGN||input.LA(1)==DIV_ASSIGN||input.LA(1)==LAND_ASSIGN||input.LA(1)==LOR_ASSIGN||input.LA(1)==MINUS_ASSIGN||input.LA(1)==MOD_ASSIGN||input.LA(1)==PLUS_ASSIGN||input.LA(1)==SL_ASSIGN||input.LA(1)==SR_ASSIGN||input.LA(1)==STAR_ASSIGN)
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set319));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("assignmentOperator", 97);
			LeaveRule("assignmentOperator", 97);
			LeaveRule_assignmentOperator();
		}
		DebugLocation(758, 1);
		} finally { DebugExitRule(GrammarFileName, "assignmentOperator"); }
		return retval;

	}
Example #10
0
	private AstParserRuleReturnScope<object, IToken> explicitConstructorInvocation()
	{
		EnterRule_explicitConstructorInvocation();
		EnterRule("explicitConstructorInvocation", 43);
		TraceIn("explicitConstructorInvocation", 43);
		AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
		retval.Start = (IToken)input.LT(1);
		int explicitConstructorInvocation_StartIndex = input.Index;

		object root_0 = default(object);

		IToken set215 = default(IToken);
		IToken char_literal217 = default(IToken);
		IToken char_literal219 = default(IToken);
		IToken string_literal221 = default(IToken);
		IToken char_literal223 = default(IToken);
		AstParserRuleReturnScope<object, IToken> nonWildcardTypeArguments214 = default(AstParserRuleReturnScope<object, IToken>);
		AstParserRuleReturnScope<object, IToken> arguments216 = default(AstParserRuleReturnScope<object, IToken>);
		AstParserRuleReturnScope<object, IToken> primary218 = default(AstParserRuleReturnScope<object, IToken>);
		AstParserRuleReturnScope<object, IToken> nonWildcardTypeArguments220 = default(AstParserRuleReturnScope<object, IToken>);
		AstParserRuleReturnScope<object, IToken> arguments222 = default(AstParserRuleReturnScope<object, IToken>);

		object set215_tree = default(object);
		object char_literal217_tree = default(object);
		object char_literal219_tree = default(object);
		object string_literal221_tree = default(object);
		object char_literal223_tree = default(object);
		try { DebugEnterRule(GrammarFileName, "explicitConstructorInvocation");
		DebugLocation(701, 4);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 43)) { return retval; }

			// Java.g:702:5: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' )
			int alt79=2;
			try { DebugEnterDecision(79, false);
			switch (input.LA(1))
			{
			case LT:
				{
				alt79 = 1;
				}
				break;
			case THIS:
				{
				int LA79_2 = input.LA(2);

				if ((EvaluatePredicate(synpred106_Java_fragment)))
				{
					alt79 = 1;
				}
				else if ((true))
				{
					alt79 = 2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 79, 2, input, 2);
					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			case BOOLEAN:
			case BYTE:
			case BooleanLiteral:
			case CHAR:
			case CharacterLiteral:
			case DOUBLE:
			case FLOAT:
			case FloatingPointLiteral:
			case IDENTIFIER:
			case INT:
			case IntegerLiteral:
			case LONG:
			case LPAREN:
			case NEW:
			case NullLiteral:
			case SHORT:
			case StringLiteral:
			case VOID:
				{
				alt79 = 2;
				}
				break;
			case SUPER:
				{
				int LA79_2 = input.LA(2);

				if ((EvaluatePredicate(synpred106_Java_fragment)))
				{
					alt79 = 1;
				}
				else if ((true))
				{
					alt79 = 2;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 79, 4, input, 2);
					DebugRecognitionException(nvae);
					throw nvae;
				}
				}
				break;
			default:
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					NoViableAltException nvae = new NoViableAltException("", 79, 0, input, 1);
					DebugRecognitionException(nvae);
					throw nvae;
				}
			}

			} finally { DebugExitDecision(79); }
			switch (alt79)
			{
			case 1:
				DebugEnterAlt(1);
				// Java.g:702:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(702, 9);
				// Java.g:702:9: ( nonWildcardTypeArguments )?
				int alt77=2;
				try { DebugEnterSubRule(77);
				try { DebugEnterDecision(77, false);
				int LA77_1 = input.LA(1);

				if ((LA77_1==LT))
				{
					alt77 = 1;
				}
				} finally { DebugExitDecision(77); }
				switch (alt77)
				{
				case 1:
					DebugEnterAlt(1);
					// Java.g:702:10: nonWildcardTypeArguments
					{
					DebugLocation(702, 10);
					PushFollow(Follow._nonWildcardTypeArguments_in_explicitConstructorInvocation3371);
					nonWildcardTypeArguments214=nonWildcardTypeArguments();
					PopFollow();
					if (state.failed) return retval;
					if (state.backtracking == 0) adaptor.AddChild(root_0, nonWildcardTypeArguments214.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(77); }

				DebugLocation(704, 9);

				set215=(IToken)input.LT(1);
				if (input.LA(1)==SUPER||input.LA(1)==THIS)
				{
					input.Consume();
					if (state.backtracking == 0) adaptor.AddChild(root_0, (object)adaptor.Create(set215));
					state.errorRecovery=false;state.failed=false;
				}
				else
				{
					if (state.backtracking>0) {state.failed=true; return retval;}
					MismatchedSetException mse = new MismatchedSetException(null,input);
					DebugRecognitionException(mse);
					throw mse;
				}

				DebugLocation(707, 9);
				PushFollow(Follow._arguments_in_explicitConstructorInvocation3429);
				arguments216=arguments();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, arguments216.Tree);
				DebugLocation(707, 19);
				char_literal217=(IToken)Match(input,SEMI,Follow._SEMI_in_explicitConstructorInvocation3431); if (state.failed) return retval;
				if (state.backtracking == 0) {
				char_literal217_tree = (object)adaptor.Create(char_literal217);
				adaptor.AddChild(root_0, char_literal217_tree);
				}

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// Java.g:709:9: primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';'
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(709, 9);
				PushFollow(Follow._primary_in_explicitConstructorInvocation3442);
				primary218=primary();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, primary218.Tree);
				DebugLocation(710, 9);
				char_literal219=(IToken)Match(input,DOT,Follow._DOT_in_explicitConstructorInvocation3452); if (state.failed) return retval;
				if (state.backtracking == 0) {
				char_literal219_tree = (object)adaptor.Create(char_literal219);
				adaptor.AddChild(root_0, char_literal219_tree);
				}
				DebugLocation(711, 9);
				// Java.g:711:9: ( nonWildcardTypeArguments )?
				int alt78=2;
				try { DebugEnterSubRule(78);
				try { DebugEnterDecision(78, false);
				int LA78_1 = input.LA(1);

				if ((LA78_1==LT))
				{
					alt78 = 1;
				}
				} finally { DebugExitDecision(78); }
				switch (alt78)
				{
				case 1:
					DebugEnterAlt(1);
					// Java.g:711:10: nonWildcardTypeArguments
					{
					DebugLocation(711, 10);
					PushFollow(Follow._nonWildcardTypeArguments_in_explicitConstructorInvocation3463);
					nonWildcardTypeArguments220=nonWildcardTypeArguments();
					PopFollow();
					if (state.failed) return retval;
					if (state.backtracking == 0) adaptor.AddChild(root_0, nonWildcardTypeArguments220.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(78); }

				DebugLocation(713, 9);
				string_literal221=(IToken)Match(input,SUPER,Follow._SUPER_in_explicitConstructorInvocation3484); if (state.failed) return retval;
				if (state.backtracking == 0) {
				string_literal221_tree = (object)adaptor.Create(string_literal221);
				adaptor.AddChild(root_0, string_literal221_tree);
				}
				DebugLocation(714, 9);
				PushFollow(Follow._arguments_in_explicitConstructorInvocation3494);
				arguments222=arguments();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, arguments222.Tree);
				DebugLocation(714, 19);
				char_literal223=(IToken)Match(input,SEMI,Follow._SEMI_in_explicitConstructorInvocation3496); if (state.failed) return retval;
				if (state.backtracking == 0) {
				char_literal223_tree = (object)adaptor.Create(char_literal223);
				adaptor.AddChild(root_0, char_literal223_tree);
				}

				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
			retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("explicitConstructorInvocation", 43);
			LeaveRule("explicitConstructorInvocation", 43);
			LeaveRule_explicitConstructorInvocation();
			if (state.backtracking > 0) { Memoize(input, 43, explicitConstructorInvocation_StartIndex); }

		}
		DebugLocation(715, 4);
		} finally { DebugExitRule(GrammarFileName, "explicitConstructorInvocation"); }
		return retval;

	}
Example #11
0
	private AstParserRuleReturnScope<object, IToken> typeArgument()
	{
		EnterRule_typeArgument();
		EnterRule("typeArgument", 37);
		TraceIn("typeArgument", 37);
		AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
		retval.Start = (IToken)input.LT(1);
		int typeArgument_StartIndex = input.Index;

		object root_0 = default(object);

		IToken char_literal189 = default(IToken);
		IToken set190 = default(IToken);
		AstParserRuleReturnScope<object, IToken> type188 = default(AstParserRuleReturnScope<object, IToken>);
		AstParserRuleReturnScope<object, IToken> type191 = default(AstParserRuleReturnScope<object, IToken>);

		object char_literal189_tree = default(object);
		object set190_tree = default(object);
		try { DebugEnterRule(GrammarFileName, "typeArgument");
		DebugLocation(653, 4);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 37)) { return retval; }

			// Java.g:654:5: ( type | '?' ( ( 'extends' | 'super' ) type )? )
			int alt70=2;
			try { DebugEnterDecision(70, false);
			int LA70_1 = input.LA(1);

			if ((LA70_1==BOOLEAN||LA70_1==BYTE||LA70_1==CHAR||LA70_1==DOUBLE||LA70_1==FLOAT||LA70_1==IDENTIFIER||LA70_1==INT||LA70_1==LONG||LA70_1==SHORT))
			{
				alt70 = 1;
			}
			else if ((LA70_1==QUES))
			{
				alt70 = 2;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				NoViableAltException nvae = new NoViableAltException("", 70, 0, input, 1);
				DebugRecognitionException(nvae);
				throw nvae;
			}
			} finally { DebugExitDecision(70); }
			switch (alt70)
			{
			case 1:
				DebugEnterAlt(1);
				// Java.g:654:9: type
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(654, 9);
				PushFollow(Follow._type_in_typeArgument2975);
				type188=type();
				PopFollow();
				if (state.failed) return retval;
				if (state.backtracking == 0) adaptor.AddChild(root_0, type188.Tree);

				}
				break;
			case 2:
				DebugEnterAlt(2);
				// Java.g:655:9: '?' ( ( 'extends' | 'super' ) type )?
				{
				root_0 = (object)adaptor.Nil();

				DebugLocation(655, 9);
				char_literal189=(IToken)Match(input,QUES,Follow._QUES_in_typeArgument2985); if (state.failed) return retval;
				if (state.backtracking == 0) {
				char_literal189_tree = (object)adaptor.Create(char_literal189);
				adaptor.AddChild(root_0, char_literal189_tree);
				}
				DebugLocation(656, 9);
				// Java.g:656:9: ( ( 'extends' | 'super' ) type )?
				int alt69=2;
				try { DebugEnterSubRule(69);
				try { DebugEnterDecision(69, false);
				int LA69_1 = input.LA(1);

				if ((LA69_1==EXTENDS||LA69_1==SUPER))
				{
					alt69 = 1;
				}
				} finally { DebugExitDecision(69); }
				switch (alt69)
				{
				case 1:
					DebugEnterAlt(1);
					// Java.g:657:13: ( 'extends' | 'super' ) type
					{
					DebugLocation(657, 13);

					set190=(IToken)input.LT(1);
					if (input.LA(1)==EXTENDS||input.LA(1)==SUPER)
					{
						input.Consume();
						if (state.backtracking == 0) adaptor.AddChild(root_0, (object)adaptor.Create(set190));
						state.errorRecovery=false;state.failed=false;
					}
					else
					{
						if (state.backtracking>0) {state.failed=true; return retval;}
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						throw mse;
					}

					DebugLocation(660, 13);
					PushFollow(Follow._type_in_typeArgument3053);
					type191=type();
					PopFollow();
					if (state.failed) return retval;
					if (state.backtracking == 0) adaptor.AddChild(root_0, type191.Tree);

					}
					break;

				}
				} finally { DebugExitSubRule(69); }


				}
				break;

			}
			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
			retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("typeArgument", 37);
			LeaveRule("typeArgument", 37);
			LeaveRule_typeArgument();
			if (state.backtracking > 0) { Memoize(input, 37, typeArgument_StartIndex); }

		}
		DebugLocation(662, 4);
		} finally { DebugExitRule(GrammarFileName, "typeArgument"); }
		return retval;

	}
Example #12
0
	private AstParserRuleReturnScope<object, IToken> primitiveType()
	{
		EnterRule_primitiveType();
		EnterRule("primitiveType", 35);
		TraceIn("primitiveType", 35);
		AstParserRuleReturnScope<object, IToken> retval = new AstParserRuleReturnScope<object, IToken>();
		retval.Start = (IToken)input.LT(1);
		int primitiveType_StartIndex = input.Index;

		object root_0 = default(object);

		IToken set182 = default(IToken);

		object set182_tree = default(object);
		try { DebugEnterRule(GrammarFileName, "primitiveType");
		DebugLocation(638, 4);
		try
		{
			if (state.backtracking > 0 && AlreadyParsedRule(input, 35)) { return retval; }

			// Java.g:639:5: ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' )
			DebugEnterAlt(1);
			// Java.g:
			{
			root_0 = (object)adaptor.Nil();

			DebugLocation(639, 5);

			set182=(IToken)input.LT(1);
			if (input.LA(1)==BOOLEAN||input.LA(1)==BYTE||input.LA(1)==CHAR||input.LA(1)==DOUBLE||input.LA(1)==FLOAT||input.LA(1)==INT||input.LA(1)==LONG||input.LA(1)==SHORT)
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (object)adaptor.Create(set182));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			retval.Stop = (IToken)input.LT(-1);

			if (state.backtracking == 0) {
			retval.Tree = (object)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
			}
		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
			retval.Tree = (object)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);

		}
		finally
		{
			TraceOut("primitiveType", 35);
			LeaveRule("primitiveType", 35);
			LeaveRule_primitiveType();
			if (state.backtracking > 0) { Memoize(input, 35, primitiveType_StartIndex); }

		}
		DebugLocation(647, 4);
		} finally { DebugExitRule(GrammarFileName, "primitiveType"); }
		return retval;

	}
        /** <summary>What error message should be generated for the various exception types?</summary>
         *
         *  <remarks>
         *  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.getClass().getName()) and,
         *  for no viable alts, the decision description and state etc...
         *
         *  Override this to change the message generated for one or more
         *  exception types.
         *  </remarks>
         */
        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 == TokenTypes.EndOfFile)
                {
                    tokenName = "EndOfFile";
                }
                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 == TokenTypes.EndOfFile)
                {
                    tokenName = "EndOfFile";
                }
                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 == TokenTypes.EndOfFile)
                {
                    tokenName = "EndOfFile";
                }
                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 == TokenTypes.EndOfFile)
                {
                    tokenName = "EndOfFile";
                }
                else
                {
                    tokenName = tokenNames[mtne.Expecting];
                }
                // workaround for a .NET framework bug (NullReferenceException)
                string nodeText = (mtne.Node != null) ? mtne.Node.ToString() ?? string.Empty : string.Empty;
                msg = "mismatched tree node: " + nodeText + " 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);
        }
Example #14
0
        /// <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);
        }
Example #15
0
	private void mESC()
	{
		Enter_ESC();
		EnterRule("ESC", 47);
		TraceIn("ESC", 47);
		try
		{
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:86:14: ( '\\\\' ( 'n' | 't' | '\\\\' | '\"' ) )
			DebugEnterAlt(1);
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:86:16: '\\\\' ( 'n' | 't' | '\\\\' | '\"' )
			{
			DebugLocation(86, 16);
			Match('\\'); 
			DebugLocation(86, 20);
			if (input.LA(1)=='\"'||input.LA(1)=='\\'||input.LA(1)=='n'||input.LA(1)=='t')
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

		}
		finally
		{
			TraceOut("ESC", 47);
			LeaveRule("ESC", 47);
			Leave_ESC();
		}
	}
Example #16
0
	private void mCHAR()
	{
		Enter_CHAR();
		EnterRule("CHAR", 49);
		TraceIn("CHAR", 49);
		try
		{
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:88:15: (~ ( '\\n' | '\\t' | '\\\\' | '\"' | ' ' ) )
			DebugEnterAlt(1);
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:88:17: ~ ( '\\n' | '\\t' | '\\\\' | '\"' | ' ' )
			{
			DebugLocation(88, 17);
			if ((input.LA(1)>='\u0000' && input.LA(1)<='\b')||(input.LA(1)>='\u000B' && input.LA(1)<='\u001F')||input.LA(1)=='!'||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF'))
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

		}
		finally
		{
			TraceOut("CHAR", 49);
			LeaveRule("CHAR", 49);
			Leave_CHAR();
		}
	}
Example #17
0
    // $ANTLR end "method"


    // $ANTLR start "association"
    // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:79:1: association returns [Association association] : (ma= multiplicity )? (labelA= label )? a= ( SIMPLE_ASSOCIATION | DIRECTIONAL_ASSOCIATION | BIDECTIONAL_ASSOCIATION | INHERRITANCE_ASSOCIATION ) (labelB= label )? (mb= multiplicity )? ;
    public Association association() // throws RecognitionException [1]
    {   
        Association association = default(Association);

        IToken a = null;
        string ma = default(string);

        string labelA = default(string);

        string labelB = default(string);

        string mb = default(string);


        association = new Association();
        try 
    	{
            // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:80:2: ( (ma= multiplicity )? (labelA= label )? a= ( SIMPLE_ASSOCIATION | DIRECTIONAL_ASSOCIATION | BIDECTIONAL_ASSOCIATION | INHERRITANCE_ASSOCIATION ) (labelB= label )? (mb= multiplicity )? )
            // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:2: (ma= multiplicity )? (labelA= label )? a= ( SIMPLE_ASSOCIATION | DIRECTIONAL_ASSOCIATION | BIDECTIONAL_ASSOCIATION | INHERRITANCE_ASSOCIATION ) (labelB= label )? (mb= multiplicity )?
            {
            	// D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:5: (ma= multiplicity )?
            	int alt11 = 2;
            	int LA11_0 = input.LA(1);

            	if ( (LA11_0 == MM) )
            	{
            	    alt11 = 1;
            	}
            	switch (alt11) 
            	{
            	    case 1 :
            	        // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:5: ma= multiplicity
            	        {
            	        	PushFollow(FOLLOW_multiplicity_in_association276);
            	        	ma = multiplicity();
            	        	state.followingStackPointer--;


            	        }
            	        break;

            	}

            	// D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:28: (labelA= label )?
            	int alt12 = 2;
            	int LA12_0 = input.LA(1);

            	if ( (LA12_0 == 21) )
            	{
            	    alt12 = 1;
            	}
            	switch (alt12) 
            	{
            	    case 1 :
            	        // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:28: labelA= label
            	        {
            	        	PushFollow(FOLLOW_label_in_association283);
            	        	labelA = label();
            	        	state.followingStackPointer--;


            	        }
            	        break;

            	}

            	a = (IToken)input.LT(1);
            	if ( (input.LA(1) >= SIMPLE_ASSOCIATION && input.LA(1) <= INHERRITANCE_ASSOCIATION) ) 
            	{
            	    input.Consume();
            	    state.errorRecovery = false;
            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}

            	// D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:150: (labelB= label )?
            	int alt13 = 2;
            	int LA13_0 = input.LA(1);

            	if ( (LA13_0 == 21) )
            	{
            	    alt13 = 1;
            	}
            	switch (alt13) 
            	{
            	    case 1 :
            	        // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:150: labelB= label
            	        {
            	        	PushFollow(FOLLOW_label_in_association312);
            	        	labelB = label();
            	        	state.followingStackPointer--;


            	        }
            	        break;

            	}

            	// D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:163: (mb= multiplicity )?
            	int alt14 = 2;
            	int LA14_0 = input.LA(1);

            	if ( (LA14_0 == MM) )
            	{
            	    alt14 = 1;
            	}
            	switch (alt14) 
            	{
            	    case 1 :
            	        // D:\\Olle\\Projects\\WikiUml\\source\\Grammar\\WikiUml.g:81:163: mb= multiplicity
            	        {
            	        	PushFollow(FOLLOW_multiplicity_in_association320);
            	        	mb = multiplicity();
            	        	state.followingStackPointer--;


            	        }
            	        break;

            	}


            		if(a.Type == SIMPLE_ASSOCIATION) association.Type = AssociationType.Simple; 
            		else if(a.Type == DIRECTIONAL_ASSOCIATION) association.Type = AssociationType.Directional;
            		else if(a.Type == BIDECTIONAL_ASSOCIATION) association.Type = AssociationType.Bidirectional;	
            		else if(a.Type == INHERRITANCE_ASSOCIATION) association.Type = AssociationType.Inherritance;	
            		association.LabelA = labelA;
            		association.LabelB = labelB;
            		association.MultiplicityA = ma;
            		association.MultiplicityB = mb;


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return association;
    }
Example #18
0
	private AstParserRuleReturnScope<CommonTree, IToken> reservedNamespace()
	{
		EnterRule_reservedNamespace();
		EnterRule("reservedNamespace", 76);
		TraceIn("reservedNamespace", 76);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set246 = default(IToken);

		CommonTree set246_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "reservedNamespace");
		DebugLocation(593, 1);
		try
		{
			// AS3.g:594:2: ( PUBLIC | PRIVATE | PROTECTED | INTERNAL )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(594, 2);

			set246=(IToken)input.LT(1);
			if (input.LA(1)==INTERNAL||input.LA(1)==PRIVATE||(input.LA(1)>=PROTECTED && input.LA(1)<=PUBLIC))
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set246));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("reservedNamespace", 76);
			LeaveRule("reservedNamespace", 76);
			LeaveRule_reservedNamespace();
		}
		DebugLocation(598, 1);
		} finally { DebugExitRule(GrammarFileName, "reservedNamespace"); }
		return retval;

	}
	private void mIDENTIFIER_START_ASCII()
	{
		EnterRule_IDENTIFIER_START_ASCII();
		EnterRule("IDENTIFIER_START_ASCII", 25);
		TraceIn("IDENTIFIER_START_ASCII", 25);
		try
		{
			// ..\\..\\NameParsing\\CSharpNames.g:184:2: ( 'a' .. 'z' | 'A' .. 'Z' | '_' )
			DebugEnterAlt(1);
			// ..\\..\\NameParsing\\CSharpNames.g:
			{
			DebugLocation(184, 2);
			if ((input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z'))
			{
				input.Consume();
			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;
			}


			}

		}
		finally
		{
			TraceOut("IDENTIFIER_START_ASCII", 25);
			LeaveRule("IDENTIFIER_START_ASCII", 25);
			LeaveRule_IDENTIFIER_START_ASCII();
		}
	}
Example #20
0
	private AstParserRuleReturnScope<CommonTree, IToken> equalityOperator()
	{
		EnterRule_equalityOperator();
		EnterRule("equalityOperator", 108);
		TraceIn("equalityOperator", 108);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set346 = default(IToken);

		CommonTree set346_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "equalityOperator");
		DebugLocation(819, 1);
		try
		{
			// AS3.g:820:2: ( STRICT_EQUAL | STRICT_NOT_EQUAL | NOT_EQUAL | EQUAL )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(820, 2);

			set346=(IToken)input.LT(1);
			if (input.LA(1)==EQUAL||input.LA(1)==NOT_EQUAL||(input.LA(1)>=STRICT_EQUAL && input.LA(1)<=STRICT_NOT_EQUAL))
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set346));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("equalityOperator", 108);
			LeaveRule("equalityOperator", 108);
			LeaveRule_equalityOperator();
		}
		DebugLocation(821, 1);
		} finally { DebugExitRule(GrammarFileName, "equalityOperator"); }
		return retval;

	}
    private void mWS()
    {
    	EnterRule_WS();
    	EnterRule("WS", 25);
    	TraceIn("WS", 25);
    		try
    		{
    		int _type = WS;
    		int _channel = DefaultTokenChannel;
    		// /Users/abdullin/MessageContracts.g:147:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )
    		DebugEnterAlt(1);
    		// /Users/abdullin/MessageContracts.g:147:9: ( ' ' | '\\t' | '\\r' | '\\n' )
    		{
    		DebugLocation(147, 9);
    		if ((input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(151, 11);
    		_channel=HIDDEN;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("WS", 25);
    		LeaveRule("WS", 25);
    		LeaveRule_WS();
        }
    }
Example #22
0
	private AstParserRuleReturnScope<CommonTree, IToken> multiplicativeOperator()
	{
		EnterRule_multiplicativeOperator();
		EnterRule("multiplicativeOperator", 116);
		TraceIn("multiplicativeOperator", 116);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set362 = default(IToken);

		CommonTree set362_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "multiplicativeOperator");
		DebugLocation(859, 1);
		try
		{
			// AS3.g:860:2: ( STAR | DIV | MOD )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(860, 2);

			set362=(IToken)input.LT(1);
			if (input.LA(1)==DIV||input.LA(1)==MOD||input.LA(1)==STAR)
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set362));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("multiplicativeOperator", 116);
			LeaveRule("multiplicativeOperator", 116);
			LeaveRule_multiplicativeOperator();
		}
		DebugLocation(861, 1);
		} finally { DebugExitRule(GrammarFileName, "multiplicativeOperator"); }
		return retval;

	}
    private void mModifier()
    {
    	EnterRule_Modifier();
    	EnterRule("Modifier", 17);
    	TraceIn("Modifier", 17);
    		try
    		{
    		int _type = Modifier;
    		int _channel = DefaultTokenChannel;
    		// /Users/abdullin/MessageContracts.g:106:2: ( '?' | '!' | ';' )
    		DebugEnterAlt(1);
    		// /Users/abdullin/MessageContracts.g:
    		{
    		DebugLocation(106, 2);
    		if (input.LA(1)=='!'||input.LA(1)==';'||input.LA(1)=='?')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("Modifier", 17);
    		LeaveRule("Modifier", 17);
    		LeaveRule_Modifier();
        }
    }
Example #24
0
	private AstParserRuleReturnScope<CommonTree, IToken> varOrConst()
	{
		EnterRule_varOrConst();
		EnterRule("varOrConst", 29);
		TraceIn("varOrConst", 29);
		AstParserRuleReturnScope<CommonTree, IToken> retval = new AstParserRuleReturnScope<CommonTree, IToken>();
		retval.Start = (IToken)input.LT(1);

		CommonTree root_0 = default(CommonTree);

		IToken set99 = default(IToken);

		CommonTree set99_tree = default(CommonTree);
		try { DebugEnterRule(GrammarFileName, "varOrConst");
		DebugLocation(308, 1);
		try
		{
			// AS3.g:309:2: ( VAR | CONST )
			DebugEnterAlt(1);
			// AS3.g:
			{
			root_0 = (CommonTree)adaptor.Nil();

			DebugLocation(309, 2);

			set99=(IToken)input.LT(1);
			if (input.LA(1)==CONST||input.LA(1)==VAR)
			{
				input.Consume();
				if (state.backtracking == 0) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set99));
				state.errorRecovery=false;state.failed=false;
			}
			else
			{
				if (state.backtracking>0) {state.failed=true; return retval;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				throw mse;
			}


			}

			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("varOrConst", 29);
			LeaveRule("varOrConst", 29);
			LeaveRule_varOrConst();
		}
		DebugLocation(310, 1);
		} finally { DebugExitRule(GrammarFileName, "varOrConst"); }
		return retval;

	}
    private void mHEX_DIGIT()
    {
    	EnterRule_HEX_DIGIT();
    	EnterRule("HEX_DIGIT", 20);
    	TraceIn("HEX_DIGIT", 20);
    		try
    		{
    		// /Users/abdullin/MessageContracts.g:122:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
    		DebugEnterAlt(1);
    		// /Users/abdullin/MessageContracts.g:
    		{
    		DebugLocation(122, 11);
    		if ((input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f'))
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}


    		}

    	}
    	finally
    	{
    		TraceOut("HEX_DIGIT", 20);
    		LeaveRule("HEX_DIGIT", 20);
    		LeaveRule_HEX_DIGIT();
        }
    }
	private void mWS()
	{
		EnterRule_WS();
		EnterRule("WS", 7);
		TraceIn("WS", 7);
		try
		{
			int _type = WS;
			int _channel = DefaultTokenChannel;
			// FuncProtoToShim.g:42:2: ( ( '\\t' | ' ' ) )
			DebugEnterAlt(1);
			// FuncProtoToShim.g:43:3: ( '\\t' | ' ' )
			{
			DebugLocation(43, 3);
			if (input.LA(1)=='\t'||input.LA(1)==' ')
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(48, 3);
			 _channel=TokenChannels.Hidden;  

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("WS", 7);
			LeaveRule("WS", 7);
			LeaveRule_WS();
		}
	}
    private void mHEX_DIGIT()
    {
    	EnterRule_HEX_DIGIT();
    	EnterRule("HEX_DIGIT", 21);
    	TraceIn("HEX_DIGIT", 21);
    		try
    		{
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:135:11: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
    		DebugEnterAlt(1);
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:
    		{
    		DebugLocation(135, 11);
    		if ((input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f'))
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}


    		}

    	}
    	finally
    	{
    		TraceOut("HEX_DIGIT", 21);
    		LeaveRule("HEX_DIGIT", 21);
    		LeaveRule_HEX_DIGIT();
        }
    }
Example #28
0
    // $ANTLR end "COMMENTS"

    // $ANTLR start "ID"
    public void mID() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ID;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Development\\TT.Net\\TT\\Template.g:58:4: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' )* )
            // C:\\Development\\TT.Net\\TT\\Template.g:58:6: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' )*
            {
            	if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}

            	// C:\\Development\\TT.Net\\TT\\Template.g:58:30: ( 'a' .. 'z' | 'A' .. 'Z' | '_' )*
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);

            	    if ( ((LA6_0 >= 'A' && LA6_0 <= 'Z') || LA6_0 == '_' || (LA6_0 >= 'a' && LA6_0 <= 'z')) )
            	    {
            	        alt6 = 1;
            	    }


            	    switch (alt6) 
            		{
            			case 1 :
            			    // C:\\Development\\TT.Net\\TT\\Template.g:
            			    {
            			    	if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    goto loop6;
            	    }
            	} while (true);

            	loop6:
            		;	// Stops C# compiler whining that label 'loop6' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    private void mWS()
    {
    	EnterRule_WS();
    	EnterRule("WS", 26);
    	TraceIn("WS", 26);
    		try
    		{
    		int _type = WS;
    		int _channel = DefaultTokenChannel;
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:160:5: ( ( ' ' | '\\t' | '\\r' | '\\n' ) )
    		DebugEnterAlt(1);
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:160:9: ( ' ' | '\\t' | '\\r' | '\\n' )
    		{
    		DebugLocation(160, 9);
    		if ((input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(164, 11);
    		_channel=HIDDEN;

    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("WS", 26);
    		LeaveRule("WS", 26);
    		LeaveRule_WS();
        }
    }
Example #30
0
	private void mSPACE()
	{
		Enter_SPACE();
		EnterRule("SPACE", 46);
		TraceIn("SPACE", 46);
		try
		{
			int _type = SPACE;
			int _channel = DefaultTokenChannel;
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:85:7: ( ( '\\n' | '\\t' | ' ' | '\\r' ) )
			DebugEnterAlt(1);
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:85:9: ( '\\n' | '\\t' | ' ' | '\\r' )
			{
			DebugLocation(85, 9);
			if ((input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ')
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(85, 30);
			_channel = Hidden;

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("SPACE", 46);
			LeaveRule("SPACE", 46);
			Leave_SPACE();
		}
	}
    private void mID()
    {
    	EnterRule_ID();
    	EnterRule("ID", 17);
    	TraceIn("ID", 17);
    		try
    		{
    		int _type = ID;
    		int _channel = DefaultTokenChannel;
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:115:5: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' | '<' | '>' | '[' | ']' )* )
    		DebugEnterAlt(1);
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:115:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' | '<' | '>' | '[' | ']' )*
    		{
    		DebugLocation(115, 7);
    		if ((input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z'))
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}

    		DebugLocation(115, 30);
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:115:30: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' | '<' | '>' | '[' | ']' )*
    		try { DebugEnterSubRule(1);
    		while (true)
    		{
    			int alt1=2;
    			try { DebugEnterDecision(1, decisionCanBacktrack[1]);
    			int LA1_0 = input.LA(1);

    			if (((LA1_0>='0' && LA1_0<='9')||LA1_0=='<'||LA1_0=='>'||(LA1_0>='A' && LA1_0<='[')||LA1_0==']'||LA1_0=='_'||(LA1_0>='a' && LA1_0<='z')))
    			{
    				alt1 = 1;
    			}


    			} finally { DebugExitDecision(1); }
    			switch ( alt1 )
    			{
    			case 1:
    				DebugEnterAlt(1);
    				// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:
    				{
    				DebugLocation(115, 30);
    				input.Consume();


    				}
    				break;

    			default:
    				goto loop1;
    			}
    		}

    		loop1:
    			;

    		} finally { DebugExitSubRule(1); }


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("ID", 17);
    		LeaveRule("ID", 17);
    		LeaveRule_ID();
        }
    }
Example #32
0
	private void mLETTER()
	{
		Enter_LETTER();
		EnterRule("LETTER", 48);
		TraceIn("LETTER", 48);
		try
		{
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:87:17: ( 'a' .. 'z' | 'A' .. 'Z' )
			DebugEnterAlt(1);
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:
			{
			DebugLocation(87, 17);
			if ((input.LA(1)>='A' && input.LA(1)<='Z')||(input.LA(1)>='a' && input.LA(1)<='z'))
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}


			}

		}
		finally
		{
			TraceOut("LETTER", 48);
			LeaveRule("LETTER", 48);
			Leave_LETTER();
		}
	}
    private void mModifier()
    {
    	EnterRule_Modifier();
    	EnterRule("Modifier", 18);
    	TraceIn("Modifier", 18);
    		try
    		{
    		int _type = Modifier;
    		int _channel = DefaultTokenChannel;
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:119:2: ( '?' | '!' | ';' )
    		DebugEnterAlt(1);
    		// D:\\_Dokumente\\GitHub\\lokad-codedsl\\Source\\MessageContracts.g:
    		{
    		DebugLocation(119, 2);
    		if (input.LA(1)=='!'||input.LA(1)==';'||input.LA(1)=='?')
    		{
    			input.Consume();
    		}
    		else
    		{
    			MismatchedSetException mse = new MismatchedSetException(null,input);
    			DebugRecognitionException(mse);
    			Recover(mse);
    			throw mse;
    		}


    		}

    		state.type = _type;
    		state.channel = _channel;
    	}
    	finally
    	{
    		TraceOut("Modifier", 18);
    		LeaveRule("Modifier", 18);
    		LeaveRule_Modifier();
        }
    }
Example #34
0
	private void mID()
	{
		Enter_ID();
		EnterRule("ID", 50);
		TraceIn("ID", 50);
		try
		{
			int _type = ID;
			int _channel = DefaultTokenChannel;
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:89:4: ( LETTER ( LETTER | DIGIT | Underscore )* )
			DebugEnterAlt(1);
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:89:6: LETTER ( LETTER | DIGIT | Underscore )*
			{
			DebugLocation(89, 6);
			mLETTER(); 
			DebugLocation(89, 12);
			// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:89:12: ( LETTER | DIGIT | Underscore )*
			try { DebugEnterSubRule(3);
			while (true)
			{
				int alt3=2;
				try { DebugEnterDecision(3, decisionCanBacktrack[3]);
				int LA3_0 = input.LA(1);

				if (((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')))
				{
					alt3=1;
				}


				} finally { DebugExitDecision(3); }
				switch ( alt3 )
				{
				case 1:
					DebugEnterAlt(1);
					// C:\\Users\\Oscar\\Documents\\Visual Studio 2010\\Projects\\TigerNET\\Grammar\\Tiger.g:
					{
					DebugLocation(89, 12);
					if ((input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z'))
					{
						input.Consume();

					}
					else
					{
						MismatchedSetException mse = new MismatchedSetException(null,input);
						DebugRecognitionException(mse);
						Recover(mse);
						throw mse;}


					}
					break;

				default:
					goto loop3;
				}
			}

			loop3:
				;

			} finally { DebugExitSubRule(3); }


			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("ID", 50);
			LeaveRule("ID", 50);
			Leave_ID();
		}
	}
Example #35
0
	private void mWS()
	{
		EnterRule_WS();
		EnterRule("WS", 41);
		TraceIn("WS", 41);
		try
		{
			int _type = WS;
			int _channel = DefaultTokenChannel;
			// FlashTeaseScript.g:233:2: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
			DebugEnterAlt(1);
			// FlashTeaseScript.g:233:4: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
			{
			DebugLocation(233, 4);
			if ((input.LA(1)>='\t' && input.LA(1)<='\n')||(input.LA(1)>='\f' && input.LA(1)<='\r')||input.LA(1)==' ')
			{
				input.Consume();

			}
			else
			{
				MismatchedSetException mse = new MismatchedSetException(null,input);
				DebugRecognitionException(mse);
				Recover(mse);
				throw mse;}

			DebugLocation(233, 34);
			 Skip(); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally
		{
			TraceOut("WS", 41);
			LeaveRule("WS", 41);
			LeaveRule_WS();
		}
	}