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

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