/*******************************************************************************
* Copyright (c) 2007, 2008 Edgar Espina.
* 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.deved.antlride.common.ui.text.rules;
import org.deved.antlride.common.ui.text.partitions.AntlrBasePartitionScanner;
import org.eclipse.jface.text.rules.ICharacterScanner;
import org.eclipse.jface.text.rules.IPredicateRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.IWhitespaceDetector;
import org.eclipse.jface.text.rules.IWordDetector;
import org.eclipse.jface.text.rules.Token;
public abstract class AntlrAbstractRule implements IPredicateRule {
protected IToken fSuccessToken;
protected IWhitespaceDetector fWhitespaceDetector;
protected IWordDetector fWordDetector;
private IWordDetector fAnyDetector;
protected StringBuilder fInput;
private StringBuilder fDebugBuffer;
private boolean fDebug;
protected int fCharsReaded;
protected boolean fEOF;
private static final String EMPTY = "";
protected AntlrAbstractRule(IToken successToken,
IWordDetector wordDetector, IWhitespaceDetector whitespaceDetector) {
fSuccessToken = successToken;
fWhitespaceDetector = whitespaceDetector;
fWordDetector = wordDetector;
fAnyDetector = AntlrAnyDetector.instance();
fInput = new StringBuilder();
fDebugBuffer = new StringBuilder();
}
protected AntlrAbstractRule(IToken successToken) {
this(successToken, AntlrWordDetector.instance(),
AntlrWhitespaceDetector.instance());
}
public IToken getSuccessToken() {
return fSuccessToken;
}
public IToken evaluate(ICharacterScanner scanner) {
int ch = scanner.read();
if (notEOF(ch)) {
scanner.unread();
return evaluate(scanner, false);
}
scanner.unread();
return Token.UNDEFINED;
}
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
fCharsReaded = 0;
return doEvaluate(scanner);
}
protected abstract IToken doEvaluate(ICharacterScanner scanner);
protected void unread(ICharacterScanner scanner, int length) {
for (int i = length - 1; i >= 0; i--)
scanner.unread();
fCharsReaded -= length;
if (fDebug) {
while (length > 0) {
fDebugBuffer.deleteCharAt(fDebugBuffer.length() - 1);
length--;
}
}
}
protected void unread(ICharacterScanner scanner) {
unread(scanner, fCharsReaded);
fCharsReaded = 0;
}
protected void consumeWS(ICharacterScanner scanner) {
fInput.setLength(0);
int ch = scanner.read();
fCharsReaded++;
if (notEOF(ch)) {
scanner.unread();
fCharsReaded--;
do {
ch = scanner.read();
fCharsReaded++;
fInput.append((char) ch);
} while (notEOF(ch) && fWhitespaceDetector.isWhitespace((char) ch));
scanner.unread();
fInput.deleteCharAt(fInput.length() - 1);
fCharsReaded--;
} else {
scanner.unread();
fCharsReaded--;
}
fDebugBuffer.append(getTextReaded());
}
protected void debugPartition() {
if (fDebug && fDebugBuffer.length() > 0) {
System.out.println(getClass().getName() + "::" + fDebugBuffer);
fDebugBuffer.setLength(0);
}
}
protected String getTextReaded() {
return fInput.length() == 0 ? EMPTY : fInput.toString();
}
protected int getTextLengthReaded() {
return fInput.length();
}
protected String getLastWordReaded(ICharacterScanner scanner) {
StringBuilder builder = new StringBuilder();
AntlrBasePartitionScanner scanner2 = ((AntlrBasePartitionScanner) scanner);
int mark = scanner2.getOffset();
scanner.unread();
int ch = scanner.read();
while (notEOF(ch) && fWordDetector.isWordPart((char) ch)) {
builder.insert(0, (char) ch);
scanner.unread();
scanner.unread();
ch = scanner.read();
}
if (notEOF(ch)
&& (fWordDetector.isWordStart((char) ch) || ch == '\'' || ch == '\"')) {
builder.insert(0, (char) ch);
}
while (scanner2.getOffset() != mark) {
scanner2.read();
}
return builder.toString();
}
protected void consumeWord(ICharacterScanner scanner) {
consume(scanner, fWordDetector);
}
protected void consumeAny(ICharacterScanner scanner) {
consume(scanner, fAnyDetector);
}
protected void consumeOne(ICharacterScanner scanner) {
consume(scanner, 1);
}
protected void consume(ICharacterScanner scanner, int count) {
fInput.setLength(0);
int ch = scanner.read();
fCharsReaded++;
if (notEOF(ch)) {
while (notEOF(ch) && count > 0) {
fInput.append((char) ch);
count--;
ch = scanner.read();
fCharsReaded++;
}
scanner.unread();
fCharsReaded--;
} else {
scanner.unread();
fCharsReaded--;
}
if (fDebug)
fDebugBuffer.append(getTextReaded());
}
protected void consume(ICharacterScanner scanner, IWordDetector wordDetector) {
fInput.setLength(0);
int ch = scanner.read();
fCharsReaded++;
if (notEOF(ch) && wordDetector.isWordStart((char) ch)) {
scanner.unread();
fCharsReaded--;
do {
ch = scanner.read();
fCharsReaded++;
fInput.append((char) ch);
} while (notEOF(ch) && wordDetector.isWordPart((char) ch));
scanner.unread();
fInput.deleteCharAt(fInput.length() - 1);
fCharsReaded--;
} else {
scanner.unread();
fCharsReaded--;
}
if (fDebug)
fDebugBuffer.append(getTextReaded());
}
protected void setDebug(boolean debug) {
fDebug = debug;
fDebugBuffer.setLength(0);
}
protected boolean notEOF(int ch) {
return !EOF(ch);
}
protected boolean EOF(int ch) {
return fEOF = (ch == ICharacterScanner.EOF);
}
}