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

public final void entryRuleLiteral() throws RecognitionException {
     
    	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();

    try {
        // InternalSingleCodetemplateParser.g:359:1: ( ruleLiteral EOF )
        // InternalSingleCodetemplateParser.g:360:1: ruleLiteral EOF
        {
         before(grammarAccess.getLiteralRule()); 
        pushFollow(FOLLOW_1);
        ruleLiteral();

        state._fsp--;

         after(grammarAccess.getLiteralRule()); 
        match(input,EOF,FOLLOW_2); 

        }

    }
    catch (RecognitionException re) {
        reportError(re);
        recover(input,re);
    }
    finally {

        	myHiddenTokenState.restore();

    }
    return ;
}
 

public final void entryRuleChild() throws RecognitionException {
     
    	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens("RULE_WS", "RULE_ID");

    try {
        // InternalBug377311TestLanguage.g:82:1: ( ruleChild EOF )
        // InternalBug377311TestLanguage.g:83:1: ruleChild EOF
        {
         before(grammarAccess.getChildRule()); 
        pushFollow(FollowSets000.FOLLOW_1);
        ruleChild();

        state._fsp--;

         after(grammarAccess.getChildRule()); 
        match(input,EOF,FollowSets000.FOLLOW_2); 

        }

    }
    catch (RecognitionException re) {
        reportError(re);
        recover(input,re);
    }
    finally {

        	myHiddenTokenState.restore();

    }
    return ;
}
 

protected void assertLexing(String input, Pair<String,String>... expectedTokens) {
	Lexer lexer = new InternalXtendLexer(null);
	CharStream stream = new ANTLRStringStream(input);
	lexer.setCharStream(stream);
	XtextTokenStream tokenStream = new XtextTokenStream(lexer, tokenDefProvider);
	List<?> tokens = tokenStream.getTokens();
	assertEquals(input + " / " + tokens, expectedTokens.length, tokens.size());
	for(int i = 0;i < tokens.size(); i++) {
		Token token = (Token) tokens.get(i);
		assertEquals(token.toString(), expectedTokens[i].getFirst(), token.getText());
		final String expected = expectedTokens[i].getSecond();
		String actual = tokenDefProvider.getTokenDefMap().get(token.getType());
		assertEquals("expected "+expected+" but was "+actual, expected, actual);
	}
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected InternalFormatterTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalFormatterTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected InternalMetamodelRefTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalMetamodelRefTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected InternalActionTestLanguage3Parser createParser(XtextTokenStream stream) {
	return new InternalActionTestLanguage3Parser(stream, getGrammarAccess());
}
 

@Override
protected InternalImportUriUiTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalImportUriUiTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

public final void ruleLiteralValue() throws RecognitionException {

        		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
        		int stackSize = keepStackSize();
        	
        try {
            // InternalSingleCodetemplateParser.g:170:2: ( ( ( ( rule__LiteralValue__Alternatives ) ) ( ( rule__LiteralValue__Alternatives )* ) ) )
            // InternalSingleCodetemplateParser.g:171:2: ( ( ( rule__LiteralValue__Alternatives ) ) ( ( rule__LiteralValue__Alternatives )* ) )
            {
            // InternalSingleCodetemplateParser.g:171:2: ( ( ( rule__LiteralValue__Alternatives ) ) ( ( rule__LiteralValue__Alternatives )* ) )
            // InternalSingleCodetemplateParser.g:172:3: ( ( rule__LiteralValue__Alternatives ) ) ( ( rule__LiteralValue__Alternatives )* )
            {
            // InternalSingleCodetemplateParser.g:172:3: ( ( rule__LiteralValue__Alternatives ) )
            // InternalSingleCodetemplateParser.g:173:4: ( rule__LiteralValue__Alternatives )
            {
             before(grammarAccess.getLiteralValueAccess().getAlternatives()); 
            // InternalSingleCodetemplateParser.g:174:4: ( rule__LiteralValue__Alternatives )
            // InternalSingleCodetemplateParser.g:174:5: rule__LiteralValue__Alternatives
            {
            pushFollow(FOLLOW_3);
            rule__LiteralValue__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getLiteralValueAccess().getAlternatives()); 

            }

            // InternalSingleCodetemplateParser.g:177:3: ( ( rule__LiteralValue__Alternatives )* )
            // InternalSingleCodetemplateParser.g:178:4: ( rule__LiteralValue__Alternatives )*
            {
             before(grammarAccess.getLiteralValueAccess().getAlternatives()); 
            // InternalSingleCodetemplateParser.g:179:4: ( rule__LiteralValue__Alternatives )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==RULE_ID||(LA1_0>=RULE_WS && LA1_0<=RULE_ANY_OTHER)) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // InternalSingleCodetemplateParser.g:179:5: rule__LiteralValue__Alternatives
            	    {
            	    pushFollow(FOLLOW_3);
            	    rule__LiteralValue__Alternatives();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);

             after(grammarAccess.getLiteralValueAccess().getAlternatives()); 

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);
            	myHiddenTokenState.restore();

        }
        return ;
    }
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS");
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected InternalHiddenTerminalsTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalHiddenTerminalsTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected InternalBug381381TestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalBug381381TestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected com.avaloq.tools.ddk.checkcfg.parser.antlr.internal.InternalCheckCfgParser createParser(XtextTokenStream stream) {
	return new com.avaloq.tools.ddk.checkcfg.parser.antlr.internal.InternalCheckCfgParser(stream, getGrammarAccess());
}
 

@Override
protected InternalBacktrackingContentAssistTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalBacktrackingContentAssistTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected InternalBug419429Parser createParser(XtextTokenStream stream) {
	return new InternalBug419429Parser(stream, getGrammarAccess());
}
 

@Override
protected InternalBug305397Parser createParser(XtextTokenStream stream) {
	return new InternalBug305397Parser(stream, getGrammarAccess());
}
 

@Override
protected InternalEnumAndReferenceTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalEnumAndReferenceTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
	tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
}
 

@Override
protected InternalXtextGrammarTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalXtextGrammarTestLanguageParser(stream, getGrammarAccess());
}
 

@Override
protected InternalAbstractIgnoreCaseLinkingTestLanguageParser createParser(XtextTokenStream stream) {
	return new InternalAbstractIgnoreCaseLinkingTestLanguageParser(stream, getGrammarAccess());
}