Merged "Open PHP Declaration" and "Open Include File" into one action "Open Declarati...
[phpeclipse.git] / 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 }