net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/ui/text/FastJavaPartitionScanner.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 IBM Corporation 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 API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.ui.text;
  12
  13 import net.sourceforge.phpeclipse.ui.text.rules.AbstractPartitioner;
  14
  15 import org.eclipse.jface.text.Assert;
  16 import org.eclipse.jface.text.IDocument;
  17 import org.eclipse.jface.text.rules.ICharacterScanner;
  18 import org.eclipse.jface.text.rules.IPartitionTokenScanner;
  19 import org.eclipse.jface.text.rules.IToken;
  20 import org.eclipse.jface.text.rules.Token;
  21
  22 /**
  23  * This scanner recognizes the JavaDoc comments, Java multi line comments, Java single line comments, Java strings.
  24  */
  25 public class FastJavaPartitionScanner implements IPartitionTokenScanner, IPHPPartitions {
  26
  27   // states
  28   private static final int PHP = 0;
  29
  30   private static final int SINGLE_LINE_COMMENT = 1;
  31
  32   private static final int MULTI_LINE_COMMENT = 2;
  33
  34   private static final int PHPDOC = 3;
  35
  36   private static final int STRING_DQ = 4;
  37
  38   private static final int STRING_SQ = 5;
  39
  40   private static final int STRING_HEREDOC = 6;
  41
  42   // beginning of prefixes and postfixes
  43   private static final int NONE = 0;
  44
  45   private static final int BACKSLASH = 1; // postfix for STRING_DQ and CHARACTER
  46
  47   private static final int SLASH = 2; // prefix for SINGLE_LINE or MULTI_LINE or JAVADOC
  48
  49   private static final int SLASH_STAR = 3; // prefix for MULTI_LINE_COMMENT or JAVADOC
  50
  51   private static final int SLASH_STAR_STAR = 4; // prefix for MULTI_LINE_COMMENT or JAVADOC
  52
  53   private static final int STAR = 5; // postfix for MULTI_LINE_COMMENT or JAVADOC
  54
  55   private static final int CARRIAGE_RETURN = 6; // postfix for STRING_DQ, CHARACTER and SINGLE_LINE_COMMENT
  56
  57 //  private static final int HEREDOC = 7;
  58
  59   /** The scanner. */
  60   private final BufferedDocumentScanner fScanner = new BufferedDocumentScanner(1000); // faster implementation
  61
  62   /** The offset of the last returned token. */
  63   private int fTokenOffset;
  64
  65   /** The length of the last returned token. */
  66   private int fTokenLength;
  67
  68   /** The state of the scanner. */
  69   private int fState;
  70
  71   /** The last significant characters read. */
  72   private int fLast;
  73
  74   /** The amount of characters already read on first call to nextToken(). */
  75   private int fPrefixLength;
  76
  77   // emulate JavaPartitionScanner
  78   private boolean fEmulate = false;
  79
  80   private int fJavaOffset;
  81
  82   private int fJavaLength;
  83
  84   private final IToken[] fTokens = new IToken[] {
  85       new Token(null),
  86       new Token(PHP_SINGLELINE_COMMENT),
  87       new Token(PHP_MULTILINE_COMMENT),
  88       new Token(PHP_PHPDOC_COMMENT),
  89       new Token(PHP_STRING_DQ),
  90       new Token(PHP_STRING_SQ),
  91       new Token(PHP_STRING_HEREDOC)};
  92
  93   public FastJavaPartitionScanner(boolean emulate) {
  94     fEmulate = emulate;
  95   }
  96
  97   public FastJavaPartitionScanner() {
  98     this(false);
  99   }
 100
 101   /*
 102    * @see org.eclipse.jface.text.rules.ITokenScanner#nextToken()
 103    */
 104   public IToken nextToken() {
 105
 106     // emulate JavaPartitionScanner
 107     if (fEmulate) {
 108       if (fJavaOffset != -1 && fTokenOffset + fTokenLength != fJavaOffset + fJavaLength) {
 109         fTokenOffset += fTokenLength;
 110         return fTokens[PHP];
 111       } else {
 112         fJavaOffset = -1;
 113         fJavaLength = 0;
 114       }
 115     }
 116
 117     fTokenOffset += fTokenLength;
 118     fTokenLength = fPrefixLength;
 119
 120     while (true) {
 121       final int ch = fScanner.read();
 122
 123       // characters
 124       switch (ch) {
 125       case ICharacterScanner.EOF:
 126         if (fTokenLength > 0) {
 127           fLast = NONE; // ignore last
 128           return preFix(fState, PHP, NONE, 0);
 129
 130         } else {
 131           fLast = NONE;
 132           fPrefixLength = 0;
 133           return Token.EOF;
 134         }
 135
 136       case '\r':
 137         // emulate JavaPartitionScanner
 138         if (!fEmulate && fLast != CARRIAGE_RETURN) {
 139           fLast = CARRIAGE_RETURN;
 140           fTokenLength++;
 141           continue;
 142
 143         } else {
 144
 145           switch (fState) {
 146           case SINGLE_LINE_COMMENT:
 147             //                                  case CHARACTER:
 148             //                                  case STRING_DQ:
 149             //                                  case STRING_SQ:
 150             if (fTokenLength > 0) {
 151               IToken token = fTokens[fState];
 152
 153               // emulate JavaPartitionScanner
 154               if (fEmulate) {
 155                 fTokenLength++;
 156                 fLast = NONE;
 157                 fPrefixLength = 0;
 158               } else {
 159                 fLast = CARRIAGE_RETURN;
 160                 fPrefixLength = 1;
 161               }
 162
 163               fState = PHP;
 164               return token;
 165
 166             } else {
 167               consume();
 168               continue;
 169             }
 170
 171           default:
 172             consume();
 173             continue;
 174           }
 175         }
 176
 177       case '\n':
 178         switch (fState) {
 179         case SINGLE_LINE_COMMENT:
 180           //                            case CHARACTER:
 181           //                            case STRING_DQ:
 182           //                            case STRING_SQ:
 183           // assert(fTokenLength > 0);
 184           return postFix(fState);
 185
 186         default:
 187           consume();
 188           continue;
 189         }
 190
 191       case '?':
 192         if (fState == SINGLE_LINE_COMMENT) {
 193           int nextch = fScanner.read();
 194           if (nextch == '>') {
 195             // <h1>This is an <?php # echo 'simple' ?> example.</h1>
 196             fTokenLength--;
 197             fScanner.unread();
 198             fScanner.unread();
 199             return postFix(fState);
 200           }
 201 //          fScanner.unread();
 202         }
 203
 204       default:
 205         if (!fEmulate && fLast == CARRIAGE_RETURN) {
 206           switch (fState) {
 207           case SINGLE_LINE_COMMENT:
 208             //                                  case CHARACTER:
 209             //                                  case STRING_DQ:
 210             //                                  case STRING_SQ:
 211             int last;
 212             int newState;
 213             switch (ch) {
 214             case '/':
 215               last = SLASH;
 216               newState = PHP;
 217               break;
 218
 219             case '*':
 220               last = STAR;
 221               newState = PHP;
 222               break;
 223
 224             case '\'':
 225               last = NONE;
 226               newState = STRING_SQ;
 227               break;
 228
 229             case '"':
 230               last = NONE;
 231               newState = STRING_DQ;
 232               break;
 233
 234             case '\r':
 235               last = CARRIAGE_RETURN;
 236               newState = PHP;
 237               break;
 238
 239             case '\\':
 240               last = BACKSLASH;
 241               newState = PHP;
 242               break;
 243
 244             default:
 245               last = NONE;
 246               newState = PHP;
 247               break;
 248             }
 249
 250             fLast = NONE; // ignore fLast
 251             return preFix(fState, newState, last, 1);
 252
 253           default:
 254             break;
 255           }
 256         }
 257       }
 258
 259       // states
 260       switch (fState) {
 261       case PHP:
 262         switch (ch) {
 263         case '#':
 264           if (fTokenLength > 0) {
 265             return preFix(PHP, SINGLE_LINE_COMMENT, NONE, 1);
 266           } else {
 267             preFix(PHP, SINGLE_LINE_COMMENT, NONE, 1);
 268             fTokenOffset += fTokenLength;
 269             fTokenLength = fPrefixLength;
 270             break;
 271           }
 272         case '/':
 273           if (fLast == SLASH) {
 274             if (fTokenLength - getLastLength(fLast) > 0) {
 275               return preFix(PHP, SINGLE_LINE_COMMENT, NONE, 2);
 276             } else {
 277               preFix(PHP, SINGLE_LINE_COMMENT, NONE, 2);
 278               fTokenOffset += fTokenLength;
 279               fTokenLength = fPrefixLength;
 280               break;
 281             }
 282
 283           } else {
 284             fTokenLength++;
 285             fLast = SLASH;
 286             break;
 287           }
 288
 289         case '*':
 290           if (fLast == SLASH) {
 291             if (fTokenLength - getLastLength(fLast) > 0)
 292               return preFix(PHP, MULTI_LINE_COMMENT, SLASH_STAR, 2);
 293             else {
 294               preFix(PHP, MULTI_LINE_COMMENT, SLASH_STAR, 2);
 295               fTokenOffset += fTokenLength;
 296               fTokenLength = fPrefixLength;
 297               break;
 298             }
 299
 300           } else {
 301             consume();
 302             break;
 303           }
 304
 305         case '\'':
 306           fLast = NONE; // ignore fLast
 307           if (fTokenLength > 0)
 308             return preFix(PHP, STRING_SQ, NONE, 1);
 309           else {
 310             preFix(PHP, STRING_SQ, NONE, 1);
 311             fTokenOffset += fTokenLength;
 312             fTokenLength = fPrefixLength;
 313             break;
 314           }
 315
 316         case '"':
 317           fLast = NONE; // ignore fLast
 318           if (fTokenLength > 0)
 319             return preFix(PHP, STRING_DQ, NONE, 1);
 320           else {
 321             preFix(PHP, STRING_DQ, NONE, 1);
 322             fTokenOffset += fTokenLength;
 323             fTokenLength = fPrefixLength;
 324             break;
 325           }
 326
 327         default:
 328           consume();
 329           break;
 330         }
 331         break;
 332
 333       case SINGLE_LINE_COMMENT:
 334         consume();
 335         break;
 336
 337       case PHPDOC:
 338         switch (ch) {
 339         case '/':
 340           switch (fLast) {
 341           case SLASH_STAR_STAR:
 342             return postFix(MULTI_LINE_COMMENT);
 343
 344           case STAR:
 345             return postFix(PHPDOC);
 346
 347           default:
 348             consume();
 349             break;
 350           }
 351           break;
 352
 353         case '*':
 354           fTokenLength++;
 355           fLast = STAR;
 356           break;
 357
 358         default:
 359           consume();
 360           break;
 361         }
 362         break;
 363
 364       case MULTI_LINE_COMMENT:
 365         switch (ch) {
 366         case '*':
 367           if (fLast == SLASH_STAR) {
 368             fLast = SLASH_STAR_STAR;
 369             fTokenLength++;
 370             fState = PHPDOC;
 371           } else {
 372             fTokenLength++;
 373             fLast = STAR;
 374           }
 375           break;
 376
 377         case '/':
 378           if (fLast == STAR) {
 379             return postFix(MULTI_LINE_COMMENT);
 380           } else {
 381             consume();
 382             break;
 383           }
 384
 385         default:
 386           consume();
 387           break;
 388         }
 389         break;
 390
 391       case STRING_DQ:
 392         switch (ch) {
 393         case '\\':
 394           fLast = (fLast == BACKSLASH) ? NONE : BACKSLASH;
 395           fTokenLength++;
 396           break;
 397
 398         case '\"':
 399           if (fLast != BACKSLASH) {
 400             return postFix(STRING_DQ);
 401
 402           } else {
 403             consume();
 404             break;
 405           }
 406
 407         default:
 408           consume();
 409           break;
 410         }
 411         break;
 412       case STRING_SQ:
 413         switch (ch) {
 414         case '\\':
 415           fLast = (fLast == BACKSLASH) ? NONE : BACKSLASH;
 416           fTokenLength++;
 417           break;
 418
 419         case '\'':
 420           if (fLast != BACKSLASH) {
 421             return postFix(STRING_SQ);
 422
 423           } else {
 424             consume();
 425             break;
 426           }
 427
 428         default:
 429           consume();
 430           break;
 431         }
 432         break;
 433       //                        case CHARACTER:
 434       //                                switch (ch) {
 435       //                                case '\\':
 436       //                                        fLast= (fLast == BACKSLASH) ? NONE : BACKSLASH;
 437       //                                        fTokenLength++;
 438       //                                        break;
 439       //
 440       //                                case '\'':
 441       //                                        if (fLast != BACKSLASH) {
 442       //                                                return postFix(CHARACTER);
 443       //
 444       //                                        } else {
 445       //                                                consume();
 446       //                                                break;
 447       //                                        }
 448       //
 449       //                                default:
 450       //                                        consume();
 451       //                                        break;
 452       //                                }
 453       //                                break;
 454       }
 455     }
 456   }
 457
 458   private static final int getLastLength(int last) {
 459     switch (last) {
 460     default:
 461       return -1;
 462
 463     case NONE:
 464       return 0;
 465
 466     case CARRIAGE_RETURN:
 467     case BACKSLASH:
 468     case SLASH:
 469     case STAR:
 470       return 1;
 471
 472     case SLASH_STAR:
 473       return 2;
 474
 475     case SLASH_STAR_STAR:
 476       return 3;
 477     }
 478   }
 479
 480   private final void consume() {
 481     fTokenLength++;
 482     fLast = NONE;
 483   }
 484
 485   private final IToken postFix(int state) {
 486     fTokenLength++;
 487     fLast = NONE;
 488     fState = PHP;
 489     fPrefixLength = 0;
 490     return fTokens[state];
 491   }
 492
 493   private final IToken preFix(int state, int newState, int last, int prefixLength) {
 494     // emulate JavaPartitionScanner
 495     if (fEmulate && state == PHP && (fTokenLength - getLastLength(fLast) > 0)) {
 496       fTokenLength -= getLastLength(fLast);
 497       fJavaOffset = fTokenOffset;
 498       fJavaLength = fTokenLength;
 499       fTokenLength = 1;
 500       fState = newState;
 501       fPrefixLength = prefixLength;
 502       fLast = last;
 503       return fTokens[state];
 504
 505     } else {
 506       fTokenLength -= getLastLength(fLast);
 507       fLast = last;
 508       fPrefixLength = prefixLength;
 509       IToken token = fTokens[state];
 510       fState = newState;
 511       return token;
 512     }
 513   }
 514
 515   private static int getState(String contentType) {
 516
 517     if (contentType == null)
 518       return PHP;
 519
 520     else if (contentType.equals(PHP_SINGLELINE_COMMENT))
 521       return SINGLE_LINE_COMMENT;
 522
 523     else if (contentType.equals(PHP_MULTILINE_COMMENT))
 524       return MULTI_LINE_COMMENT;
 525
 526     else if (contentType.equals(PHP_PHPDOC_COMMENT))
 527       return PHPDOC;
 528
 529     else if (contentType.equals(PHP_STRING_DQ))
 530       return STRING_DQ;
 531
 532     else if (contentType.equals(PHP_STRING_SQ))
 533       return STRING_SQ;
 534
 535     else if (contentType.equals(PHP_STRING_HEREDOC))
 536       return STRING_HEREDOC;
 537
 538     //          else if (contentType.equals(JAVA_CHARACTER))
 539     //                  return CHARACTER;
 540
 541     else
 542       return PHP;
 543   }
 544
 545   /*
 546    * @see IPartitionTokenScanner#setPartialRange(IDocument, int, int, String, int)
 547    */
 548   public void setPartialRange(IDocument document, int offset, int length, String contentType, int partitionOffset) {
 549     fScanner.setRange(document, offset, length);
 550     setRange(document, offset, length);
 551     fTokenOffset = partitionOffset;
 552     fTokenLength = 0;
 553     fPrefixLength = offset - partitionOffset;
 554     fLast = NONE;
 555
 556     if (offset == partitionOffset) {
 557       // restart at beginning of partition
 558       fState = PHP;
 559     } else {
 560       fState = getState(contentType);
 561     }
 562
 563     // emulate JavaPartitionScanner
 564     if (fEmulate) {
 565       fJavaOffset = -1;
 566       fJavaLength = 0;
 567     }
 568   }
 569
 570   /*
 571    * @see ITokenScanner#setRange(IDocument, int, int)
 572    */
 573   public void setRange(IDocument document, int offset, int length) {
 574     fScanner.setRange(document, offset, length);
 575     fTokenOffset = offset;
 576     fTokenLength = 0;
 577     fPrefixLength = 0;
 578     fLast = NONE;
 579     fState = PHP;
 580
 581     // emulate JavaPartitionScanner
 582     if (fEmulate) {
 583       fJavaOffset = -1;
 584       fJavaLength = 0;
 585     }
 586   }
 587
 588   /*
 589    * @see ITokenScanner#getTokenLength()
 590    */
 591   public int getTokenLength() {
 592     return fTokenLength;
 593   }
 594
 595   /*
 596    * @see ITokenScanner#getTokenOffset()
 597    */
 598   public int getTokenOffset() {
 599     if (AbstractPartitioner.DEBUG) {
 600       Assert.isTrue(fTokenOffset >= 0, Integer.toString(fTokenOffset));
 601     }
 602     return fTokenOffset;
 603   }
 604
 605 }