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