Added SQL proposals
[phpeclipse.git] / 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             getNextToken();
177             counter++;
178           } else if (fToken == TokenNameRBRACE) {
179             getNextToken();
180             --counter;
181             if (counter == 0 && goBack) {
182               return;
183             }
184           } else {
185             getNextToken();
186           }
187         }
188       } catch (SyntaxError e) {
189         // TODO Auto-generated catch block
190         e.printStackTrace();
191       }
192     }
193     public void parseIdentifiers(char[] charArray, StringBuffer buf) {
194       char[] ident;
195       String identifier;
196       int counter = 0;
197       int phpdocOffset = -1;
198       int phpdocLength = -1;
199       fScanner.setSource(charArray);
200       fScanner.setPHPMode(false);
201       fToken = TokenNameEOF;
202       getNextToken();
203       try {
204         while (fToken != TokenNameEOF && fToken != TokenNameERROR) {
205           phpdocOffset = -1;
206           if (fToken == TokenNameCOMMENT_PHPDOC) {
207             phpdocOffset = fScanner.getCurrentTokenStartPosition();
208             phpdocLength = fScanner.getCurrentTokenEndPosition()
209                 - fScanner.getCurrentTokenStartPosition() + 1;
210             getNextToken();
211             if (fToken == TokenNameEOF || fToken == TokenNameERROR) {
212               break;
213             }
214           }
215           if (fToken == TokenNamefunction) {
216             getNextToken();
217             if (fToken == TokenNameAND) {
218               getNextToken();
219             }
220             if (fToken == TokenNameIdentifier) {
221               ident = fScanner.getCurrentIdentifierSource();
222               addIdentifierInformation('f', ident, buf, phpdocOffset,
223                   phpdocLength);
224               getNextToken();
225               parseDeclarations(null, buf, true);
226             }
227           } else if (fToken == TokenNameclass) {
228             getNextToken();
229             if (fToken == TokenNameIdentifier) {
230               ident = fScanner.getCurrentIdentifierSource();
231               addIdentifierInformation('c', ident, buf, phpdocOffset,
232                   phpdocLength);
233               getNextToken();
234               //skip fTokens for classname, extends and others until we have
235               // the opening '{'
236               while (fToken != TokenNameLBRACE && fToken != TokenNameEOF
237                   && fToken != TokenNameERROR) {
238                 getNextToken();
239               }
240               parseDeclarations(ident, buf, true);
241             }
242           } else if (fToken == TokenNameIdentifier) {
243             ident = fScanner.getCurrentIdentifierSource();
244             getNextToken();
245             if (ident.length==6 && 
246                 ident[0]=='d' && 
247                 ident[1]=='e' && 
248                 ident[2]=='f' && 
249                 ident[3]=='i' && 
250                 ident[4]=='n' && 
251                 ident[5]=='e') {
252               if (fToken == TokenNameLPAREN) {
253                 getNextToken();
254                 if (fToken == TokenNameStringLiteral) {
255                   ident = fScanner.getCurrentStringLiteralSource();
256                   addIdentifierInformation('d', ident, buf, phpdocOffset,
257                       phpdocLength);
258                   getNextToken();
259                 }
260               }
261             }
262           } else {
263             getNextToken();
264           }
265         }
266       } catch (SyntaxError e) {
267         // TODO Auto-generated catch block
268         e.printStackTrace();
269       }
270     }
271   }
272   class StringComparator implements Comparator {
273     public int compare(Object o1, Object o2) {
274       String s1 = (String) o1;
275       String s2 = (String) o2;
276       return s1.compareTo(s2);
277       //        return s1.toUpperCase().compareTo(s2.toUpperCase());
278     }
279     public boolean equals(Object o) {
280       String s = (String) o;
281       return compare(this, o) == 0;
282     }
283   }
284   private HashMap fFileMap;
285   private String fFilename;
286   private TreeMap fIndentifierMap;
287   public IdentifierIndexManager(String filename) {
288     fFilename = filename;
289     initialize();
290     readFile();
291   }
292   /**
293    * Check if 2 char arrays are equal
294    * 
295    * @param a
296    * @param b
297    * @return
298    */
299   private static boolean equalCharArrays(char[] a, char[] b) {
300     if (a.length != b.length) {
301       return false;
302     }
303     for (int i = 0; i < b.length; i++) {
304       if (a[i] != b[i]) {
305         return false;
306       }
307     }
308     return true;
309   }
310   /**
311    * Add the information for a given IFile resource
312    *  
313    */
314   public void addFile(IFile fileToParse) {
315     //    InputStream iStream;
316     LineCreator lineCreator = new LineCreator();
317     try {
318       //      iStream = fileToParse.getContents();
319       //
320       //      StringBuffer buf = new StringBuffer();
321       //      int c0;
322       //      try {
323       //        while ((c0 = iStream.read()) != (-1)) {
324       //          buf.append((char) c0);
325       //        }
326       //      } catch (IOException e) {
327       //        return;
328       //      }
329       InputStream stream = null;
330       try {
331         stream = new BufferedInputStream(fileToParse.getContents());
332         StringBuffer lineBuffer = new StringBuffer();
333         lineBuffer.append(fileToParse.getFullPath().toString());
334         int lineLength = lineBuffer.length();
335         // lineCreator.parseIdentifiers(buf.toString().toCharArray(),
336         // lineBuffer);
337         lineCreator.parseIdentifiers(Util.getInputStreamAsCharArray(stream, -1,
338             null), lineBuffer);
339         if (lineLength != lineBuffer.length()) {
340           addLine(lineBuffer.toString());
341         }
342       } catch (IOException e) {
343         return;
344       } finally {
345         try {
346           if (stream != null) {
347             stream.close();
348           }
349         } catch (IOException e) {
350         }
351       }
352     } catch (CoreException e1) {
353       // TODO Auto-generated catch block
354       e1.printStackTrace();
355     }
356   }
357   /**
358    * Adds a line of the index file for function, class, class-method and
359    * class-variable names
360    * 
361    * @param line
362    */
363   private void addLine(String line) {
364     StringTokenizer tokenizer;
365     String phpFileName = null;
366     String token;
367     String identifier = null;
368     String classname = null;
369     String offset = null;
370     PHPIdentifierLocation phpIdentifier = null;
371     boolean tokenExists = false;
372     tokenizer = new StringTokenizer(line, "\t");
373     // first token contains the filename:
374     if (tokenizer.hasMoreTokens()) {
375       phpFileName = tokenizer.nextToken();
376       //System.out.println(token);
377     } else {
378       return;
379     }
380     // all the other tokens are identifiers:
381     while (tokenizer.hasMoreTokens()) {
382       token = tokenizer.nextToken();
383       //System.out.println(token);
384       switch (token.charAt(0)) {
385         case 'c' :
386           // class name
387           identifier = token.substring(1);
388           classname = identifier;
389           phpIdentifier = new PHPIdentifierLocation(identifier,
390               PHPIdentifier.CLASS, phpFileName);
391           break;
392         case 'd' :
393           // define
394           identifier = token.substring(1);
395           phpIdentifier = new PHPIdentifierLocation(identifier,
396               PHPIdentifier.DEFINE, phpFileName);
397           break;
398         case 'f' :
399           // function name
400           identifier = token.substring(1);
401           phpIdentifier = new PHPIdentifierLocation(identifier,
402               PHPIdentifier.FUNCTION, phpFileName);
403           break;
404         case 'k' :
405           // constructor function name
406           identifier = token.substring(1);
407           phpIdentifier = new PHPIdentifierLocation(identifier,
408               PHPIdentifier.CONSTRUCTOR, phpFileName);
409           break;
410         case 'm' :
411           //method inside a class
412           identifier = token.substring(1);
413           phpIdentifier = new PHPIdentifierLocation(identifier,
414               PHPIdentifier.METHOD, phpFileName, classname);
415           break;
416         case 'v' :
417           // variable inside a class
418           identifier = token.substring(1);
419           phpIdentifier = new PHPIdentifierLocation(identifier,
420               PHPIdentifier.VARIABLE, phpFileName, classname);
421           break;
422         case 'o' :
423           // offset information
424           identifier = null;
425           if (phpIdentifier != null) {
426             offset = token.substring(1);
427             phpIdentifier.setOffset(Integer.parseInt(offset));
428           }
429           break;
430         case 'p' :
431           // PHPdoc offset information
432           identifier = null;
433           if (phpIdentifier != null) {
434             offset = token.substring(1);
435             phpIdentifier.setPHPDocOffset(Integer.parseInt(offset));
436           }
437           break;
438         case 'l' :
439           // PHPdoc length information
440           identifier = null;
441           if (phpIdentifier != null) {
442             offset = token.substring(1);
443             phpIdentifier.setPHPDocLength(Integer.parseInt(offset));
444           }
445           break;
446         default :
447           identifier = null;
448           phpIdentifier = null;
449           classname = null;
450       }
451       if (identifier != null && phpIdentifier != null) {
452         tokenExists = true;
453         ArrayList list = (ArrayList) fIndentifierMap.get(identifier);
454         if (list == null) {
455           list = new ArrayList();
456           list.add(phpIdentifier);
457           fIndentifierMap.put(identifier, list);
458         } else {
459           boolean flag = false;
460           for (int i = 0; i < list.size(); i++) {
461             if (list.get(i).equals(phpIdentifier)) {
462               flag = true;
463               break;
464             }
465           }
466           if (flag == false) {
467             list.add(phpIdentifier);
468           }
469         }
470       }
471     }
472     if (tokenExists) {
473       fFileMap.put(phpFileName, line);
474     }
475   }
476   /**
477    * Change the information for a given IFile resource
478    *  
479    */
480   public void changeFile(IFile fileToParse) {
481     removeFile(fileToParse);
482     addFile(fileToParse);
483   }
484   /**
485    * Get a list of all PHPIdentifierLocation object's associated with an
486    * identifier
487    * 
488    * @param identifier
489    * @return
490    */
491   public List getLocations(String identifier) {
492     return (List) fIndentifierMap.get(identifier);
493   }
494   /**
495    * Initialize (i.e. clear) the current index information
496    *  
497    */
498   public void initialize() {
499     fIndentifierMap = new TreeMap(new StringComparator());
500     fFileMap = new HashMap();
501   }
502   private void readFile() {
503     FileReader fileReader;
504     try {
505       fileReader = new FileReader(fFilename);
506       BufferedReader bufferedReader = new BufferedReader(fileReader);
507       String line;
508       while (bufferedReader.ready()) {
509         // all entries for one file are in a line
510         // separated by tabs !
511         line = bufferedReader.readLine();
512         addLine(line);
513       }
514       fileReader.close();
515     } catch (FileNotFoundException e) {
516       // ignore this
517       // TODO DialogBox which asks the user if she/he likes to build new index?
518     } catch (IOException e) {
519       // TODO Auto-generated catch block
520       e.printStackTrace();
521     }
522   }
523   /**
524    * Remove the information for a given IFile resource
525    *  
526    */
527   public void removeFile(IFile fileToParse) {
528     //    String line = (String)
529     // fFileMap.get(fileToParse.getLocation().toString());
530     String line = (String) fFileMap.get(fileToParse.getFullPath().toString());
531     if (line != null) {
532       removeLine(line);
533     }
534   }
535   /**
536    * Removes a line of the index file for function, class, class-method and
537    * class-variable names
538    * 
539    * @param line
540    */
541   private void removeLine(String line) {
542     StringTokenizer tokenizer;
543     String phpFileName = null;
544     String token;
545     String identifier = null;
546     String classname = null;
547     PHPIdentifier phpIdentifier = null;
548     boolean tokenExists = false;
549     tokenizer = new StringTokenizer(line, "\t");
550     // first token contains the filename:
551     if (tokenizer.hasMoreTokens()) {
552       phpFileName = tokenizer.nextToken();
553       //System.out.println(token);
554     } else {
555       return;
556     }
557     // all the other tokens are identifiers:
558     while (tokenizer.hasMoreTokens()) {
559       token = tokenizer.nextToken();
560       //System.out.println(token);
561       switch (token.charAt(0)) {
562         case 'c' :
563           // class name
564           identifier = token.substring(1);
565           classname = identifier;
566           phpIdentifier = new PHPIdentifierLocation(identifier,
567               PHPIdentifier.CLASS, phpFileName);
568           break;
569         case 'd' :
570           // define
571           identifier = token.substring(1);
572           phpIdentifier = new PHPIdentifierLocation(identifier,
573               PHPIdentifier.DEFINE, phpFileName);
574           break;
575         case 'f' :
576           // function name
577           identifier = token.substring(1);
578           phpIdentifier = new PHPIdentifierLocation(identifier,
579               PHPIdentifier.FUNCTION, phpFileName);
580           break;
581         case 'k' :
582           // constructor function name
583           identifier = token.substring(1);
584           phpIdentifier = new PHPIdentifierLocation(identifier,
585               PHPIdentifier.CONSTRUCTOR, phpFileName);
586           break;
587         case 'm' :
588           //method inside a class
589           identifier = token.substring(1);
590           phpIdentifier = new PHPIdentifierLocation(identifier,
591               PHPIdentifier.METHOD, phpFileName, classname);
592           break;
593         case 'v' :
594           // variable inside a class
595           identifier = token.substring(1);
596           phpIdentifier = new PHPIdentifierLocation(identifier,
597               PHPIdentifier.VARIABLE, phpFileName, classname);
598           break;
599         default :
600           identifier = null;
601           phpIdentifier = null;
602           classname = null;
603       }
604       if (identifier != null && phpIdentifier != null) {
605         ArrayList list = (ArrayList) fIndentifierMap.get(identifier);
606         if (list == null) {
607         } else {
608           for (int i = 0; i < list.size(); i++) {
609             if (list.get(i).equals(phpIdentifier)) {
610               list.remove(i);
611               break;
612             }
613           }
614           if (list.size() == 0) {
615             fIndentifierMap.remove(identifier);
616           }
617         }
618       }
619     }
620     fFileMap.remove(phpFileName);
621   }
622   /**
623    * Save the current index information in the projects index file
624    *  
625    */
626   public void writeFile() {
627     FileWriter fileWriter;
628     try {
629       fileWriter = new FileWriter(fFilename);
630       String line;
631       Collection collection = fFileMap.values();
632       Iterator iterator = collection.iterator();
633       while (iterator.hasNext()) {
634         line = (String) iterator.next();
635         fileWriter.write(line + '\n');
636       }
637       fileWriter.close();
638     } catch (FileNotFoundException e) {
639       // ignore exception; project is deleted by user
640     } catch (IOException e) {
641       // TODO Auto-generated catch block
642       e.printStackTrace();
643     }
644   }
645   /**
646    * @param fromKey
647    * @param toKey
648    * @return
649    */
650   public SortedMap getIdentifierMap() {
651     return fIndentifierMap;
652   }
653 }