History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/tools/java/ClassPath.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/tools/java/ClassPath.java+314−0
@@ -0,0 +1,314 @@
1+/*
2+ * Copyright (c) 1994, 2007, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package sun.tools.java;
27+
28+import java.util.Enumeration;
29+import java.util.Hashtable;
30+import java.io.File;
31+import java.io.IOException;
32+import java.util.zip.*;
33+
34+/**
35+ * This class is used to represent a class path, which can contain both
36+ * directories and zip files.
37+ *
38+ * WARNING: The contents of this source file are not part of any
39+ * supported API. Code that depends on them does so at its own risk:
40+ * they are subject to change or removal without notice.
41+ */
42+public
43+class ClassPath {
44+ static final char dirSeparator = File.pathSeparatorChar;
45+
46+ /**
47+ * The original class path string
48+ */
49+ String pathstr;
50+
51+ /**
52+ * List of class path entries
53+ */
54+ private ClassPathEntry[] path;
55+
56+ /**
57+ * Build a class path from the specified path string
58+ */
59+ public ClassPath(String pathstr) {
60+ init(pathstr);
61+ }
62+
63+ /**
64+ * Build a class path from the specified array of class path
65+ * element strings. This constructor, and the corresponding
66+ * "init" method, were added as part of the fix for 6473331, which
67+ * adds support for Class-Path manifest entries in JAR files to
68+ * rmic. It is conceivable that the value of a Class-Path
69+ * manifest entry will contain a path separator, which would cause
70+ * incorrect behavior if the expanded path were passed to the
71+ * previous constructor as a single path-separator-delimited
72+ * string; use of this constructor avoids that problem.
73+ */
74+ public ClassPath(String[] patharray) {
75+ init(patharray);
76+ }
77+
78+ /**
79+ * Build a default class path from the path strings specified by
80+ * the properties sun.boot.class.path and env.class.path, in that
81+ * order.
82+ */
83+ public ClassPath() {
84+ String syscp = System.getProperty("sun.boot.class.path");
85+ String envcp = System.getProperty("env.class.path");
86+ if (envcp == null) envcp = ".";
87+ String cp = syscp + File.pathSeparator + envcp;
88+ init(cp);
89+ }
90+
91+ private void init(String pathstr) {
92+ int i, j, n;
93+ // Save original class path string
94+ this.pathstr = pathstr;
95+
96+ if (pathstr.length() == 0) {
97+ this.path = new ClassPathEntry[0];
98+ }
99+
100+ // Count the number of path separators
101+ i = n = 0;
102+ while ((i = pathstr.indexOf(dirSeparator, i)) != -1) {
103+ n++; i++;
104+ }
105+ // Build the class path
106+ ClassPathEntry[] path = new ClassPathEntry[n+1];
107+ int len = pathstr.length();
108+ for (i = n = 0; i < len; i = j + 1) {
109+ if ((j = pathstr.indexOf(dirSeparator, i)) == -1) {
110+ j = len;
111+ }
112+ if (i == j) {
113+ path[n] = new ClassPathEntry();
114+ path[n++].dir = new File(".");
115+ } else {
116+ File file = new File(pathstr.substring(i, j));
117+ if (file.isFile()) {
118+ try {
119+ ZipFile zip = new ZipFile(file);
120+ path[n] = new ClassPathEntry();
121+ path[n++].zip = zip;
122+ } catch (ZipException e) {
123+ } catch (IOException e) {
124+ // Ignore exceptions, at least for now...
125+ }
126+ } else {
127+ path[n] = new ClassPathEntry();
128+ path[n++].dir = file;
129+ }
130+ }
131+ }
132+ // Trim class path to exact size
133+ this.path = new ClassPathEntry[n];
134+ System.arraycopy((Object)path, 0, (Object)this.path, 0, n);
135+ }
136+
137+ private void init(String[] patharray) {
138+ // Save original class path string
139+ if (patharray.length == 0) {
140+ this.pathstr = "";
141+ } else {
142+ StringBuilder sb = new StringBuilder(patharray[0]);
143+ for (int i = 1; i < patharray.length; i++) {
144+ sb.append(File.separator);
145+ sb.append(patharray[i]);
146+ }
147+ this.pathstr = sb.toString();
148+ }
149+
150+ // Build the class path
151+ ClassPathEntry[] path = new ClassPathEntry[patharray.length];
152+ int n = 0;
153+ for (String name : patharray) {
154+ File file = new File(name);
155+ if (file.isFile()) {
156+ try {
157+ ZipFile zip = new ZipFile(file);
158+ path[n] = new ClassPathEntry();
159+ path[n++].zip = zip;
160+ } catch (ZipException e) {
161+ } catch (IOException e) {
162+ // Ignore exceptions, at least for now...
163+ }
164+ } else {
165+ path[n] = new ClassPathEntry();
166+ path[n++].dir = file;
167+ }
168+ }
169+ // Trim class path to exact size
170+ this.path = new ClassPathEntry[n];
171+ System.arraycopy((Object)path, 0, (Object)this.path, 0, n);
172+ }
173+
174+ /**
175+ * Find the specified directory in the class path
176+ */
177+ public ClassFile getDirectory(String name) {
178+ return getFile(name, true);
179+ }
180+
181+ /**
182+ * Load the specified file from the class path
183+ */
184+ public ClassFile getFile(String name) {
185+ return getFile(name, false);
186+ }
187+
188+ private final String fileSeparatorChar = "" + File.separatorChar;
189+
190+ private ClassFile getFile(String name, boolean isDirectory) {
191+ String subdir = name;
192+ String basename = "";
193+ if (!isDirectory) {
194+ int i = name.lastIndexOf(File.separatorChar);
195+ subdir = name.substring(0, i + 1);
196+ basename = name.substring(i + 1);
197+ } else if (!subdir.equals("")
198+ && !subdir.endsWith(fileSeparatorChar)) {
199+ // zip files are picky about "foo" vs. "foo/".
200+ // also, the getFiles caches are keyed with a trailing /
201+ subdir = subdir + File.separatorChar;
202+ name = subdir; // Note: isDirectory==true & basename==""
203+ }
204+ for (int i = 0; i < path.length; i++) {
205+ if (path[i].zip != null) {
206+ String newname = name.replace(File.separatorChar, '/');
207+ ZipEntry entry = path[i].zip.getEntry(newname);
208+ if (entry != null) {
209+ return new ClassFile(path[i].zip, entry);
210+ }
211+ } else {
212+ File file = new File(path[i].dir.getPath(), name);
213+ String list[] = path[i].getFiles(subdir);
214+ if (isDirectory) {
215+ if (list.length > 0) {
216+ return new ClassFile(file);
217+ }
218+ } else {
219+ for (int j = 0; j < list.length; j++) {
220+ if (basename.equals(list[j])) {
221+ // Don't bother checking !file.isDir,
222+ // since we only look for names which
223+ // cannot already be packages (foo.java, etc).
224+ return new ClassFile(file);
225+ }
226+ }
227+ }
228+ }
229+ }
230+ return null;
231+ }
232+
233+ /**
234+ * Returns list of files given a package name and extension.
235+ */
236+ public Enumeration getFiles(String pkg, String ext) {
237+ Hashtable files = new Hashtable();
238+ for (int i = path.length; --i >= 0; ) {
239+ if (path[i].zip != null) {
240+ Enumeration e = path[i].zip.entries();
241+ while (e.hasMoreElements()) {
242+ ZipEntry entry = (ZipEntry)e.nextElement();
243+ String name = entry.getName();
244+ name = name.replace('/', File.separatorChar);
245+ if (name.startsWith(pkg) && name.endsWith(ext)) {
246+ files.put(name, new ClassFile(path[i].zip, entry));
247+ }
248+ }
249+ } else {
250+ String[] list = path[i].getFiles(pkg);
251+ for (int j = 0; j < list.length; j++) {
252+ String name = list[j];
253+ if (name.endsWith(ext)) {
254+ name = pkg + File.separatorChar + name;
255+ File file = new File(path[i].dir.getPath(), name);
256+ files.put(name, new ClassFile(file));
257+ }
258+ }
259+ }
260+ }
261+ return files.elements();
262+ }
263+
264+ /**
265+ * Release resources.
266+ */
267+ public void close() throws IOException {
268+ for (int i = path.length; --i >= 0; ) {
269+ if (path[i].zip != null) {
270+ path[i].zip.close();
271+ }
272+ }
273+ }
274+
275+ /**
276+ * Returns original class path string
277+ */
278+ public String toString() {
279+ return pathstr;
280+ }
281+}
282+
283+/**
284+ * A class path entry, which can either be a directory or an open zip file.
285+ */
286+class ClassPathEntry {
287+ File dir;
288+ ZipFile zip;
289+
290+ Hashtable subdirs = new Hashtable(29); // cache of sub-directory listings
291+ String[] getFiles(String subdir) {
292+ String files[] = (String[]) subdirs.get(subdir);
293+ if (files == null) {
294+ // search the directory, exactly once
295+ File sd = new File(dir.getPath(), subdir);
296+ if (sd.isDirectory()) {
297+ files = sd.list();
298+ if (files == null) {
299+ // should not happen, but just in case, fail silently
300+ files = new String[0];
301+ }
302+ if (files.length == 0) {
303+ String nonEmpty[] = { "" };
304+ files = nonEmpty;
305+ }
306+ } else {
307+ files = new String[0];
308+ }
309+ subdirs.put(subdir, files);
310+ }
311+ return files;
312+ }
313+
314+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t