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

@Override
public Document createDocument(final String before) throws Exception {
  XtextDocument _xblockexpression = null;
  {
    XtendDocumentTokenSource _xtendDocumentTokenSource = new XtendDocumentTokenSource();
    final Procedure1<XtendDocumentTokenSource> _function = (XtendDocumentTokenSource it) -> {
      AntlrTokenDefProvider _antlrTokenDefProvider = new AntlrTokenDefProvider();
      final Procedure1<AntlrTokenDefProvider> _function_1 = (AntlrTokenDefProvider it_1) -> {
        XtendAntlrTokenFileProvider _xtendAntlrTokenFileProvider = new XtendAntlrTokenFileProvider();
        it_1.setAntlrTokenFileProvider(_xtendAntlrTokenFileProvider);
      };
      AntlrTokenDefProvider _doubleArrow = ObjectExtensions.<AntlrTokenDefProvider>operator_doubleArrow(_antlrTokenDefProvider, _function_1);
      it.setTokenDefProvider(_doubleArrow);
      final Provider<Lexer> _function_2 = () -> {
        return this.createLexer();
      };
      it.setLexer(_function_2);
      it.setFlexerFactory(this.flexerFactory);
    };
    final XtendDocumentTokenSource source = ObjectExtensions.<XtendDocumentTokenSource>operator_doubleArrow(_xtendDocumentTokenSource, _function);
    final XtextDocument document = new XtextDocument(source, null, this.outdatedStateManager, this.operationCanceledManager);
    document.set(before);
    _xblockexpression = document;
  }
  return _xblockexpression;
}
 

private IXtextDocument createDocument(String model) throws Exception {
	resource = getResource(new StringInputStream(model));
	DocumentTokenSource tokenSource = new DocumentTokenSource();
	tokenSource.setLexer(new Provider<Lexer>(){
		@Override
		public Lexer get() {
			return new InternalXtextLexer();
		}});
	
	final XtextDocument document = new XtextDocument(tokenSource, get(ITextEditComposer.class), new OutdatedStateManager(), new OperationCanceledManager()) {
		@Override
		public <T> T internalModify(IUnitOfWork<T, XtextResource> work) {
			try {
				return work.exec((XtextResource) resource);
			}
			catch (Exception e) {
				throw new RuntimeException(e);
			}
		}
	};
	document.set(model);
	return document;
}
 

protected Document createDocument(String before) {
	DocumentTokenSource source = new DocumentTokenSource();
	source.setLexer(new Provider<Lexer>() {
		@Override
		public Lexer get() {
			return new org.eclipse.xtext.parser.antlr.internal.InternalXtextLexer();
		}
	});
	XtextDocument document = new XtextDocument(source, null, new OutdatedStateManager(), new OperationCanceledManager());
	document.set(before);
	return document;
}
 

protected boolean isSameTokenSequence(String originalText, String newText, int expectedLength) {
	Lexer originalLexer = lexerProvider.get();
	Lexer newLexer = lexerProvider.get();
	originalLexer.setCharStream(new ANTLRStringStream(originalText));
	newLexer.setCharStream(new ANTLRStringStream(newText));
	return isSameTokenSequence(originalLexer, newLexer, expectedLength);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalSequencerTestLanguageLexer.class;
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalEcore2XtextTestLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalBug288760TestLanguageLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalMyDslLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalBug362902Lexer.class);
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalXtextGrammarTestLanguageLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalBug309949TestLanguageLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalBug348427TestLanguageLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalRefactoringTestLanguage2Lexer.class;
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalBacktrackingContentAssistTestLanguageLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalEnumRulesUiTestLanguageLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalDomainmodelLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalOutlineTestLanguageLexer.class);
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalStatemachineLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalBug303200TestLanguageLexer.class;
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalBug286935TestLanguageLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalTerminalRulesTestLanguageLexer.class);
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalRegionAccessTestLanguageLexer.class);
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalFragmentTestLanguageLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalEcoreFragmentTestLanguageLexer.class;
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalIndentationAwareTestLanguageLexer.class);
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalBug287941TestLanguageLexer.class);
}
 

@Override
public Lexer get() {
	return new InternalXtendLexer(null);
}
 

public void configureRuntimeLexer(Binder binder) {
	binder.bind(Lexer.class)
		.annotatedWith(Names.named(LexerBindings.RUNTIME))
		.to(InternalTwoContextsTestLanguageLexer.class);
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalSyntacticSequencerTestLanguageLexer.class;
}
 

public Class<? extends Lexer> bindLexer() {
	return InternalEncodingTestLanguageLexer.class;
}