--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2000, 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+
+package net.sourceforge.phpdt.internal.ui.text.spelling;
+
+import java.text.BreakIterator;
+import java.util.LinkedList;
+import java.util.Locale;
+
+import net.sourceforge.phpdt.corext.refactoring.nls.NLSElement;
+import net.sourceforge.phpdt.internal.ui.text.phpdoc.IHtmlTagConstants;
+import net.sourceforge.phpdt.internal.ui.text.phpdoc.IJavaDocTagConstants;
+import net.sourceforge.phpdt.internal.ui.text.spelling.engine.DefaultSpellChecker;
+import net.sourceforge.phpdt.internal.ui.text.spelling.engine.ISpellCheckIterator;
+
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.TextUtilities;
+
+/**
+ * Iterator to spell-check javadoc comment regions.
+ *
+ * @since 3.0
+ */
+public class SpellCheckIterator implements ISpellCheckIterator,
+ IJavaDocTagConstants, IHtmlTagConstants {
+
+ /** The content of the region */
+ private final String fContent;
+
+ /** The line delimiter */
+ private final String fDelimiter;
+
+ /** The last token */
+ private String fLastToken = null;
+
+ /** The next break */
+ private int fNext = 1;
+
+ /** The offset of the region */
+ private final int fOffset;
+
+ /** The predecessor break */
+ private int fPredecessor;
+
+ /** The previous break */
+ private int fPrevious = 0;
+
+ /** The sentence breaks */
+ private final LinkedList fSentenceBreaks = new LinkedList();
+
+ /** Does the current word start a sentence? */
+ private boolean fStartsSentence = false;
+
+ /** The successor break */
+ private int fSuccessor;
+
+ /** The word iterator */
+ private final BreakIterator fWordIterator;
+
+ /**
+ * Creates a new spell check iterator.
+ *
+ * @param document
+ * The document containing the specified partition
+ * @param region
+ * The region to spell-check
+ * @param locale
+ * The locale to use for spell-checking
+ */
+ public SpellCheckIterator(final IDocument document, final IRegion region,
+ final Locale locale) {
+
+ fOffset = region.getOffset();
+ fWordIterator = BreakIterator.getWordInstance(locale);
+ fDelimiter = TextUtilities.getDefaultLineDelimiter(document);
+
+ String content;
+ try {
+
+ content = document.get(region.getOffset(), region.getLength());
+ if (content.startsWith(NLSElement.TAG_PREFIX))
+ content = ""; //$NON-NLS-1$
+
+ } catch (Exception exception) {
+ content = ""; //$NON-NLS-1$
+ }
+ fContent = content;
+
+ fWordIterator.setText(content);
+ fPredecessor = fWordIterator.first();
+ fSuccessor = fWordIterator.next();
+
+ final BreakIterator iterator = BreakIterator
+ .getSentenceInstance(locale);
+ iterator.setText(content);
+
+ int offset = iterator.current();
+ while (offset != BreakIterator.DONE) {
+
+ fSentenceBreaks.add(new Integer(offset));
+ offset = iterator.next();
+ }
+ }
+
+ /*
+ * @see org.eclipse.spelling.done.ISpellCheckIterator#getBegin()
+ */
+ public final int getBegin() {
+ return fPrevious + fOffset;
+ }
+
+ /*
+ * @see org.eclipse.spelling.done.ISpellCheckIterator#getEnd()
+ */
+ public final int getEnd() {
+ return fNext + fOffset - 1;
+ }
+
+ /*
+ * @see java.util.Iterator#hasNext()
+ */
+ public final boolean hasNext() {
+ return fSuccessor != BreakIterator.DONE;
+ }
+
+ /**
+ * Does the specified token consist of at least one letter and digits only?
+ *
+ * @param begin
+ * The begin index
+ * @param end
+ * The end index
+ * @return <code>true</code> iff the token consists of digits and at least
+ * one letter only, <code>false</code> otherwise
+ */
+ protected final boolean isAlphaNumeric(final int begin, final int end) {
+
+ char character = 0;
+
+ boolean letter = false;
+ for (int index = begin; index < end; index++) {
+
+ character = fContent.charAt(index);
+ if (Character.isLetter(character))
+ letter = true;
+
+ if (!Character.isLetterOrDigit(character))
+ return false;
+ }
+ return letter;
+ }
+
+ /**
+ * Was the last token a Javadoc tag tag?
+ *
+ * @param tags
+ * The javadoc tags to check
+ * @return <code>true</code> iff the last token was a Javadoc tag,
+ * <code>false</code> otherwise
+ */
+ protected final boolean isJavadocToken(final String[] tags) {
+
+ if (fLastToken != null) {
+
+ for (int index = 0; index < tags.length; index++) {
+
+ if (fLastToken.equals(tags[index]))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Is the current token a single letter token surrounded by non-whitespace
+ * characters?
+ *
+ * @param begin
+ * The begin index
+ * @return <code>true</code> iff the token is a single letter token,
+ * <code>false</code> otherwise
+ */
+ protected final boolean isSingleLetter(final int begin) {
+
+ if (begin > 0 && begin < fContent.length() - 1)
+ return Character.isWhitespace(fContent.charAt(begin - 1))
+ && Character.isLetter(fContent.charAt(begin))
+ && Character.isWhitespace(fContent.charAt(begin + 1));
+
+ return false;
+ }
+
+ /**
+ * Does the specified token look like an URL?
+ *
+ * @param begin
+ * The begin index
+ * @return <code>true</code> iff this token look like an URL,
+ * <code>false</code> otherwise
+ */
+ protected final boolean isUrlToken(final int begin) {
+
+ for (int index = 0; index < DefaultSpellChecker.URL_PREFIXES.length; index++) {
+
+ if (fContent.startsWith(DefaultSpellChecker.URL_PREFIXES[index],
+ begin))
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Does the specified token consist of whitespace only?
+ *
+ * @param begin
+ * The begin index
+ * @param end
+ * The end index
+ * @return <code>true</code> iff the token consists of whitespace only,
+ * <code>false</code> otherwise
+ */
+ protected final boolean isWhitespace(final int begin, final int end) {
+
+ for (int index = begin; index < end; index++) {
+
+ if (!Character.isWhitespace(fContent.charAt(index)))
+ return false;
+ }
+ return true;
+ }
+
+ /*
+ * @see java.util.Iterator#next()
+ */
+ public final Object next() {
+
+ String token = nextToken();
+ while (token == null && fSuccessor != BreakIterator.DONE)
+ token = nextToken();
+
+ fLastToken = token;
+
+ return token;
+ }
+
+ /**
+ * Advances the end index to the next word break.
+ */
+ protected final void nextBreak() {
+
+ fNext = fSuccessor;
+ fPredecessor = fSuccessor;
+
+ fSuccessor = fWordIterator.next();
+ }
+
+ /**
+ * Returns the next sentence break.
+ *
+ * @return The next sentence break
+ */
+ protected final int nextSentence() {
+ return ((Integer) fSentenceBreaks.getFirst()).intValue();
+ }
+
+ /**
+ * Determines the next token to be spell-checked.
+ *
+ * @return The next token to be spell-checked, or <code>null</code> iff
+ * the next token is not a candidate for spell-checking.
+ */
+ protected String nextToken() {
+
+ String token = null;
+
+ fPrevious = fPredecessor;
+ fStartsSentence = false;
+
+ nextBreak();
+
+ boolean update = false;
+ if (fNext - fPrevious > 0) {
+
+ if (fSuccessor != BreakIterator.DONE
+ && fContent.charAt(fPrevious) == JAVADOC_TAG_PREFIX) {
+
+ nextBreak();
+ if (Character.isLetter(fContent.charAt(fPrevious + 1))) {
+ update = true;
+ token = fContent.substring(fPrevious, fNext);
+ } else
+ fPredecessor = fNext;
+
+ } else if (fSuccessor != BreakIterator.DONE
+ && fContent.charAt(fPrevious) == HTML_TAG_PREFIX
+ && (Character.isLetter(fContent.charAt(fNext)) || fContent
+ .charAt(fNext) == '/')) {
+
+ if (fContent.startsWith(HTML_CLOSE_PREFIX, fPrevious))
+ nextBreak();
+
+ nextBreak();
+
+ if (fSuccessor != BreakIterator.DONE
+ && fContent.charAt(fNext) == HTML_TAG_POSTFIX) {
+
+ nextBreak();
+ if (fSuccessor != BreakIterator.DONE) {
+ update = true;
+ token = fContent.substring(fPrevious, fNext);
+ }
+ }
+ } else if (!isWhitespace(fPrevious, fNext)
+ && isAlphaNumeric(fPrevious, fNext)) {
+
+ if (isUrlToken(fPrevious))
+ skipTokens(fPrevious, ' ');
+ else if (isJavadocToken(JAVADOC_PARAM_TAGS))
+ fLastToken = null;
+ else if (isJavadocToken(JAVADOC_REFERENCE_TAGS)) {
+ fLastToken = null;
+ skipTokens(fPrevious, fDelimiter.charAt(0));
+ } else if (fNext - fPrevious > 1 || isSingleLetter(fPrevious))
+ token = fContent.substring(fPrevious, fNext);
+
+ update = true;
+ }
+ }
+
+ if (update && fSentenceBreaks.size() > 0) {
+
+ if (fPrevious >= nextSentence()) {
+
+ while (fSentenceBreaks.size() > 0
+ && fPrevious >= nextSentence())
+ fSentenceBreaks.removeFirst();
+
+ fStartsSentence = (fLastToken == null) || (token != null);
+ }
+ }
+ return token;
+ }
+
+ /*
+ * @see java.util.Iterator#remove()
+ */
+ public final void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Skip the tokens until the stop character is reached.
+ *
+ * @param begin
+ * The begin index
+ * @param stop
+ * The stop character
+ */
+ protected final void skipTokens(final int begin, final char stop) {
+
+ int end = begin;
+
+ while (end < fContent.length() && fContent.charAt(end) != stop)
+ end++;
+
+ if (end < fContent.length()) {
+
+ fNext = end;
+ fPredecessor = fNext;
+
+ fSuccessor = fWordIterator.following(fNext);
+ } else
+ fSuccessor = BreakIterator.DONE;
+ }
+
+ /*
+ * @see org.eclipse.spelling.done.ISpellCheckIterator#startsSentence()
+ */
+ public final boolean startsSentence() {
+ return fStartsSentence;
+ }
+}
git://secure.phpeclipse.com / phpeclipse.git / blobdiff