net.sourceforge.phpeclipse/src/net/sourceforge/phpeclipse/builder/IdentifierIndexManager.java

   1 package net.sourceforge.phpeclipse.builder;
   2
   3 import java.io.BufferedInputStream;
   4 import java.io.BufferedReader;
   5 import java.io.FileNotFoundException;
   6 import java.io.FileReader;
   7 import java.io.FileWriter;
   8 import java.io.IOException;
   9 import java.io.InputStream;
  10 import java.util.ArrayList;
  11 import java.util.Collection;
  12 import java.util.Comparator;
  13 import java.util.HashMap;
  14 import java.util.Iterator;
  15 import java.util.List;
  16 import java.util.Set;
  17 import java.util.SortedMap;
  18 import java.util.StringTokenizer;
  19 import java.util.TreeMap;
  20
  21 import net.sourceforge.phpdt.core.compiler.ITerminalSymbols;
  22 import net.sourceforge.phpdt.core.compiler.InvalidInputException;
  23 import net.sourceforge.phpdt.internal.compiler.parser.Scanner;
  24 import net.sourceforge.phpdt.internal.compiler.parser.SyntaxError;
  25 import net.sourceforge.phpdt.internal.compiler.util.Util;
  26 import net.sourceforge.phpeclipse.PHPeclipsePlugin;
  27 import net.sourceforge.phpeclipse.obfuscator.PHPIdentifier;
  28
  29 import org.eclipse.core.resources.IFile;
  30 import org.eclipse.core.runtime.CoreException;
  31 import org.eclipse.core.runtime.IStatus;
  32
  33 /**
  34  * Manages the identifer index information for a specific project
  35  *
  36  */
  37 public class IdentifierIndexManager {
  38         public class LineCreator implements ITerminalSymbols {
  39                 private Scanner fScanner;
  40
  41                 private int fToken;
  42
  43                 public LineCreator() {
  44                         fScanner = new Scanner(true, false, false, false, true, null, null,
  45                                         true /* taskCaseSensitive */);
  46                 }
  47
  48                 /**
  49                  * Add the information of the current identifier to the line
  50                  *
  51                  * @param typeOfIdentifier
  52                  *            the type of the identifier ('c'lass, 'd'efine, 'f'unction,
  53                  *            'm'ethod(class), 'v'ariable(class) 'g'lobal variable)
  54                  * @param identifier
  55                  *            current identifier
  56                  * @param line
  57                  *            Buffer for the current index line
  58                  */
  59                 private void addIdentifierInformation(char typeOfIdentifier,
  60                                 char[] identifier, StringBuffer line) {
  61                         line.append('\t');
  62                         line.append(typeOfIdentifier);
  63                         line.append(identifier);
  64                 }
  65
  66                 /**
  67                  * Add the information of the current identifier to the line
  68                  *
  69                  * @param typeOfIdentifier
  70                  *            the type of the identifier ('c'lass, 'd'efine, 'f'unction,
  71                  *            'm'ethod(class), 'v'ariable(class) 'g'lobal variable)
  72                  * @param identifier
  73                  *            current identifier
  74                  * @param line
  75                  *            Buffer for the current index line
  76                  * @param phpdocOffset
  77                  *            the offset of the PHPdoc comment if available
  78                  * @param phpdocLength
  79                  *            the length of the PHPdoc comment if available
  80                  */
  81                 private void addIdentifierInformation(char typeOfIdentifier,
  82                                 char[] identifier, StringBuffer line, int phpdocOffset,
  83                                 int phpdocLength) {
  84                         line.append('\t');
  85                         line.append(typeOfIdentifier);
  86                         line.append(identifier);
  87                         line.append("\to"); // Offset
  88                         line.append(fScanner.getCurrentTokenStartPosition());
  89                         if (phpdocOffset >= 0) {
  90                                 line.append("\tp"); // phpdoc offset
  91                                 line.append(phpdocOffset);
  92                                 line.append("\tl"); // phpdoc length
  93                                 line.append(phpdocLength);
  94                         }
  95                 }
  96
  97                 private void addClassVariableInformation(char typeOfIdentifier,
  98                                 char[] identifier, StringBuffer line, int phpdocOffset,
  99                                 int phpdocLength) {
 100                         line.append('\t');
 101                         line.append(typeOfIdentifier);
 102                         line.append(identifier);
 103                         line.append("\to"); // Offset
 104                         // we don't store the '$' in the index for class variables:
 105                         line.append(fScanner.getCurrentTokenStartPosition() + 1);
 106                         if (phpdocOffset >= 0) {
 107                                 line.append("\tp"); // phpdoc offset
 108                                 line.append(phpdocOffset);
 109                                 line.append("\tl"); // phpdoc length
 110                                 line.append(phpdocLength);
 111                         }
 112                 }
 113
 114                 /**
 115                  * Get the next token from input
 116                  */
 117                 private void getNextToken() throws InvalidInputException {
 118                         // try {
 119                         fToken = fScanner.getNextToken();
 120                         if (Scanner.DEBUG) {
 121                                 int currentEndPosition = fScanner.getCurrentTokenEndPosition();
 122                                 int currentStartPosition = fScanner
 123                                                 .getCurrentTokenStartPosition();
 124                                 System.out.print(currentStartPosition + ","
 125                                                 + currentEndPosition + ": ");
 126                                 System.out.println(fScanner.toStringAction(fToken));
 127                         }
 128                         return;
 129                 }
 130
 131                 private void skipComments()
 132                 {
 133                         try {
 134                                 getNextToken();
 135                                 while (fToken == TokenNameCOMMENT_BLOCK  || fToken == TokenNameCOMMENT_PHPDOC) {
 136                                                 getNextToken();
 137                                 }
 138                         } catch (InvalidInputException e1) {
 139                                 // TODO Auto-generated catch block
 140                                 e1.printStackTrace();
 141                         }
 142                 }
 143
 144                 private void parseDeclarations(char[] parent, StringBuffer buf,
 145                                 boolean goBack) {
 146                         char[] ident;
 147                         char[] classVariable;
 148                         int counter = 0;
 149                         boolean hasModifiers = false;
 150                         int phpdocOffset = -1;
 151                         int phpdocLength = -1;
 152
 153                         try {
 154                                 while (fToken != TokenNameEOF && fToken != TokenNameERROR) {
 155                                         phpdocOffset = -1;
 156                                         hasModifiers = false;
 157                                         if (fToken == TokenNameCOMMENT_PHPDOC) {
 158                                                 phpdocOffset = fScanner.getCurrentTokenStartPosition();
 159                                                 phpdocLength = fScanner.getCurrentTokenEndPosition()
 160                                                                 - fScanner.getCurrentTokenStartPosition() + 1;
 161                                                 getNextToken();
 162                                                 while (fToken == TokenNamestatic
 163                                                                 || fToken == TokenNamefinal
 164                                                                 || fToken == TokenNamepublic
 165                                                                 || fToken == TokenNameprotected
 166                                                                 || fToken == TokenNameprivate
 167                                                                 || fToken == TokenNameabstract) {
 168                                                         hasModifiers = true;
 169                                                         getNextToken();
 170                                                 }
 171                                                 if (fToken == TokenNameEOF || fToken == TokenNameERROR) {
 172                                                         break;
 173                                                 }
 174                                         }
 175                                         if (fToken == TokenNamefunction) {
 176                                                 skipComments();
 177                                                 if (fToken == TokenNameAND) {
 178                                                         getNextToken();
 179                                                 }
 180                                                 if (fToken == TokenNameIdentifier) {
 181                                                         ident = fScanner.getCurrentIdentifierSource();
 182                                                         if (parent != null
 183                                                                         && equalCharArrays(parent, ident)) {
 184                                                                 // constructor function
 185                                                                 addIdentifierInformation('k', ident, buf,
 186                                                                                 phpdocOffset, phpdocLength);
 187                                                         } else {
 188                                                                 if (parent != null) {
 189                                                                         // class method function
 190                                                                         addIdentifierInformation('m', ident, buf,
 191                                                                                         phpdocOffset, phpdocLength);
 192                                                                 } else {
 193                                                                         // nested function ?!
 194                                                                         addIdentifierInformation('f', ident, buf,
 195                                                                                         phpdocOffset, phpdocLength);
 196                                                                 }
 197                                                         }
 198                                                         skipComments();
 199                                                         parseDeclarations(null, buf, true);
 200                                                 }
 201                                         } else if (fToken == TokenNameclass
 202                                                         || fToken == TokenNameinterface) {
 203                                                 skipComments();
 204                                                 if (fToken == TokenNameIdentifier) {
 205                                                         ident = fScanner.getCurrentIdentifierSource();
 206                                                         addIdentifierInformation('c', ident, buf,
 207                                                                         phpdocOffset, phpdocLength);
 208                                                         skipComments();
 209                                                         if (fToken == TokenNameextends) {
 210                                                                 skipComments();
 211                                                                 while (fToken == TokenNameIdentifier) {
 212                                                                         ident = fScanner
 213                                                                                         .getCurrentIdentifierSource();
 214                                                                         // extends ident
 215                                                                         addIdentifierInformation('e', ident, buf);
 216                                                                         skipComments();
 217                                                                 if (fToken == TokenNameCOMMA) {
 218                                                                         skipComments();
 219                                                                         }
 220                                                                 }
 221                                                         }
 222                                                         if (fToken == TokenNameimplements) {
 223                                                                 skipComments();
 224                                                                 while (fToken == TokenNameIdentifier) {
 225                                                                         ident = fScanner
 226                                                                                         .getCurrentIdentifierSource();
 227                                                                         // implements ident
 228                                                                         addIdentifierInformation('e', ident, buf);
 229                                                                         skipComments();
 230                                                                         if (fToken == TokenNameCOMMA) {
 231                                                                                 skipComments();
 232 //                                                                              getNextToken();
 233                                                                         }
 234                                                                 }
 235                                                         }
 236                                                         // skip tokens for classname, extends and others
 237                                                         // until we have
 238                                                         // the opening '{'
 239                                                         while (fToken != TokenNameLBRACE
 240                                                                         && fToken != TokenNameEOF
 241                                                                         && fToken != TokenNameERROR) {
 242                                                                 getNextToken();
 243                                                         }
 244                                                         parseDeclarations(ident, buf, true);
 245                                                 }
 246                                         } else if (fToken == TokenNamevar || hasModifiers
 247                                                         || fToken == TokenNamestatic
 248                                                         || fToken == TokenNamefinal
 249                                                         || fToken == TokenNamepublic
 250                                                         || fToken == TokenNameprotected
 251                                                         || fToken == TokenNameprivate) {
 252                                                 while (fToken == TokenNamevar
 253                                                                 || fToken == TokenNamestatic
 254                                                                 || fToken == TokenNamefinal
 255                                                                 || fToken == TokenNamepublic
 256                                                                 || fToken == TokenNameprotected
 257                                                                 || fToken == TokenNameprivate) {
 258                                                         skipComments();
 259                                                 }
 260                                                 while (fToken == TokenNameVariable) {
 261                                                         ident = fScanner.getCurrentIdentifierSource();
 262                                                         classVariable = new char[ident.length - 1];
 263                                                         System.arraycopy(ident, 1, classVariable, 0,
 264                                                                         ident.length - 1);
 265                                                         addClassVariableInformation('v', classVariable,
 266                                                                         buf, phpdocOffset, phpdocLength);
 267                                                         skipComments();
 268                                                         if (fToken == TokenNameCOMMA) {
 269                                                                 skipComments();
 270                                                         }
 271                                                 }
 272                                         } else if (!hasModifiers && fToken == TokenNameIdentifier) {
 273                                                 ident = fScanner.getCurrentIdentifierSource();
 274                                                 getNextToken();
 275                                                 if (ident.length == 6 && ident[0] == 'd'
 276                                                                 && ident[1] == 'e' && ident[2] == 'f'
 277                                                                 && ident[3] == 'i' && ident[4] == 'n'
 278                                                                 && ident[5] == 'e') {
 279                                                         if (fToken == TokenNameLPAREN) {
 280                                                                 getNextToken();
 281                                                                 if (fToken == TokenNameStringDoubleQuote) {
 282                                                                         ident = fScanner
 283                                                                                         .getCurrentStringLiteralSource();
 284                                                                         addIdentifierInformation('d', ident, buf,
 285                                                                                         phpdocOffset, phpdocLength);
 286                                                                         getNextToken();
 287                                                                 } else if (fToken == TokenNameStringSingleQuote) {
 288                                                                         ident = fScanner
 289                                                                                         .getCurrentStringLiteralSource();
 290                                                                         addIdentifierInformation('d', ident, buf,
 291                                                                                         phpdocOffset, phpdocLength);
 292                                                                         getNextToken();
 293                                                                 }
 294                                                         }
 295                                                 }
 296                                         } else if (fToken == TokenNameglobal) {
 297                                                 // global variable
 298                                                 while (fToken != TokenNameEOF
 299                                                                 && fToken != TokenNameERROR
 300                                                                 && fToken != TokenNameSEMICOLON
 301                                                                 && fToken != TokenNameLBRACE
 302                                                                 && fToken != TokenNameRBRACE) {
 303                                                         getNextToken();
 304                                                         if (fToken == TokenNameVariable) {
 305                                                                 ident = fScanner.getCurrentIdentifierSource();
 306                                                                 addIdentifierInformation('g', ident, buf,
 307                                                                                 phpdocOffset, phpdocLength);
 308                                                         }
 309                                                 }
 310                                         } else if (fToken == TokenNameLBRACE) {
 311                                                 getNextToken();
 312                                                 counter++;
 313                                         } else if (fToken == TokenNameRBRACE) {
 314                                                 getNextToken();
 315                                                 --counter;
 316                                                 if (counter == 0 && goBack) {
 317                                                         return;
 318                                                 }
 319                                         } else {
 320                                                 getNextToken();
 321                                         }
 322                                 }
 323                         } catch (InvalidInputException e) {
 324                                 // ignore errors
 325                         } catch (SyntaxError e) {
 326                                 // TODO Auto-generated catch block
 327                                 e.printStackTrace();
 328                         }
 329
 330                 }
 331
 332                 synchronized public void parseIdentifiers(char[] charArray,
 333                                 StringBuffer buf) {
 334                         char[] ident;
 335                         String identifier;
 336                         boolean hasModifiers = false;
 337                         int phpdocOffset = -1;
 338                         int phpdocLength = -1;
 339                         fScanner.setSource(charArray);
 340                         fScanner.setPHPMode(false);
 341                         fToken = TokenNameEOF;
 342
 343                         try {
 344                                 getNextToken();
 345                                 while (fToken != TokenNameEOF) { // && fToken !=
 346                                         // TokenNameERROR) {
 347                                         phpdocOffset = -1;
 348                                         hasModifiers = false;
 349                                         switch (fToken) {
 350                                         case TokenNameCOMMENT_PHPDOC:
 351                                                 phpdocOffset = fScanner.getCurrentTokenStartPosition();
 352                                                 phpdocLength = fScanner.getCurrentTokenEndPosition()
 353                                                                 - fScanner.getCurrentTokenStartPosition() + 1;
 354                                                 getNextToken();
 355                                                 while (fToken == TokenNamestatic
 356                                                                 || fToken == TokenNamefinal
 357                                                                 || fToken == TokenNamepublic
 358                                                                 || fToken == TokenNameprotected
 359                                                                 || fToken == TokenNameprivate
 360                                                                 || fToken == TokenNameabstract) {
 361                                                         hasModifiers = true;
 362                                                         getNextToken();
 363                                                 }
 364                                                 if (fToken == TokenNameEOF || fToken == TokenNameERROR) {
 365                                                         break;
 366                                                 }
 367                                                 break;
 368
 369                                         case TokenNamefunction:
 370                                                 skipComments();
 371                                                 if (fToken == TokenNameAND) {
 372                                                         getNextToken();
 373                                                 }
 374                                                 if (fToken == TokenNameIdentifier) {
 375                                                         ident = fScanner.getCurrentIdentifierSource();
 376                                                         addIdentifierInformation('f', ident, buf,
 377                                                                         phpdocOffset, phpdocLength);
 378                                                         skipComments();
 379                                                         if (fToken == TokenNameLPAREN) {
 380                                                                 skipComments();
 381                                                                 do {
 382                                                                         if (fToken == TokenNameVariable) {
 383                                                                                 ident = fScanner.getCurrentIdentifierSource();
 384                                                                                 addIdentifierInformation('v', ident, buf,
 385                                                                                                 phpdocOffset, phpdocLength);
 386                                                                                 skipComments();
 387                                                                                 if (fToken == TokenNameCOMMA) {
 388                                                                                         skipComments();
 389                                                                                 }
 390                                                                         }
 391 /*                                                                      skipComments();
 392                                                                         if (fToken == TokenNameCOMMA) {
 393                                                                                 skipComments();
 394                                                                         }*/
 395                                                                 } while (fToken != TokenNameRPAREN );
 396                                                         }
 397                                                         parseDeclarations(null, buf, true);
 398                                                 }
 399                                                 break;
 400
 401                                         case TokenNameclass:
 402                                         case TokenNameinterface:
 403                                                 skipComments();
 404                                                 if (fToken == TokenNameIdentifier) {
 405                                                         ident = fScanner.getCurrentIdentifierSource();
 406                                                         addIdentifierInformation('c', ident, buf,
 407                                                                         phpdocOffset, phpdocLength);
 408                                                         skipComments();
 409                                                         if (fToken == TokenNameextends) {
 410                                                                 skipComments();
 411                                                                 while (fToken == TokenNameIdentifier) {
 412                                                                         ident = fScanner
 413                                                                                         .getCurrentIdentifierSource();
 414                                                                         // extends ident
 415                                                                         addIdentifierInformation('e', ident, buf);
 416                                                                         skipComments();
 417                                                                         if (fToken == TokenNameCOMMA) {
 418                                                                                 skipComments();
 419                                                                         }
 420                                                                 }
 421                                                         }
 422                                                         if (fToken == TokenNameimplements) {
 423                                                                 skipComments();
 424                                                                 while (fToken == TokenNameIdentifier) {
 425                                                                         ident = fScanner
 426                                                                                         .getCurrentIdentifierSource();
 427                                                                         // implements ident
 428                                                                         addIdentifierInformation('e', ident, buf);
 429                                                                         skipComments();
 430                                                                         if (fToken == TokenNameCOMMA) {
 431                                                                                 skipComments();
 432                                                                         }
 433                                                                 }
 434                                                         }
 435                                                         // skip fTokens for classname, extends and others
 436                                                         // until we have
 437                                                         // the opening '{'
 438                                                         while (fToken != TokenNameLBRACE
 439                                                                         && fToken != TokenNameEOF
 440                                                                         && fToken != TokenNameERROR) {
 441                                                                 getNextToken();
 442                                                         }
 443                                                         parseDeclarations(ident, buf, true);
 444                                                 }
 445                                                 break;
 446
 447                                         case TokenNameVariable:
 448                                                 // global variable
 449                                                 ident = fScanner.getCurrentIdentifierSource();
 450                                                 addIdentifierInformation('g', ident, buf, phpdocOffset,
 451                                                                 phpdocLength);
 452                                                 getNextToken();
 453                                                 break;
 454
 455                                         default:
 456                                                 getNextToken();
 457                                         }
 458
 459                                 }
 460                         } catch (InvalidInputException e) {
 461                                 // ignore errors
 462                         } catch (SyntaxError e) {
 463                                 // TODO Auto-generated catch block
 464                                 e.printStackTrace();
 465                         }
 466                 }
 467         }
 468
 469         class StringComparator implements Comparator {
 470                 public int compare(Object o1, Object o2) {
 471                         String s1 = (String) o1;
 472                         String s2 = (String) o2;
 473                         return s1.compareTo(s2);
 474                         // return s1.toUpperCase().compareTo(s2.toUpperCase());
 475                 }
 476
 477                 public boolean equals(Object o) {
 478                         String s = (String) o;
 479                         return compare(this, o) == 0;
 480                 }
 481         }
 482
 483         private HashMap fFileMap;
 484
 485         private String fFilename;
 486
 487         private TreeMap fIndentifierMap;
 488
 489         public IdentifierIndexManager(String filename) {
 490                 fFilename = filename;
 491                 initialize();
 492                 readFile();
 493         }
 494
 495         /**
 496          * Check if 2 char arrays are equal
 497          *
 498          * @param a
 499          * @param b
 500          * @return
 501          */
 502         private static boolean equalCharArrays(char[] a, char[] b) {
 503                 if (a.length != b.length) {
 504                         return false;
 505                 }
 506                 for (int i = 0; i < b.length; i++) {
 507                         if (a[i] != b[i]) {
 508                                 return false;
 509                         }
 510                 }
 511                 return true;
 512         }
 513
 514         public LineCreator createLineCreator() {
 515                 return new LineCreator();
 516         }
 517
 518         /**
 519          * Add the information for a given IFile resource
 520          *
 521          */
 522         public void addFile(IFile fileToParse) {
 523                 LineCreator lineCreator = createLineCreator();
 524                 try {
 525                         addInputStream(new BufferedInputStream(fileToParse.getContents()),
 526                                         fileToParse.getProjectRelativePath().toString(),
 527                                         lineCreator, fileToParse.getCharset());
 528                 } catch (CoreException e1) {
 529                         // TODO Auto-generated catch block
 530                         e1.printStackTrace();
 531                 }
 532         }
 533
 534         /**
 535          * @param fileToParse
 536          * @param lineCreator
 537          * @throws CoreException
 538          */
 539         public void addInputStream(InputStream stream, String filePath,
 540                         LineCreator lineCreator, String charset) throws CoreException {
 541                 try {
 542                         StringBuffer lineBuffer = new StringBuffer();
 543                         lineBuffer.append(filePath);
 544                         lineCreator.parseIdentifiers(Util.getInputStreamAsCharArray(stream,
 545                                         -1, charset), lineBuffer);
 546                         addLine(lineBuffer.toString());
 547                 } catch (IOException e) {
 548                         e.printStackTrace();
 549                 } finally {
 550                         try {
 551                                 if (stream != null) {
 552                                         stream.close();
 553                                 }
 554                         } catch (IOException e) {
 555                                 // do nothing
 556                         }
 557                 }
 558         }
 559
 560         /**
 561          * Adds a line of the index file for function, class, class-method and
 562          * class-variable names
 563          *
 564          * @param line
 565          */
 566         private void addLine(String line) {
 567                 addLine(fIndentifierMap, fFileMap, line, null);
 568         }
 569
 570         public TreeMap getIdentifiers(IFile file) {
 571                 TreeMap treeMap = new TreeMap(new StringComparator());
 572                 addIdentifiers(treeMap, file);
 573                 return treeMap;
 574         }
 575
 576         public TreeMap getIdentifiers(String startClazz) {
 577                 TreeMap treeMap = new TreeMap(new StringComparator());
 578                 addIdentifiers(treeMap, startClazz);
 579                 return treeMap;
 580         }
 581
 582         public void addIdentifiers(TreeMap treeMap, IFile file) {
 583                 String line = (String) fFileMap.get(file.getProjectRelativePath()
 584                                 .toString());
 585                 if (line != null) {
 586                         PHPIdentifierLocation ident;
 587                         ArrayList allClassNames = new ArrayList();
 588                         addLine(treeMap, null, line, allClassNames);
 589                         int i = 0;
 590                         while (i < allClassNames.size()) {
 591                                 String clazz = (String) allClassNames.get(i++);
 592                                 addClassName(treeMap, clazz, allClassNames);
 593                         }
 594                 }
 595         }
 596
 597         public void addIdentifiers(TreeMap treeMap, String startClazz) {
 598                 PHPIdentifierLocation ident;
 599                 ArrayList allClassNames = new ArrayList();
 600                 addClassName(treeMap, startClazz, allClassNames);
 601                 int i = 0;
 602                 while (i < allClassNames.size()) {
 603                         String clazz = (String) allClassNames.get(i++);
 604                         addClassName(treeMap, clazz, allClassNames);
 605                 }
 606         }
 607
 608         /**
 609          * @param treeMap
 610          * @param clazz
 611          * @param allClassNames
 612          */
 613         private boolean addClassName(TreeMap treeMap, String clazz,
 614                         List allClassNames) {
 615                 String line;
 616                 PHPIdentifierLocation ident;
 617                 List list = getLocations(clazz);
 618                 if (list == null) {
 619                         return false;
 620                 }
 621                 boolean result = false;
 622                 for (int i = 0; i < list.size(); i++) {
 623                         ident = (PHPIdentifierLocation) list.get(i);
 624                         if (ident.isClass()) {
 625                                 line = (String) fFileMap.get(ident.getFilename());
 626                                 addLine(treeMap, null, line, allClassNames);
 627                                 result = true;
 628                         }
 629                 }
 630                 return result;
 631         }
 632
 633         /**
 634          * Adds a line of the index file for function, class, class-method and
 635          * class-variable names
 636          *
 637          * @param line
 638          */
 639         public void addLine(TreeMap treeMap, HashMap fileMap, String line,
 640                         List allClassNames) {
 641                 StringTokenizer tokenizer;
 642                 String phpFileName = null;
 643                 String token;
 644                 String identifier = null;
 645                 String classname = null;
 646                 String offset = null;
 647                 PHPIdentifierLocation phpIdentifier = null;
 648                 boolean tokenExists = false;
 649                 tokenizer = new StringTokenizer(line, "\t");
 650                 // first token contains the filename:
 651                 try {
 652                         if (tokenizer.hasMoreTokens()) {
 653                                 phpFileName = tokenizer.nextToken();
 654                                 // System.out.println(token);
 655                         } else {
 656                                 return;
 657                         }
 658                         // all the other tokens are identifiers:
 659                         while (tokenizer.hasMoreTokens()) {
 660                                 token = tokenizer.nextToken();
 661                                 // System.out.println(token);
 662                                 switch (token.charAt(0)) {
 663                                 case 'c':
 664                                         // class name
 665                                         identifier = token.substring(1);
 666                                         classname = identifier;
 667                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 668                                                         PHPIdentifier.CLASS, phpFileName);
 669                                         break;
 670                                 case 'd':
 671                                         // define
 672                                         identifier = token.substring(1);
 673                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 674                                                         PHPIdentifier.DEFINE, phpFileName);
 675                                         break;
 676                                 case 'e':
 677                                         // extends <class name>
 678                                         // not in map
 679                                         identifier = null;
 680                                         phpIdentifier = null;
 681                                         if (allClassNames != null) {
 682                                                 String extName = token.substring(1);
 683                                                 if (!allClassNames.contains(extName)) {
 684                                                         allClassNames.add(extName);
 685                                                 }
 686                                         }
 687                                         break;
 688                                 case 'f':
 689                                         // function name
 690                                         identifier = token.substring(1);
 691                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 692                                                         PHPIdentifier.FUNCTION, phpFileName);
 693                                         break;
 694                                 case 'g':
 695                                         // global variable
 696                                         identifier = token.substring(1);
 697                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 698                                                         PHPIdentifier.GLOBAL_VARIABLE, phpFileName);
 699                                         break;
 700                                 case 'i':
 701                                         // implements <class name>
 702                                         // not in map
 703                                         identifier = null;
 704                                         phpIdentifier = null;
 705                                         if (allClassNames != null) {
 706                                                 String implName = token.substring(1);
 707                                                 if (!allClassNames.contains(implName)) {
 708                                                         allClassNames.add(implName);
 709                                                 }
 710                                         }
 711                                         break;
 712                                 case 'k':
 713                                         // constructor function name
 714                                         identifier = token.substring(1);
 715                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 716                                                         PHPIdentifier.CONSTRUCTOR, phpFileName);
 717                                         break;
 718                                 case 'm':
 719                                         // method inside a class
 720                                         identifier = token.substring(1);
 721                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 722                                                         PHPIdentifier.METHOD, phpFileName, classname);
 723                                         break;
 724                                 case 'v':
 725                                         // variable inside a class
 726                                         identifier = token.substring(1);
 727                                         phpIdentifier = new PHPIdentifierLocation(identifier,
 728                                                         PHPIdentifier.VARIABLE, phpFileName, classname);
 729                                         break;
 730                                 case 'o':
 731                                         // offset information
 732                                         identifier = null;
 733                                         if (phpIdentifier != null) {
 734                                                 offset = token.substring(1);
 735                                                 phpIdentifier.setOffset(Integer.parseInt(offset));
 736                                         }
 737                                         break;
 738                                 case 'p':
 739                                         // PHPdoc offset information
 740                                         identifier = null;
 741                                         if (phpIdentifier != null) {
 742                                                 offset = token.substring(1);
 743                                                 phpIdentifier.setPHPDocOffset(Integer.parseInt(offset));
 744                                         }
 745                                         break;
 746                                 case 'l':
 747                                         // PHPdoc length information
 748                                         identifier = null;
 749                                         if (phpIdentifier != null) {
 750                                                 offset = token.substring(1);
 751                                                 phpIdentifier.setPHPDocLength(Integer.parseInt(offset));
 752                                         }
 753                                         break;
 754                                 default:
 755                                         PHPeclipsePlugin.log(IStatus.ERROR,
 756                                                         "Unknown token character in IdentifierIndexManager: "
 757                                                                         + token.charAt(0));
 758                                         identifier = null;
 759                                         phpIdentifier = null;
 760                                         classname = null;
 761                                 }
 762                                 if (identifier != null && phpIdentifier != null) {
 763                                         tokenExists = true;
 764                                         ArrayList list = (ArrayList) treeMap.get(identifier);
 765                                         if (list == null) {
 766                                                 list = new ArrayList();
 767                                                 list.add(phpIdentifier);
 768                                                 treeMap.put(identifier, list);
 769                                         } else {
 770                                                 boolean flag = false;
 771                                                 for (int i = 0; i < list.size(); i++) {
 772                                                         if (list.get(i).equals(phpIdentifier)) {
 773                                                                 flag = true;
 774                                                                 break;
 775                                                         }
 776                                                 }
 777                                                 if (flag == false) {
 778                                                         list.add(phpIdentifier);
 779                                                 }
 780                                         }
 781                                 }
 782                         }
 783                         if (fileMap != null) {
 784                                 fileMap.put(phpFileName, line);
 785                         }
 786                 } catch (Throwable e) {
 787                         // write to workspace/.metadata/.log file
 788                         PHPeclipsePlugin.log(e);
 789                 }
 790                 // if (tokenExists) {
 791
 792                 // }
 793         }
 794
 795         /**
 796          * Change the information for a given IFile resource
 797          *
 798          */
 799         public void changeFile(IFile fileToParse) {
 800                 removeFile(fileToParse);
 801                 addFile(fileToParse);
 802         }
 803
 804         /**
 805          * Get a list of all PHPIdentifierLocation object's associated with an
 806          * identifier
 807          *
 808          * @param identifier
 809          * @return
 810          */
 811         public List getLocations(String identifier) {
 812                 List list = (List) fIndentifierMap.get(identifier);
 813                 if (list != null) {
 814                         return list;
 815                 }
 816                 return new ArrayList();
 817         }
 818
 819         /**
 820          * Initialize (i.e. clear) the current index information
 821          *
 822          */
 823         public void initialize() {
 824                 fIndentifierMap = new TreeMap(new StringComparator());
 825                 fFileMap = new HashMap();
 826         }
 827
 828         private void readFile() {
 829                 FileReader fileReader;
 830                 try {
 831                         fileReader = new FileReader(fFilename);
 832                         BufferedReader bufferedReader = new BufferedReader(fileReader);
 833                         String line;
 834                         while (bufferedReader.ready()) {
 835                                 // all entries for one file are in a line
 836                                 // separated by tabs !
 837                                 line = bufferedReader.readLine();
 838                                 addLine(line);
 839                         }
 840                         fileReader.close();
 841                 } catch (FileNotFoundException e) {
 842                         // ignore this
 843                         // TODO DialogBox which asks the user if she/he likes to build new
 844                         // index?
 845                 } catch (IOException e) {
 846                         // TODO Auto-generated catch block
 847                         e.printStackTrace();
 848                 }
 849         }
 850
 851         /**
 852          * Remove the information for a given IFile resource
 853          *
 854          */
 855         public void removeFile(IFile fileToParse) {
 856                 // String line = (String)
 857                 // fFileMap.get(fileToParse.getLocation().toString());
 858                 String line = (String) fFileMap.get(fileToParse
 859                                 .getProjectRelativePath().toString());
 860                 if (line != null) {
 861                         removeLine(line);
 862                 }
 863         }
 864
 865         /**
 866          * Removes a line of the index file for function, class, class-method and
 867          * class-variable names
 868          *
 869          * @param line
 870          */
 871         private void removeLine(String line) {
 872                 StringTokenizer tokenizer;
 873                 String phpFileName = null;
 874                 String token;
 875                 String identifier = null;
 876                 String classname = null;
 877                 PHPIdentifier phpIdentifier = null;
 878                 boolean tokenExists = false;
 879                 tokenizer = new StringTokenizer(line, "\t");
 880                 // first token contains the filename:
 881                 if (tokenizer.hasMoreTokens()) {
 882                         phpFileName = tokenizer.nextToken();
 883                         // System.out.println(token);
 884                 } else {
 885                         return;
 886                 }
 887                 int offset = -1;
 888                 // all the other tokens are identifiers:
 889                 while (tokenizer.hasMoreTokens()) {
 890                         token = tokenizer.nextToken();
 891                         // System.out.println(token);
 892                         switch (token.charAt(0)) {
 893                         case 'c':
 894                                 // class name
 895                                 identifier = token.substring(1);
 896                                 classname = identifier;
 897                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 898                                                 PHPIdentifier.CLASS, phpFileName);
 899                                 break;
 900                         case 'd':
 901                                 // define
 902                                 identifier = token.substring(1);
 903                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 904                                                 PHPIdentifier.DEFINE, phpFileName);
 905                                 break;
 906                         case 'e':
 907                                 // extends <class name>
 908                                 identifier = null;
 909                                 phpIdentifier = null;
 910                                 break;
 911                         case 'f':
 912                                 // function name
 913                                 identifier = token.substring(1);
 914                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 915                                                 PHPIdentifier.FUNCTION, phpFileName);
 916                                 break;
 917                         case 'g':
 918                                 // global variable
 919                                 identifier = token.substring(1);
 920                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 921                                                 PHPIdentifier.GLOBAL_VARIABLE, phpFileName);
 922                                 break;
 923                         case 'i':
 924                                 // implements <class name>
 925                                 identifier = null;
 926                                 phpIdentifier = null;
 927                                 break;
 928                         case 'k':
 929                                 // constructor function name
 930                                 identifier = token.substring(1);
 931                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 932                                                 PHPIdentifier.CONSTRUCTOR, phpFileName);
 933                                 break;
 934                         case 'm':
 935                                 // method inside a class
 936                                 identifier = token.substring(1);
 937                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 938                                                 PHPIdentifier.METHOD, phpFileName, classname);
 939                                 break;
 940                         case 'o':
 941                                 // offset information
 942                                 identifier = null;
 943                                 break;
 944                         case 'p':
 945                                 // PHPdoc offset information
 946                                 identifier = null;
 947                                 break;
 948                         case 'l':
 949                                 // PHPdoc length information
 950                                 identifier = null;
 951                                 break;
 952                         case 'v':
 953                                 // variable inside a class
 954                                 identifier = token.substring(1);
 955                                 phpIdentifier = new PHPIdentifierLocation(identifier,
 956                                                 PHPIdentifier.VARIABLE, phpFileName, classname);
 957                                 break;
 958                         default:
 959                                 PHPeclipsePlugin.log(IStatus.ERROR,
 960                                                 "Unknown token character in IdentifierIndexManager: "
 961                                                                 + token.charAt(0));
 962                                 identifier = null;
 963                                 phpIdentifier = null;
 964                                 classname = null;
 965                         }
 966                         if (identifier != null && phpIdentifier != null) {
 967                                 ArrayList list = (ArrayList) fIndentifierMap.get(identifier);
 968                                 if (list == null) {
 969                                 } else {
 970                                         for (int i = 0; i < list.size(); i++) {
 971                                                 if (list.get(i).equals(phpIdentifier)) {
 972                                                         list.remove(i);
 973                                                         break;
 974                                                 }
 975                                         }
 976                                         if (list.size() == 0) {
 977                                                 fIndentifierMap.remove(identifier);
 978                                         }
 979                                 }
 980                         }
 981                 }
 982                 fFileMap.remove(phpFileName);
 983         }
 984
 985         /**
 986          * Save the current index information in the projects index file
 987          *
 988          */
 989         public void writeFile() {
 990                 FileWriter fileWriter;
 991                 try {
 992                         fileWriter = new FileWriter(fFilename);
 993                         String line;
 994                         Collection collection = fFileMap.values();
 995                         Iterator iterator = collection.iterator();
 996                         while (iterator.hasNext()) {
 997                                 line = (String) iterator.next();
 998                                 fileWriter.write(line + '\n');
 999                         }
1000                         fileWriter.close();
1001                 } catch (FileNotFoundException e) {
1002                         // ignore exception; project is deleted by user
1003                 } catch (IOException e) {
1004                         // TODO Auto-generated catch block
1005                         e.printStackTrace();
1006                 }
1007         }
1008
1009         /**
1010          * @param fromKey
1011          * @param toKey
1012          * @return
1013          */
1014         public SortedMap getIdentifierMap() {
1015                 return fIndentifierMap;
1016         }
1017
1018         synchronized public List getFileList(String filePattern) {
1019                 Set set = fFileMap.keySet();
1020                 if (set.isEmpty()) {
1021                         return null;
1022                 }
1023                 Iterator iter = set.iterator();
1024                 ArrayList list = new ArrayList();
1025                 String fileName;
1026                 int index;
1027                 while (iter.hasNext()) {
1028                         fileName = (String) iter.next();
1029                         if ((index = fileName.indexOf(filePattern)) != -1
1030                                         && fileName.length() == (index + filePattern.length())) {
1031                                 list.add(fileName);
1032                         }
1033                 }
1034                 return list;
1035         }
1036 }