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