private void ensureOverviewHoverManagerInstalled() changed to
[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.15 $
10  */
11 package net.sourceforge.phpeclipse.phpeditor.php;
12
13 import java.util.*;
14
15 import org.eclipse.jface.text.*;
16 import org.eclipse.jface.text.rules.*;
17
18 /**
19  * 
20  */
21 public class PHPPartitionScanner implements IPartitionTokenScanner {
22   private static final boolean DEBUG = false;
23   private IDocument fDocument = null;
24   private int fOffset = -1;
25   private String fContentType = IPHPPartitionScannerConstants.HTML;
26   private String fPrevContentType;
27
28   private boolean partitionBorder = false;
29   private int fTokenOffset;
30   private int fEnd = -1;
31   private int fLength;
32   private Map tokens = new HashMap();
33
34   public PHPPartitionScanner() {
35     this.tokens.put(
36       IPHPPartitionScannerConstants.PHP,
37       new Token(IPHPPartitionScannerConstants.PHP));
38     this.tokens.put(
39       IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT,
40       new Token(IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT));
41     this.tokens.put(
42       IPHPPartitionScannerConstants.HTML,
43       new Token(IPHPPartitionScannerConstants.HTML));
44     this.tokens.put(
45       IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT,
46       new Token(IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT));
47     this.tokens.put(
48       IDocument.DEFAULT_CONTENT_TYPE,
49       new Token(IDocument.DEFAULT_CONTENT_TYPE));
50   }
51
52   private IToken getToken(String type) {
53     fLength = fOffset - fTokenOffset;
54     IToken token = (IToken) this.tokens.get(type);
55     Assert.isNotNull(token, "Token for type \"" + type + "\" not found!");
56     if (DEBUG) {
57       System.out.println(
58         "Partition: fTokenOffset="
59           + fTokenOffset
60           + " fContentType="
61           + fContentType
62           + " fLength="
63           + fLength);
64     }
65     return token;
66   }
67
68 /* (non-Javadoc)
69  * @see org.eclipse.jface.text.rules.IPartitionTokenScanner#setPartialRange(org.eclipse.jface.text.IDocument, int, int, java.lang.String, int)
70  */
71 public void setPartialRange(
72     IDocument document,
73     int offset,
74     int length,
75     String contentType,
76     int partitionOffset)
77 {
78     this.setRange(document, offset, length);
79     if (DEBUG)
80     {
81         System.out.println(
82             "PartialRange: contentType="
83                 + contentType
84                 + " partitionOffset="
85                 + partitionOffset);
86     }
87         
88         if(offset == partitionOffset)
89         {
90                 try
91         {
92             fContentType = fDocument.getContentType(offset);
93         }
94         catch (BadLocationException e)
95         {
96             //should never happen
97         }
98         }
99     else if (this.tokens.containsKey(contentType))
100         fContentType = contentType;
101     // TODO Calculate previouse contenttype
102     if (partitionOffset > -1)
103     {
104         partitionBorder = false;
105         fTokenOffset = partitionOffset;
106     }
107 }
108
109   /* (non-Javadoc)
110    * @see org.eclipse.jface.text.rules.ITokenScanner#getTokenLength()
111    */
112   public int getTokenLength() {
113     return fLength;
114   }
115
116   /* (non-Javadoc)
117    * @see org.eclipse.jface.text.rules.ITokenScanner#getTokenOffset()
118    */
119   public int getTokenOffset() {
120     return fTokenOffset;
121   }
122
123 /* (non-Javadoc)
124  * @see org.eclipse.jface.text.rules.ITokenScanner#nextToken()
125  */
126 public IToken nextToken()
127 {
128     int c;
129
130     // check if we are not allready at the end of the
131     // file
132     if ((c = read()) == ICharacterScanner.EOF)
133     {
134         partitionBorder = false;
135         return Token.EOF;
136     }
137     else
138         unread();
139
140     if (partitionBorder)
141     {
142         fTokenOffset = fOffset;
143         partitionBorder = false;
144     }
145
146     while ((c = read()) != ICharacterScanner.EOF)
147     {
148         switch (c)
149         {
150             case '<' :
151                 if (fContentType
152                     != IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT
153                     && checkPattern(new char[] { '?', 'p', 'h', 'p' }, true))
154                 {
155                     if (fContentType != IPHPPartitionScannerConstants.PHP
156                         && fOffset - 5 > 0)
157                     {
158                         fOffset -= 5;
159                         IToken token = getToken(fContentType);
160                         // save previouse contenttype
161                         fPrevContentType = fContentType;
162
163                         fContentType = IPHPPartitionScannerConstants.PHP;
164
165                         return token;
166                     }
167                     else
168                         fContentType = IPHPPartitionScannerConstants.PHP;
169
170                     // remember offset of this partition
171                     fTokenOffset = fOffset - 5;
172                 }
173                 else if (
174                     fContentType
175                         != IPHPPartitionScannerConstants.PHP_MULTILINE_COMMENT
176                     && checkPattern(new char[] { '?' }, false))
177                 {
178                     if (fContentType != IPHPPartitionScannerConstants.PHP
179                         && fOffset - 2 > 0)
180                     {
181                         fOffset -= 2;
182                             IToken token = getToken(fContentType);
183                 // save previouse contenttype
184                         fPrevContentType =
185                         fContentType;
186                             fContentType = IPHPPartitionScannerConstants.PHP;
187                             return token;
188                             }
189                     else
190                         fContentType = IPHPPartitionScannerConstants.PHP;
191             // remember offset of this partition
192                         fTokenOffset = fOffset - 2;
193                             }
194                 else if (checkPattern(new char[] { '!', '-', '-' }))
195                 { // return previouse partition
196                 if (
197                     fContentType
198                         != IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT
199                     && fOffset - 4 > 0)
200                     {
201                         fOffset -= 4;
202                             IToken token = getToken(fContentType);
203                             fContentType =
204                                 IPHPPartitionScannerConstants
205                                     .HTML_MULTILINE_COMMENT;
206                             return token;
207                             }
208                     else
209                         fContentType =
210                             IPHPPartitionScannerConstants
211                                 .HTML_MULTILINE_COMMENT;
212                             fTokenOffset = fOffset - 4;
213                             }
214                 break; case '?' :
215                 if (fContentType == IPHPPartitionScannerConstants.PHP)
216                 {
217                     if ((c = read()) == '>')
218                     { // TODO Actually calculate the previouse contenttype from the document
219                     if (
220                         fPrevContentType
221                         != null)
222                             fContentType = fPrevContentType; else
223                                 fContentType =
224                                     IPHPPartitionScannerConstants.HTML;
225                                     partitionBorder = true;
226                                     return getToken(
227                                         IPHPPartitionScannerConstants.PHP);
228                                     }
229                     else if (c != ICharacterScanner.EOF)
230                         unread(); }
231                 break; case '-' :
232                 if (fContentType
233                     == IPHPPartitionScannerConstants.HTML_MULTILINE_COMMENT
234                     && checkPattern(new char[] { '-', '>' }))
235                 {
236                     fContentType = IPHPPartitionScannerConstants.HTML;
237                         partitionBorder = true;
238                         return getToken(
239                             IPHPPartitionScannerConstants
240                                 .HTML_MULTILINE_COMMENT);
241                         }
242                 break; case '/' :
243                 if ((c = read()) == '*')
244                 { // MULTINE COMMENT JAVASCRIPT, CSS, PHP
245                 if (
246                     fContentType == IPHPPartitionScannerConstants.PHP
247                     && fOffset - 2 > 0)
248                     {
249                         fOffset -= 2;
250                             IToken token = getToken(fContentType);
251                             fContentType =
252                                 IPHPPartitionScannerConstants
253                                     .PHP_MULTILINE_COMMENT;
254                             return token;
255                             }
256                     else if (
257                         fContentType
258                             == IPHPPartitionScannerConstants
259                                 .PHP_MULTILINE_COMMENT)
260                     {
261
262                         fTokenOffset = fOffset - 2; }
263
264                 }
265                 else if (c != ICharacterScanner.EOF)
266                     unread(); break; case '*' :
267                         if ((c = read()) == '/')
268                         {
269                             if (fContentType
270                                 == IPHPPartitionScannerConstants
271                                     .PHP_MULTILINE_COMMENT)
272                             {
273                                 fContentType =
274                                     IPHPPartitionScannerConstants.PHP;
275                                     partitionBorder = true;
276                                     return getToken(
277                                         IPHPPartitionScannerConstants
278                                             .PHP_MULTILINE_COMMENT);
279                                     }
280                             else if (
281                                 fContentType
282                                     == IPHPPartitionScannerConstants
283                                         .CSS_MULTILINE_COMMENT)
284                             {
285                             }
286                             else if (
287                                 fContentType
288                                     == IPHPPartitionScannerConstants
289                                         .JS_MULTILINE_COMMENT)
290                             {
291                             }
292                         }
293                         else if (c != ICharacterScanner.EOF)
294                             unread(); break; }
295     } // end of file reached but we have to return the
296     // last partition.
297     return getToken(fContentType);
298         }
299   /* (non-Javadoc)
300    * @see org.eclipse.jface.text.rules.ITokenScanner#setRange(org.eclipse.jface.text.IDocument, int, int)
301    */
302   public void setRange(IDocument document, int offset, int length) {
303     if (DEBUG) {
304       System.out.println("SET RANGE: offset=" + offset + " length=" + length);
305     }
306
307     fDocument = document;
308     fOffset = offset;
309     fTokenOffset = offset;
310     fLength = 0;
311     fEnd = fOffset + length;
312     //partitionBorder = false;
313   }
314
315   private int read() {
316     try {
317       if (fOffset < fEnd) {
318         return fDocument.getChar(fOffset++);
319       }
320       return ICharacterScanner.EOF;
321     } catch (BadLocationException e) {
322       // should never happen
323       // TODO write stacktrace to log
324       fOffset = fEnd;
325       return ICharacterScanner.EOF;
326     }
327   }
328
329   private void unread() {
330     --fOffset;
331   }
332
333   private boolean checkPattern(char[] pattern) {
334     return checkPattern(pattern, false);
335   }
336
337   /**
338    * Check if next character sequence read from document is equals to 
339    * the provided pattern. Pattern is read from left to right until the 
340    * first character read doesn't match. If this happens all read characters are
341    * unread.
342    * @param pattern The pattern to check.
343    * @return <code>true</code> if pattern is equals else returns <code>false</code>.
344    */
345   private boolean checkPattern(char[] pattern, boolean ignoreCase) {
346     int prevOffset = fOffset;
347     for (int i = 0; i < pattern.length; i++) {
348       int c = read();
349
350       if (c == ICharacterScanner.EOF
351         || !letterEquals(c, pattern[i], ignoreCase)) {
352         fOffset = prevOffset;
353         return false;
354       }
355     }
356
357     return true;
358   }
359
360   private boolean letterEquals(int test, char letter, boolean ignoreCase) {
361     if (test == letter)
362       return true;
363     else if (
364       ignoreCase
365         && Character.isLowerCase(letter)
366         && test == Character.toUpperCase(letter))
367       return true;
368     else if (
369       ignoreCase
370         && Character.isUpperCase(letter)
371         && test == Character.toLowerCase(letter))
372       return true;
373
374     return false;
375   }
376
377 }