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

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