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