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