/**
     * Returns whether the MLC token containing <code>offs</code> appears to have a "nested" comment
     * (i.e., contains "<code>/*</code>" somewhere inside of it). This implies that it is likely a
     * "new" MLC and needs to be closed. While not foolproof, this is usually good enough of a sign.
     *
     * @param textArea
     * @param line
     * @param offs
     * @return Whether a comment appears to be nested inside this one.
     */
    private boolean appearsNested(RSyntaxTextArea textArea, int line, int offs) {

      final int firstLine = line; // Remember the line we start at.

      while (line < textArea.getLineCount()) {
        Token t = textArea.getTokenListForLine(line);
        int i = 0;
        // If examining the first line, start at offs.
        if (line++ == firstLine) {
          t = RSyntaxUtilities.getTokenAtOffset(t, offs);
          if (t == null) { // offs was at end of the line
            continue;
          }
          i = t.documentToToken(offs);
        } else {
          i = t.getTextOffset();
        }
        int textOffset = t.getTextOffset();
        while (i < textOffset + t.length() - 1) {
          if (t.charAt(i - textOffset) == '/' && t.charAt(i - textOffset + 1) == '*') {
            return true;
          }
          i++;
        }
        // If tokens come after this one on this line, our MLC ended.
        if (t.getNextToken() != null) {
          return false;
        }
      }

      return true; // No match - MLC goes to the end of the file
    }
 /** {@inheritDoc} */
 @Override
 public boolean getShouldIndentNextLineAfter(Token t) {
   if (t != null && t.length() == 1) {
     char ch = t.charAt(0);
     return ch == '{' || ch == '(';
   }
   return false;
 }
Exemple #3
0
 /**
  * Makes one token point to the same text segment, and have the same value as another token.
  *
  * @param t2 The token from which to copy.
  */
 public void copyFrom(Token t2) {
   text = t2.getTextArray();
   textOffset = t2.getTextOffset();
   textCount = t2.length();
   setOffset(t2.getOffset());
   setType(t2.getType());
   hyperlink = t2.isHyperlink();
   languageIndex = t2.getLanguageIndex();
   nextToken = t2.getNextToken();
 }
  /**
   * This is called by the nested wrapped line views to determine the break location. This can be
   * reimplemented to alter the breaking behavior. It will either break at word or character
   * boundaries depending upon the break argument given at construction.
   */
  protected int calculateBreakPosition(int p0, Token tokenList, float x0) {
    // System.err.println("------ beginning calculateBreakPosition() --------");
    int p = p0;
    RSyntaxTextArea textArea = (RSyntaxTextArea) getContainer();
    float currentWidth = getWidth();
    if (currentWidth == Integer.MAX_VALUE) currentWidth = getPreferredSpan(X_AXIS);
    // Make sure width>0; this is a huge hack to fix a bug where
    // loading text into an RTextArea before it is visible if word wrap
    // is enabled causes an infinite loop in calculateBreakPosition()
    // because of the 0-width!  We cannot simply check in setSize()
    // because the width is set to 0 somewhere else too somehow...
    currentWidth = Math.max(currentWidth, MIN_WIDTH);
    Token t = tokenList;
    while (t != null && t.isPaintable()) {
      // FIXME:  Replace the code below with the commented-out line below.  This will
      // allow long tokens to be broken at embedded spaces (such as MLC's).  But it
      // currently throws BadLocationExceptions sometimes...
      float tokenWidth = t.getWidth(textArea, this, x0);
      if (tokenWidth > currentWidth) {
        // If the current token alone is too long for this line,
        // break at a character boundary.
        if (p == p0) {
          return t.getOffsetBeforeX(textArea, this, 0, currentWidth);
        }
        // Return the first non-whitespace char (i.e., don't start
        // off the continuation of a wrapped line with whitespace).
        return t.isWhitespace() ? p + t.length() : p;
        // return getBreakLocation(t, fm, x0, currentWidth, this);
      }
      currentWidth -= tokenWidth;
      x0 += tokenWidth;
      p += t.length();
      // System.err.println("*** *** *** token fit entirely (width==" + tokenWidth + "), adding " +
      // t.textCount + " to p, now p==" + p);
      t = t.getNextToken();
    }
    // System.err.println("... ... whole line fits; returning p==" + p);
    // System.err.println("------ ending calculateBreakPosition() --------");

    //		return p;
    return p + 1;
  }
Exemple #5
0
  /**
   * Adds a token to the token list.
   *
   * @param length The length of the token
   * @param id The id of the token
   */
  protected void addToken(int length, byte id) {
    if (id >= Token.INTERNAL_FIRST && id <= Token.INTERNAL_LAST)
      throw new InternalError("Invalid id: " + id);

    if (length == 0 && id != Token.END) return;

    if (firstToken == null) {
      firstToken = new Token(length, id);
      lastToken = firstToken;
    } else if (lastToken == null) {
      lastToken = firstToken;
      firstToken.length = length;
      firstToken.id = id;
    } else if (lastToken.next == null) {
      lastToken.next = new Token(length, id);
      lastToken = lastToken.next;
    } else {
      lastToken = lastToken.next;
      lastToken.length = length;
      lastToken.id = id;
    }
  }
  /**
   * Modifies the passed-in token list to start at the specified offset. For example, if the token
   * list covered positions 20-60 in the document (inclusive) like so:
   *
   * <pre>
   *   [token1] -> [token2] -> [token3] -> [token4]
   *   20     30   31     40   41     50   51     60
   * </pre>
   *
   * and you used this method to make the token list start at position 44, then the token list would
   * be modified to be the following:
   *
   * <pre>
   *   [part-of-old-token3] -> [token4]
   *   44                 50   51     60
   * </pre>
   *
   * Tokens that come before the specified position are forever lost, and the token containing that
   * position is made to begin at that position if necessary. All token types remain the same as
   * they were originally.
   *
   * <p>This method can be useful if you are only interested in part of a token list (i.e., the line
   * it represents), but you don't want to modify the token list yourself.
   *
   * @param tokenList The list to make start at the specified position. This parameter is modified.
   * @param pos The position at which the new token list is to start. If this position is not in the
   *     passed-in token list, returned token list will either be <code>null</code> or the
   *     unpaintable token(s) at the end of the passed-in token list.
   * @param e How to expand tabs.
   * @param textArea The text area from which the token list came.
   * @param x0 The initial x-pixel position of the old token list.
   * @param tempToken A temporary token to use when creating the token list result. This may be
   *     <code>null</code> but callers can pass in a "buffer" token for performance if desired.
   * @return Information about the "sub" token list. This will be <code>null</code> if <code>pos
   *     </code> was not a valid offset into the token list.
   * @see #getSubTokenList(Token, int, TabExpander, RSyntaxTextArea, float)
   */
  public static TokenSubList getSubTokenList(
      Token tokenList,
      int pos,
      TabExpander e,
      final RSyntaxTextArea textArea,
      float x0,
      TokenImpl tempToken) {

    if (tempToken == null) {
      tempToken = new TokenImpl();
    }
    Token t = tokenList;

    // Loop through the token list until you find the one that contains
    // pos.  Remember the cumulative width of all of these tokens.
    while (t != null && t.isPaintable() && !t.containsPosition(pos)) {
      x0 += t.getWidth(textArea, e, x0);
      t = t.getNextToken();
    }

    // Make the token that contains pos start at pos.
    if (t != null && t.isPaintable()) {

      if (t.getOffset() != pos) {
        // Number of chars between p0 and token start.
        int difference = pos - t.getOffset();
        x0 += t.getWidthUpTo(t.length() - difference + 1, textArea, e, x0);
        tempToken.copyFrom(t);
        tempToken.makeStartAt(pos);

        return new TokenSubList(tempToken, x0);

      } else { // t.getOffset()==pos
        return new TokenSubList(t, x0);
      }
    }

    // This could be a null token, so we need to just return it.
    return new TokenSubList(tokenList, x0);
    // return null;

  }
  public void testNextToken() {
    String script = "   bean = * com;\n    bean2 = * blablabla();\n \n   \n\r \r\n";
    ScriptTokenizer tokenizer =
        new ScriptTokenizer(new ScriptTokenizerInputBuffer(new StringReader(script)));

    Token token = tokenizer.nextToken();
    assertEquals(1, token.getLineNo());
    assertEquals(4, token.length());
    assertEquals(3, token.getFrom());
    assertEquals('b', token.getBuffer()[token.getFrom()]);
    assertEquals('e', token.getBuffer()[token.getFrom() + 1]);
    assertEquals('a', token.getBuffer()[token.getFrom() + 2]);
    assertEquals('n', token.getBuffer()[token.getFrom() + 3]);

    assertEquals(4, token.getCharNoBefore());
    //        assertEquals(, );

    token = tokenizer.nextToken();
    assertEquals(1, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(8, token.getFrom());
    assertEquals('=', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertEquals(1, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(10, token.getFrom());
    assertEquals('*', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertEquals(1, token.getLineNo());
    assertEquals(3, token.length());
    assertEquals(12, token.getFrom());
    assertEquals('c', token.getBuffer()[token.getFrom()]);
    assertEquals('o', token.getBuffer()[token.getFrom() + 1]);
    assertEquals('m', token.getBuffer()[token.getFrom() + 2]);

    token = tokenizer.nextToken();
    assertEquals(1, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(15, token.getFrom());
    assertEquals(';', token.getBuffer()[token.getFrom()]);

    // line 2
    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(5, token.length());
    assertEquals(21, token.getFrom());
    assertEquals('b', token.getBuffer()[token.getFrom()]);
    assertEquals('e', token.getBuffer()[token.getFrom() + 1]);
    assertEquals('a', token.getBuffer()[token.getFrom() + 2]);
    assertEquals('n', token.getBuffer()[token.getFrom() + 3]);
    assertEquals('2', token.getBuffer()[token.getFrom() + 4]);

    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(27, token.getFrom());
    assertEquals('=', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(29, token.getFrom());
    assertEquals('*', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(9, token.length());
    assertEquals(31, token.getFrom());
    assertEquals('b', token.getBuffer()[token.getFrom()]);
    assertEquals('l', token.getBuffer()[token.getFrom() + 1]);
    assertEquals('a', token.getBuffer()[token.getFrom() + 2]);
    assertEquals('b', token.getBuffer()[token.getFrom() + 3]);
    assertEquals('l', token.getBuffer()[token.getFrom() + 4]);
    assertEquals('a', token.getBuffer()[token.getFrom() + 5]);
    assertEquals('b', token.getBuffer()[token.getFrom() + 6]);
    assertEquals('l', token.getBuffer()[token.getFrom() + 7]);
    assertEquals('a', token.getBuffer()[token.getFrom() + 8]);

    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(40, token.getFrom());
    assertEquals('(', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(41, token.getFrom());
    assertEquals(')', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertEquals(2, token.getLineNo());
    assertEquals(1, token.length());
    assertEquals(42, token.getFrom());
    assertEquals(';', token.getBuffer()[token.getFrom()]);

    token = tokenizer.nextToken();
    assertNull(token);
  }
  /**
   * Draws a single view (i.e., a line of text for a wrapped view), wrapping the text onto multiple
   * lines if necessary. Any selected text is rendered with the editor's "selected text" color.
   *
   * @param painter The painter to use to render tokens.
   * @param g The graphics context in which to paint.
   * @param r The rectangle in which to paint.
   * @param view The <code>View</code> to paint.
   * @param fontHeight The height of the font being used.
   * @param y The y-coordinate at which to begin painting.
   * @param selStart The start of the selection.
   * @param selEnd The end of the selection.
   */
  protected void drawViewWithSelection(
      TokenPainter painter,
      Graphics2D g,
      Rectangle r,
      View view,
      int fontHeight,
      int y,
      int selStart,
      int selEnd) {

    float x = r.x;

    LayeredHighlighter h = (LayeredHighlighter) host.getHighlighter();

    RSyntaxDocument document = (RSyntaxDocument) getDocument();
    Element map = getElement();

    int p0 = view.getStartOffset();
    int lineNumber = map.getElementIndex(p0);
    int p1 = view.getEndOffset(); // - 1;

    setSegment(p0, p1 - 1, document, drawSeg);
    // System.err.println("drawSeg=='" + drawSeg + "' (p0/p1==" + p0 + "/" + p1 + ")");
    int start = p0 - drawSeg.offset;
    Token token = document.getTokenListForLine(lineNumber);

    // If this line is an empty line, then the token list is simply a
    // null token.  In this case, the line highlight will be skipped in
    // the loop below, so unfortunately we must manually do it here.
    if (token != null && token.getType() == Token.NULL) {
      h.paintLayeredHighlights(g, p0, p1, r, host, this);
      return;
    }

    // Loop through all tokens in this view and paint them!
    while (token != null && token.isPaintable()) {

      int p = calculateBreakPosition(p0, token, x);
      x = r.x;

      h.paintLayeredHighlights(g, p0, p, r, host, this);

      while (token != null && token.isPaintable() && token.getEndOffset() - 1 < p) { // <=p) {

        // Selection starts in this token
        if (token.containsPosition(selStart)) {

          if (selStart > token.getOffset()) {
            tempToken.copyFrom(token);
            tempToken.textCount = selStart - tempToken.getOffset();
            x = painter.paint(tempToken, g, x, y, host, this);
            tempToken.textCount = token.length();
            tempToken.makeStartAt(selStart);
            // Clone required since token and tempToken must be
            // different tokens for else statement below
            token = new TokenImpl(tempToken);
          }

          int selCount = Math.min(token.length(), selEnd - token.getOffset());
          if (selCount == token.length()) {
            x = painter.paintSelected(token, g, x, y, host, this);
          } else {
            tempToken.copyFrom(token);
            tempToken.textCount = selCount;
            x = painter.paintSelected(tempToken, g, x, y, host, this);
            tempToken.textCount = token.length();
            tempToken.makeStartAt(token.getOffset() + selCount);
            token = tempToken;
            x = painter.paint(token, g, x, y, host, this);
          }

        }

        // Selection ends in this token
        else if (token.containsPosition(selEnd)) {
          tempToken.copyFrom(token);
          tempToken.textCount = selEnd - tempToken.getOffset();
          x = painter.paintSelected(tempToken, g, x, y, host, this);
          tempToken.textCount = token.length();
          tempToken.makeStartAt(selEnd);
          token = tempToken;
          x = painter.paint(token, g, x, y, host, this);
        }

        // This token is entirely selected
        else if (token.getOffset() >= selStart && token.getEndOffset() <= selEnd) {
          x = painter.paintSelected(token, g, x, y, host, this);
        }

        // This token is entirely unselected
        else {
          x = painter.paint(token, g, x, y, host, this);
        }

        token = token.getNextToken();
      }

      // If there's a token that's going to be split onto the next line
      if (token != null && token.isPaintable() && token.getOffset() < p) {

        int tokenOffset = token.getOffset();
        Token orig = token;
        token =
            new TokenImpl(
                drawSeg, tokenOffset - start, p - 1 - start, tokenOffset, token.getType());

        // Selection starts in this token
        if (token.containsPosition(selStart)) {

          if (selStart > token.getOffset()) {
            tempToken.copyFrom(token);
            tempToken.textCount = selStart - tempToken.getOffset();
            x = painter.paint(tempToken, g, x, y, host, this);
            tempToken.textCount = token.length();
            tempToken.makeStartAt(selStart);
            // Clone required since token and tempToken must be
            // different tokens for else statement below
            token = new TokenImpl(tempToken);
          }

          int selCount = Math.min(token.length(), selEnd - token.getOffset());
          if (selCount == token.length()) {
            x = painter.paintSelected(token, g, x, y, host, this);
          } else {
            tempToken.copyFrom(token);
            tempToken.textCount = selCount;
            x = painter.paintSelected(tempToken, g, x, y, host, this);
            tempToken.textCount = token.length();
            tempToken.makeStartAt(token.getOffset() + selCount);
            token = tempToken;
            x = painter.paint(token, g, x, y, host, this);
          }

        }

        // Selection ends in this token
        else if (token.containsPosition(selEnd)) {
          tempToken.copyFrom(token);
          tempToken.textCount = selEnd - tempToken.getOffset();
          x = painter.paintSelected(tempToken, g, x, y, host, this);
          tempToken.textCount = token.length();
          tempToken.makeStartAt(selEnd);
          token = tempToken;
          x = painter.paint(token, g, x, y, host, this);
        }

        // This token is entirely selected
        else if (token.getOffset() >= selStart && token.getEndOffset() <= selEnd) {
          x = painter.paintSelected(token, g, x, y, host, this);
        }

        // This token is entirely unselected
        else {
          x = painter.paint(token, g, x, y, host, this);
        }

        token = new TokenImpl(orig);
        ((TokenImpl) token).makeStartAt(p);
      }

      p0 = (p == p0) ? p1 : p;
      y += fontHeight;
    } // End of while (token!=null && token.isPaintable()).

    // NOTE: We should re-use code from Token (paintBackground()) here,
    // but don't because I'm just too lazy.
    if (host.getEOLMarkersVisible()) {
      g.setColor(host.getForegroundForTokenType(Token.WHITESPACE));
      g.setFont(host.getFontForTokenType(Token.WHITESPACE));
      g.drawString("\u00B6", x, y - fontHeight);
    }
  }
  /**
   * Draws the passed-in text using syntax highlighting for the current language. Tokens are checked
   * for being in a selected region, and are rendered appropriately if they are.
   *
   * @param painter The painter to render the tokens.
   * @param token The list of tokens to draw.
   * @param g The graphics context in which to draw.
   * @param x The x-coordinate at which to draw.
   * @param y The y-coordinate at which to draw.
   * @param selStart The start of the selection.
   * @param selEnd The end of the selection.
   * @return The x-coordinate representing the end of the painted text.
   */
  private float drawLineWithSelection(
      TokenPainter painter, Token token, Graphics2D g, float x, float y, int selStart, int selEnd) {

    float nextX = x; // The x-value at the end of our text.
    boolean useSTC = host.getUseSelectedTextColor();

    while (token != null && token.isPaintable() && nextX < clipEnd) {

      // Selection starts in this token
      if (token.containsPosition(selStart)) {

        if (selStart > token.getOffset()) {
          tempToken.copyFrom(token);
          tempToken.textCount = selStart - tempToken.getOffset();
          nextX = painter.paint(tempToken, g, nextX, y, host, this, clipStart);
          tempToken.textCount = token.length();
          tempToken.makeStartAt(selStart);
          // Clone required since token and tempToken must be
          // different tokens for else statement below
          token = new TokenImpl(tempToken);
        }

        int tokenLen = token.length();
        int selCount = Math.min(tokenLen, selEnd - token.getOffset());
        if (selCount == tokenLen) {
          nextX = painter.paintSelected(token, g, nextX, y, host, this, clipStart, useSTC);
        } else {
          tempToken.copyFrom(token);
          tempToken.textCount = selCount;
          nextX = painter.paintSelected(tempToken, g, nextX, y, host, this, clipStart, useSTC);
          tempToken.textCount = token.length();
          tempToken.makeStartAt(token.getOffset() + selCount);
          token = tempToken;
          nextX = painter.paint(token, g, nextX, y, host, this, clipStart);
        }

      }

      // Selection ends in this token
      else if (token.containsPosition(selEnd)) {
        tempToken.copyFrom(token);
        tempToken.textCount = selEnd - tempToken.getOffset();
        nextX = painter.paintSelected(tempToken, g, nextX, y, host, this, clipStart, useSTC);
        tempToken.textCount = token.length();
        tempToken.makeStartAt(selEnd);
        token = tempToken;
        nextX = painter.paint(token, g, nextX, y, host, this, clipStart);
      }

      // This token is entirely selected
      else if (token.getOffset() >= selStart && token.getEndOffset() <= selEnd) {
        nextX = painter.paintSelected(token, g, nextX, y, host, this, clipStart, useSTC);
      }

      // This token is entirely unselected
      else {
        nextX = painter.paint(token, g, nextX, y, host, this, clipStart);
      }

      token = token.getNextToken();
    }

    // NOTE: We should re-use code from Token (paintBackground()) here,
    // but don't because I'm just too lazy.
    if (host.getEOLMarkersVisible()) {
      g.setColor(host.getForegroundForTokenType(Token.WHITESPACE));
      g.setFont(host.getFontForTokenType(Token.WHITESPACE));
      g.drawString("\u00B6", nextX, y);
    }

    // Return the x-coordinate at the end of the painted text.
    return nextX;
  }
  /** {@inheritDoc} */
  public void markOccurrences(
      RSyntaxDocument doc,
      Token t,
      RSyntaxTextAreaHighlighter h,
      MarkOccurrencesHighlightPainter p) {

    char[] lexeme = t.getLexeme().toCharArray();
    int tokenOffs = t.getOffset();
    Element root = doc.getDefaultRootElement();
    int lineCount = root.getElementCount();
    int curLine = root.getElementIndex(t.getOffset());

    // For now, we only check for tags on the current line, for
    // simplicity.  Tags spanning multiple lines aren't common anyway.
    boolean found = false;
    boolean forward = true;
    t = doc.getTokenListForLine(curLine);
    while (t != null && t.isPaintable()) {
      if (t.getType() == Token.MARKUP_TAG_DELIMITER) {
        if (t.isSingleChar('<') && t.getOffset() + 1 == tokenOffs) {
          found = true;
          break;
        } else if (t.is(CLOSE_TAG_START) && t.getOffset() + 2 == tokenOffs) {
          found = true;
          forward = false;
          break;
        }
      }
      t = t.getNextToken();
    }

    if (!found) {
      return;
    }

    if (forward) {

      int depth = 0;
      t = t.getNextToken().getNextToken();

      do {

        while (t != null && t.isPaintable()) {
          if (t.getType() == Token.MARKUP_TAG_DELIMITER) {
            if (t.isSingleChar('<')) {
              depth++;
            } else if (t.is(TAG_SELF_CLOSE)) {
              if (depth > 0) {
                depth--;
              } else {
                return; // No match for this tag
              }
            } else if (t.is(CLOSE_TAG_START)) {
              if (depth > 0) {
                depth--;
              } else {
                Token match = t.getNextToken();
                if (match != null && match.is(lexeme)) {
                  try {
                    int end = match.getOffset() + match.length();
                    h.addMarkedOccurrenceHighlight(match.getOffset(), end, p);
                    end = tokenOffs + match.length();
                    h.addMarkedOccurrenceHighlight(tokenOffs, end, p);
                  } catch (BadLocationException ble) {
                    ble.printStackTrace(); // Never happens
                  }
                }
                return; // We're done!
              }
            }
          }
          t = t.getNextToken();
        }

        if (++curLine < lineCount) {
          t = doc.getTokenListForLine(curLine);
        }

      } while (curLine < lineCount);

    } else { // !forward

      Stack<Token> matches = new Stack<Token>();
      boolean inPossibleMatch = false;
      t = doc.getTokenListForLine(curLine);
      final int endBefore = tokenOffs - 2; // Stop before "</".

      do {

        while (t != null && t.getOffset() < endBefore && t.isPaintable()) {
          if (t.getType() == Token.MARKUP_TAG_DELIMITER) {
            if (t.isSingleChar('<')) {
              Token next = t.getNextToken();
              if (next != null) {
                if (next.is(lexeme)) {
                  matches.push(next);
                  inPossibleMatch = true;
                } else {
                  inPossibleMatch = false;
                }
                t = next;
              }
            } else if (t.isSingleChar('>')) {
              inPossibleMatch = false;
            } else if (inPossibleMatch && t.is(TAG_SELF_CLOSE)) {
              matches.pop();
            } else if (t.is(CLOSE_TAG_START)) {
              Token next = t.getNextToken();
              if (next != null) {
                // Invalid XML might not have a match
                if (next.is(lexeme) && !matches.isEmpty()) {
                  matches.pop();
                }
                t = next;
              }
            }
          }
          t = t.getNextToken();
        }

        if (!matches.isEmpty()) {
          try {
            Token match = matches.pop();
            int end = match.getOffset() + match.length();
            h.addMarkedOccurrenceHighlight(match.getOffset(), end, p);
            end = tokenOffs + match.length();
            h.addMarkedOccurrenceHighlight(tokenOffs, end, p);
          } catch (BadLocationException ble) {
            ble.printStackTrace(); // Never happens
          }
          return;
        }

        if (--curLine >= 0) {
          t = doc.getTokenListForLine(curLine);
        }

      } while (curLine >= 0);
    }
  }