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