4ffa4a769e5c6b447cfa3ecb46bd2beaee9c7c6c
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / compiler / batch / FileSystem.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2004 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials 
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.compiler.batch;
12
13 import java.io.File;
14
15 import net.sourceforge.phpdt.core.compiler.CharOperation;
16 import net.sourceforge.phpdt.internal.compiler.env.INameEnvironment;
17 import net.sourceforge.phpdt.internal.compiler.env.NameEnvironmentAnswer;
18 import net.sourceforge.phpdt.internal.compiler.util.SuffixConstants;
19
20 public class FileSystem implements INameEnvironment, SuffixConstants {
21         Classpath[] classpaths;
22
23         String[] knownFileNames;
24
25         interface Classpath {
26                 NameEnvironmentAnswer findClass(char[] typeName,
27                                 String qualifiedPackageName, String qualifiedBinaryFileName);
28
29                 boolean isPackage(String qualifiedPackageName);
30
31                 /**
32                  * This method resets the environment. The resulting state is equivalent
33                  * to a new name environment without creating a new object.
34                  */
35                 void reset();
36         }
37
38         /*
39          * classPathNames is a collection is Strings representing the full path of
40          * each class path initialFileNames is a collection is Strings, the trailing
41          * '.java' will be removed if its not already.
42          */
43
44         public FileSystem(String[] classpathNames, String[] initialFileNames,
45                         String encoding) {
46                 this(classpathNames, initialFileNames, encoding, null);
47         }
48
49         public FileSystem(String[] classpathNames, String[] initialFileNames,
50                         String encoding, int[] classpathDirectoryModes) {
51                 int classpathSize = classpathNames.length;
52                 this.classpaths = new Classpath[classpathSize];
53                 String[] pathNames = new String[classpathSize];
54                 int problemsOccured = 0;
55                 for (int i = 0; i < classpathSize; i++) {
56                         // try {
57                         File file = new File(convertPathSeparators(classpathNames[i]));
58                         if (file.isDirectory()) {
59                                 if (file.exists()) {
60                                         if (classpathDirectoryModes == null) {
61                                                 this.classpaths[i] = new ClasspathDirectory(file,
62                                                                 encoding);
63                                         } else {
64                                                 this.classpaths[i] = new ClasspathDirectory(file,
65                                                                 encoding, classpathDirectoryModes[i]);
66                                         }
67                                         pathNames[i] = ((ClasspathDirectory) this.classpaths[i]).path;
68                                 }
69                         } else {
70                                 String lowercaseClasspathName = classpathNames[i].toLowerCase();
71                                 // if (lowercaseClasspathName.endsWith(SUFFIX_STRING_jar)
72                                 // || lowercaseClasspathName.endsWith(SUFFIX_STRING_zip)) {
73                                 // this.classpaths[i] = this.getClasspathJar(file); // will
74                                 // throw an IOException if file does not exist
75                                 // pathNames[i] = classpathNames[i].substring(0,
76                                 // classpathNames[i].lastIndexOf('.'));
77                                 // }
78                         }
79                         // } catch (IOException e) {
80                         // this.classpaths[i] = null;
81                         // }
82                         if (this.classpaths[i] == null)
83                                 problemsOccured++;
84                 }
85                 if (problemsOccured > 0) {
86                         Classpath[] newPaths = new Classpath[classpathSize
87                                         - problemsOccured];
88                         String[] newNames = new String[classpathSize - problemsOccured];
89                         for (int i = 0, current = 0; i < classpathSize; i++)
90                                 if (this.classpaths[i] != null) {
91                                         newPaths[current] = this.classpaths[i];
92                                         newNames[current++] = pathNames[i];
93                                 }
94                         classpathSize = newPaths.length;
95                         this.classpaths = newPaths;
96                         pathNames = newNames;
97                 }
98
99                 this.knownFileNames = new String[initialFileNames.length];
100                 for (int i = initialFileNames.length; --i >= 0;) {
101                         String fileName = initialFileNames[i];
102                         String matchingPathName = null;
103                         if (fileName.lastIndexOf(".") != -1) //$NON-NLS-1$
104                                 fileName = fileName.substring(0, fileName.lastIndexOf('.')); // remove
105                                                                                                                                                                 // trailing
106                                                                                                                                                                 // ".java"
107
108                         fileName = convertPathSeparators(fileName);
109                         for (int j = 0; j < classpathSize; j++)
110                                 if (fileName.startsWith(pathNames[j]))
111                                         matchingPathName = pathNames[j];
112                         if (matchingPathName == null)
113                                 this.knownFileNames[i] = fileName; // leave as is...
114                         else
115                                 this.knownFileNames[i] = fileName.substring(matchingPathName
116                                                 .length());
117                 }
118         }
119
120         public void cleanup() {
121                 for (int i = 0, max = this.classpaths.length; i < max; i++)
122                         this.classpaths[i].reset();
123         }
124
125         private String convertPathSeparators(String path) {
126                 return File.separatorChar == '/' ? path.replace('\\', '/') : path
127                                 .replace('/', '\\');
128         }
129
130         // private NameEnvironmentAnswer findClass(String qualifiedTypeName, char[]
131         // typeName){
132         // for (int i = 0, length = this.knownFileNames.length; i < length; i++)
133         // if (qualifiedTypeName.equals(this.knownFileNames[i]))
134         // return null; // looking for a file which we know was provided at the
135         // beginning of the compilation
136         //
137         // String qualifiedBinaryFileName = qualifiedTypeName + SUFFIX_STRING_class;
138         // String qualifiedPackageName =
139         // qualifiedTypeName.length() == typeName.length
140         // ? "" //$NON-NLS-1$
141         // : qualifiedBinaryFileName.substring(0, qualifiedTypeName.length() -
142         // typeName.length - 1);
143         // String qp2 = File.separatorChar == '/' ? qualifiedPackageName :
144         // qualifiedPackageName.replace('/', File.separatorChar);
145         // if (qualifiedPackageName == qp2) {
146         // for (int i = 0, length = this.classpaths.length; i < length; i++) {
147         // NameEnvironmentAnswer answer = this.classpaths[i].findClass(typeName,
148         // qualifiedPackageName, qualifiedBinaryFileName);
149         // if (answer != null) return answer;
150         // }
151         // } else {
152         // String qb2 = qualifiedBinaryFileName.replace('/', File.separatorChar);
153         // for (int i = 0, length = this.classpaths.length; i < length; i++) {
154         // Classpath p = this.classpaths[i];
155         // NameEnvironmentAnswer answer = (p instanceof ClasspathJar)
156         // ? p.findClass(typeName, qualifiedPackageName, qualifiedBinaryFileName)
157         // : p.findClass(typeName, qp2, qb2);
158         // if (answer != null) return answer;
159         // }
160         // }
161         // return null;
162         // }
163         public NameEnvironmentAnswer findType(char[][] compoundName) {
164                 // if (compoundName != null)
165                 // return findClass(
166                 // new String(CharOperation.concatWith(compoundName, '/')),
167                 // compoundName[compoundName.length - 1]);
168                 return null;
169         }
170
171         public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName) {
172                 // if (typeName != null)
173                 // return findClass(
174                 // new String(CharOperation.concatWith(packageName, typeName, '/')),
175                 // typeName);
176                 return null;
177         }
178
179         // public ClasspathJar getClasspathJar(File file) throws IOException {
180         // return new ClasspathJar(new ZipFile(file), true);
181         // }
182         public boolean isPackage(char[][] compoundName, char[] packageName) {
183                 String qualifiedPackageName = new String(CharOperation.concatWith(
184                                 compoundName, packageName, '/'));
185                 String qp2 = File.separatorChar == '/' ? qualifiedPackageName
186                                 : qualifiedPackageName.replace('/', File.separatorChar);
187                 if (qualifiedPackageName == qp2) {
188                         for (int i = 0, length = this.classpaths.length; i < length; i++)
189                                 if (this.classpaths[i].isPackage(qualifiedPackageName))
190                                         return true;
191                 }
192                 // else {
193                 // for (int i = 0, length = this.classpaths.length; i < length; i++) {
194                 // Classpath p = this.classpaths[i];
195                 // if ((p instanceof ClasspathJar) ? p.isPackage(qualifiedPackageName) :
196                 // p.isPackage(qp2))
197                 // return true;
198                 // }
199                 // }
200                 return false;
201         }
202 }