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