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