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           List list=(List) fIndentifierMap.get(identifier);
 720           if (list!=null) {
 721                   return list;
 722           }
 723           return new ArrayList();
 724   }
 725
 726   /**
 727    * Initialize (i.e. clear) the current index information
 728    *
 729    */
 730   public void initialize() {
 731     fIndentifierMap = new TreeMap(new StringComparator());
 732     fFileMap = new HashMap();
 733   }
 734
 735   private void readFile() {
 736     FileReader fileReader;
 737     try {
 738       fileReader = new FileReader(fFilename);
 739       BufferedReader bufferedReader = new BufferedReader(fileReader);
 740       String line;
 741       while (bufferedReader.ready()) {
 742         // all entries for one file are in a line
 743         // separated by tabs !
 744         line = bufferedReader.readLine();
 745         addLine(line);
 746       }
 747       fileReader.close();
 748     } catch (FileNotFoundException e) {
 749       // ignore this
 750       // TODO DialogBox which asks the user if she/he likes to build new index?
 751     } catch (IOException e) {
 752       // TODO Auto-generated catch block
 753       e.printStackTrace();
 754     }
 755   }
 756
 757   /**
 758    * Remove the information for a given IFile resource
 759    *
 760    */
 761   public void removeFile(IFile fileToParse) {
 762     //    String line = (String)
 763     // fFileMap.get(fileToParse.getLocation().toString());
 764     String line = (String) fFileMap.get(fileToParse.getProjectRelativePath().toString());
 765     if (line != null) {
 766       removeLine(line);
 767     }
 768   }
 769
 770   /**
 771    * Removes a line of the index file for function, class, class-method and class-variable names
 772    *
 773    * @param line
 774    */
 775   private void removeLine(String line) {
 776     StringTokenizer tokenizer;
 777     String phpFileName = null;
 778     String token;
 779     String identifier = null;
 780     String classname = null;
 781     PHPIdentifier phpIdentifier = null;
 782     boolean tokenExists = false;
 783     tokenizer = new StringTokenizer(line, "\t");
 784     // first token contains the filename:
 785     if (tokenizer.hasMoreTokens()) {
 786       phpFileName = tokenizer.nextToken();
 787       //System.out.println(token);
 788     } else {
 789       return;
 790     }
 791     int offset = -1;
 792     // all the other tokens are identifiers:
 793     while (tokenizer.hasMoreTokens()) {
 794       token = tokenizer.nextToken();
 795       //System.out.println(token);
 796       switch (token.charAt(0)) {
 797       case 'c':
 798         // class name
 799         identifier = token.substring(1);
 800         classname = identifier;
 801         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.CLASS, phpFileName);
 802         break;
 803       case 'd':
 804         // define
 805         identifier = token.substring(1);
 806         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.DEFINE, phpFileName);
 807         break;
 808       case 'e':
 809         // extends <class name>
 810         identifier = null;
 811         phpIdentifier = null;
 812         break;
 813       case 'f':
 814         // function name
 815         identifier = token.substring(1);
 816         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.FUNCTION, phpFileName);
 817         break;
 818       case 'g':
 819         // global variable
 820         identifier = token.substring(1);
 821         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.GLOBAL_VARIABLE, phpFileName);
 822         break;
 823       case 'i':
 824         // implements <class name>
 825         identifier = null;
 826         phpIdentifier = null;
 827         break;
 828       case 'k':
 829         // constructor function name
 830         identifier = token.substring(1);
 831         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.CONSTRUCTOR, phpFileName);
 832         break;
 833       case 'm':
 834         //method inside a class
 835         identifier = token.substring(1);
 836         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.METHOD, phpFileName, classname);
 837         break;
 838       case 'o':
 839         // offset information
 840         identifier = null;
 841         break;
 842       case 'p':
 843         // PHPdoc offset information
 844         identifier = null;
 845         break;
 846       case 'l':
 847         // PHPdoc length information
 848         identifier = null;
 849         break;
 850       case 'v':
 851         // variable inside a class
 852         identifier = token.substring(1);
 853         phpIdentifier = new PHPIdentifierLocation(identifier, PHPIdentifier.VARIABLE, phpFileName, classname);
 854         break;
 855       default:
 856         PHPeclipsePlugin.log(IStatus.ERROR, "Unknown token character in IdentifierIndexManager: " + token.charAt(0));
 857         identifier = null;
 858         phpIdentifier = null;
 859         classname = null;
 860       }
 861       if (identifier != null && phpIdentifier != null) {
 862         ArrayList list = (ArrayList) fIndentifierMap.get(identifier);
 863         if (list == null) {
 864         } else {
 865           for (int i = 0; i < list.size(); i++) {
 866             if (list.get(i).equals(phpIdentifier)) {
 867               list.remove(i);
 868               break;
 869             }
 870           }
 871           if (list.size() == 0) {
 872             fIndentifierMap.remove(identifier);
 873           }
 874         }
 875       }
 876     }
 877     fFileMap.remove(phpFileName);
 878   }
 879
 880   /**
 881    * Save the current index information in the projects index file
 882    *
 883    */
 884   public void writeFile() {
 885     FileWriter fileWriter;
 886     try {
 887       fileWriter = new FileWriter(fFilename);
 888       String line;
 889       Collection collection = fFileMap.values();
 890       Iterator iterator = collection.iterator();
 891       while (iterator.hasNext()) {
 892         line = (String) iterator.next();
 893         fileWriter.write(line + '\n');
 894       }
 895       fileWriter.close();
 896     } catch (FileNotFoundException e) {
 897       // ignore exception; project is deleted by user
 898     } catch (IOException e) {
 899       // TODO Auto-generated catch block
 900       e.printStackTrace();
 901     }
 902   }
 903
 904   /**
 905    * @param fromKey
 906    * @param toKey
 907    * @return
 908    */
 909   public SortedMap getIdentifierMap() {
 910     return fIndentifierMap;
 911   }
 912
 913   synchronized public List getFileList(String filePattern) {
 914     Set set = fFileMap.keySet();
 915     if (set.isEmpty()) {
 916       return null;
 917     }
 918     Iterator iter = set.iterator();
 919     ArrayList list = new ArrayList();
 920     String fileName;
 921     int index;
 922     while (iter.hasNext()) {
 923       fileName = (String) iter.next();
 924       if ((index = fileName.indexOf(filePattern)) != -1 && fileName.length() == (index + filePattern.length())) {
 925         list.add(fileName);
 926       }
 927     }
 928     return list;
 929   }
 930 }