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