Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2010 itemis AG (http://www.itemis.eu) and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html /
  
  package org.eclipse.xtext.ui.editor.model;
  
 import java.util.List;
 
 import  org.eclipse.jface.text.DocumentEvent;
 import  org.eclipse.jface.text.IRegion;
 import  org.eclipse.jface.text.Region;
 import  org.eclipse.xtext.ide.LexerIdeBindings;
 
For languages with lexers without backtracking. For these we can start lexing from the first damaged token instead of from the beginning. This is a lot faster especially when editing the trunk of big files. As opposed to the original BacktrackingLexerDocumentTokenSource, the damaged region returned by this class always includes the token touching the region the event refers to, i.e. the first token overlapping wit the region or the token that ends with the beginning of the region.

Author(s):
Jan Koehnlein - Initial contribution and API
Sebastian Zarnekow - Initial contribution and API
Sven Efftinge
 
 public class DocumentTokenSource {
 
 	public static class TokenInfo {
 
 		private final int length;
 		private final int type;
 
 		public TokenInfo(CommonToken token) {
 			 = token.getStopIndex() - token.getStartIndex() + 1;
 			 = token.getType();
 		}
 
 		public int hashCode() {
 			final int prime = 31;
 			int result = 1;
 			result = prime * result + ;
 			result = prime * result + ;
 			return result;
 		}
 
 		public boolean equals(Object obj) {
 			if (this == obj)
 				return true;
 			if (obj == null)
 				return false;
 			if (getClass() != obj.getClass())
 				return false;
 			TokenInfo other = (TokenInfoobj;
 			if ( != other.length)
 				return false;
 			if ( != other.type)
 				return false;
 			return true;
 		}
 
 		public String toString() {
 			return "TokenInfo [length=" +  + ", type=" +  + "]";
 		}
 
 		public int getAntlrTokenType() {
 			return this.;
 		}
 
 		public int getLength() {
 			return this.;
 		}
 	}

Author(s):
Sven Efftinge - Initial contribution and API
 
 	public static class TokenAdapter implements ILexerTokenRegion {
		private TokenInfo token;
		private int offset;
		public TokenAdapter(TokenInfo tokenint offset) {
			this. = token;
			this. = offset;
		}
		public int getLength() {
			return .getLength();
		}
		public int getOffset() {
			return ;
		}
		public int getLexerTokenType() {
		}
	}
	public static class IRegionIterable implements Iterable<ILexerTokenRegion> {
		private Iterable<TokenInfotokens = null;
		public IRegionIterable(Iterable<TokenInfotokens) {
			this. = tokens;
		}
				private int offset = 0;
					if (!.hasNext()) {
						return null;
					}
					TokenInfo next = .next();
					try {
						return new TokenAdapter(next);
finally {
						 += next.getLength();
					}
				}
			};
		}
		public boolean equals(Object obj) {
			if (obj == this)
				return true;
			if (!(obj instanceof IRegionIterable))
				return false;
			return  == ((IRegionIterable)obj).;
		}
		public int hashCode() {
			return System.identityHashCode();
		}
	}

Author(s):
Jan Koehnlein
Since:
2.4
	protected static class RepairEntryData {
		final int offset;
		final int index;
		public RepairEntryData(int offsetint indexCommonToken newTokenTokenSource lexer) {
			super();
			this. = offset;
			this. = index;
			this. = newToken;
			this. = lexer;
		}
	}
	private static final Logger logger = Logger.getLogger(DocumentTokenSource.class);
	private boolean checkInvariant = false;
	private List<TokenInfotokenInfos = Collections.emptyList();
	private IRegion previousRegion;
	private DocumentEvent previousEvent;
	@Named(LexerIdeBindings.HIGHLIGHTING)
	private Provider<Lexerlexer;
	}
	public IRegion getLastDamagedRegion() {
	}
	public void setLexer(Provider<Lexerlexer) {
		this. = lexer;
	}
	protected void setTokens(List<TokenInfoinfos) {
		this. = Collections.unmodifiableList(Lists.newArrayList(infos));
	}

Since:
2.4
	}
	protected List<TokenInfocreateTokenInfos(String string) {
		List<TokenInforesult = Lists.newArrayListWithExpectedSize(string.length() / 3);
		TokenSource source = createTokenSource(string);
		CommonToken token = (CommonTokensource.nextToken();
		while (token != .) {
			TokenInfo info = createTokenInfo(token);
			result.add(info);
			token = (CommonTokensource.nextToken();
		}
		return result;
	}
	protected TokenInfo createTokenInfo(CommonToken token) {
		TokenInfo info = new TokenInfo(token);
		return info;
	}
	public void updateStructure(final DocumentEvent e) {
		try {
			if ( == e &&  != null) {
				return;
			}
finally {
			}
		}
	}
	protected void doCheckInvariant(final DocumentEvent e) {
		List<TokenInfoparsedTokenInfos = createTokenInfos(e.fDocument.get());
		if (!parsedTokenInfos.equals()) {
			throw new IllegalStateException("Expected: '" + parsedTokenInfos + "' but was: '"
		}
	}
	protected IRegion computeDamageRegion(final DocumentEvent e) {
		// empty document -> no dirty region
		if (e.getDocument().getLength() == 0) {
			setTokens(createTokenInfos(e.fDocument.get()));
			return new Region(0, 0);
		}
		// previously empty -> full document dirty
			setTokens(createTokenInfos(e.fDocument.get()));
			return new Region(0, e.getDocument().getLength());
		}
		try {
			RepairEntryData repairEntryData = getRepairEntryData(e);
			int tokenStartsAt = repairEntryData.offset;
			int tokenInfoIdx = repairEntryData.index;
			CommonToken token = repairEntryData.newToken;
			if (token == .
			int regionOffset = tokenStartsAt;
			int regionLength = e.fDocument.getLength()- tokenStartsAt;
			int lengthDiff = e.fText.length() - e.fLength;
			// compute region length
			while (true) {
				if (token == . || tokenInfoIdx >= .size())
					break;
				while (true) {
					if (tokenInfoIdx >= .size())
						break;
					TokenInfo tokenInfo = .get(tokenInfoIdx);
					if (token.getStartIndex() >= e.fOffset + e.fText.length()) {
						if (tokenStartsAt + lengthDiff == token.getStartIndex() && tokenInfo.type == token.getType()
								&& token.getStopIndex() - token.getStartIndex() + 1 == tokenInfo.length) {
							return new Region(regionOffsettoken.getStartIndex() - regionOffset);
						}
					}
					if (tokenStartsAt + lengthDiff + tokenInfo.length > token.getStopIndex() + 1)
						break;
					tokenStartsAt += tokenInfo.length;
					if (tokenStartsAt + lengthDiff > token.getStartIndex())
						break;
				}
				token = (CommonTokenrepairEntryData.tokenSource.nextToken();
			}
			// add subsequent tokens
			if (tokenInfoIdx >= .size()) {
				while (token != .) {
					token = (CommonTokenrepairEntryData.tokenSource.nextToken();
				}
			}
			return new Region(regionOffsetregionLength);
catch(Exception exc) {
			.error("Error computing damaged region"exc);
			return new Region(0, e.fDocument.getLength());
finally {
		}
	}

Since:
2.4
	protected RepairEntryData getRepairEntryData(DocumentEvent ethrows Exception {
		int tokenStartsAt = 0;
		int tokenInfoIdx = 0;
		for(tokenInfoIdx = 0; tokenInfoIdxgetInternalModifyableTokenInfos().size(); ++tokenInfoIdx) {
			TokenInfo oldToken = getInternalModifyableTokenInfos().get(tokenInfoIdx);
			if(tokenStartsAt <= e.getOffset() && tokenStartsAt + oldToken.getLength() >= e.getOffset())
				break;
			tokenStartsAt += oldToken.getLength();
		}
		final TokenSource delegate = createTokenSource(e.fDocument.get(tokenStartsAte.fDocument.getLength() - tokenStartsAt));
		final int offset = tokenStartsAt;
		TokenSource source = new TokenSource() {
			public Token nextToken() {
				CommonToken commonToken = (CommonTokendelegate.nextToken();
				commonToken.setText(commonToken.getText());
				commonToken.setStartIndex(commonToken.getStartIndex()+offset);
				commonToken.setStopIndex(commonToken.getStopIndex()+offset);
				return commonToken;
			}
			public String getSourceName() {
				return delegate.getSourceName();
			}
		};
		final CommonToken token = (CommonTokensource.nextToken();
		return new RepairEntryData(offsettokenInfoIdxtokensource);
	}

Deprecated:
use createTokenSource(String) instead.
	protected Lexer createLexer(String string) {
		Lexer l = .get();
		return l;
	}

Since:
2.4
	protected TokenSource createTokenSource(String string) {
		Lexer l = .get();
		return l;
	}
	public void setCheckInvariant(boolean checkInvariant) {
		this. = checkInvariant;
	}
	public boolean isCheckInvariant() {
	}
New to GrepCode? Check out our FAQ X