secure.phpeclipse.com Git - phpeclipse.git/blob

   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 //incastrix
  17 //import net.sourceforge.phpdt.internal.corext.Assert;
  18 import org.eclipse.core.runtime.Assert;
  19 import net.sourceforge.phpdt.internal.ui.text.SmartBackspaceManager.UndoSpec;
  20 import net.sourceforge.phpdt.ui.PreferenceConstants;
  21 //import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  22 import net.sourceforge.phpeclipse.phpeditor.PHPUnitEditor;
  23 import net.sourceforge.phpeclipse.ui.WebUI;
  24
  25 import org.eclipse.jface.preference.IPreferenceStore;
  26 import org.eclipse.jface.text.BadLocationException;
  27 import org.eclipse.jface.text.DocumentCommand;
  28 import org.eclipse.jface.text.IAutoEditStrategy;
  29 import org.eclipse.jface.text.IDocument;
  30 import org.eclipse.jface.text.IRegion;
  31 import org.eclipse.jface.text.ITextSelection;
  32 import org.eclipse.jface.text.ITypedRegion;
  33 import org.eclipse.jface.text.Region;
  34 import org.eclipse.jface.text.TextSelection;
  35 import org.eclipse.jface.text.TextUtilities;
  36 import org.eclipse.text.edits.DeleteEdit;
  37 import org.eclipse.text.edits.MalformedTreeException;
  38 import org.eclipse.text.edits.ReplaceEdit;
  39 import org.eclipse.text.edits.TextEdit;
  40 import org.eclipse.ui.IEditorPart;
  41 import org.eclipse.ui.IWorkbenchPage;
  42 import org.eclipse.ui.texteditor.ITextEditorExtension2;
  43 import org.eclipse.ui.texteditor.ITextEditorExtension3;
  44
  45 /**
  46  * Modifies <code>DocumentCommand</code>s inserting semicolons and opening
  47  * braces to place them smartly, i.e. moving them to the end of a line if that
  48  * is what the user expects.
  49  *
  50  * <p>
  51  * In practice, semicolons and braces (and the caret) are moved to the end of
  52  * the line if they are typed anywhere except for semicolons in a
  53  * <code>for</code> statements definition. If the line contains a semicolon or
  54  * brace after the current caret position, the cursor is moved after it.
  55  * </p>
  56  *
  57  * @see org.eclipse.jface.text.DocumentCommand
  58  * @since 3.0
  59  */
  60 public class SmartSemicolonAutoEditStrategy implements IAutoEditStrategy {
  61
  62         /** String representation of a semicolon. */
  63         private static final String SEMICOLON = ";"; //$NON-NLS-1$
  64
  65         /** Char representation of a semicolon. */
  66         private static final char SEMICHAR = ';';
  67
  68         /** String represenattion of a opening brace. */
  69         private static final String BRACE = "{"; //$NON-NLS-1$
  70
  71         /** Char representation of a opening brace */
  72         private static final char BRACECHAR = '{';
  73
  74         private char fCharacter;
  75
  76         private String fPartitioning;
  77
  78         /**
  79          * Creates a new SmartSemicolonAutoEditStrategy.
  80          *
  81          * @param partitioning
  82          *            the document partitioning
  83          */
  84         public SmartSemicolonAutoEditStrategy(String partitioning) {
  85                 fPartitioning = partitioning;
  86         }
  87
  88         /*
  89          * @see org.eclipse.jface.text.IAutoEditStrategy#customizeDocumentCommand(org.eclipse.jface.text.IDocument,
  90          *      org.eclipse.jface.text.DocumentCommand)
  91          */
  92         public void customizeDocumentCommand(IDocument document,
  93                         DocumentCommand command) {
  94                 // 0: early pruning
  95                 // also customize if <code>doit</code> is false (so it works in code
  96                 // completion situations)
  97                 // if (!command.doit)
  98                 // return;
  99
 100                 if (command.text == null)
 101                         return;
 102
 103                 if (command.text.equals(SEMICOLON))
 104                         fCharacter = SEMICHAR;
 105                 else if (command.text.equals(BRACE))
 106                         fCharacter = BRACECHAR;
 107                 else
 108                         return;
 109
 110                 IPreferenceStore store = WebUI.getDefault()
 111                                 .getPreferenceStore();
 112                 if (fCharacter == SEMICHAR
 113                                 && !store
 114                                                 .getBoolean(PreferenceConstants.EDITOR_SMART_SEMICOLON))
 115                         return;
 116                 if (fCharacter == BRACECHAR
 117                                 && !store
 118                                                 .getBoolean(PreferenceConstants.EDITOR_SMART_OPENING_BRACE))
 119                         return;
 120
 121                 IWorkbenchPage page = WebUI.getActivePage();
 122                 if (page == null)
 123                         return;
 124                 IEditorPart part = page.getActiveEditor();
 125                 if (!(part instanceof PHPUnitEditor))
 126                         return;
 127                 PHPUnitEditor editor = (PHPUnitEditor) part;
 128                 if (editor.getInsertMode() != ITextEditorExtension3.SMART_INSERT
 129                                 || !editor.isEditable())
 130                         return;
 131                 ITextEditorExtension2 extension = (ITextEditorExtension2) editor
 132                                 .getAdapter(ITextEditorExtension2.class);
 133                 if (extension != null && !extension.validateEditorInputState())
 134                         return;
 135                 if (isMultilineSelection(document, command))
 136                         return;
 137
 138                 // 1: find concerned line / position in java code, location in statement
 139                 int pos = command.offset;
 140                 ITextSelection line;
 141                 try {
 142                         IRegion l = document.getLineInformationOfOffset(pos);
 143                         line = new TextSelection(document, l.getOffset(), l.getLength());
 144                 } catch (BadLocationException e) {
 145                         return;
 146                 }
 147
 148                 // 2: choose action based on findings (is for-Statement?)
 149                 // for now: compute the best position to insert the new character
 150                 int positionInLine = computeCharacterPosition(document, line, pos
 151                                 - line.getOffset(), fCharacter, fPartitioning);
 152                 int position = positionInLine + line.getOffset();
 153
 154                 // never position before the current position!
 155                 if (position < pos)
 156                         return;
 157
 158                 // never double already existing content
 159                 if (alreadyPresent(document, fCharacter, position))
 160                         return;
 161
 162                 // don't do special processing if what we do is actually the normal
 163                 // behaviour
 164                 String insertion = adjustSpacing(document, position, fCharacter);
 165                 if (command.offset == position && insertion.equals(command.text))
 166                         return;
 167
 168                 try {
 169
 170                         final SmartBackspaceManager manager = (SmartBackspaceManager) editor
 171                                         .getAdapter(SmartBackspaceManager.class);
 172                         if (manager != null
 173                                         && WebUI.getDefault().getPreferenceStore()
 174                                                         .getBoolean(
 175                                                                         PreferenceConstants.EDITOR_SMART_BACKSPACE)) {
 176                                 TextEdit e1 = new ReplaceEdit(command.offset, command.text
 177                                                 .length(), document.get(command.offset, command.length));
 178                                 UndoSpec s1 = new UndoSpec(command.offset
 179                                                 + command.text.length(), new Region(command.offset, 0),
 180                                                 new TextEdit[] { e1 }, 0, null);
 181
 182                                 DeleteEdit smart = new DeleteEdit(position, insertion.length());
 183                                 ReplaceEdit raw = new ReplaceEdit(command.offset,
 184                                                 command.length, command.text);
 185                                 UndoSpec s2 = new UndoSpec(position + insertion.length(),
 186                                                 new Region(command.offset + command.text.length(), 0),
 187                                                 new TextEdit[] { smart, raw }, 2, s1);
 188                                 manager.register(s2);
 189                         }
 190
 191                         // 3: modify command
 192                         command.offset = position;
 193                         command.length = 0;
 194                         command.caretOffset = position;
 195                         command.text = insertion;
 196                         command.doit = true;
 197                         command.owner = null;
 198                 } catch (MalformedTreeException e) {
 199                         WebUI.log(e);
 200                 } catch (BadLocationException e) {
 201                         WebUI.log(e);
 202                 }
 203
 204         }
 205
 206         /**
 207          * Returns <code>true</code> if the document command is applied on a multi
 208          * line selection, <code>false</code> otherwise.
 209          *
 210          * @param document
 211          *            the document
 212          * @param command
 213          *            the command
 214          * @return <code>true</code> if <code>command</code> is a multiline
 215          *         command
 216          */
 217         private boolean isMultilineSelection(IDocument document,
 218                         DocumentCommand command) {
 219                 try {
 220                         return document.getNumberOfLines(command.offset, command.length) > 1;
 221                 } catch (BadLocationException e) {
 222                         // ignore
 223                         return false;
 224                 }
 225         }
 226
 227         /**
 228          * Adds a space before a brace if it is inserted after a parenthesis, equal
 229          * sign, or one of the keywords <code>try, else, do</code>.
 230          *
 231          * @param document
 232          *            the document we are working on
 233          * @param position
 234          *            the insert position of <code>character</code>
 235          * @param character
 236          *            the character to be inserted
 237          * @return a <code>String</code> consisting of <code>character</code>
 238          *         plus any additional spacing
 239          */
 240         private String adjustSpacing(IDocument doc, int position, char character) {
 241                 if (character == BRACECHAR) {
 242                         if (position > 0 && position <= doc.getLength()) {
 243                                 int pos = position - 1;
 244                                 if (looksLike(doc, pos, ")") //$NON-NLS-1$
 245                                                 || looksLike(doc, pos, "=") //$NON-NLS-1$
 246                                                 || looksLike(doc, pos, "]") //$NON-NLS-1$
 247                                                 || looksLike(doc, pos, "try") //$NON-NLS-1$
 248                                                 || looksLike(doc, pos, "else") //$NON-NLS-1$
 249                                                 || looksLike(doc, pos, "synchronized") //$NON-NLS-1$
 250                                                 || looksLike(doc, pos, "static") //$NON-NLS-1$
 251                                                 || looksLike(doc, pos, "finally") //$NON-NLS-1$
 252                                                 || looksLike(doc, pos, "do")) //$NON-NLS-1$
 253                                         return new String(new char[] { ' ', character });
 254                         }
 255                 }
 256
 257                 return new String(new char[] { character });
 258         }
 259
 260         /**
 261          * Checks whether a character to be inserted is already present at the
 262          * insert location (perhaps separated by some whitespace from
 263          * <code>position</code>.
 264          *
 265          * @param document
 266          *            the document we are working on
 267          * @param position
 268          *            the insert position of <code>ch</code>
 269          * @param character
 270          *            the character to be inserted
 271          * @return <code>true</code> if <code>ch</code> is already present at
 272          *         <code>location</code>, <code>false</code> otherwise
 273          */
 274         private boolean alreadyPresent(IDocument document, char ch, int position) {
 275                 int pos = firstNonWhitespaceForward(document, position, fPartitioning,
 276                                 document.getLength());
 277                 try {
 278                         if (pos != -1 && document.getChar(pos) == ch)
 279                                 return true;
 280                 } catch (BadLocationException e) {
 281                 }
 282
 283                 return false;
 284         }
 285
 286         /**
 287          * Computes the next insert position of the given character in the current
 288          * line.
 289          *
 290          * @param document
 291          *            the document we are working on
 292          * @param line
 293          *            the line where the change is being made
 294          * @param offset
 295          *            the position of the caret in the line when
 296          *            <code>character</code> was typed
 297          * @param character
 298          *            the character to look for
 299          * @param partitioning
 300          *            the document partitioning
 301          * @return the position where <code>character</code> should be inserted /
 302          *         replaced
 303          */
 304         protected static int computeCharacterPosition(IDocument document,
 305                         ITextSelection line, int offset, char character, String partitioning) {
 306                 String text = line.getText();
 307                 if (text == null)
 308                         return 0;
 309
 310                 int insertPos;
 311                 if (character == BRACECHAR) {
 312
 313                         insertPos = computeArrayInitializationPos(document, line, offset,
 314                                         partitioning);
 315
 316                         if (insertPos == -1) {
 317                                 insertPos = computeAfterTryDoElse(document, line, offset);
 318                         }
 319
 320                         if (insertPos == -1) {
 321                                 insertPos = computeAfterParenthesis(document, line, offset,
 322                                                 partitioning);
 323                         }
 324
 325                 } else if (character == SEMICHAR) {
 326
 327                         if (isForStatement(text, offset)) {
 328                                 insertPos = -1; // don't do anything in for statements, as semis
 329                                                                 // are vital part of these
 330                         } else {
 331                                 int nextPartitionPos = nextPartitionOrLineEnd(document, line,
 332                                                 offset, partitioning);
 333                                 insertPos = startOfWhitespaceBeforeOffset(text,
 334                                                 nextPartitionPos);
 335                                 // if there is a semi present, return its location as
 336                                 // alreadyPresent() will take it out this way.
 337                                 if (insertPos > 0 && text.charAt(insertPos - 1) == character)
 338                                         insertPos = insertPos - 1;
 339                         }
 340
 341                 } else {
 342                         Assert.isTrue(false);
 343                         return -1;
 344                 }
 345
 346                 return insertPos;
 347         }
 348
 349         /**
 350          * Computes an insert position for an opening brace if <code>offset</code>
 351          * maps to a position in <code>document</code> that looks like being the
 352          * RHS of an assignment or like an array definition.
 353          *
 354          * @param document
 355          *            the document being modified
 356          * @param line
 357          *            the current line under investigation
 358          * @param offset
 359          *            the offset of the caret position, relative to the line start.
 360          * @param partitioning
 361          *            the document partitioning
 362          * @return an insert position relative to the line start if
 363          *         <code>line</code> looks like being an array initialization at
 364          *         <code>offset</code>, -1 otherwise
 365          */
 366         private static int computeArrayInitializationPos(IDocument document,
 367                         ITextSelection line, int offset, String partitioning) {
 368                 // search backward while WS, find = (not != <= >= ==) in default
 369                 // partition
 370                 int pos = offset + line.getOffset();
 371
 372                 if (pos == 0)
 373                         return -1;
 374
 375                 int p = firstNonWhitespaceBackward(document, pos - 1, partitioning, -1);
 376
 377                 if (p == -1)
 378                         return -1;
 379
 380                 try {
 381
 382                         char ch = document.getChar(p);
 383                         if (ch != '=' && ch != ']')
 384                                 return -1;
 385
 386                         if (p == 0)
 387                                 return offset;
 388
 389                         p = firstNonWhitespaceBackward(document, p - 1, partitioning, -1);
 390                         if (p == -1)
 391                                 return -1;
 392
 393                         ch = document.getChar(p);
 394                         if (Scanner.isPHPIdentifierPart(ch) || ch == ']' || ch == '[')
 395                                 return offset;
 396
 397                 } catch (BadLocationException e) {
 398                 }
 399                 return -1;
 400         }
 401
 402         /**
 403          * Computes an insert position for an opening brace if <code>offset</code>
 404          * maps to a position in <code>document</code> involving a keyword taking
 405          * a block after it. These are: <code>try</code>, <code>do</code>,
 406          * <code>synchronized</code>, <code>static</code>,
 407          * <code>finally</code>, or <code>else</code>.
 408          *
 409          * @param document
 410          *            the document being modified
 411          * @param line
 412          *            the current line under investigation
 413          * @param offset
 414          *            the offset of the caret position, relative to the line start.
 415          * @return an insert position relative to the line start if
 416          *         <code>line</code> contains one of the above keywords at or
 417          *         before <code>offset</code>, -1 otherwise
 418          */
 419         private static int computeAfterTryDoElse(IDocument doc,
 420                         ITextSelection line, int offset) {
 421                 // search backward while WS, find 'try', 'do', 'else' in default
 422                 // partition
 423                 int p = offset + line.getOffset();
 424                 p = firstWhitespaceToRight(doc, p);
 425                 if (p == -1)
 426                         return -1;
 427                 p--;
 428
 429                 if (looksLike(doc, p, "try") //$NON-NLS-1$
 430                                 || looksLike(doc, p, "do") //$NON-NLS-1$
 431                                 || looksLike(doc, p, "synchronized") //$NON-NLS-1$
 432                                 || looksLike(doc, p, "static") //$NON-NLS-1$
 433                                 || looksLike(doc, p, "finally") //$NON-NLS-1$
 434                                 || looksLike(doc, p, "else")) //$NON-NLS-1$
 435                         return p + 1 - line.getOffset();
 436
 437                 return -1;
 438         }
 439
 440         /**
 441          * Computes an insert position for an opening brace if <code>offset</code>
 442          * maps to a position in <code>document</code> with a expression in
 443          * parenthesis that will take a block after the closing parenthesis.
 444          *
 445          * @param document
 446          *            the document being modified
 447          * @param line
 448          *            the current line under investigation
 449          * @param offset
 450          *            the offset of the caret position, relative to the line start.
 451          * @param partitioning
 452          *            the document partitioning
 453          * @return an insert position relative to the line start if
 454          *         <code>line</code> contains a parenthesized expression that can
 455          *         be followed by a block, -1 otherwise
 456          */
 457         private static int computeAfterParenthesis(IDocument document,
 458                         ITextSelection line, int offset, String partitioning) {
 459                 // find the opening parenthesis for every closing parenthesis on the
 460                 // current line after offset
 461                 // return the position behind the closing parenthesis if it looks like a
 462                 // method declaration
 463                 // or an expression for an if, while, for, catch statement
 464                 int pos = offset + line.getOffset();
 465                 int length = line.getOffset() + line.getLength();
 466                 int scanTo = scanForward(document, pos, partitioning, length, '}');
 467                 if (scanTo == -1)
 468                         scanTo = length;
 469
 470                 int closingParen = findClosingParenToLeft(document, pos, partitioning) - 1;
 471
 472                 while (true) {
 473                         int startScan = closingParen + 1;
 474                         closingParen = scanForward(document, startScan, partitioning,
 475                                         scanTo, ')');
 476                         if (closingParen == -1)
 477                                 break;
 478
 479                         int openingParen = findOpeningParenMatch(document, closingParen,
 480                                         partitioning);
 481
 482                         // no way an expression at the beginning of the document can mean
 483                         // anything
 484                         if (openingParen < 1)
 485                                 break;
 486
 487                         // only select insert positions for parenthesis currently embracing
 488                         // the caret
 489                         if (openingParen > pos)
 490                                 continue;
 491
 492                         if (looksLikeAnonymousClassDef(document, openingParen - 1,
 493                                         partitioning))
 494                                 return closingParen + 1 - line.getOffset();
 495
 496                         if (looksLikeIfWhileForCatch(document, openingParen - 1,
 497                                         partitioning))
 498                                 return closingParen + 1 - line.getOffset();
 499
 500                         if (looksLikeMethodDecl(document, openingParen - 1, partitioning))
 501                                 return closingParen + 1 - line.getOffset();
 502
 503                 }
 504
 505                 return -1;
 506         }
 507
 508         /**
 509          * Finds a closing parenthesis to the left of <code>position</code> in
 510          * document, where that parenthesis is only separated by whitespace from
 511          * <code>position</code>. If no such parenthesis can be found,
 512          * <code>position</code> is returned.
 513          *
 514          * @param document
 515          *            the document being modified
 516          * @param position
 517          *            the first character position in <code>document</code> to be
 518          *            considered
 519          * @param partitioning
 520          *            the document partitioning
 521          * @return the position of a closing parenthesis left to
 522          *         <code>position</code> separated only by whitespace, or
 523          *         <code>position</code> if no parenthesis can be found
 524          */
 525         private static int findClosingParenToLeft(IDocument document, int position,
 526                         String partitioning) {
 527                 final char CLOSING_PAREN = ')';
 528                 try {
 529                         if (position < 1)
 530                                 return position;
 531
 532                         int nonWS = firstNonWhitespaceBackward(document, position - 1,
 533                                         partitioning, -1);
 534                         if (nonWS != -1 && document.getChar(nonWS) == CLOSING_PAREN)
 535                                 return nonWS;
 536                 } catch (BadLocationException e1) {
 537                 }
 538                 return position;
 539         }
 540
 541         /**
 542          * Finds the first whitespace character position to the right of (and
 543          * including) <code>position</code>.
 544          *
 545          * @param document
 546          *            the document being modified
 547          * @param position
 548          *            the first character position in <code>document</code> to be
 549          *            considered
 550          * @return the position of a whitespace character greater or equal than
 551          *         <code>position</code> separated only by whitespace, or -1 if
 552          *         none found
 553          */
 554         private static int firstWhitespaceToRight(IDocument document, int position) {
 555                 int length = document.getLength();
 556                 Assert.isTrue(position >= 0);
 557                 Assert.isTrue(position <= length);
 558
 559                 try {
 560                         while (position < length) {
 561                                 char ch = document.getChar(position);
 562                                 if (Character.isWhitespace(ch))
 563                                         return position;
 564                                 position++;
 565                         }
 566                         return position;
 567                 } catch (BadLocationException e) {
 568                 }
 569                 return -1;
 570         }
 571
 572         /**
 573          * Finds the highest position in <code>document</code> such that the
 574          * position is &lt;= <code>position</code> and &gt; <code>bound</code>
 575          * and <code>Character.isWhitespace(document.getChar(pos))</code>
 576          * evaluates to <code>false</code> and the position is in the default
 577          * partition.
 578          *
 579          * @param document
 580          *            the document being modified
 581          * @param position
 582          *            the first character position in <code>document</code> to be
 583          *            considered
 584          * @param partitioning
 585          *            the document partitioning
 586          * @param bound
 587          *            the first position in <code>document</code> to not consider
 588          *            any more, with <code>bound</code> &gt; <code>position</code>
 589          * @return the highest position of one element in <code>chars</code> in [<code>position</code>,
 590          *         <code>scanTo</code>) that resides in a Java partition, or
 591          *         <code>-1</code> if none can be found
 592          */
 593         private static int firstNonWhitespaceBackward(IDocument document,
 594                         int position, String partitioning, int bound) {
 595                 Assert.isTrue(position < document.getLength());
 596                 Assert.isTrue(bound >= -1);
 597
 598                 try {
 599                         while (position > bound) {
 600                                 char ch = document.getChar(position);
 601                                 if (!Character.isWhitespace(ch)
 602                                                 && isDefaultPartition(document, position, partitioning))
 603                                         return position;
 604                                 position--;
 605                         }
 606                 } catch (BadLocationException e) {
 607                 }
 608                 return -1;
 609         }
 610
 611         /**
 612          * Finds the smallest position in <code>document</code> such that the
 613          * position is &gt;= <code>position</code> and &lt; <code>bound</code>
 614          * and <code>Character.isWhitespace(document.getChar(pos))</code>
 615          * evaluates to <code>false</code> and the position is in the default
 616          * partition.
 617          *
 618          * @param document
 619          *            the document being modified
 620          * @param position
 621          *            the first character position in <code>document</code> to be
 622          *            considered
 623          * @param partitioning
 624          *            the document partitioning
 625          * @param bound
 626          *            the first position in <code>document</code> to not consider
 627          *            any more, with <code>bound</code> &gt; <code>position</code>
 628          * @return the smallest position of one element in <code>chars</code> in [<code>position</code>,
 629          *         <code>scanTo</code>) that resides in a Java partition, or
 630          *         <code>-1</code> if none can be found
 631          */
 632         private static int firstNonWhitespaceForward(IDocument document,
 633                         int position, String partitioning, int bound) {
 634                 Assert.isTrue(position >= 0);
 635                 Assert.isTrue(bound <= document.getLength());
 636
 637                 try {
 638                         while (position < bound) {
 639                                 char ch = document.getChar(position);
 640                                 if (!Character.isWhitespace(ch)
 641                                                 && isDefaultPartition(document, position, partitioning))
 642                                         return position;
 643                                 position++;
 644                         }
 645                 } catch (BadLocationException e) {
 646                 }
 647                 return -1;
 648         }
 649
 650         /**
 651          * Finds the highest position in <code>document</code> such that the
 652          * position is &lt;= <code>position</code> and &gt; <code>bound</code>
 653          * and <code>document.getChar(position) == ch</code> evaluates to
 654          * <code>true</code> for at least one ch in <code>chars</code> and the
 655          * position is in the default partition.
 656          *
 657          * @param document
 658          *            the document being modified
 659          * @param position
 660          *            the first character position in <code>document</code> to be
 661          *            considered
 662          * @param partitioning
 663          *            the document partitioning
 664          * @param bound
 665          *            the first position in <code>document</code> to not consider
 666          *            any more, with <code>scanTo</code> &gt;
 667          *            <code>position</code>
 668          * @param chars
 669          *            an array of <code>char</code> to search for
 670          * @return the highest position of one element in <code>chars</code> in (<code>bound</code>,
 671          *         <code>position</code>] that resides in a Java partition, or
 672          *         <code>-1</code> if none can be found
 673          */
 674         private static int scanBackward(IDocument document, int position,
 675                         String partitioning, int bound, char[] chars) {
 676                 Assert.isTrue(bound >= -1);
 677                 Assert.isTrue(position < document.getLength());
 678
 679                 Arrays.sort(chars);
 680
 681                 try {
 682                         while (position > bound) {
 683
 684                                 if (Arrays.binarySearch(chars, document.getChar(position)) >= 0
 685                                                 && isDefaultPartition(document, position, partitioning))
 686                                         return position;
 687
 688                                 position--;
 689                         }
 690                 } catch (BadLocationException e) {
 691                 }
 692                 return -1;
 693         }
 694
 695         // /**
 696         // * Finds the highest position in <code>document</code> such that the
 697         // position is &lt;= <code>position</code>
 698         // * and &gt; <code>bound</code> and <code>document.getChar(position) ==
 699         // ch</code> evaluates to <code>true</code>
 700         // * and the position is in the default partition.
 701         // *
 702         // * @param document the document being modified
 703         // * @param position the first character position in <code>document</code>
 704         // to be considered
 705         // * @param bound the first position in <code>document</code> to not
 706         // consider any more, with <code>scanTo</code> &gt; <code>position</code>
 707         // * @param chars an array of <code>char</code> to search for
 708         // * @return the highest position of one element in <code>chars</code> in
 709         // [<code>position</code>, <code>scanTo</code>) that resides in a Java
 710         // partition, or <code>-1</code> if none can be found
 711         // */
 712         // private static int scanBackward(IDocument document, int position, int
 713         // bound, char ch) {
 714         // return scanBackward(document, position, bound, new char[] {ch});
 715         // }
 716         //
 717         /**
 718          * Finds the lowest position in <code>document</code> such that the
 719          * position is &gt;= <code>position</code> and &lt; <code>bound</code>
 720          * and <code>document.getChar(position) == ch</code> evaluates to
 721          * <code>true</code> for at least one ch in <code>chars</code> and the
 722          * position is in the default partition.
 723          *
 724          * @param document
 725          *            the document being modified
 726          * @param position
 727          *            the first character position in <code>document</code> to be
 728          *            considered
 729          * @param partitioning
 730          *            the document partitioning
 731          * @param bound
 732          *            the first position in <code>document</code> to not consider
 733          *            any more, with <code>scanTo</code> &gt;
 734          *            <code>position</code>
 735          * @param chars
 736          *            an array of <code>char</code> to search for
 737          * @return the lowest position of one element in <code>chars</code> in [<code>position</code>,
 738          *         <code>bound</code>) that resides in a Java partition, or
 739          *         <code>-1</code> if none can be found
 740          */
 741         private static int scanForward(IDocument document, int position,
 742                         String partitioning, int bound, char[] chars) {
 743                 Assert.isTrue(position >= 0);
 744                 Assert.isTrue(bound <= document.getLength());
 745
 746                 Arrays.sort(chars);
 747
 748                 try {
 749                         while (position < bound) {
 750
 751                                 if (Arrays.binarySearch(chars, document.getChar(position)) >= 0
 752                                                 && isDefaultPartition(document, position, partitioning))
 753                                         return position;
 754
 755                                 position++;
 756                         }
 757                 } catch (BadLocationException e) {
 758                 }
 759                 return -1;
 760         }
 761
 762         /**
 763          * Finds the lowest position in <code>document</code> such that the
 764          * position is &gt;= <code>position</code> and &lt; <code>bound</code>
 765          * and <code>document.getChar(position) == ch</code> evaluates to
 766          * <code>true</code> and the position is in the default partition.
 767          *
 768          * @param document
 769          *            the document being modified
 770          * @param position
 771          *            the first character position in <code>document</code> to be
 772          *            considered
 773          * @param partitioning
 774          *            the document partitioning
 775          * @param bound
 776          *            the first position in <code>document</code> to not consider
 777          *            any more, with <code>scanTo</code> &gt;
 778          *            <code>position</code>
 779          * @param chars
 780          *            an array of <code>char</code> to search for
 781          * @return the lowest position of one element in <code>chars</code> in [<code>position</code>,
 782          *         <code>bound</code>) that resides in a Java partition, or
 783          *         <code>-1</code> if none can be found
 784          */
 785         private static int scanForward(IDocument document, int position,
 786                         String partitioning, int bound, char ch) {
 787                 return scanForward(document, position, partitioning, bound,
 788                                 new char[] { ch });
 789         }
 790
 791         /**
 792          * Checks whether the content of <code>document</code> in the range (<code>offset</code>,
 793          * <code>length</code>) contains the <code>new</code> keyword.
 794          *
 795          * @param document
 796          *            the document being modified
 797          * @param offset
 798          *            the first character position in <code>document</code> to be
 799          *            considered
 800          * @param length
 801          *            the length of the character range to be considered
 802          * @param partitioning
 803          *            the document partitioning
 804          * @return <code>true</code> if the specified character range contains a
 805          *         <code>new</code> keyword, <code>false</code> otherwise.
 806          */
 807         private static boolean isNewMatch(IDocument document, int offset,
 808                         int length, String partitioning) {
 809                 Assert.isTrue(length >= 0);
 810                 Assert.isTrue(offset >= 0);
 811                 Assert.isTrue(offset + length < document.getLength() + 1);
 812
 813                 try {
 814                         String text = document.get(offset, length);
 815                         int pos = text.indexOf("new"); //$NON-NLS-1$
 816
 817                         while (pos != -1
 818                                         && !isDefaultPartition(document, pos + offset, partitioning))
 819                                 pos = text.indexOf("new", pos + 2); //$NON-NLS-1$
 820
 821                         if (pos < 0)
 822                                 return false;
 823
 824                         if (pos != 0 && Scanner.isPHPIdentifierPart(text.charAt(pos - 1)))
 825                                 return false;
 826
 827                         if (pos + 3 < length
 828                                         && Scanner.isPHPIdentifierPart(text.charAt(pos + 3)))
 829                                 return false;
 830
 831                         return true;
 832
 833                 } catch (BadLocationException e) {
 834                 }
 835                 return false;
 836         }
 837
 838         /**
 839          * Checks whether the content of <code>document</code> at
 840          * <code>position</code> looks like an anonymous class definition.
 841          * <code>position</code> must be to the left of the opening parenthesis of
 842          * the definition's parameter list.
 843          *
 844          * @param document
 845          *            the document being modified
 846          * @param position
 847          *            the first character position in <code>document</code> to be
 848          *            considered
 849          * @param partitioning
 850          *            the document partitioning
 851          * @return <code>true</code> if the content of <code>document</code>
 852          *         looks like an anonymous class definition, <code>false</code>
 853          *         otherwise
 854          */
 855         private static boolean looksLikeAnonymousClassDef(IDocument document,
 856                         int position, String partitioning) {
 857                 int previousCommaOrParen = scanBackward(document, position - 1,
 858                                 partitioning, -1, new char[] { ',', '(' });
 859                 if (previousCommaOrParen == -1 || position < previousCommaOrParen + 5) // 2
 860                                                                                                                                                                 // for
 861                                                                                                                                                                 // borders,
 862                                                                                                                                                                 // 3
 863                                                                                                                                                                 // for
 864                                                                                                                                                                 // "new"
 865                         return false;
 866
 867                 if (isNewMatch(document, previousCommaOrParen + 1, position
 868                                 - previousCommaOrParen - 2, partitioning))
 869                         return true;
 870
 871                 return false;
 872         }
 873
 874         /**
 875          * Checks whether <code>position</code> resides in a default (Java)
 876          * partition of <code>document</code>.
 877          *
 878          * @param document
 879          *            the document being modified
 880          * @param position
 881          *            the position to be checked
 882          * @param partitioning
 883          *            the document partitioning
 884          * @return <code>true</code> if <code>position</code> is in the default
 885          *         partition of <code>document</code>, <code>false</code>
 886          *         otherwise
 887          */
 888         private static boolean isDefaultPartition(IDocument document, int position,
 889                         String partitioning) {
 890                 Assert.isTrue(position >= 0);
 891                 Assert.isTrue(position <= document.getLength());
 892
 893                 try {
 894                         // don't use getPartition2 since we're interested in the scanned
 895                         // character's partition
 896                         ITypedRegion region = TextUtilities.getPartition(document,
 897                                         partitioning, position, false);
 898                         return region.getType().equals(IDocument.DEFAULT_CONTENT_TYPE);
 899
 900                 } catch (BadLocationException e) {
 901                 }
 902
 903                 return false;
 904         }
 905
 906         /**
 907          * Finds the position of the parenthesis matching the closing parenthesis at
 908          * <code>position</code>.
 909          *
 910          * @param document
 911          *            the document being modified
 912          * @param position
 913          *            the position in <code>document</code> of a closing
 914          *            parenthesis
 915          * @param partitioning
 916          *            the document partitioning
 917          * @return the position in <code>document</code> of the matching
 918          *         parenthesis, or -1 if none can be found
 919          */
 920         private static int findOpeningParenMatch(IDocument document, int position,
 921                         String partitioning) {
 922                 final char CLOSING_PAREN = ')';
 923                 final char OPENING_PAREN = '(';
 924
 925                 Assert.isTrue(position < document.getLength());
 926                 Assert.isTrue(position >= 0);
 927                 Assert.isTrue(isDefaultPartition(document, position, partitioning));
 928
 929                 try {
 930
 931                         Assert.isTrue(document.getChar(position) == CLOSING_PAREN);
 932
 933                         int depth = 1;
 934                         while (true) {
 935                                 position = scanBackward(document, position - 1, partitioning,
 936                                                 -1, new char[] { CLOSING_PAREN, OPENING_PAREN });
 937                                 if (position == -1)
 938                                         return -1;
 939
 940                                 if (document.getChar(position) == CLOSING_PAREN)
 941                                         depth++;
 942                                 else
 943                                         depth--;
 944
 945                                 if (depth == 0)
 946                                         return position;
 947                         }
 948
 949                 } catch (BadLocationException e) {
 950                         return -1;
 951                 }
 952         }
 953
 954         /**
 955          * Checks whether, to the left of <code>position</code> and separated only
 956          * by whitespace, <code>document</code> contains a keyword taking a
 957          * parameter list and a block after it. These are: <code>if</code>,
 958          * <code>while</code>, <code>catch</code>, <code>for</code>,
 959          * <code>synchronized</code>, <code>switch</code>.
 960          *
 961          * @param document
 962          *            the document being modified
 963          * @param position
 964          *            the first character position in <code>document</code> to be
 965          *            considered
 966          * @param partitioning
 967          *            the document partitioning
 968          * @return <code>true</code> if <code>document</code> contains any of
 969          *         the above keywords to the left of <code>position</code>,
 970          *         <code>false</code> otherwise
 971          */
 972         private static boolean looksLikeIfWhileForCatch(IDocument document,
 973                         int position, String partitioning) {
 974                 position = firstNonWhitespaceBackward(document, position, partitioning,
 975                                 -1);
 976                 if (position == -1)
 977                         return false;
 978
 979                 return looksLike(document, position, "if") //$NON-NLS-1$
 980                                 || looksLike(document, position, "while") //$NON-NLS-1$
 981                                 || looksLike(document, position, "catch") //$NON-NLS-1$
 982                                 || looksLike(document, position, "synchronized") //$NON-NLS-1$
 983                                 || looksLike(document, position, "switch") //$NON-NLS-1$
 984                                 || looksLike(document, position, "for"); //$NON-NLS-1$
 985         }
 986
 987         /**
 988          * Checks whether code>document</code> contains the <code>String</code> <code>like</code>
 989          * such that its last character is at <code>position</code>. If <code>like</code>
 990          * starts with a identifier part (as determined by
 991          * {@link Scanner#isPHPIdentifierPart(char)}), it is also made sure that
 992          * <code>like</code> is preceded by some non-identifier character or
 993          * stands at the document start.
 994          *
 995          * @param document
 996          *            the document being modified
 997          * @param position
 998          *            the first character position in <code>document</code> to be
 999          *            considered
1000          * @param like
1001          *            the <code>String</code> to look for.
1002          * @return <code>true</code> if <code>document</code> contains <code>like</code>
1003          *         such that it ends at <code>position</code>, <code>false</code>
1004          *         otherwise
1005          */
1006         private static boolean looksLike(IDocument document, int position,
1007                         String like) {
1008                 int length = like.length();
1009                 if (position < length - 1)
1010                         return false;
1011
1012                 try {
1013                         if (!like.equals(document.get(position - length + 1, length)))
1014                                 return false;
1015
1016                         if (position >= length
1017                                         && Scanner.isPHPIdentifierPart(like.charAt(0))
1018                                         && Scanner.isPHPIdentifierPart(document.getChar(position
1019                                                         - length)))
1020                                 return false;
1021
1022                 } catch (BadLocationException e) {
1023                         return false;
1024                 }
1025
1026                 return true;
1027         }
1028
1029         /**
1030          * Checks whether the content of <code>document</code> at
1031          * <code>position</code> looks like a method declaration header (i.e. only
1032          * the return type and method name). <code>position</code> must be just
1033          * left of the opening parenthesis of the parameter list.
1034          *
1035          * @param document
1036          *            the document being modified
1037          * @param position
1038          *            the first character position in <code>document</code> to be
1039          *            considered
1040          * @param partitioning
1041          *            the document partitioning
1042          * @return <code>true</code> if the content of <code>document</code>
1043          *         looks like a method definition, <code>false</code> otherwise
1044          */
1045         private static boolean looksLikeMethodDecl(IDocument document,
1046                         int position, String partitioning) {
1047
1048                 // method name
1049                 position = eatIdentToLeft(document, position, partitioning);
1050                 if (position < 1)
1051                         return false;
1052
1053                 position = eatBrackets(document, position - 1, partitioning);
1054                 if (position < 1)
1055                         return false;
1056
1057                 position = eatIdentToLeft(document, position - 1, partitioning);
1058
1059                 return position != -1;
1060         }
1061
1062         /**
1063          * From <code>position</code> to the left, eats any whitespace and then a
1064          * pair of brackets as used to declare an array return type like
1065          *
1066          * <pre>
1067          * String [ ]
1068          * </pre>. The return value is either the position of the opening bracket
1069          * or <code>position</code> if no pair of brackets can be parsed.
1070          *
1071          * @param document
1072          *            the document being modified
1073          * @param position
1074          *            the first character position in <code>document</code> to be
1075          *            considered
1076          * @param partitioning
1077          *            the document partitioning
1078          * @return the smallest character position of bracket pair or
1079          *         <code>position</code>
1080          */
1081         private static int eatBrackets(IDocument document, int position,
1082                         String partitioning) {
1083                 // accept array return type
1084                 int pos = firstNonWhitespaceBackward(document, position, partitioning,
1085                                 -1);
1086                 try {
1087                         if (pos > 1 && document.getChar(pos) == ']') {
1088                                 pos = firstNonWhitespaceBackward(document, pos - 1,
1089                                                 partitioning, -1);
1090                                 if (pos > 0 && document.getChar(pos) == '[')
1091                                         return pos;
1092                         }
1093                 } catch (BadLocationException e) {
1094                         // won't happen
1095                 }
1096                 return position;
1097         }
1098
1099         /**
1100          * From <code>position</code> to the left, eats any whitespace and the
1101          * first identifier, returning the position of the first identifier
1102          * character (in normal read order).
1103          * <p>
1104          * When called on a document with content <code>" some string  "</code> and
1105          * positionition 13, the return value will be 6 (the first letter in
1106          * <code>string</code>).
1107          * </p>
1108          *
1109          * @param document
1110          *            the document being modified
1111          * @param position
1112          *            the first character position in <code>document</code> to be
1113          *            considered
1114          * @param partitioning
1115          *            the document partitioning
1116          * @return the smallest character position of an identifier or -1 if none
1117          *         can be found; always &lt;= <code>position</code>
1118          */
1119         private static int eatIdentToLeft(IDocument document, int position,
1120                         String partitioning) {
1121                 if (position < 0)
1122                         return -1;
1123                 Assert.isTrue(position < document.getLength());
1124
1125                 int p = firstNonWhitespaceBackward(document, position, partitioning, -1);
1126                 if (p == -1)
1127                         return -1;
1128
1129                 try {
1130                         while (p >= 0) {
1131
1132                                 char ch = document.getChar(p);
1133                                 if (Scanner.isPHPIdentifierPart(ch)) {
1134                                         p--;
1135                                         continue;
1136                                 }
1137
1138                                 // length must be > 0
1139                                 if (Character.isWhitespace(ch) && p != position)
1140                                         return p + 1;
1141                                 else
1142                                         return -1;
1143
1144                         }
1145
1146                         // start of document reached
1147                         return 0;
1148
1149                 } catch (BadLocationException e) {
1150                 }
1151                 return -1;
1152         }
1153
1154         /**
1155          * Returns a position in the first java partition after the last non-empty
1156          * and non-comment partition. There is no non-whitespace from the returned
1157          * position to the end of the partition it is contained in.
1158          *
1159          * @param document
1160          *            the document being modified
1161          * @param line
1162          *            the line under investigation
1163          * @param offset
1164          *            the caret offset into <code>line</code>
1165          * @param partitioning
1166          *            the document partitioning
1167          * @return the position of the next Java partition, or the end of
1168          *         <code>line</code>
1169          */
1170         private static int nextPartitionOrLineEnd(IDocument document,
1171                         ITextSelection line, int offset, String partitioning) {
1172                 // run relative to document
1173                 final int docOffset = offset + line.getOffset();
1174                 final int eol = line.getOffset() + line.getLength();
1175                 int nextPartitionPos = eol; // init with line end
1176                 int validPosition = docOffset;
1177
1178                 try {
1179                         ITypedRegion partition = TextUtilities.getPartition(document,
1180                                         partitioning, nextPartitionPos, true);
1181                         validPosition = getValidPositionForPartition(document, partition,
1182                                         eol);
1183                         while (validPosition == -1) {
1184                                 nextPartitionPos = partition.getOffset() - 1;
1185                                 if (nextPartitionPos < docOffset) {
1186                                         validPosition = docOffset;
1187                                         break;
1188                                 }
1189                                 partition = TextUtilities.getPartition(document, partitioning,
1190                                                 nextPartitionPos, false);
1191                                 validPosition = getValidPositionForPartition(document,
1192                                                 partition, eol);
1193                         }
1194                 } catch (BadLocationException e) {
1195                 }
1196
1197                 validPosition = Math.max(validPosition, docOffset);
1198                 // make relative to line
1199                 validPosition -= line.getOffset();
1200                 return validPosition;
1201         }
1202
1203         /**
1204          * Returns a valid insert location (except for whitespace) in
1205          * <code>partition</code> or -1 if there is no valid insert location. An
1206          * valid insert location is right after any java string or character
1207          * partition, or at the end of a java default partition, but never behind
1208          * <code>maxOffset</code>. Comment partitions or empty java partitions do
1209          * never yield valid insert positions.
1210          *
1211          * @param doc
1212          *            the document being modified
1213          * @param partition
1214          *            the current partition
1215          * @param maxOffset
1216          *            the maximum offset to consider
1217          * @return a valid insert location in <code>partition</code>, or -1 if
1218          *         there is no valid insert location
1219          */
1220         private static int getValidPositionForPartition(IDocument doc,
1221                         ITypedRegion partition, int maxOffset) {
1222                 final int INVALID = -1;
1223
1224                 if (IPHPPartitions.PHP_PHPDOC_COMMENT.equals(partition.getType()))
1225                         return INVALID;
1226                 if (IPHPPartitions.PHP_MULTILINE_COMMENT.equals(partition.getType()))
1227                         return INVALID;
1228                 if (IPHPPartitions.PHP_SINGLELINE_COMMENT.equals(partition.getType()))
1229                         return INVALID;
1230
1231                 int endOffset = Math.min(maxOffset, partition.getOffset()
1232                                 + partition.getLength());
1233
1234                 // if (IPHPPartitions.JAVA_CHARACTER.equals(partition.getType()))
1235                 // return endOffset;
1236                 if (IPHPPartitions.PHP_STRING_DQ.equals(partition.getType()))
1237                         return endOffset;
1238                 if (IPHPPartitions.PHP_STRING_SQ.equals(partition.getType()))
1239                         return endOffset;
1240                 if (IPHPPartitions.PHP_STRING_HEREDOC.equals(partition.getType()))
1241                         return endOffset;
1242                 if (IDocument.DEFAULT_CONTENT_TYPE.equals(partition.getType())) {
1243                         try {
1244                                 if (doc.get(partition.getOffset(),
1245                                                 endOffset - partition.getOffset()).trim().length() == 0)
1246                                         return INVALID;
1247                                 else
1248                                         return endOffset;
1249                         } catch (BadLocationException e) {
1250                                 return INVALID;
1251                         }
1252                 }
1253                 // default: we don't know anything about the partition - assume valid
1254                 return endOffset;
1255         }
1256
1257         /**
1258          * Determines whether the current line contains a for statement. Algorithm:
1259          * any "for" word in the line is a positive, "for" contained in a string
1260          * literal will produce a false positive.
1261          *
1262          * @param line
1263          *            the line where the change is being made
1264          * @param offset
1265          *            the position of the caret
1266          * @return <code>true</code> if <code>line</code> contains
1267          *         <code>for</code>, <code>false</code> otherwise
1268          */
1269         private static boolean isForStatement(String line, int offset) {
1270                 /* searching for (^|\s)for(\s|$) */
1271                 int forPos = line.indexOf("for"); //$NON-NLS-1$
1272                 if (forPos != -1) {
1273                         if ((forPos == 0 || !Scanner.isPHPIdentifierPart(line
1274                                         .charAt(forPos - 1)))
1275                                         && (line.length() == forPos + 3 || !Scanner
1276                                                         .isPHPIdentifierPart(line.charAt(forPos + 3))))
1277                                 return true;
1278                 }
1279                 return false;
1280         }
1281
1282         /**
1283          * Returns the position in <code>text</code> after which there comes only
1284          * whitespace, up to <code>offset</code>.
1285          *
1286          * @param text
1287          *            the text being searched
1288          * @param offset
1289          *            the maximum offset to search for
1290          * @return the smallest value <code>v</code> such that
1291          *         <code>text.substring(v, offset).trim() == 0</code>
1292          */
1293         private static int startOfWhitespaceBeforeOffset(String text, int offset) {
1294                 int i = Math.min(offset, text.length());
1295                 for (; i >= 1; i--) {
1296                         if (!Character.isWhitespace(text.charAt(i - 1)))
1297                                 break;
1298                 }
1299                 return i;
1300         }
1301 }