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