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