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