/**
* Used to iterate over the " in the scanner as groovy can have """ for multi-line GString. If its
* looking for the starting " then need to check for an empty string like "" or """""" in which
* case just return a " indicatign the end of the scanning.
*
* @param scanner
* @param checkForEmpty
* @return
*/
private char iterateBeginningForDoubleQuotes(ICharacterScanner scanner, char lastChar) {
if (lastChar != '"') {
lastChar = (char) scanner.read();
buffer.append(lastChar);
return lastChar;
}
int countQuotes = 1; // The last char is a " so start at 1
while (lastChar == '"') {
lastChar = (char) scanner.read();
buffer.append(lastChar);
if (lastChar == '"') {
++countQuotes;
}
}
if ((countQuotes == 2 || countQuotes == 6)) {
return '"'; // Signifies the end of the scanning
}
return lastChar;
}
protected boolean endSequenceDetected(ICharacterScanner scanner) {
PartitionScanner partitionScanner = (PartitionScanner) scanner;
int offset = partitionScanner.getTokenOffset();
try {
IDocument document = partitionScanner.getDocument();
if ('\\' == document.getChar(offset - 1)) return false;
} catch (BadLocationException e) {
}
int stack = 0;
int readChars = 1;
char c = (char) scanner.read();
while (c != '\n') {
if (c == '(') stack++;
else if (c == ')') {
if (stack <= 1) {
return true;
} else stack--;
} else if (((int) c) == 65535) {
break;
}
c = (char) scanner.read();
readChars++;
}
for (int i = 0; i < readChars; i++) scanner.unread();
return false;
}
protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {
if (resume) {
if (endSequenceDetected(scanner)) return fToken;
} else {
int c = scanner.read();
if (c == fStartSequence[0]) {
if (sequenceDetected(scanner, fStartSequence, false)) {
char c1 = (char) scanner.read();
if (c1 != ' ' && c1 != '\n') {
if (c1 == fEndSequence[0]) {
if (sequenceDetected(scanner, fStartSequence, false)) {
scanner.unread();
return Token.UNDEFINED;
}
}
if (endSequenceDetected(scanner)) return fToken;
}
scanner.unread();
}
}
}
scanner.unread();
return Token.UNDEFINED;
}
protected boolean endSequenceDetected(ICharacterScanner scanner) {
char[][] originalDelimiters = scanner.getLegalLineDelimiters();
int count = originalDelimiters.length;
if (fLineDelimiters == null || originalDelimiters.length != count) {
fSortedLineDelimiters = new char[count][];
} else {
while (count > 0 && fLineDelimiters[count - 1] == originalDelimiters[count - 1]) count--;
}
if (count != 0) {
fLineDelimiters = originalDelimiters;
System.arraycopy(fLineDelimiters, 0, fSortedLineDelimiters, 0, fLineDelimiters.length);
Arrays.sort(fSortedLineDelimiters, fLineDelimiterComparator);
}
int readCount = 1;
char c;
char test;
while ((c = (char) scanner.read()) != ICharacterScanner.EOF) {
if (c == fEscapeCharacter) {
// Skip escaped character(s)
if (fEscapeContinuesLine) {
c = (char) scanner.read();
for (int i = 0; i < fSortedLineDelimiters.length; i++) {
if (c == fSortedLineDelimiters[i][0]
&& sequenceDetected(scanner, fSortedLineDelimiters[i], true)) break;
}
} else scanner.read();
} else if (fEndSequence.length > 0 && c == fEndSequence[0]) {
// Check if the specified end sequence has been found.
scanner.unread();
scanner.unread();
test = (char) scanner.read();
scanner.read();
if (sequenceDetected(scanner, fEndSequence, true)) {
if (test != ' ') return true;
}
} else if (fBreaksOnEOL) {
// Check for end of line since it can be used to terminate the pattern.
for (int i = 0; i < fSortedLineDelimiters.length; i++) {
if (c == fSortedLineDelimiters[i][0]
&& sequenceDetected(scanner, fSortedLineDelimiters[i], true)) return false;
}
}
readCount++;
}
if (fBreaksOnEOF) return true;
for (; readCount > 0; readCount--) scanner.unread();
return false;
}
@Override
public IToken evaluate(ICharacterScanner scanner) {
int character = scanner.read();
if (isBracket((char) character)) {
do {
character = scanner.read();
} while (isBracket((char) character));
scanner.unread();
return fToken;
} else {
scanner.unread();
return Token.UNDEFINED;
}
}
/*
* @see org.eclipse.jface.text.rules.IRule#evaluate(org.eclipse.jface.text.rules.ICharacterScanner)
*/
public IToken evaluate(ICharacterScanner scanner) {
int character = scanner.read();
if (character == '@') {
while ((character = scanner.read()) != ICharacterScanner.EOF) {
if (!Character.isJavaIdentifierPart(character)) {
scanner.unread();
break;
}
}
return fToken;
} else {
scanner.unread();
return Token.UNDEFINED;
}
}
public IToken evaluate(ICharacterScanner scanner) {
Arrays.fill(candidates, true);
int candidateCount = todoTags.length;
int count = 0;
int c;
while ((c = scanner.read()) != ICharacterScanner.EOF) {
for (int i = 0; i < todoTags.length; i++) {
if (candidates[i]) {
final char[] tag = todoTags[i];
if (count < tag.length) {
final boolean eq =
caseSensitive ? c == tag[count] : Character.toUpperCase((char) c) == tag[count];
if (!eq) {
candidates[i] = false;
--candidateCount;
if (candidateCount == 0) {
unreadScanner(scanner, count + 1);
return Token.UNDEFINED;
}
}
} else if (count == tag.length) {
if (!Character.isJavaIdentifierPart((char) c)) {
scanner.unread();
return getSuccessToken();
}
}
}
}
++count;
if (count == maxLength) {
c = scanner.read();
if (c != ICharacterScanner.EOF && !Character.isJavaIdentifierPart((char) c)) {
c = ICharacterScanner.EOF;
}
scanner.unread();
break;
}
}
if (c == ICharacterScanner.EOF) {
for (int i = 0; i < todoTags.length; i++) {
if (candidates[i] && count == todoTags[i].length) {
return getSuccessToken();
}
}
}
unreadScanner(scanner, count);
return Token.UNDEFINED;
}
protected boolean sequenceDetected(
ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
int c = scanner.read();
if (sequence[0] == '<') {
if (c == '?') {
// processing instruction - abort
scanner.unread();
return false;
}
if (c == '!') {
scanner.unread();
// comment - abort
return false;
}
} else if (sequence[0] == '>') {
// if (c == '<')
// {
// scanner.unread();
// // comment - abort
// return false;
// }
scanner.unread();
}
return super.sequenceDetected(scanner, sequence, eofAllowed);
}
public IToken evaluate(ICharacterScanner scanner) {
StringBuffer sb = new StringBuffer();
int c = -1;
int readCount = 0;
while (true) {
c = scanner.read();
if (c == EOF) {
scanner.unread();
return Token.EOF;
}
sb.append((char) c);
readCount++;
if (!Character.isJavaIdentifierStart(c) && c != '<' && c != '>') {
for (int j = 0; j < readCount; j++) {
scanner.unread();
}
return Token.UNDEFINED;
} else if (c == '>') {
return fToken;
}
}
}
/**
* @see
* org.eclipse.jface.text.rules.IRule#evaluate(org.eclipse.jface.text.rules.ICharacterScanner)
*/
@Override
public IToken evaluate(ICharacterScanner scanner) {
IToken token = super.evaluate(scanner);
if (token == Token.UNDEFINED) {
return token;
}
// check if the following character is a ( - which is an argument list
// for a
// function. if so then this is a function call name
int cnt = 0;
int ch;
do {
ch = scanner.read();
cnt += 1;
} while (fWhiteSpaceDetector.isWhitespace((char) ch));
if (ch == '(') {
// bingo !
while (cnt > 0) {
scanner.unread();
cnt -= 1;
}
return token;
}
// not a function call, so this is not a valid presentation
unreadBuffer(scanner);
return Token.UNDEFINED;
}
public IToken evaluateKeyword(ICharacterScanner scanner, String[] m_parts) {
int pos = 0;
int partNo = 0;
StringBuilder buffer = new StringBuilder();
char c = (char) scanner.read();
if (m_parts[partNo].charAt(pos) == c) {
pos++;
boolean cleanBuffer = false;
boolean canContinue = true;
boolean allowWhiteSpaces = false;
do {
buffer.append(c);
c = (char) scanner.read();
if (pos > m_parts[partNo].length() - 1) {
// goto next partition
partNo++;
pos = 0;
allowWhiteSpaces = true;
if (partNo > m_parts.length - 1) {
// everything is OK - time to exit
canContinue = false;
break;
}
}
if (m_parts[partNo].charAt(pos) == c) {
allowWhiteSpaces = false;
pos++;
} else if (!allowWhiteSpaces || !Character.isWhitespace(c)) {
canContinue = false;
cleanBuffer = true;
}
} while (canContinue);
scanner.unread();
if (cleanBuffer) {
unreadBuffer(scanner, buffer.length());
} else {
preExit(scanner);
return m_token;
}
} else {
scanner.unread();
}
return Token.UNDEFINED;
}
/**
* @see
* org.eclipse.jface.text.rules.IRule#evaluate(org.eclipse.jface.text.rules.ICharacterScanner)
*/
public IToken evaluate(ICharacterScanner scanner) {
int ch = scanner.read();
if (fChars.indexOf(ch) >= 0) {
return fToken;
}
scanner.unread();
return Token.UNDEFINED;
}
public IToken evaluate(ICharacterScanner scanner) {
String pattern = "[-@&#+]";
int c = scanner.read();
if (String.valueOf((char) c).matches(pattern)) {
if (fColumn == UNDEFINED || (fColumn == scanner.getColumn() - 1)) {
do {
c = scanner.read();
} while (String.valueOf((char) c).matches(pattern));
scanner.unread();
return fToken;
}
}
scanner.unread();
return Token.UNDEFINED;
}
protected boolean sequenceDetected(
ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
if (sequence[0] == '<') {
CharacterScannerDeco decoScanner = new CharacterScannerDeco(scanner);
if (decoScanner.firstMatch(new int[] {'<', '>'}) == '>') {
int c = scanner.read();
if (c == '!') {
c = scanner.read();
if (!Character.isUpperCase((char) c)) {
scanner.unread();
scanner.unread();
return false;
}
}
}
}
return super.sequenceDetected(scanner, sequence, eofAllowed);
}
public IToken evaluate(ICharacterScanner scanner, boolean resume) {
boolean inExpression = false;
int curlyDepth = 0;
int c = scanner.read();
int p = -1;
int p2;
if (c == '"') {
if (fColumn == UNDEFINED || (fColumn == scanner.getColumn() - 1)) {
IToken curToken = null;
int count = 0;
while (curToken == null && c != ICharacterScanner.EOF) {
p2 = p;
p = c;
c = scanner.read();
count++;
if (p != '\\' || p2 == '\\') {
if (c == '{') {
if (p == '#') inExpression = true;
if (inExpression) curlyDepth++;
} else if (c == '}') {
if (inExpression) {
curlyDepth--;
if (curlyDepth == 0) inExpression = false;
}
} else if (c == '"' && !inExpression) curToken = fToken;
}
}
if (curToken != null) {
return curToken;
} else {
while (count > 0) {
scanner.unread();
count--;
}
}
}
}
scanner.unread();
return Token.UNDEFINED;
}
@Override
public IToken evaluate(ICharacterScanner scanner) {
int readNum = scanner.read();
char c = (char) readNum;
if (c != firstChar) {
scanner.unread();
return Token.UNDEFINED;
}
buffer.setLength(0);
buffer.append(c);
boolean stringStart = false;
do {
if (!stringStart && isStringIdentifier(c)) {
// Could be a groovy GString formatted as """blah blah """
// So iterate over them if necessary
c = iterateBeginningForDoubleQuotes(scanner, c);
stringStart = true;
} else {
readNum = scanner.read();
c = (char) readNum;
buffer.append(c);
}
// Must of located an end string so try and match
// against the regex
if (stringStart && isStringIdentifier(c)) {
iterateEndForDoubleQuotes(
scanner, c); // Get the full string including trailing " for GStrings
Matcher matcher = regexPattern.matcher(buffer.toString());
if (matcher.find()) {
return token;
} else {
break;
}
}
} while (readNum != ICharacterScanner.EOF);
unread(scanner);
return Token.UNDEFINED;
}
@SuppressWarnings("unused")
private void scanToEndOfLine(ICharacterScanner scanner) {
int c;
char[][] delimiters = scanner.getLegalLineDelimiters();
while ((c = scanner.read()) != ICharacterScanner.EOF) {
// Check for end of line since it can be used to terminate the pattern.
for (int i = 0; i < delimiters.length; i++) {
if (c == delimiters[i][0] && sequenceDetected(scanner, delimiters[i])) {
return;
}
}
}
}
public static boolean isTag(final ICharacterScanner scanner, final String tag) {
final int length = tag.length();
int i = 0;
for (; i < length; i++) {
if (tag.charAt(i) != scanner.read()) {
unwind(scanner, i + 1);
return false;
}
}
unwind(scanner, length);
return true;
}
protected boolean endSequenceDetected(ICharacterScanner scanner) {
int c;
boolean doubleQuoted = false;
boolean singleQuoted = false;
char[][] delimiters = scanner.getLegalLineDelimiters();
boolean previousWasEscapeCharacter = false;
while ((c = scanner.read()) != ICharacterScanner.EOF) {
if (c == fEscapeCharacter) {
// Skip the escaped character.
scanner.read();
} else if (c == '"') {
if (singleQuoted == false) {
doubleQuoted = !doubleQuoted;
}
} else if (c == '\'') {
if (doubleQuoted == false) {
singleQuoted = !singleQuoted;
}
} else if (fEndSequence.length > 0 && c == fEndSequence[0]) {
// Check if the specified end sequence has been found.
if (doubleQuoted == false
&& singleQuoted == false
&& sequenceDetected(scanner, fEndSequence, true)) return true;
} else if (fBreaksOnEOL) {
// Check for end of line since it can be used to terminate the pattern.
for (int i = 0; i < delimiters.length; i++) {
if (c == delimiters[i][0] && sequenceDetected(scanner, delimiters[i], true)) {
if (!fEscapeContinuesLine || !previousWasEscapeCharacter) return true;
}
}
}
previousWasEscapeCharacter = (c == fEscapeCharacter);
}
if (fBreaksOnEOF) return true;
scanner.unread();
return false;
}
/* Copied from my superclass and modified to support case sensitivity. */
protected boolean endSequenceDetected(ICharacterScanner scanner) {
if (!ignoreCase) return super.endSequenceDetected(scanner);
int c;
char[][] delimiters = scanner.getLegalLineDelimiters();
while ((c = scanner.read()) != ICharacterScanner.EOF) {
if (c == fEscapeCharacter) {
// Skip the escaped character.
scanner.read();
} else if (fEndSequence.length > 0
&& (c == fEndSequence[0] || Character.toLowerCase((char) c) == fEndSequence[0])) {
// Check if the specified end sequence has been found.
if (sequenceDetected(scanner, fEndSequence, true)) return true;
} else if (fBreaksOnEOL) {
// Check for end of line since it can be used to terminate the pattern.
for (int i = 0; i < delimiters.length; i++) {
if (c == delimiters[i][0] && sequenceDetected(scanner, delimiters[i], false)) return true;
}
}
}
scanner.unread();
return true;
}
protected boolean sequenceDetected(
ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
if (sequence[0] == '<') {
int c = scanner.read();
if (c == '?' || c == '!' || c == '%') {
scanner.unread();
return false;
}
} else if (sequence[0] == '>') {
// 前の１文字を読む
scanner.unread();
scanner.unread();
int c = scanner.read();
// 元に戻しておく
scanner.read();
if (c == '%') {
return false;
}
}
return super.sequenceDetected(scanner, sequence, eofAllowed);
}
protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {
if (resume) {
scanner.unread();
int c = scanner.read();
int f = 0;
while (c != fStartSequence[0] || f != fStartSequence[1]) {
scanner.unread();
scanner.unread();
f = c;
c = scanner.read();
}
scanner.unread();
c = scanner.read();
if (c == fStartSequence[0]) {
if (sequenceDetected(scanner, fStartSequence, false)) {
if (endSequenceDetected(scanner)) {
return fToken;
}
}
}
} else {
int c = scanner.read();
if (c == fStartSequence[0]) {
if (sequenceDetected(scanner, fStartSequence, false)) {
if (endSequenceDetected(scanner)) {
return fToken;
}
}
}
}
scanner.unread();
return Token.UNDEFINED;
}
/* Copied from my superclass and modified to support case sensitivity. */
protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {
if (!ignoreCase) return super.doEvaluate(scanner, resume);
if (resume) {
if (endSequenceDetected(scanner)) return fToken;
} else {
int c = scanner.read();
if (c == fStartSequence[0] || Character.toLowerCase((char) c) == fStartSequence[0]) {
if (sequenceDetected(scanner, fStartSequence, false)) {
if (endSequenceDetected(scanner)) return fToken;
}
}
}
scanner.unread();
return Token.UNDEFINED;
}
@Override
public IToken evaluate(ICharacterScanner scanner) {
int c = scanner.read();
if (c == '#') {
c = scanner.read();
int readCount = 2;
if (c == sequence[0]) {
for (int i = 1; i < sequence.length; i++) {
if (sequence[i] != scanner.read()) {
while (readCount-- > 0) {
scanner.unread();
}
return Token.UNDEFINED;
}
readCount += 1;
}
return token;
} else {
scanner.unread();
}
}
scanner.unread();
return Token.UNDEFINED;
}
private boolean sequenceDetected(ICharacterScanner scanner, char[] sequence) {
for (int i = 1; i < sequence.length; i++) {
int c = scanner.read();
if (c == ICharacterScanner.EOF) {
return true;
} else if (c != sequence[i]) {
// Non-matching character detected, rewind the scanner back to the start.
for (; i > 0; i--) {
scanner.unread();
}
return false;
}
}
return true;
}
/* Copied from my superclass and modified to support case sensitivity. */
protected boolean sequenceDetected(
ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
if (!ignoreCase) return super.sequenceDetected(scanner, sequence, eofAllowed);
for (int i = 1; i < sequence.length; i++) {
int c = scanner.read();
if (c == ICharacterScanner.EOF && eofAllowed) {
return true;
} else if (c != sequence[i] || c != Character.toLowerCase((char) c)) {
// Non-matching character detected, rewind the scanner back to the start.
// Do not unread the first character.
scanner.unread();
for (int j = i - 1; j > 0; j--) scanner.unread();
return false;
}
}
return true;
}
private char iterateEndForDoubleQuotes(ICharacterScanner scanner, char lastChar) {
if (lastChar != '"') {
return lastChar;
}
while (lastChar == '"') {
lastChar = (char) scanner.read();
if (lastChar == '"') {
buffer.append(lastChar);
} else {
scanner.unread();
}
}
return lastChar;
}
/**
* @see
* org.jboss.ide.eclipse.freemarker.target.TargetMultiLineRule#sequenceDetected(org.eclipse.jface.text.rules.ICharacterScanner,
* char[], boolean)
*/
@Override
protected boolean sequenceDetected(
ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
int c = scanner.read();
if (sequence[0] == XmlLexicalConstants.LEFT_ANGLE_BRACKET) {
if (c == XmlLexicalConstants.QUESTION_MARK) {
// processing instruction - abort
scanner.unread();
return false;
}
if (c == XmlLexicalConstants.EXCLAMATION_MARK) {
scanner.unread();
// comment - abort
return false;
}
} else if (sequence[0] == XmlLexicalConstants.RIGHT_ANGLE_BRACKET) {
scanner.unread();
}
return super.sequenceDetected(scanner, sequence, eofAllowed);
}
private static boolean isChar(final ICharacterScanner scanner, int i) {
int c = scanner.read();
scanner.unread();
return c == i;
}
public IToken evaluate(ICharacterScanner scanner) {
// We need to back up to be able to detect the ' on the rule's label
scanner.unread();
int c = scanner.read();
// We need to check for the start of the file.
boolean bStartFile = false;
if (c == -1) {
bStartFile = true;
}
if (bStartFile == true || c != ICharacterScanner.EOF && fDetector.isWordStart((char) c)) {
c = scanner.read();
if ((fColumn == UNDEFINED || (fColumn == scanner.getColumn() - 1))
&& fDetector.isWordPart((char) c)) {
_fBuffer.setLength(0);
do {
_fBuffer.append((char) c);
c = scanner.read();
} while (c != ICharacterScanner.EOF && (fDetector.isWordPart((char) c)));
scanner.unread();
// Changed to not have the substring because it doesn't
// allow for single character agent names
_fBuffer = new StringBuffer(_fBuffer); // .substring(1));
String buffer = _fBuffer.toString().trim();
int intPos = buffer.indexOf('\\');
if (intPos != -1) {
buffer = buffer.substring(intPos + 1);
}
IToken token = (IToken) fWords.get(buffer);
if (buffer.length() != 0 && (char) c == '(') {
// This is an agent.
if (token == null) {
Iterator iter = fWords.keySet().iterator();
while (iter.hasNext()) {
String key = (String) iter.next();
if (buffer.equalsIgnoreCase(key)) {
token = (IToken) fWords.get(key);
break;
}
}
}
if (token != null) {
return token;
}
if (fDefaultToken.isUndefined()) {
unreadBuffer(scanner);
}
return fDefaultToken;
}
}
} else {
c = scanner.read();
}
scanner.unread();
return Token.UNDEFINED;
}