a lot of fixes
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / php / PHPPartitionScanner.java
1 /**
2  * This program and the accompanying materials
3  * are made available under the terms of the Common Public License v1.0
4  * which accompanies this distribution, and is available at
5  * http://www.eclipse.org/legal/cpl-v10.html
6  * Created on 05.03.2003
7  *
8  * @author Stefan Langer (musk)
9  * @version $Revision: 1.19 $
10  */
11 package net.sourceforge.phpeclipse.phpeditor.php;
12
13
14 import java.util.ArrayList;
15 import java.util.HashMap;
16 import java.util.Map;
17
18 import org.eclipse.jface.text.Assert;
19 import org.eclipse.jface.text.BadLocationException;
20 import org.eclipse.jface.text.IDocument;
21 import org.eclipse.jface.text.ITypedRegion;
22 import org.eclipse.jface.text.rules.ICharacterScanner;
23 import org.eclipse.jface.text.rules.IPartitionTokenScanner;
24 import org.eclipse.jface.text.rules.IToken;
25 import org.eclipse.jface.text.rules.Token;
26
27 /**
28  * 
29  */
30 public class PHPPartitionScanner implements IPartitionTokenScanner
31 {
32     private static final boolean DEBUG = false;
33     private boolean fInString = false;
34     private boolean fInDoubString = false;
35     private IDocument fDocument = null;
36     private int fOffset = -1;
37     private String fContentType = IPHPPartitionScannerConstants.HTML;
38     private String fPrevContentType = IPHPPartitionScannerConstants.HTML;
39     private boolean partitionBorder = false;
40     private int fTokenOffset;
41     private int fEnd = -1;
42     private int fLength;
43     private int fCurrentLength;
44     private Map tokens = new HashMap();
45
46     public PHPPartitionScanner()
47     {
48         this.tokens.put(
49             IPHPPartitionScannerConstants.PHP,
50             new Token(IPHPPartitionScannerConstants.PHP));
51         this.tokens.put(
52             IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT,
53             new Token(IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT));
54         this.tokens.put(
55             IPHPPartitionScannerConstants.HTML,
56             new Token(IPHPPartitionScannerConstants.HTML));
57         this.tokens.put(
58             IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT,
59             new Token(IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT));
60         this.tokens.put(
61             IDocument.DEFAULT_CONTENT_TYPE,
62             new Token(IDocument.DEFAULT_CONTENT_TYPE));
63     }
64
65     private IToken getToken(String type)
66     {
67         fLength = fCurrentLength;
68         if (DEBUG)
69         {
70
71             try
72             {
73                 if (fLength <= 0)
74                 {
75                     int line = fDocument.getLineOfOffset(fOffset);
76                     System.err.println(
77                         "Error at "
78                             + line
79                             + " offset:"
80                             + String.valueOf(
81                                 fOffset - fDocument.getLineOffset(line)));
82                 }
83             }
84             catch (BadLocationException e)
85             {   // should never happen
86                 // TODO Write stacktrace to log
87                 e.printStackTrace();
88             }
89         }
90         Assert.isTrue(fLength > 0, "Partition length <= 0!");
91         fCurrentLength = 0;
92         // String can never cross partition borders so reset string detection
93         fInString = false;
94         fInDoubString = false;
95         IToken token = (IToken) this.tokens.get(type);
96         Assert.isNotNull(token, "Token for type \"" + type + "\" not found!");
97         if (DEBUG)
98         {
99             System.out.println(
100                 "Partition: fTokenOffset="
101                     + fTokenOffset
102                     + " fContentType="
103                     + type
104                     + " fLength="
105                     + fLength);
106         }
107         return token;
108     }
109
110     /* (non-Javadoc)
111      * @see org.eclipse.jface.text.rules.IPartitionTokenScanner#setPartialRange(org.eclipse.jface.text.IDocument, int, int, java.lang.String, int)
112      */
113     public void setPartialRange(
114         IDocument document,
115         int offset,
116         int length,
117         String contentType,
118         int partitionOffset)
119     {
120         if (DEBUG)
121         {
122             System.out.println(
123                 "PartialRange: contentType="
124                     + contentType
125                     + " partitionOffset="
126                     + partitionOffset);
127         }
128
129         try
130         {
131             if (partitionOffset > -1)
132             {
133                 partitionBorder = false;
134                 // because of strings we have to parse the whole partition
135                 this.setRange(
136                     document,
137                     partitionOffset,
138                     offset - partitionOffset + length);
139                 // sometimes we get a wrong partition so we retrieve the partition
140                 // directly from the document
141                 fContentType = fDocument.getContentType(partitionOffset);
142             }
143             else
144                 this.setRange(document, offset, length);
145
146         }
147         catch (BadLocationException e)
148         {
149             // should never happen
150             // TODO print stack trace to log
151             // fall back just scan the whole document again
152             this.setRange(document, 0, fDocument.getLength());
153         }
154
155     }
156
157     /* (non-Javadoc)
158      * @see org.eclipse.jface.text.rules.ITokenScanner#getTokenLength()
159      */
160     public int getTokenLength()
161     {
162         return fLength;
163     }
164
165     /* (non-Javadoc)
166      * @see org.eclipse.jface.text.rules.ITokenScanner#getTokenOffset()
167      */
168     public int getTokenOffset()
169     {
170         return fTokenOffset;
171     }
172
173     /* (non-Javadoc)
174      * @see org.eclipse.jface.text.rules.ITokenScanner#nextToken()
175      */
176     public IToken nextToken()
177     {
178         int c;
179
180         // check if we are not allready at the end of the
181         // file
182         if ((c = read()) == ICharacterScanner.EOF)
183         {
184             partitionBorder = false;
185             return Token.EOF;
186         }
187         else
188             unread();
189
190         if (partitionBorder)
191         {
192             fTokenOffset = fOffset;
193             partitionBorder = false;
194         }
195
196         while ((c = read()) != ICharacterScanner.EOF)
197         {
198             switch (c)
199             {
200                 case '<' :
201                     if (!isInString(IPHPPartitionScannerConstants.PHP)
202                         && fContentType
203                             != IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT
204                         && checkPattern(new char[] { '?', 'p', 'h', 'p' }, true))
205                     {
206                         if (fContentType != IPHPPartitionScannerConstants.PHP
207                             && fCurrentLength > 5)
208                         {
209                             unread(5);
210                             IToken token = getToken(fContentType);
211                             // save previouse contenttype
212                             //TODO build stack for previouse contenttype 
213                             fPrevContentType = fContentType;
214
215                             fContentType = IPHPPartitionScannerConstants.PHP;
216
217                             return token;
218                         }
219                         else
220                             fContentType = IPHPPartitionScannerConstants.PHP;
221
222                         // remember offset of this partition
223                         fTokenOffset = fOffset - 5;
224                         fCurrentLength = 5;
225                     }
226                     else if (
227                         !isInString(IPHPPartitionScannerConstants.PHP)
228                             && fContentType
229                                 != IPHPPartitionScannerConstants
230                                     .PHP_MULTILINE_COMMENT
231                             && checkPattern(new char[] { '?' }, false))
232                     {
233                         if (fContentType != IPHPPartitionScannerConstants.PHP
234                             && fCurrentLength > 2)
235                         {
236                             unread(2);
237                             IToken token = getToken(fContentType);
238                             // save previouse contenttype
239                             fPrevContentType = fContentType;
240                             fContentType = IPHPPartitionScannerConstants.PHP;
241                             return token;
242                         }
243                         else
244                             fContentType = IPHPPartitionScannerConstants.PHP;
245                         // remember offset of this partition
246                         fTokenOffset = fOffset - 2;
247                         fCurrentLength = 2;
248                     }
249                     else if (
250                         !isInString(IPHPPartitionScannerConstants.PHP)
251                             && checkPattern(new char[] { '!', '-', '-' }))
252                     { // return previouse partition
253                         if (fContentType
254                             != IPHPPartitionScannerConstants
255                                 .HTML_MULTILINE_COMMENT
256                             && fCurrentLength > 4)
257                         {
258                             unread(4);
259                             IToken token = getToken(fContentType);
260                             fContentType =
261                                 IPHPPartitionScannerConstants
262                                     .HTML_MULTILINE_COMMENT;
263                             return token;
264                         }
265                         else
266                             fContentType =
267                                 IPHPPartitionScannerConstants
268                                     .HTML_MULTILINE_COMMENT;
269                                     
270                         fTokenOffset = fOffset - 4;
271                         fCurrentLength = 4;
272                     }
273                     break;
274                 case '?' :
275                     if (!isInString(IPHPPartitionScannerConstants.PHP)
276                         && fContentType == IPHPPartitionScannerConstants.PHP)
277                     {
278                         if ((c = read()) == '>')
279                         { 
280                             if (fPrevContentType != null)
281                                 fContentType = fPrevContentType;
282                             else
283                                 fContentType =
284                                     IPHPPartitionScannerConstants.HTML;
285                             partitionBorder = true;
286                             return getToken(IPHPPartitionScannerConstants.PHP);
287                         }
288                         else if (c != ICharacterScanner.EOF)
289                             unread();
290                     }
291                     break;
292                 case '-' :
293                     if (!isInString(IPHPPartitionScannerConstants.PHP)
294                         && fContentType
295                             == IPHPPartitionScannerConstants
296                                 .HTML_MULTILINE_COMMENT
297                         && checkPattern(new char[] { '-', '>' }))
298                     {
299                         fContentType = IPHPPartitionScannerConstants.HTML;
300                         partitionBorder = true;
301                         return getToken(
302                             IPHPPartitionScannerConstants
303                                 .HTML_MULTILINE_COMMENT);
304                     }
305                     break;
306                 case '/' :
307                     if (!isInString(IPHPPartitionScannerConstants.PHP) && (c = read()) == '*')
308                     { // MULTINE COMMENT JAVASCRIPT, CSS, PHP
309                         if (fContentType == IPHPPartitionScannerConstants.PHP
310                             && fCurrentLength > 2)
311                         {
312                             unread(2);
313                             IToken token = getToken(fContentType);
314                             fContentType =
315                                 IPHPPartitionScannerConstants
316                                     .PHP_MULTILINE_COMMENT;
317                             return token;
318                         }
319                         else if (
320                             fContentType
321                                 == IPHPPartitionScannerConstants
322                                     .PHP_MULTILINE_COMMENT)
323                         {
324
325                             fTokenOffset = fOffset - 2;
326                             fCurrentLength = 2;
327                         }
328
329                     }
330                     else if (!isInString(IPHPPartitionScannerConstants.PHP) && c != ICharacterScanner.EOF)
331                         unread();
332                     break;
333                 case '*' :
334                     if (!isInString(IPHPPartitionScannerConstants.PHP) && (c = read()) == '/')
335                     {
336                         if (fContentType
337                             == IPHPPartitionScannerConstants
338                                 .PHP_MULTILINE_COMMENT)
339                         {
340                             fContentType = IPHPPartitionScannerConstants.PHP;
341                             partitionBorder = true;
342                             return getToken(
343                                 IPHPPartitionScannerConstants
344                                     .PHP_MULTILINE_COMMENT);
345                         }
346                         else if (
347                             fContentType
348                                 == IPHPPartitionScannerConstants
349                                     .CSS_MULTILINE_COMMENT)
350                         {
351                         }
352                         else if (
353                             fContentType
354                                 == IPHPPartitionScannerConstants
355                                     .JS_MULTILINE_COMMENT)
356                         {
357                         }
358                     }
359                     else if (!isInString(IPHPPartitionScannerConstants.PHP) && c != ICharacterScanner.EOF)
360                         unread();
361                     break;
362                 case '\'' :
363                     if (!fInDoubString)
364                         fInString = !fInString;
365                     break;
366                 case '"' :
367                     // toggle String mode
368                     if (!fInString)
369                         fInDoubString = !fInDoubString;
370                     break;
371             }
372         } // end of file reached but we have to return the
373         // last partition.
374         return getToken(fContentType);
375     }
376     /* (non-Javadoc)
377      * @see org.eclipse.jface.text.rules.ITokenScanner#setRange(org.eclipse.jface.text.IDocument, int, int)
378      */
379     public void setRange(IDocument document, int offset, int length)
380     {
381         if (DEBUG)
382         {
383             System.out.println(
384                 "SET RANGE: offset=" + offset + " length=" + length);
385         }
386
387         fDocument = document;
388         fOffset = offset;
389         fTokenOffset = offset;
390         fCurrentLength = 0;
391         fLength = 0;
392         fEnd = fOffset + length;
393         fInString = false;
394         fInDoubString = false;
395         fContentType = IPHPPartitionScannerConstants.HTML;
396 //        String[] prev = getPartitionStack(offset);
397     }
398
399     private int read()
400     {
401         try
402         {
403             if (fOffset < fEnd)
404             {
405                 fCurrentLength++;
406                 return fDocument.getChar(fOffset++);
407             }
408             return ICharacterScanner.EOF;
409         }
410         catch (BadLocationException e)
411         {
412             // should never happen
413             // TODO write stacktrace to log
414             fOffset = fEnd;
415             return ICharacterScanner.EOF;
416         }
417     }
418
419     private void unread()
420     {
421         --fOffset;
422         --fCurrentLength;
423     }
424     
425     private void unread(int num)
426     {
427         fOffset -= num;
428         fCurrentLength -= num;
429     }
430
431     private boolean checkPattern(char[] pattern)
432     {
433         return checkPattern(pattern, false);
434     }
435
436     /**
437      * Check if next character sequence read from document is equals to 
438      * the provided pattern. Pattern is read from left to right until the 
439      * first character read doesn't match. If this happens all read characters are
440      * unread.
441      * @param pattern The pattern to check.
442      * @return <code>true</code> if pattern is equals else returns <code>false</code>.
443      */
444     private boolean checkPattern(char[] pattern, boolean ignoreCase)
445     {
446         int prevOffset = fOffset;
447         int prevLength = fCurrentLength;
448         for (int i = 0; i < pattern.length; i++)
449         {
450             int c = read();
451
452             if (c == ICharacterScanner.EOF
453                 || !letterEquals(c, pattern[i], ignoreCase))
454             {
455                 fOffset = prevOffset;
456                 fCurrentLength = prevLength;
457                 return false;
458             }
459         }
460
461         return true;
462     }
463
464     private boolean letterEquals(int test, char letter, boolean ignoreCase)
465     {
466         if (test == letter)
467             return true;
468         else if (
469             ignoreCase
470                 && Character.isLowerCase(letter)
471                 && test == Character.toUpperCase(letter))
472             return true;
473         else if (
474             ignoreCase
475                 && Character.isUpperCase(letter)
476                 && test == Character.toLowerCase(letter))
477             return true;
478
479         return false;
480     }
481     
482     /**
483      * Checks wether the offset is in a <code>String</code> and the specified 
484      * contenttype is the current content type.
485      * Strings are delimited, mutual exclusive, by a " or by a '.
486      * 
487      * @param contentType The contenttype to check.
488      * @return <code>true</code> if the current offset is in a string else 
489      *                  returns false.
490      */
491     private  boolean isInString(String contentType)
492     {
493         if(fContentType == contentType)
494                 return (fInString || fInDoubString);
495         else
496                 return false;           
497     }
498     
499     /**
500      * Returns the previouse partition stack for the given offset.
501      * 
502      * @param offset The offset to return the previouse partitionstack for.
503      * 
504      * @return The stack as a string array.
505      */
506     private String[] getPartitionStack(int offset)
507     {
508         ArrayList types = new ArrayList();
509         int tmpOffset = 0;
510         try
511         {
512             ITypedRegion region = fDocument.getPartition(offset);
513             tmpOffset = region.getOffset();
514             while(tmpOffset-1 > 0)
515             {
516                 region = fDocument.getPartition(tmpOffset-1);
517                 tmpOffset = region.getOffset();
518                 types.add(0, region.getType());
519             }
520         }
521         catch (BadLocationException e)
522         {
523            if(DEBUG)
524            {
525                         e.printStackTrace();
526            }
527         }
528         
529                 String[] retVal = new String[types.size()];
530         
531         retVal = (String[])types.toArray(retVal);
532         return retVal;
533     }
534     
535 }