net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/ui/text/JavaHeuristicScanner.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.ui.text;
  12
  13 import java.util.Arrays;
  14
  15 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
  16
  17 import org.eclipse.jface.text.Assert;
  18 import org.eclipse.jface.text.BadLocationException;
  19 import org.eclipse.jface.text.IDocument;
  20 import org.eclipse.jface.text.IRegion;
  21 import org.eclipse.jface.text.ITypedRegion;
  22 import org.eclipse.jface.text.Region;
  23 import org.eclipse.jface.text.TextUtilities;
  24
  25 /**
  26  * Utility methods for heuristic based Java manipulations in an incomplete Java source file.
  27  *
  28  * <p>An instance holds some internal position in the document and is therefore not threadsafe.</p>
  29  *
  30  * @since 3.0
  31  */
  32 public class JavaHeuristicScanner implements Symbols {
  33         /**
  34          * Returned by all methods when the requested position could not be found, or if a
  35          * {@link BadLocationException} was thrown while scanning.
  36          */
  37         public static final int NOT_FOUND= -1;
  38
  39         /**
  40          * Special bound parameter that means either -1 (backward scanning) or
  41          * <code>fDocument.getLength()</code> (forward scanning).
  42          */
  43         public static final int UNBOUND= -2;
  44
  45
  46         /* character constants */
  47         private static final char LBRACE= '{';
  48         private static final char RBRACE= '}';
  49         private static final char LPAREN= '(';
  50         private static final char RPAREN= ')';
  51         private static final char SEMICOLON= ';';
  52         private static final char COLON= ':';
  53         private static final char COMMA= ',';
  54         private static final char LBRACKET= '[';
  55         private static final char RBRACKET= ']';
  56         private static final char QUESTIONMARK= '?';
  57         private static final char EQUAL= '=';
  58
  59         /**
  60          * Specifies the stop condition, upon which the <code>scanXXX</code> methods will decide whether
  61          * to keep scanning or not. This interface may implemented by clients.
  62          */
  63         public interface StopCondition {
  64                 /**
  65                  * Instructs the scanner to return the current position.
  66                  *
  67                  * @param ch the char at the current position
  68                  * @param position the current position
  69                  * @param forward the iteration direction
  70                  * @return <code>true</code> if the stop condition is met.
  71                  */
  72                 boolean stop(char ch, int position, boolean forward);
  73         }
  74
  75         /**
  76          * Stops upon a non-whitespace (as defined by {@link Character#isWhitespace(char)}) character.
  77          */
  78         private static class NonWhitespace implements StopCondition {
  79                 /*
  80                  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
  81                  */
  82                 public boolean stop(char ch, int position, boolean forward) {
  83                         return !Character.isWhitespace(ch);
  84                 }
  85         }
  86
  87         /**
  88          * Stops upon a non-whitespace character in the default partition.
  89          *
  90          * @see NonWhitespace
  91          */
  92         private class NonWhitespaceDefaultPartition extends NonWhitespace {
  93                 /*
  94                  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
  95                  */
  96                 public boolean stop(char ch, int position, boolean forward) {
  97                         return super.stop(ch, position, true) && isDefaultPartition(position);
  98                 }
  99         }
 100
 101         /**
 102          * Stops upon a non-java identifier (as defined by {@link Scanner#isPHPIdentifierPart(char)}) character.
 103          */
 104         private static class NonJavaIdentifierPart implements StopCondition {
 105                 /*
 106                  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
 107                  */
 108                 public boolean stop(char ch, int position, boolean forward) {
 109                         return !Scanner.isPHPIdentifierPart(ch);
 110                 }
 111         }
 112
 113         /**
 114          * Stops upon a non-java identifier character in the default partition.
 115          *
 116          * @see NonJavaIdentifierPart
 117          */
 118         private class NonJavaIdentifierPartDefaultPartition extends NonJavaIdentifierPart {
 119                 /*
 120                  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char)
 121                  */
 122                 public boolean stop(char ch, int position, boolean forward) {
 123                         return super.stop(ch, position, true) || !isDefaultPartition(position);
 124                 }
 125         }
 126
 127         /**
 128          * Stops upon a character in the default partition that matches the given character list.
 129          */
 130         private class CharacterMatch implements StopCondition {
 131                 private final char[] fChars;
 132
 133                 /**
 134                  * Creates a new instance.
 135                  * @param ch the single character to match
 136                  */
 137                 public CharacterMatch(char ch) {
 138                         this(new char[] {ch});
 139                 }
 140
 141                 /**
 142                  * Creates a new instance.
 143                  * @param chars the chars to match.
 144                  */
 145                 public CharacterMatch(char[] chars) {
 146                         Assert.isNotNull(chars);
 147                         Assert.isTrue(chars.length > 0);
 148                         fChars= chars;
 149                         Arrays.sort(chars);
 150                 }
 151
 152                 /*
 153                  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char, int)
 154                  */
 155                 public boolean stop(char ch, int position, boolean forward) {
 156                         return Arrays.binarySearch(fChars, ch) >= 0 && isDefaultPartition(position);
 157                 }
 158         }
 159
 160         /**
 161          * Acts like character match, but skips all scopes introduced by parenthesis, brackets, and
 162          * braces.
 163          */
 164         protected class SkippingScopeMatch extends CharacterMatch {
 165                 private char fOpening, fClosing;
 166                 private int fDepth= 0;
 167
 168                 /**
 169                  * Creates a new instance.
 170                  * @param ch the single character to match
 171                  */
 172                 public SkippingScopeMatch(char ch) {
 173                         super(ch);
 174                 }
 175
 176                 /**
 177                  * Creates a new instance.
 178                  * @param chars the chars to match.
 179                  */
 180                 public SkippingScopeMatch(char[] chars) {
 181                         super(chars);
 182                 }
 183
 184                 /*
 185                  * @see net.sourceforge.phpdt.internal.ui.text.JavaHeuristicScanner.StopCondition#stop(char, int)
 186                  */
 187                 public boolean stop(char ch, int position, boolean forward) {
 188
 189                         if (fDepth == 0 && super.stop(ch, position, true))
 190                                 return true;
 191                         else if (ch == fOpening)
 192                                 fDepth++;
 193                         else if (ch == fClosing) {
 194                                 fDepth--;
 195                                 if (fDepth == 0) {
 196                                         fOpening= 0;
 197                                         fClosing= 0;
 198                                 }
 199                         } else if (fDepth == 0) {
 200                                 fDepth= 1;
 201                                 if (forward) {
 202
 203                                         switch (ch) {
 204                                                 case LBRACE:
 205                                                         fOpening= LBRACE;
 206                                                         fClosing= RBRACE;
 207                                                         break;
 208                                                 case LPAREN:
 209                                                         fOpening= LPAREN;
 210                                                         fClosing= RPAREN;
 211                                                         break;
 212                                                 case LBRACKET:
 213                                                         fOpening= LBRACKET;
 214                                                         fClosing= RBRACKET;
 215                                                         break;
 216                                         }
 217
 218                                 } else {
 219                                         switch (ch) {
 220                                                 case RBRACE:
 221                                                         fOpening= RBRACE;
 222                                                         fClosing= LBRACE;
 223                                                         break;
 224                                                 case RPAREN:
 225                                                         fOpening= RPAREN;
 226                                                         fClosing= LPAREN;
 227                                                         break;
 228                                                 case RBRACKET:
 229                                                         fOpening= RBRACKET;
 230                                                         fClosing= LBRACKET;
 231                                                         break;
 232                                         }
 233
 234                                 }
 235                         }
 236
 237                         return false;
 238
 239                 }
 240
 241         }
 242
 243         /** The document being scanned. */
 244         private IDocument fDocument;
 245         /** The partitioning being used for scanning. */
 246         private String fPartitioning;
 247         /** The partition to scan in. */
 248         private String fPartition;
 249
 250         /* internal scan state */
 251
 252         /** the most recently read character. */
 253         private char fChar;
 254         /** the most recently read position. */
 255         private int fPos;
 256
 257         /* preset stop conditions */
 258         private final StopCondition fNonWSDefaultPart= new NonWhitespaceDefaultPartition();
 259         private final static StopCondition fNonWS= new NonWhitespace();
 260         private final StopCondition fNonIdent= new NonJavaIdentifierPartDefaultPartition();
 261
 262         /**
 263          * Creates a new instance.
 264          *
 265          * @param document the document to scan
 266          * @param partitioning the partitioning to use for scanning
 267          * @param partition the partition to scan in
 268          */
 269         public JavaHeuristicScanner(IDocument document, String partitioning, String partition) {
 270                 Assert.isNotNull(document);
 271                 Assert.isNotNull(partitioning);
 272                 Assert.isNotNull(partition);
 273                 fDocument= document;
 274                 fPartitioning= partitioning;
 275                 fPartition= partition;
 276         }
 277
 278         /**
 279          * Calls <code>this(document, IJavaPartitions.JAVA_PARTITIONING, IDocument.DEFAULT_CONTENT_TYPE)</code>.
 280          *
 281          * @param document the document to scan.
 282          */
 283         public JavaHeuristicScanner(IDocument document) {
 284                 this(document, IPHPPartitions.PHP_PARTITIONING, IDocument.DEFAULT_CONTENT_TYPE);
 285         }
 286
 287         /**
 288          * Returns the most recent internal scan position.
 289          *
 290          * @return the most recent internal scan position.
 291          */
 292         public int getPosition() {
 293                 return fPos;
 294         }
 295
 296         /**
 297          * Returns the next token in forward direction, starting at <code>start</code>, and not extending
 298          * further than <code>bound</code>. The return value is one of the constants defined in {@link Symbols}.
 299          * After a call, {@link #getPosition()} will return the position just after the scanned token
 300          * (i.e. the next position that will be scanned).
 301          *
 302          * @param start the first character position in the document to consider
 303          * @param bound the first position not to consider any more
 304          * @return a constant from {@link Symbols} describing the next token
 305          */
 306         public int nextToken(int start, int bound) {
 307                 int pos= scanForward(start, bound, fNonWSDefaultPart);
 308                 if (pos == NOT_FOUND)
 309                         return TokenEOF;
 310
 311                 fPos++;
 312
 313                 switch (fChar) {
 314                         case LBRACE:
 315                                 return TokenLBRACE;
 316                         case RBRACE:
 317                                 return TokenRBRACE;
 318                         case LBRACKET:
 319                                 return TokenLBRACKET;
 320                         case RBRACKET:
 321                                 return TokenRBRACKET;
 322                         case LPAREN:
 323                                 return TokenLPAREN;
 324                         case RPAREN:
 325                                 return TokenRPAREN;
 326                         case SEMICOLON:
 327                                 return TokenSEMICOLON;
 328                         case COMMA:
 329                                 return TokenCOMMA;
 330                         case QUESTIONMARK:
 331                                 return TokenQUESTIONMARK;
 332                         case EQUAL:
 333                                 return TokenEQUAL;
 334                 }
 335
 336                 // else
 337                 if (Scanner.isPHPIdentifierPart(fChar)) {
 338                         // assume an ident or keyword
 339                         int from= pos, to;
 340                         pos= scanForward(pos + 1, bound, fNonIdent);
 341                         if (pos == NOT_FOUND)
 342                                 to= bound == UNBOUND ? fDocument.getLength() : bound;
 343                         else
 344                                 to= pos;
 345
 346                         String identOrKeyword;
 347                         try {
 348                                 identOrKeyword= fDocument.get(from, to - from);
 349                         } catch (BadLocationException e) {
 350                                 return TokenEOF;
 351                         }
 352
 353                         return getToken(identOrKeyword);
 354
 355
 356                 } else {
 357                         // operators, number literals etc
 358                         return TokenOTHER;
 359                 }
 360         }
 361
 362         /**
 363          * Returns the next token in backward direction, starting at <code>start</code>, and not extending
 364          * further than <code>bound</code>. The return value is one of the constants defined in {@link Symbols}.
 365          * After a call, {@link #getPosition()} will return the position just before the scanned token
 366          * starts (i.e. the next position that will be scanned).
 367          *
 368          * @param start the first character position in the document to consider
 369          * @param bound the first position not to consider any more
 370          * @return a constant from {@link Symbols} describing the previous token
 371          */
 372         public int previousToken(int start, int bound) {
 373                 int pos= scanBackward(start, bound, fNonWSDefaultPart);
 374                 if (pos == NOT_FOUND)
 375                         return TokenEOF;
 376
 377                 fPos--;
 378
 379                 switch (fChar) {
 380                         case LBRACE:
 381                                 return TokenLBRACE;
 382                         case RBRACE:
 383                                 return TokenRBRACE;
 384                         case LBRACKET:
 385                                 return TokenLBRACKET;
 386                         case RBRACKET:
 387                                 return TokenRBRACKET;
 388                         case LPAREN:
 389                                 return TokenLPAREN;
 390                         case RPAREN:
 391                                 return TokenRPAREN;
 392                         case SEMICOLON:
 393                                 return TokenSEMICOLON;
 394                         case COLON:
 395                                 return TokenCOLON;
 396                         case COMMA:
 397                                 return TokenCOMMA;
 398                         case QUESTIONMARK:
 399                                 return TokenQUESTIONMARK;
 400                         case EQUAL:
 401                                 return TokenEQUAL;
 402                 }
 403
 404                 // else
 405                 if (Scanner.isPHPIdentifierPart(fChar)) {
 406                         // assume an ident or keyword
 407                         int from, to= pos + 1;
 408                         pos= scanBackward(pos - 1, bound, fNonIdent);
 409                         if (pos == NOT_FOUND)
 410                                 from= bound == UNBOUND ? 0 : bound + 1;
 411                         else
 412                                 from= pos + 1;
 413
 414                         String identOrKeyword;
 415                         try {
 416                                 identOrKeyword= fDocument.get(from, to - from);
 417                         } catch (BadLocationException e) {
 418                                 return TokenEOF;
 419                         }
 420
 421                         return getToken(identOrKeyword);
 422
 423
 424                 } else {
 425                         // operators, number literals etc
 426                         return TokenOTHER;
 427                 }
 428
 429         }
 430
 431         /**
 432          * Returns one of the keyword constants or <code>TokenIDENT</code> for a scanned identifier.
 433          *
 434          * @param s a scanned identifier
 435          * @return one of the constants defined in {@link Symbols}
 436          */
 437         private int getToken(String s) {
 438                 Assert.isNotNull(s);
 439
 440                 switch (s.length()) {
 441                         case 2:
 442                                 if ("if".equals(s)) //$NON-NLS-1$
 443                                         return TokenIF;
 444                                 if ("do".equals(s)) //$NON-NLS-1$
 445                                         return TokenDO;
 446                                 break;
 447                         case 3:
 448                                 if ("for".equals(s)) //$NON-NLS-1$
 449                                         return TokenFOR;
 450                                 if ("try".equals(s)) //$NON-NLS-1$
 451                                         return TokenTRY;
 452                                 if ("new".equals(s)) //$NON-NLS-1$
 453                                         return TokenNEW;
 454                                 break;
 455                         case 4:
 456                                 if ("case".equals(s)) //$NON-NLS-1$
 457                                         return TokenCASE;
 458                                 if ("else".equals(s)) //$NON-NLS-1$
 459                                         return TokenELSE;
 460                                 if ("goto".equals(s)) //$NON-NLS-1$
 461                                         return TokenGOTO;
 462                                 break;
 463                         case 5:
 464                                 if ("break".equals(s)) //$NON-NLS-1$
 465                                         return TokenBREAK;
 466                                 if ("catch".equals(s)) //$NON-NLS-1$
 467                                         return TokenCATCH;
 468                                 if ("while".equals(s)) //$NON-NLS-1$
 469                                         return TokenWHILE;
 470                                 break;
 471                         case 6:
 472                                 if ("return".equals(s)) //$NON-NLS-1$
 473                                         return TokenRETURN;
 474                                 if ("static".equals(s)) //$NON-NLS-1$
 475                                         return TokenSTATIC;
 476                                 if ("switch".equals(s)) //$NON-NLS-1$
 477                                         return TokenSWITCH;
 478                                 break;
 479                         case 7:
 480                                 if ("default".equals(s)) //$NON-NLS-1$
 481                                         return TokenDEFAULT;
 482                                 if ("finally".equals(s)) //$NON-NLS-1$
 483                                         return TokenFINALLY;
 484                                 break;
 485                         case 12:
 486                                 if ("synchronized".equals(s)) //$NON-NLS-1$
 487                                         return TokenSYNCHRONIZED;
 488                                 break;
 489                 }
 490                 return TokenIDENT;
 491         }
 492
 493         /**
 494          * Returns the position of the closing peer character (forward search). Any scopes introduced by opening peers
 495          * are skipped. All peers accounted for must reside in the default partition.
 496          *
 497          * <p>Note that <code>start</code> must not point to the opening peer, but to the first
 498          * character being searched.</p>
 499          *
 500          * @param start the start position
 501          * @param openingPeer the opening peer character (e.g. '{')
 502          * @param closingPeer the closing peer character (e.g. '}')
 503          * @return the matching peer character position, or <code>NOT_FOUND</code>
 504          */
 505         public int findClosingPeer(int start, final char openingPeer, final char closingPeer) {
 506                 Assert.isNotNull(fDocument);
 507                 Assert.isTrue(start >= 0);
 508
 509                 try {
 510                         int depth= 1;
 511                         start -= 1;
 512                         while (true) {
 513                                 start= scanForward(start + 1, UNBOUND, new CharacterMatch(new char[] {openingPeer, closingPeer}));
 514                                 if (start == NOT_FOUND)
 515                                         return NOT_FOUND;
 516
 517                                 if (fDocument.getChar(start) == openingPeer)
 518                                         depth++;
 519                                 else
 520                                         depth--;
 521
 522                                 if (depth == 0)
 523                                         return start;
 524                         }
 525
 526                 } catch (BadLocationException e) {
 527                         return NOT_FOUND;
 528                 }
 529         }
 530
 531         /**
 532          * Returns the position of the opening peer character (backward search). Any scopes introduced by closing peers
 533          * are skipped. All peers accounted for must reside in the default partition.
 534          *
 535          * <p>Note that <code>start</code> must not point to the closing peer, but to the first
 536          * character being searched.</p>
 537          *
 538          * @param start the start position
 539          * @param openingPeer the opening peer character (e.g. '{')
 540          * @param closingPeer the closing peer character (e.g. '}')
 541          * @return the matching peer character position, or <code>NOT_FOUND</code>
 542          */
 543         public int findOpeningPeer(int start, char openingPeer, char closingPeer) {
 544                 Assert.isTrue(start < fDocument.getLength());
 545
 546                 try {
 547                         int depth= 1;
 548                         start += 1;
 549                         while (true) {
 550                                 start= scanBackward(start - 1, UNBOUND, new CharacterMatch(new char[] {openingPeer, closingPeer}));
 551                                 if (start == NOT_FOUND)
 552                                         return NOT_FOUND;
 553
 554                                 if (fDocument.getChar(start) == closingPeer)
 555                                         depth++;
 556                                 else
 557                                         depth--;
 558
 559                                 if (depth == 0)
 560                                         return start;
 561                         }
 562
 563                 } catch (BadLocationException e) {
 564                         return NOT_FOUND;
 565                 }
 566         }
 567
 568         /**
 569          * Computes the surrounding block around <code>offset</code>. The search is started at the
 570          * beginning of <code>offset</code>, i.e. an opening brace at <code>offset</code> will not be
 571          * part of the surrounding block, but a closing brace will.
 572          *
 573          * @param offset the offset for which the surrounding block is computed
 574          * @return a region describing the surrounding block, or <code>null</code> if none can be found
 575          */
 576         public IRegion findSurroundingBlock(int offset) {
 577                 if (offset < 1 || offset >= fDocument.getLength())
 578                         return null;
 579
 580                 int begin= findOpeningPeer(offset - 1, LBRACE, RBRACE);
 581                 int end= findClosingPeer(offset, LBRACE, RBRACE);
 582                 if (begin == NOT_FOUND || end == NOT_FOUND)
 583                         return null;
 584                 return new Region(begin, end + 1 - begin);
 585         }
 586
 587         /**
 588          * Finds the smallest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
 589          * and &lt; <code>bound</code> and <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>
 590          * and the position is in the default partition.
 591          *
 592          * @param position the first character position in <code>fDocument</code> to be considered
 593          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
 594          * @return the smallest position of a non-whitespace character in [<code>position</code>, <code>bound</code>) that resides in a Java partition, or <code>NOT_FOUND</code> if none can be found
 595          */
 596         public int findNonWhitespaceForward(int position, int bound) {
 597                 return scanForward(position, bound, fNonWSDefaultPart);
 598         }
 599
 600         /**
 601          * Finds the smallest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
 602          * and &lt; <code>bound</code> and <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>.
 603          *
 604          * @param position the first character position in <code>fDocument</code> to be considered
 605          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
 606          * @return the smallest position of a non-whitespace character in [<code>position</code>, <code>bound</code>), or <code>NOT_FOUND</code> if none can be found
 607          */
 608         public int findNonWhitespaceForwardInAnyPartition(int position, int bound) {
 609                 return scanForward(position, bound, fNonWS);
 610         }
 611
 612         /**
 613          * Finds the highest position in <code>fDocument</code> such that the position is &lt;= <code>position</code>
 614          * and &gt; <code>bound</code> and <code>Character.isWhitespace(fDocument.getChar(pos))</code> evaluates to <code>false</code>
 615          * and the position is in the default partition.
 616          *
 617          * @param position the first character position in <code>fDocument</code> to be considered
 618          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>position</code>, or <code>UNBOUND</code>
 619          * @return the highest position of a non-whitespace character in (<code>bound</code>, <code>position</code>] that resides in a Java partition, or <code>NOT_FOUND</code> if none can be found
 620          */
 621         public int findNonWhitespaceBackward(int position, int bound) {
 622                 return scanBackward(position, bound, fNonWSDefaultPart);
 623         }
 624
 625         /**
 626          * Finds the lowest position <code>p</code> in <code>fDocument</code> such that <code>start</code> &lt;= p &lt;
 627          * <code>bound</code> and <code>condition.stop(fDocument.getChar(p), p)</code> evaluates to <code>true</code>.
 628          *
 629          * @param start the first character position in <code>fDocument</code> to be considered
 630          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>start</code>, or <code>UNBOUND</code>
 631          * @param condition the <code>StopCondition</code> to check
 632          * @return the lowest position in [<code>start</code>, <code>bound</code>) for which <code>condition</code> holds, or <code>NOT_FOUND</code> if none can be found
 633          */
 634         public int scanForward(int start, int bound, StopCondition condition) {
 635                 Assert.isTrue(start >= 0);
 636
 637                 if (bound == UNBOUND)
 638                         bound= fDocument.getLength();
 639
 640                 Assert.isTrue(bound <= fDocument.getLength());
 641
 642                 try {
 643                         fPos= start;
 644                         while (fPos < bound) {
 645
 646                                 fChar= fDocument.getChar(fPos);
 647                                 if (condition.stop(fChar, fPos, true))
 648                                         return fPos;
 649
 650                                 fPos++;
 651                         }
 652                 } catch (BadLocationException e) {
 653                 }
 654                 return NOT_FOUND;
 655         }
 656
 657
 658         /**
 659          * Finds the lowest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
 660          * and &lt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code>
 661          * and the position is in the default partition.
 662          *
 663          * @param position the first character position in <code>fDocument</code> to be considered
 664          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
 665          * @param ch the <code>char</code> to search for
 666          * @return the lowest position of <code>ch</code> in (<code>bound</code>, <code>position</code>] that resides in a Java partition, or <code>NOT_FOUND</code> if none can be found
 667          */
 668         public int scanForward(int position, int bound, char ch) {
 669                 return scanForward(position, bound, new CharacterMatch(ch));
 670         }
 671
 672         /**
 673          * Finds the lowest position in <code>fDocument</code> such that the position is &gt;= <code>position</code>
 674          * and &lt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code> for at least one
 675          * ch in <code>chars</code> and the position is in the default partition.
 676          *
 677          * @param position the first character position in <code>fDocument</code> to be considered
 678          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &gt; <code>position</code>, or <code>UNBOUND</code>
 679          * @param chars an array of <code>char</code> to search for
 680          * @return the lowest position of a non-whitespace character in [<code>position</code>, <code>bound</code>) that resides in a Java partition, or <code>NOT_FOUND</code> if none can be found
 681          */
 682         public int scanForward(int position, int bound, char[] chars) {
 683                 return scanForward(position, bound, new CharacterMatch(chars));
 684         }
 685
 686         /**
 687          * Finds the highest position <code>p</code> in <code>fDocument</code> such that <code>bound</code> &lt; <code>p</code> &lt;= <code>start</code>
 688          * and <code>condition.stop(fDocument.getChar(p), p)</code> evaluates to <code>true</code>.
 689          *
 690          * @param start the first character position in <code>fDocument</code> to be considered
 691          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>start</code>, or <code>UNBOUND</code>
 692          * @param condition the <code>StopCondition</code> to check
 693          * @return the highest position in (<code>bound</code>, <code>start</code> for which <code>condition</code> holds, or <code>NOT_FOUND</code> if none can be found
 694          */
 695         public int scanBackward(int start, int bound, StopCondition condition) {
 696                 if (bound == UNBOUND)
 697                         bound= -1;
 698
 699                 Assert.isTrue(bound >= -1);
 700                 Assert.isTrue(start < fDocument.getLength() );
 701
 702                 try {
 703                         fPos= start;
 704                         while (fPos > bound) {
 705
 706                                 fChar= fDocument.getChar(fPos);
 707                                 if (condition.stop(fChar, fPos, false))
 708                                         return fPos;
 709
 710                                 fPos--;
 711                         }
 712                 } catch (BadLocationException e) {
 713                 }
 714                 return NOT_FOUND;
 715         }
 716
 717         /**
 718          * Finds the highest position in <code>fDocument</code> such that the position is &lt;= <code>position</code>
 719          * and &gt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code> for at least one
 720          * ch in <code>chars</code> and the position is in the default partition.
 721          *
 722          * @param position the first character position in <code>fDocument</code> to be considered
 723          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>position</code>, or <code>UNBOUND</code>
 724          * @param ch the <code>char</code> to search for
 725          * @return the highest position of one element in <code>chars</code> in (<code>bound</code>, <code>position</code>] that resides in a Java partition, or <code>NOT_FOUND</code> if none can be found
 726          */
 727         public int scanBackward(int position, int bound, char ch) {
 728                 return scanBackward(position, bound, new CharacterMatch(ch));
 729         }
 730
 731         /**
 732          * Finds the highest position in <code>fDocument</code> such that the position is &lt;= <code>position</code>
 733          * and &gt; <code>bound</code> and <code>fDocument.getChar(position) == ch</code> evaluates to <code>true</code> for at least one
 734          * ch in <code>chars</code> and the position is in the default partition.
 735          *
 736          * @param position the first character position in <code>fDocument</code> to be considered
 737          * @param bound the first position in <code>fDocument</code> to not consider any more, with <code>bound</code> &lt; <code>position</code>, or <code>UNBOUND</code>
 738          * @param chars an array of <code>char</code> to search for
 739          * @return the highest position of one element in <code>chars</code> in (<code>bound</code>, <code>position</code>] that resides in a Java partition, or <code>NOT_FOUND</code> if none can be found
 740          */
 741         public int scanBackward(int position, int bound, char[] chars) {
 742                 return scanBackward(position, bound, new CharacterMatch(chars));
 743         }
 744
 745         /**
 746          * Checks whether <code>position</code> resides in a default (Java) partition of <code>fDocument</code>.
 747          *
 748          * @param position the position to be checked
 749          * @return <code>true</code> if <code>position</code> is in the default partition of <code>fDocument</code>, <code>false</code> otherwise
 750          */
 751         public boolean isDefaultPartition(int position) {
 752                 Assert.isTrue(position >= 0);
 753                 Assert.isTrue(position <= fDocument.getLength());
 754
 755                 try {
 756                         ITypedRegion region= TextUtilities.getPartition(fDocument, fPartitioning, position, false);
 757                         return region.getType().equals(fPartition);
 758
 759                 } catch (BadLocationException e) {
 760                 }
 761
 762                 return false;
 763         }
 764
 765         /**
 766          * Checks if the line seems to be an open condition not followed by a block (i.e. an if, while,
 767          * or for statement with just one following statement, see example below).
 768          *
 769          * <pre>
 770          * if (condition)
 771          *     doStuff();
 772          * </pre>
 773          *
 774          * <p>Algorithm: if the last non-WS, non-Comment code on the line is an if (condition), while (condition),
 775          * for( expression), do, else, and there is no statement after that </p>
 776          *
 777          * @param position the insert position of the new character
 778          * @param bound the lowest position to consider
 779          * @return <code>true</code> if the code is a conditional statement or loop without a block, <code>false</code> otherwise
 780          */
 781         public boolean isBracelessBlockStart(int position, int bound) {
 782                 if (position < 1)
 783                         return false;
 784
 785                 switch (previousToken(position, bound)) {
 786                         case TokenDO:
 787                         case TokenELSE:
 788                                 return true;
 789                         case TokenRPAREN:
 790                                 position= findOpeningPeer(fPos, LPAREN, RPAREN);
 791                                 if (position > 0) {
 792                                         switch (previousToken(position - 1, bound)) {
 793                                                 case TokenIF:
 794                                                 case TokenFOR:
 795                                                 case TokenWHILE:
 796                                                         return true;
 797                                         }
 798                                 }
 799                 }
 800
 801                 return false;
 802         }
 803 }