org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken Java Examples

@Test public void testMergeFirstDatatypeRuleToken() {
	AntlrDatatypeRuleToken tokenToMerge = new AntlrDatatypeRuleToken();
	tokenToMerge.setText("text");
	tokenToMerge.setStartOffset(6);
	AntlrDatatypeRuleToken token = new AntlrDatatypeRuleToken();
	token.merge(tokenToMerge);
	assertEquals("text", token.getText());
	assertEquals(10, token.getExpectedOffset());
}
 

public final String entryRuleDatatype2() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDatatype2 = null;


    try {
        // InternalUnassignedTextTestLanguage.g:366:49: (iv_ruleDatatype2= ruleDatatype2 EOF )
        // InternalUnassignedTextTestLanguage.g:367:2: iv_ruleDatatype2= ruleDatatype2 EOF
        {
         newCompositeNode(grammarAccess.getDatatype2Rule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDatatype2=ruleDatatype2();

        state._fsp--;

         current =iv_ruleDatatype2.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleDatatype3() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDatatype3 = null;


    try {
        // InternalFormatterTestLanguage.g:1245:49: (iv_ruleDatatype3= ruleDatatype3 EOF )
        // InternalFormatterTestLanguage.g:1246:2: iv_ruleDatatype3= ruleDatatype3 EOF
        {
         newCompositeNode(grammarAccess.getDatatype3Rule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDatatype3=ruleDatatype3();

        state._fsp--;

         current =iv_ruleDatatype3.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQN() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQN = null;


    try {
        // InternalRefactoringTestLanguage.g:153:43: (iv_ruleFQN= ruleFQN EOF )
        // InternalRefactoringTestLanguage.g:154:2: iv_ruleFQN= ruleFQN EOF
        {
         newCompositeNode(grammarAccess.getFQNRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleFQN=ruleFQN();

        state._fsp--;

         current =iv_ruleFQN.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQN() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQN = null;


    try {
        // InternalRefactoringTestLanguage1.g:178:43: (iv_ruleFQN= ruleFQN EOF )
        // InternalRefactoringTestLanguage1.g:179:2: iv_ruleFQN= ruleFQN EOF
        {
         newCompositeNode(grammarAccess.getFQNRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleFQN=ruleFQN();

        state._fsp--;

         current =iv_ruleFQN.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQN() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQN = null;


    try {
        // InternalContentAssistTestLanguage.g:347:43: (iv_ruleFQN= ruleFQN EOF )
        // InternalContentAssistTestLanguage.g:348:2: iv_ruleFQN= ruleFQN EOF
        {
         newCompositeNode(grammarAccess.getFQNRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleFQN=ruleFQN();

        state._fsp--;

         current =iv_ruleFQN.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null;


    try {
        // InternalXtype.g:1022:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF )
        // InternalXtype.g:1023:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); 
        }
        pushFollow(FOLLOW_1);
        iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleQualifiedNameInStaticImport.getText(); 
        }
        match(input,EOF,FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQN2() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQN2 = null;


    try {
        // InternalFragmentTestLanguageEx.g:785:44: (iv_ruleFQN2= ruleFQN2 EOF )
        // InternalFragmentTestLanguageEx.g:786:2: iv_ruleFQN2= ruleFQN2 EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getFQN2Rule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleFQN2=ruleFQN2();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleFQN2.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleQN() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleQN = null;


    try {
        // InternalContentAssistTestLanguage.g:390:42: (iv_ruleQN= ruleQN EOF )
        // InternalContentAssistTestLanguage.g:391:2: iv_ruleQN= ruleQN EOF
        {
         newCompositeNode(grammarAccess.getQNRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleQN=ruleQN();

        state._fsp--;

         current =iv_ruleQN.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

@Test public void testMergeSecondDatatypeRuleTokenUnmatched() {
	AntlrDatatypeRuleToken tokenToMerge = new AntlrDatatypeRuleToken();
	tokenToMerge.setText("ext");
	tokenToMerge.setStartOffset(9);
	AntlrDatatypeRuleToken token = new AntlrDatatypeRuleToken();
	token.setStartOffset(tokenToMerge.getStartOffset() - 4);
	token.setExpectedOffset(tokenToMerge.getStartOffset() - 3);
	token.setText("t");
	token.merge(tokenToMerge);
	assertEquals("t ext", token.getText());
	assertEquals(12, token.getExpectedOffset());
}
 

public final String entryRuleDataTypeVariable() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDataTypeVariable = null;


    try {
        // InternalBug296889ExTestLanguage.g:457:56: (iv_ruleDataTypeVariable= ruleDataTypeVariable EOF )
        // InternalBug296889ExTestLanguage.g:458:2: iv_ruleDataTypeVariable= ruleDataTypeVariable EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getDataTypeVariableRule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDataTypeVariable=ruleDataTypeVariable();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleDataTypeVariable.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQN() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQN = null;


    try {
        // InternalRefactoringTestLanguage2.g:178:43: (iv_ruleFQN= ruleFQN EOF )
        // InternalRefactoringTestLanguage2.g:179:2: iv_ruleFQN= ruleFQN EOF
        {
         newCompositeNode(grammarAccess.getFQNRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleFQN=ruleFQN();

        state._fsp--;

         current =iv_ruleFQN.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleQualifiedName() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleQualifiedName = null;


    try {
        // InternalBuilderTestLanguage.g:337:53: (iv_ruleQualifiedName= ruleQualifiedName EOF )
        // InternalBuilderTestLanguage.g:338:2: iv_ruleQualifiedName= ruleQualifiedName EOF
        {
         newCompositeNode(grammarAccess.getQualifiedNameRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleQualifiedName=ruleQualifiedName();

        state._fsp--;

         current =iv_ruleQualifiedName.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQN() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQN = null;


    try {
        // InternalRefactoringTestLanguage2.g:178:43: (iv_ruleFQN= ruleFQN EOF )
        // InternalRefactoringTestLanguage2.g:179:2: iv_ruleFQN= ruleFQN EOF
        {
         newCompositeNode(grammarAccess.getFQNRule()); 
        pushFollow(FOLLOW_1);
        iv_ruleFQN=ruleFQN();

        state._fsp--;

         current =iv_ruleFQN.getText(); 
        match(input,EOF,FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleMaybeEmpty() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleMaybeEmpty = null;


    try {
        // InternalGH1462TestLanguage.g:1234:50: (iv_ruleMaybeEmpty= ruleMaybeEmpty EOF )
        // InternalGH1462TestLanguage.g:1235:2: iv_ruleMaybeEmpty= ruleMaybeEmpty EOF
        {
         newCompositeNode(grammarAccess.getMaybeEmptyRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleMaybeEmpty=ruleMaybeEmpty();

        state._fsp--;

         current =iv_ruleMaybeEmpty.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleDataTypeExpression() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDataTypeExpression = null;


    try {
        // InternalBug296889ExTestLanguage.g:347:58: (iv_ruleDataTypeExpression= ruleDataTypeExpression EOF )
        // InternalBug296889ExTestLanguage.g:348:2: iv_ruleDataTypeExpression= ruleDataTypeExpression EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getDataTypeExpressionRule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDataTypeExpression=ruleDataTypeExpression();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleDataTypeExpression.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleIdOrKeyword() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleIdOrKeyword = null;


    try {
        // InternalParametersTestLanguageEx.g:1286:51: (iv_ruleIdOrKeyword= ruleIdOrKeyword EOF )
        // InternalParametersTestLanguageEx.g:1287:2: iv_ruleIdOrKeyword= ruleIdOrKeyword EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getIdOrKeywordRule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleIdOrKeyword=ruleIdOrKeyword();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleIdOrKeyword.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleDatatype() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDatatype = null;


    try {
        // InternalBug250313.g:434:48: (iv_ruleDatatype= ruleDatatype EOF )
        // InternalBug250313.g:435:2: iv_ruleDatatype= ruleDatatype EOF
        {
         newCompositeNode(grammarAccess.getDatatypeRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDatatype=ruleDatatype();

        state._fsp--;

         current =iv_ruleDatatype.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleBoolean() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleBoolean = null;


    try {
        // InternalAssignmentFinderTestLanguage.g:750:47: (iv_ruleBoolean= ruleBoolean EOF )
        // InternalAssignmentFinderTestLanguage.g:751:2: iv_ruleBoolean= ruleBoolean EOF
        {
         newCompositeNode(grammarAccess.getBooleanRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleBoolean=ruleBoolean();

        state._fsp--;

         current =iv_ruleBoolean.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleIdOrKeyword2() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleIdOrKeyword2 = null;


    try {
        // InternalTwoParametersTestLanguage.g:1203:52: (iv_ruleIdOrKeyword2= ruleIdOrKeyword2 EOF )
        // InternalTwoParametersTestLanguage.g:1204:2: iv_ruleIdOrKeyword2= ruleIdOrKeyword2 EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getIdOrKeyword2Rule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleIdOrKeyword2=ruleIdOrKeyword2();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleIdOrKeyword2.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleModelId() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleModelId = null;


    try {
        // InternalDatatypeRulesTestLanguage.g:242:47: (iv_ruleModelId= ruleModelId EOF )
        // InternalDatatypeRulesTestLanguage.g:243:2: iv_ruleModelId= ruleModelId EOF
        {
         newCompositeNode(grammarAccess.getModelIdRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleModelId=ruleModelId();

        state._fsp--;

         current =iv_ruleModelId.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleVirtualSemi() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleVirtualSemi = null;


    try {
        // InternalBug347012TestLanguage.g:214:51: (iv_ruleVirtualSemi= ruleVirtualSemi EOF )
        // InternalBug347012TestLanguage.g:215:2: iv_ruleVirtualSemi= ruleVirtualSemi EOF
        {
         newCompositeNode(grammarAccess.getVirtualSemiRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleVirtualSemi=ruleVirtualSemi();

        state._fsp--;

         current =iv_ruleVirtualSemi.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleIdOrKeyword() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleIdOrKeyword = null;


    try {
        // InternalTwoParametersTestLanguage.g:1047:51: (iv_ruleIdOrKeyword= ruleIdOrKeyword EOF )
        // InternalTwoParametersTestLanguage.g:1048:2: iv_ruleIdOrKeyword= ruleIdOrKeyword EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getIdOrKeywordRule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleIdOrKeyword=ruleIdOrKeyword();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleIdOrKeyword.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleIdOrKeyword() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleIdOrKeyword = null;


    try {
        // InternalParametersTestLanguage.g:1217:51: (iv_ruleIdOrKeyword= ruleIdOrKeyword EOF )
        // InternalParametersTestLanguage.g:1218:2: iv_ruleIdOrKeyword= ruleIdOrKeyword EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getIdOrKeywordRule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleIdOrKeyword=ruleIdOrKeyword();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleIdOrKeyword.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleDataTypeExpression() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDataTypeExpression = null;


    try {
        // InternalBug296889TestLanguage.g:347:58: (iv_ruleDataTypeExpression= ruleDataTypeExpression EOF )
        // InternalBug296889TestLanguage.g:348:2: iv_ruleDataTypeExpression= ruleDataTypeExpression EOF
        {
        if ( state.backtracking==0 ) {
           newCompositeNode(grammarAccess.getDataTypeExpressionRule()); 
        }
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDataTypeExpression=ruleDataTypeExpression();

        state._fsp--;
        if (state.failed) return current;
        if ( state.backtracking==0 ) {
           current =iv_ruleDataTypeExpression.getText(); 
        }
        match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return current;

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleGraphical() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleGraphical = null;


    try {
        // InternalBug292245TestLanguage.g:349:49: (iv_ruleGraphical= ruleGraphical EOF )
        // InternalBug292245TestLanguage.g:350:2: iv_ruleGraphical= ruleGraphical EOF
        {
         newCompositeNode(grammarAccess.getGraphicalRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleGraphical=ruleGraphical();

        state._fsp--;

         current =iv_ruleGraphical.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleKeyOne() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleKeyOne = null;


    try {
        // InternalHelloWorld.g:311:46: (iv_ruleKeyOne= ruleKeyOne EOF )
        // InternalHelloWorld.g:312:3: iv_ruleKeyOne= ruleKeyOne EOF
        {
         newCompositeNode(grammarAccess.getKeyOneRule()); 
        pushFollow(FOLLOW_1);
        iv_ruleKeyOne=ruleKeyOne();

        state._fsp--;

         current =iv_ruleKeyOne.getText(); 
        match(input,EOF,FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleKeyOther() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleKeyOther = null;


    try {
        // InternalHelloWorld.g:361:48: (iv_ruleKeyOther= ruleKeyOther EOF )
        // InternalHelloWorld.g:362:3: iv_ruleKeyOther= ruleKeyOther EOF
        {
         newCompositeNode(grammarAccess.getKeyOtherRule()); 
        pushFollow(FOLLOW_1);
        iv_ruleKeyOther=ruleKeyOther();

        state._fsp--;

         current =iv_ruleKeyOther.getText(); 
        match(input,EOF,FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleFQNWithWC() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleFQNWithWC = null;


    try {
        // InternalRefactoringTestLanguage.g:309:49: (iv_ruleFQNWithWC= ruleFQNWithWC EOF )
        // InternalRefactoringTestLanguage.g:310:2: iv_ruleFQNWithWC= ruleFQNWithWC EOF
        {
         newCompositeNode(grammarAccess.getFQNWithWCRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleFQNWithWC=ruleFQNWithWC();

        state._fsp--;

         current =iv_ruleFQNWithWC.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}
 

public final String entryRuleDatEnum() throws RecognitionException {
    String current = null;

    AntlrDatatypeRuleToken iv_ruleDatEnum = null;


    try {
        // InternalAssignmentFinderTestLanguage.g:838:47: (iv_ruleDatEnum= ruleDatEnum EOF )
        // InternalAssignmentFinderTestLanguage.g:839:2: iv_ruleDatEnum= ruleDatEnum EOF
        {
         newCompositeNode(grammarAccess.getDatEnumRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        iv_ruleDatEnum=ruleDatEnum();

        state._fsp--;

         current =iv_ruleDatEnum.getText(); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }

        catch (RecognitionException re) {
            recover(input,re);
            appendSkippedTokens();
        }
    finally {
    }
    return current;
}