Config editor through XML file
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / php / PHPPartitionScanner.java
1 /**********************************************************************
2 Copyright (c) 2000, 2002 IBM Corp. 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 implementation
10     Klaus Hartlage - www.eclipseproject.de
11 **********************************************************************/
12 package net.sourceforge.phpeclipse.phpeditor.php;
13
14 import java.io.CharArrayWriter;
15 import java.util.ArrayList;
16 import java.util.List;
17
18 import org.eclipse.jface.text.rules.ICharacterScanner;
19 import org.eclipse.jface.text.rules.IPredicateRule;
20 import org.eclipse.jface.text.rules.IToken;
21 import org.eclipse.jface.text.rules.IWordDetector;
22 import org.eclipse.jface.text.rules.MultiLineRule;
23 import org.eclipse.jface.text.rules.RuleBasedPartitionScanner;
24 import org.eclipse.jface.text.rules.Token;
25 import org.eclipse.jface.text.rules.WordRule;
26
27 /**
28  * This scanner recognizes the JavaDoc comments and Java multi line comments.
29  */
30 public class PHPPartitionScanner extends RuleBasedPartitionScanner {
31
32   private final static String SKIP = "__skip"; //$NON-NLS-1$
33   public final static String HTML_MULTILINE_COMMENT = "__html_multiline_comment"; //$NON-NLS-1$
34   //    public final static String JAVA_DOC= "__java_javadoc"; //$NON-NLS-1$
35   public final static String PHP = "__php"; //$NON-NLS-1$
36   //public final static String HTML = "__html"; //$NON-NLS-1$
37
38   public final static IToken php = new Token(PHP);
39   //public final static IToken html = new Token(HTML);
40   public final static IToken comment = new Token(HTML_MULTILINE_COMMENT);
41
42   protected final static char[] php0EndSequence = { '<', '?' };
43   protected final static char[] php1EndSequence = { '<', '?', 'p', 'h', 'p' };
44   protected final static char[] php2EndSequence = { '<', '?', 'P', 'H', 'P' };
45
46   private StringBuffer test;
47
48   public class PHPMultiLineRule extends MultiLineRule {
49
50     public PHPMultiLineRule(String startSequence, String endSequence, IToken token) {
51       super(startSequence, endSequence, token);
52     }
53
54     public PHPMultiLineRule(String startSequence, String endSequence, IToken token, char escapeCharacter) {
55       super(startSequence, endSequence, token, escapeCharacter);
56     }
57
58     protected boolean endSequenceDetected(ICharacterScanner scanner) {
59       int c;
60       int c2;
61
62       boolean lineCommentMode = false;
63       boolean multiLineCommentMode = false;
64       boolean stringMode = false;
65
66       char[][] delimiters = scanner.getLegalLineDelimiters();
67       while ((c = scanner.read()) != ICharacterScanner.EOF) {
68         if (c == '#') {
69           // read until end of line
70           while ((c = scanner.read()) != ICharacterScanner.EOF) {
71             if (fEndSequence.length > 0 && c == fEndSequence[0]) {
72               // Check if the specified end sequence has been found.
73               if (sequenceDetected(scanner, fEndSequence, true))
74                 return true;
75             } else if (c == '\n') {
76               break;
77             }
78           }
79           continue;
80         } else if (c == '/' && (c = scanner.read()) != ICharacterScanner.EOF) {
81           if (c == '/') {
82             // read until end of line
83             while ((c = scanner.read()) != ICharacterScanner.EOF) {
84               if (fEndSequence.length > 0 && c == fEndSequence[0]) {
85                 // Check if the specified end sequence has been found.
86                 if (sequenceDetected(scanner, fEndSequence, true))
87                   return true;
88               } else if (c == '\n') {
89                 break;
90               }
91             }
92             continue;
93           } else if (c == '*') {
94             // multi-line comment
95             while ((c = scanner.read()) != ICharacterScanner.EOF) {
96               if (c == '*' && (c = scanner.read()) != ICharacterScanner.EOF) {
97                 if (c == '/') {
98                   break;
99                 }
100                 scanner.unread();
101               }
102             }
103
104             continue;
105           } else {
106             scanner.unread();
107           }
108         } else if (c == '"') {
109           // string mode
110           while ((c = scanner.read()) != ICharacterScanner.EOF) {
111             if (c == '\\') {
112               c = scanner.read();
113             } else if (c == '"') {
114               break;
115             }
116           }
117           continue;
118         } else if (c == '\'') {
119           // string mode
120           while ((c = scanner.read()) != ICharacterScanner.EOF) {
121             if (c == '\\') {
122               c = scanner.read();
123             } else if (c == '\'') {
124               break;
125             }
126           }
127           continue;
128         }
129
130         if (c == fEscapeCharacter) {
131           // Skip the escaped character.
132           scanner.read();
133         } else if (fEndSequence.length > 0 && c == fEndSequence[0]) {
134           // Check if the specified end sequence has been found.
135           if (sequenceDetected(scanner, fEndSequence, true))
136             return true;
137         } else if (fBreaksOnEOL) {
138           // Check for end of line since it can be used to terminate the pattern.
139           for (int i = 0; i < delimiters.length; i++) {
140             if (c == delimiters[i][0] && sequenceDetected(scanner, delimiters[i], false))
141               return true;
142           }
143         }
144       } 
145       boolean phpMode = false;
146       if (c == ICharacterScanner.EOF) {
147         phpMode = true;
148       }
149       scanner.unread();
150       return phpMode;
151     }
152   }
153
154   //  public class HTMLMultiLineRule extends MultiLineRule {
155   //
156   //    public HTMLMultiLineRule(String startSequence, String endSequence, IToken token) {
157   //      super(startSequence, endSequence, token);
158   //    }
159   //
160   //    public HTMLMultiLineRule(String startSequence, String endSequence, IToken token, char escapeCharacter) {
161   //      super(startSequence, endSequence, token, escapeCharacter);
162   //    }
163   //
164   //    protected boolean endSequenceDetected(ICharacterScanner scanner) {
165   //      int c;
166   //
167   //      char[][] delimiters = scanner.getLegalLineDelimiters();
168   //      while ((c = scanner.read()) != ICharacterScanner.EOF) {
169   //        if (c == '<') {
170   //          //       scanner.unread();
171   //          if (sequenceDetected(scanner, php2EndSequence, true)) {
172   //            // <?PHP
173   //            scanner.unread();
174   //            scanner.unread();
175   //            scanner.unread();
176   //            scanner.unread();
177   //            scanner.unread();
178   //            return true;
179   //          }
180   //          if (sequenceDetected(scanner, php1EndSequence, true)) {
181   //            // <?php
182   //            scanner.unread();
183   //            scanner.unread();
184   //            scanner.unread();
185   //            scanner.unread();
186   //            scanner.unread();
187   //            return true;
188   //          }
189   //          if (sequenceDetected(scanner, php0EndSequence, true)) {
190   //            // <?
191   //            scanner.unread();
192   //            scanner.unread();
193   //            return true;
194   //          }
195   //          //      scanner.read();
196   //        }
197   //
198   //      }
199   //      scanner.unread();
200   //      return false;
201   //    }
202   //
203   //    protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {
204   //
205   //      if (resume) {
206   //
207   //        if (endSequenceDetected(scanner))
208   //          return fToken;
209   //
210   //      } else {
211   //
212   //        int c = scanner.read();
213   //        //     if (c == fStartSequence[0]) {
214   //        //       if (sequenceDetected(scanner, fStartSequence, false)) {
215   //        if (endSequenceDetected(scanner))
216   //          return fToken;
217   //        //       }
218   //        //     }
219   //      }
220   //
221   //      scanner.unread();
222   //      return Token.UNDEFINED;
223   //    }
224   //
225   //    public IToken evaluate(ICharacterScanner scanner, boolean resume) {
226   //      if (fColumn == UNDEFINED)
227   //        return doEvaluate(scanner, resume);
228   //
229   //      int c = scanner.read();
230   //      scanner.unread();
231   //      //    if (c == fStartSequence[0])
232   //      return (fColumn == scanner.getColumn() ? doEvaluate(scanner, resume) : Token.UNDEFINED);
233   //      //    else
234   //      //      return Token.UNDEFINED;
235   //    }
236   //  }
237
238 //  public class HTMLPatternRule implements IPredicateRule {
239 //
240 //    protected static final int UNDEFINED = -1;
241 //
242 //    /** The token to be returned on success */
243 //    protected IToken fToken;
244 //
245 //    /** The pattern's column constrain */
246 //    protected int fColumn = UNDEFINED;
247 //    /** The pattern's escape character */
248 //    protected char fEscapeCharacter;
249 //    /** Indicates whether end of line termines the pattern */
250 //    protected boolean fBreaksOnEOL;
251 //
252 //    /**
253 //     * Creates a rule for the given starting and ending sequence.
254 //     * When these sequences are detected the rule will return the specified token.
255 //     * Alternatively, the sequence can also be ended by the end of the line.
256 //     * Any character which follows the given escapeCharacter will be ignored.
257 //     *
258 //     * @param startSequence the pattern's start sequence
259 //     * @param endSequence the pattern's end sequence, <code>null</code> is a legal value
260 //     * @param token the token which will be returned on success
261 //     * @param escapeCharacter any character following this one will be ignored
262 //     * @param indicates whether the end of the line also termines the pattern
263 //     */
264 //    public HTMLPatternRule(IToken token) {
265 //      fToken = token;
266 //      fEscapeCharacter = (char) 0;
267 //      fBreaksOnEOL = false;
268 //    }
269 //
270 //    /**
271 //     * Sets a column constraint for this rule. If set, the rule's token
272 //     * will only be returned if the pattern is detected starting at the 
273 //     * specified column. If the column is smaller then 0, the column
274 //     * constraint is considered removed.
275 //     *
276 //     * @param column the column in which the pattern starts
277 //     */
278 //    public void setColumnConstraint(int column) {
279 //      if (column < 0)
280 //        column = UNDEFINED;
281 //      fColumn = column;
282 //    }
283 //
284 //    /**
285 //     * Evaluates this rules without considering any column constraints.
286 //     *
287 //     * @param scanner the character scanner to be used
288 //     * @return the token resulting from this evaluation
289 //     */
290 //    protected IToken doEvaluate(ICharacterScanner scanner) {
291 //      return doEvaluate(scanner, false);
292 //    }
293 //
294 //    /**
295 //     * Evaluates this rules without considering any column constraints. Resumes
296 //     * detection, i.e. look sonly for the end sequence required by this rule if the
297 //     * <code>resume</code> flag is set.
298 //     *
299 //     * @param scanner the character scanner to be used
300 //     * @param resume <code>true</code> if detection should be resumed, <code>false</code> otherwise
301 //     * @return the token resulting from this evaluation
302 //     * @since 2.0
303 //     */
304 //    protected IToken doEvaluate(ICharacterScanner scanner, boolean resume) {
305 //
306 //      if (resume) {
307 //
308 //        if (endSequenceDetected(scanner))
309 //          return fToken;
310 //
311 //      } else {
312 //
313 //        int c = scanner.read();
314 //        //      if (c == fStartSequence[0]) {
315 //        //        if (sequenceDetected(scanner, fStartSequence, false)) {
316 //        if (endSequenceDetected(scanner))
317 //          return fToken;
318 //        //        }
319 //        //      }
320 //      }
321 //
322 //      scanner.unread();
323 //      return Token.UNDEFINED;
324 //    }
325 //
326 //    /*
327 //     * @see IRule#evaluate
328 //     */
329 //    public IToken evaluate(ICharacterScanner scanner) {
330 //      return evaluate(scanner, false);
331 //    }
332 //
333 //    /**
334 //     * Returns whether the end sequence was detected. As the pattern can be considered 
335 //     * ended by a line delimiter, the result of this method is <code>true</code> if the 
336 //     * rule breaks on the end  of the line, or if the EOF character is read.
337 //     *
338 //     * @param scanner the character scanner to be used
339 //     * @return <code>true</code> if the end sequence has been detected
340 //     */
341 //    protected boolean endSequenceDetected(ICharacterScanner scanner) {
342 //      int c;
343 //
344 //      char[][] delimiters = scanner.getLegalLineDelimiters();
345 //      while ((c = scanner.read()) != ICharacterScanner.EOF) {
346 //        if (c == '<') {
347 //          //       scanner.unread();
348 //          if (sequenceDetected(scanner, php2EndSequence, true)) {
349 //            // <?PHP
350 //            scanner.unread();
351 //            scanner.unread();
352 //            scanner.unread();
353 //            scanner.unread();
354 //            scanner.unread();
355 //            return true;
356 //          }
357 //          if (sequenceDetected(scanner, php1EndSequence, true)) {
358 //            // <?php
359 //            scanner.unread();
360 //            scanner.unread();
361 //            scanner.unread();
362 //            scanner.unread();
363 //            scanner.unread();
364 //            return true;
365 //          }
366 //          if (sequenceDetected(scanner, php0EndSequence, true)) {
367 //            // <?
368 //            scanner.unread();
369 //            scanner.unread();
370 //            return true;
371 //          }
372 //          //      scanner.read();
373 //        }
374 //
375 //      }
376 //      scanner.unread();
377 //      return false;
378 //    }
379 //
380 //    /**
381 //     * Returns whether the next characters to be read by the character scanner
382 //     * are an exact match with the given sequence. No escape characters are allowed 
383 //     * within the sequence. If specified the sequence is considered to be found
384 //     * when reading the EOF character.
385 //     *
386 //     * @param scanner the character scanner to be used
387 //     * @param sequence the sequence to be detected
388 //     * @param eofAllowed indicated whether EOF terminates the pattern
389 //     * @return <code>true</code> if the given sequence has been detected
390 //     */
391 //    protected boolean sequenceDetected(ICharacterScanner scanner, char[] sequence, boolean eofAllowed) {
392 //      for (int i = 1; i < sequence.length; i++) {
393 //        int c = scanner.read();
394 //        if (c == ICharacterScanner.EOF && eofAllowed) {
395 //          return true;
396 //        } else if (c != sequence[i]) {
397 //          // Non-matching character detected, rewind the scanner back to the start.
398 //          scanner.unread();
399 //          for (int j = i - 1; j > 0; j--)
400 //            scanner.unread();
401 //          return false;
402 //        }
403 //      }
404 //
405 //      return true;
406 //    }
407 //
408 //    /*
409 //     * @see IPredicateRule#evaluate(ICharacterScanner, boolean)
410 //     * @since 2.0
411 //     */
412 //    public IToken evaluate(ICharacterScanner scanner, boolean resume) {
413 //      if (fColumn == UNDEFINED)
414 //        return doEvaluate(scanner, resume);
415 //
416 //      int c = scanner.read();
417 //      scanner.unread();
418 //      //    if (c == fStartSequence[0])
419 //      return (fColumn == scanner.getColumn() ? doEvaluate(scanner, resume) : Token.UNDEFINED);
420 //      //    else
421 //      //      return Token.UNDEFINED;
422 //    }
423 //
424 //    /*
425 //     * @see IPredicateRule#getSuccessToken()
426 //     * @since 2.0
427 //     */
428 //    public IToken getSuccessToken() {
429 //      return fToken;
430 //    }
431 //  }
432   /**
433    * Detector for empty comments.
434    */
435 //  static class EmptyCommentDetector implements IWordDetector {
436 //
437 //    /* (non-Javadoc)
438 //    * Method declared on IWordDetector
439 //      */
440 //    public boolean isWordStart(char c) {
441 //      return (c == '/');
442 //    }
443 //
444 //    /* (non-Javadoc)
445 //    * Method declared on IWordDetector
446 //      */
447 //    public boolean isWordPart(char c) {
448 //      return (c == '*' || c == '/');
449 //    }
450 //  };
451
452   /**
453    * 
454    */
455 //  static class WordPredicateRule extends WordRule implements IPredicateRule {
456 //
457 //    private IToken fSuccessToken;
458 //
459 //    public WordPredicateRule(IToken successToken) {
460 //      super(new EmptyCommentDetector());
461 //      fSuccessToken = successToken;
462 //      addWord("/**/", fSuccessToken);
463 //    }
464 //
465 //    /*
466 //     * @see org.eclipse.jface.text.rules.IPredicateRule#evaluate(ICharacterScanner, boolean)
467 //     */
468 //    public IToken evaluate(ICharacterScanner scanner, boolean resume) {
469 //      return super.evaluate(scanner);
470 //    }
471 //
472 //    /*
473 //     * @see org.eclipse.jface.text.rules.IPredicateRule#getSuccessToken()
474 //     */
475 //    public IToken getSuccessToken() {
476 //      return fSuccessToken;
477 //    }
478 //  };
479
480   /**
481    * Creates the partitioner and sets up the appropriate rules.
482    */
483   public PHPPartitionScanner() {
484     super();
485
486     //    IToken php = new Token(PHP);
487     //    IToken html = new Token(HTML);
488     //    IToken comment = new Token(HTML_MULTILINE_COMMENT);
489
490     List rules = new ArrayList();
491
492     // Add rule for single line comments.
493     //  rules.add(new EndOfLineRule("//", Token.UNDEFINED));
494
495     // Add rule for strings and character constants.
496     //          rules.add(new SingleLineRule("\"", "\"", Token.UNDEFINED, '\\'));
497     //  rules.add(new SingleLineRule("'", "'", Token.UNDEFINED, '\\')); 
498
499     // Add special case word rule.
500     //    rules.add(new WordPredicateRule(comment));
501
502     // Add rules for multi-line comments and javadoc.
503     //rules.add(new MultiLineRule("/**", "*/", javaDoc));
504     //  rules.add(new HTMLMultiLineRule("<", "<?", html));
505
506     rules.add(new MultiLineRule("<!--", "-->", comment));
507     rules.add(new PHPMultiLineRule("<?\r", "?>", php));
508     rules.add(new PHPMultiLineRule("<?\n", "?>", php));
509     rules.add(new PHPMultiLineRule("<?\t", "?>", php));
510     rules.add(new PHPMultiLineRule("<? ", "?>", php));
511     rules.add(new PHPMultiLineRule("<?php", "?>", php));
512     rules.add(new PHPMultiLineRule("<?PHP", "?>", php));
513
514     //    rules.add(new HTMLPatternRule(html)); // "<", "<?",
515     //Add rule for processing instructions
516
517     IPredicateRule[] result = new IPredicateRule[rules.size()];
518     rules.toArray(result);
519     setPredicateRules(result);
520    // setDefaultReturnToken(html);
521   }
522
523   //    public IToken nextToken() {
524   //      
525   //      if (fContentType == null || fRules == null)
526   //        return getNextToken();
527   //      
528   //      fTokenOffset= fOffset;
529   //      fColumn= UNDEFINED;
530   //      boolean resume= (fPartitionOffset < fOffset);
531   //          
532   //      IPredicateRule rule;
533   //      IToken token;
534   //      
535   //      for (int i= 0; i < fRules.length; i++) {
536   //        rule= (IPredicateRule) fRules[i];
537   //        token= rule.getSuccessToken();
538   //        if (fContentType.equals(token.getData())) {
539   //          if (resume)
540   //            fTokenOffset= fPartitionOffset;
541   //          token= rule.evaluate(this, resume);
542   //          if (!token.isUndefined()) {
543   //            fContentType= null;
544   //            return token;
545   //          }
546   //        }
547   //      }
548   //      
549   //      fContentType= null;
550   //      return getNextToken();
551   //    }
552   //    
553   //    public IToken getNextToken() {
554   //      
555   //      IToken token;
556   //      
557   //      while (true) {
558   //        
559   //        fTokenOffset= fOffset;
560   //        fColumn= UNDEFINED;
561   //        
562   //        if (fRules != null) {
563   //          for (int i= 0; i < fRules.length; i++) {
564   //            token= (fRules[i].evaluate(this));
565   //            if (!token.isUndefined())
566   //              return token;
567   //          }
568   //        }
569   //        
570   //        if (read() == EOF)
571   //          return Token.EOF;
572   //        else
573   //          return fDefaultReturnToken;
574   //      }
575   //    }
576 }