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 }