/*******************************************************************************
* Copyright (c) 2000, 2006 IBM Corporation 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
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.aspectj.org.eclipse.jdt.internal.core.dom.rewrite;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.aspectj.org.eclipse.jdt.core.JavaCore;
import org.aspectj.org.eclipse.jdt.core.compiler.IScanner;
import org.aspectj.org.eclipse.jdt.core.compiler.ITerminalSymbols;
import org.aspectj.org.eclipse.jdt.core.compiler.InvalidInputException;
/**
* Wraps a scanner and offers convenient methods for finding tokens
*/
public class TokenScanner {
public static final int END_OF_FILE= 20001;
public static final int LEXICAL_ERROR= 20002;
public static final int DOCUMENT_ERROR= 20003;
private final IScanner scanner;
private final int endPosition;
/**
* Creates a TokenScanner
* @param scanner The scanner to be wrapped
*/
public TokenScanner(IScanner scanner) {
this.scanner= scanner;
this.endPosition= this.scanner.getSource().length - 1;
}
/**
* Returns the wrapped scanner
* @return IScanner
*/
public IScanner getScanner() {
return this.scanner;
}
/**
* Sets the scanner offset to the given offset.
* @param offset The offset to set
*/
public void setOffset(int offset) {
this.scanner.resetTo(offset, this.endPosition);
}
/**
* @return Returns the offset after the current token
*/
public int getCurrentEndOffset() {
return this.scanner.getCurrentTokenEndPosition() + 1;
}
/**
* @return Returns the start offset of the current token
*/
public int getCurrentStartOffset() {
return this.scanner.getCurrentTokenStartPosition();
}
/**
* @return Returns the length of the current token
*/
public int getCurrentLength() {
return getCurrentEndOffset() - getCurrentStartOffset();
}
/**
* Reads the next token.
* @param ignoreComments If set, comments will be overread
* @return Return the token id.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int readNext(boolean ignoreComments) throws CoreException {
int curr= 0;
do {
try {
curr= this.scanner.getNextToken();
if (curr == ITerminalSymbols.TokenNameEOF) {
throw new CoreException(createError(END_OF_FILE, "End Of File", null)); //$NON-NLS-1$
}
} catch (InvalidInputException e) {
throw new CoreException(createError(LEXICAL_ERROR, e.getMessage(), e));
}
} while (ignoreComments && isComment(curr));
return curr;
}
/**
* Reads the next token from the given offset.
* @param offset The offset to start reading from.
* @param ignoreComments If set, comments will be overread.
* @return Returns the token id.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int readNext(int offset, boolean ignoreComments) throws CoreException {
setOffset(offset);
return readNext(ignoreComments);
}
/**
* Reads the next token from the given offset and returns the start offset of the token.
* @param offset The offset to start reading from.
* @param ignoreComments If set, comments will be overread
* @return Returns the start position of the next token.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int getNextStartOffset(int offset, boolean ignoreComments) throws CoreException {
readNext(offset, ignoreComments);
return getCurrentStartOffset();
}
/**
* Reads the next token from the given offset and returns the offset after the token.
* @param offset The offset to start reading from.
* @param ignoreComments If set, comments will be overread
* @return Returns the start position of the next token.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int getNextEndOffset(int offset, boolean ignoreComments) throws CoreException {
readNext(offset, ignoreComments);
return getCurrentEndOffset();
}
/**
* Reads until a token is reached.
* @param tok The token to read to.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public void readToToken(int tok) throws CoreException {
int curr= 0;
do {
curr= readNext(false);
} while (curr != tok);
}
/**
* Reads until a token is reached, starting from the given offset.
* @param tok The token to read to.
* @param offset The offset to start reading from.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public void readToToken(int tok, int offset) throws CoreException {
setOffset(offset);
readToToken(tok);
}
/**
* Reads from the given offset until a token is reached and returns the start offset of the token.
* @param token The token to be found.
* @param startOffset The offset to start reading from.
* @return Returns the start position of the found token.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int getTokenStartOffset(int token, int startOffset) throws CoreException {
readToToken(token, startOffset);
return getCurrentStartOffset();
}
/**
* Reads from the given offset until a token is reached and returns the offset after the token.
* @param token The token to be found.
* @param startOffset Offset to start reading from
* @return Returns the end position of the found token.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int getTokenEndOffset(int token, int startOffset) throws CoreException {
readToToken(token, startOffset);
return getCurrentEndOffset();
}
/**
* Reads from the given offset until a token is reached and returns the offset after the previous token.
* @param token The token to be found.
* @param startOffset The offset to start scanning from.
* @return Returns the end offset of the token previous to the given token.
* @exception CoreException Thrown when the end of the file has been reached (code END_OF_FILE)
* or a lexical error was detected while scanning (code LEXICAL_ERROR)
*/
public int getPreviousTokenEndOffset(int token, int startOffset) throws CoreException {
setOffset(startOffset);
int res= startOffset;
int curr= readNext(false);
while (curr != token) {
res= getCurrentEndOffset();
curr= readNext(false);
}
return res;
}
public static boolean isComment(int token) {
return token == ITerminalSymbols.TokenNameCOMMENT_BLOCK || token == ITerminalSymbols.TokenNameCOMMENT_JAVADOC
|| token == ITerminalSymbols.TokenNameCOMMENT_LINE;
}
public static boolean isModifier(int token) {
switch (token) {
case ITerminalSymbols.TokenNamepublic:
case ITerminalSymbols.TokenNameprotected:
case ITerminalSymbols.TokenNameprivate:
case ITerminalSymbols.TokenNamestatic:
case ITerminalSymbols.TokenNamefinal:
case ITerminalSymbols.TokenNameabstract:
case ITerminalSymbols.TokenNamenative:
case ITerminalSymbols.TokenNamevolatile:
case ITerminalSymbols.TokenNamestrictfp:
case ITerminalSymbols.TokenNametransient:
case ITerminalSymbols.TokenNamesynchronized:
return true;
default:
return false;
}
}
public static IStatus createError(int code, String message, Throwable throwable) {
return new Status(IStatus.ERROR, JavaCore.PLUGIN_ID, code, message, throwable);
}
}