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