author | redestad |
Fri, 31 Mar 2017 08:59:35 +0200 | |
changeset 44458 | cf6145299178 |
parent 42408 | d6f09ae68eab |
child 45504 | ea7475564d07 |
permissions | -rw-r--r-- |
4548 | 1 |
/* |
35807
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
2 |
* Copyright (c) 2009, 2016, Oracle and/or its affiliates. All rights reserved. |
4548 | 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 |
|
5520 | 7 |
* published by the Free Software Foundation. Oracle designates this |
4548 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5520 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
4548 | 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 |
* |
|
5520 | 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. |
|
4548 | 24 |
*/ |
25 |
||
29780
8f8e54a1fa20
8076420: Consolidate javac file handling in javac.file package
jjg
parents:
29291
diff
changeset
|
26 |
package com.sun.tools.javac.file; |
4548 | 27 |
|
28 |
import java.io.IOException; |
|
29 |
import java.io.InputStream; |
|
30 |
import java.lang.ref.SoftReference; |
|
31 |
import java.lang.reflect.Constructor; |
|
42407
f3702cff2933
8169069: Module system implementation refresh (11/2016)
alanb
parents:
41637
diff
changeset
|
32 |
import java.lang.reflect.InvocationTargetException; |
36526 | 33 |
import java.lang.reflect.Method; |
4548 | 34 |
import java.net.URL; |
35 |
import java.net.URLClassLoader; |
|
36 |
import java.nio.ByteBuffer; |
|
37 |
import java.nio.CharBuffer; |
|
38 |
import java.nio.charset.Charset; |
|
39 |
import java.nio.charset.CharsetDecoder; |
|
40 |
import java.nio.charset.CoderResult; |
|
41 |
import java.nio.charset.CodingErrorAction; |
|
42 |
import java.nio.charset.IllegalCharsetNameException; |
|
43 |
import java.nio.charset.UnsupportedCharsetException; |
|
27579 | 44 |
import java.nio.file.Path; |
4548 | 45 |
import java.util.Collection; |
46 |
import java.util.HashMap; |
|
47 |
import java.util.Iterator; |
|
48 |
import java.util.Map; |
|
29291
076c277565f7
8073550: java* tools: replace obj.getClass hacks with Assert.checkNonNull or Objects.requireNonNull
mcimadamore
parents:
27579
diff
changeset
|
49 |
import java.util.Objects; |
11314 | 50 |
import java.util.Set; |
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
51 |
|
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
52 |
import javax.tools.JavaFileManager; |
4548 | 53 |
import javax.tools.JavaFileObject; |
54 |
import javax.tools.JavaFileObject.Kind; |
|
55 |
||
11314 | 56 |
import com.sun.tools.javac.main.Option; |
57 |
import com.sun.tools.javac.main.OptionHelper; |
|
58 |
import com.sun.tools.javac.main.OptionHelper.GrumpyHelper; |
|
36526 | 59 |
import com.sun.tools.javac.resources.CompilerProperties.Errors; |
60 |
import com.sun.tools.javac.util.Abort; |
|
29780
8f8e54a1fa20
8076420: Consolidate javac file handling in javac.file package
jjg
parents:
29291
diff
changeset
|
61 |
import com.sun.tools.javac.util.Context; |
8f8e54a1fa20
8076420: Consolidate javac file handling in javac.file package
jjg
parents:
29291
diff
changeset
|
62 |
import com.sun.tools.javac.util.DefinedBy; |
26266
2d24bda701dc
8056061: Mark implementations of public interfaces with an annotation
jlahoda
parents:
25874
diff
changeset
|
63 |
import com.sun.tools.javac.util.DefinedBy.Api; |
29780
8f8e54a1fa20
8076420: Consolidate javac file handling in javac.file package
jjg
parents:
29291
diff
changeset
|
64 |
import com.sun.tools.javac.util.Log; |
8f8e54a1fa20
8076420: Consolidate javac file handling in javac.file package
jjg
parents:
29291
diff
changeset
|
65 |
import com.sun.tools.javac.util.Options; |
10813
95b39a692cd0
7101146: Paths should more directly managed by BaseFileManager
jjg
parents:
10461
diff
changeset
|
66 |
|
4548 | 67 |
/** |
68 |
* Utility methods for building a filemanager. |
|
69 |
* There are no references here to file-system specific objects such as |
|
70 |
* java.io.File or java.nio.file.Path. |
|
71 |
*/ |
|
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
72 |
public abstract class BaseFileManager implements JavaFileManager { |
4548 | 73 |
protected BaseFileManager(Charset charset) { |
74 |
this.charset = charset; |
|
75 |
byteBufferCache = new ByteBufferCache(); |
|
10818 | 76 |
locations = createLocations(); |
4548 | 77 |
} |
78 |
||
79 |
/** |
|
80 |
* Set the context for JavacPathFileManager. |
|
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
81 |
* @param context the context containing items to be associated with the file manager |
4548 | 82 |
*/ |
10813
95b39a692cd0
7101146: Paths should more directly managed by BaseFileManager
jjg
parents:
10461
diff
changeset
|
83 |
public void setContext(Context context) { |
4548 | 84 |
log = Log.instance(context); |
85 |
options = Options.instance(context); |
|
86 |
classLoaderClass = options.get("procloader"); |
|
41637 | 87 |
|
88 |
// Avoid initializing Lint |
|
89 |
boolean warn = options.isLintSet("path"); |
|
90 |
locations.update(log, warn, FSInfo.instance(context)); |
|
35807
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
91 |
|
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
92 |
// Setting this option is an indication that close() should defer actually closing |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
93 |
// the file manager until after a specified period of inactivity. |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
94 |
// This is to accomodate clients which save references to Symbols created for use |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
95 |
// within doclets or annotation processors, and which then attempt to use those |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
96 |
// references after the tool exits, having closed any internally managed file manager. |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
97 |
// Ideally, such clients should run the tool via the javax.tools API, providing their |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
98 |
// own file manager, which can be closed by the client when all use of that file |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
99 |
// manager is complete. |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
100 |
// If the option has a numeric value, it will be interpreted as the duration, |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
101 |
// in seconds, of the period of inactivity to wait for, before the file manager |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
102 |
// is actually closed. |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
103 |
// See also deferredClose(). |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
104 |
String s = options.get("fileManager.deferClose"); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
105 |
if (s != null) { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
106 |
try { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
107 |
deferredCloseTimeout = (int) (Float.parseFloat(s) * 1000); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
108 |
} catch (NumberFormatException e) { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
109 |
deferredCloseTimeout = 60 * 1000; // default: one minute, in millis |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
110 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
111 |
} |
10813
95b39a692cd0
7101146: Paths should more directly managed by BaseFileManager
jjg
parents:
10461
diff
changeset
|
112 |
} |
95b39a692cd0
7101146: Paths should more directly managed by BaseFileManager
jjg
parents:
10461
diff
changeset
|
113 |
|
10818 | 114 |
protected Locations createLocations() { |
115 |
return new Locations(); |
|
4548 | 116 |
} |
117 |
||
118 |
/** |
|
119 |
* The log to be used for error reporting. |
|
120 |
*/ |
|
121 |
public Log log; |
|
122 |
||
123 |
/** |
|
124 |
* User provided charset (through javax.tools). |
|
125 |
*/ |
|
126 |
protected Charset charset; |
|
127 |
||
128 |
protected Options options; |
|
129 |
||
130 |
protected String classLoaderClass; |
|
131 |
||
42407
f3702cff2933
8169069: Module system implementation refresh (11/2016)
alanb
parents:
41637
diff
changeset
|
132 |
protected final Locations locations; |
10813
95b39a692cd0
7101146: Paths should more directly managed by BaseFileManager
jjg
parents:
10461
diff
changeset
|
133 |
|
27379
5ae894733e09
8062579: JavacTask, DocumentationTask impls should close file manager when possible
jjg
parents:
27318
diff
changeset
|
134 |
/** |
5ae894733e09
8062579: JavacTask, DocumentationTask impls should close file manager when possible
jjg
parents:
27318
diff
changeset
|
135 |
* A flag for clients to use to indicate that this file manager should |
5ae894733e09
8062579: JavacTask, DocumentationTask impls should close file manager when possible
jjg
parents:
27318
diff
changeset
|
136 |
* be closed when it is no longer required. |
5ae894733e09
8062579: JavacTask, DocumentationTask impls should close file manager when possible
jjg
parents:
27318
diff
changeset
|
137 |
*/ |
5ae894733e09
8062579: JavacTask, DocumentationTask impls should close file manager when possible
jjg
parents:
27318
diff
changeset
|
138 |
public boolean autoClose; |
5ae894733e09
8062579: JavacTask, DocumentationTask impls should close file manager when possible
jjg
parents:
27318
diff
changeset
|
139 |
|
35807
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
140 |
/** |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
141 |
* Wait for a period of inactivity before calling close(). |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
142 |
* The length of the period of inactivity is given by {@code deferredCloseTimeout} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
143 |
*/ |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
144 |
protected void deferredClose() { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
145 |
Thread t = new Thread(getClass().getName() + " DeferredClose") { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
146 |
@Override |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
147 |
public void run() { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
148 |
try { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
149 |
synchronized (BaseFileManager.this) { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
150 |
long now = System.currentTimeMillis(); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
151 |
while (now < lastUsedTime + deferredCloseTimeout) { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
152 |
BaseFileManager.this.wait(lastUsedTime + deferredCloseTimeout - now); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
153 |
now = System.currentTimeMillis(); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
154 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
155 |
deferredCloseTimeout = 0; |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
156 |
close(); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
157 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
158 |
} catch (InterruptedException e) { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
159 |
} catch (IOException e) { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
160 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
161 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
162 |
}; |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
163 |
t.setDaemon(true); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
164 |
t.start(); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
165 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
166 |
|
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
167 |
synchronized void updateLastUsedTime() { |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
168 |
if (deferredCloseTimeout > 0) { // avoid updating the time unnecessarily |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
169 |
lastUsedTime = System.currentTimeMillis(); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
170 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
171 |
} |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
172 |
|
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
173 |
private long lastUsedTime = System.currentTimeMillis(); |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
174 |
protected long deferredCloseTimeout = 0; |
2eb1d877da0f
8147801: java.nio.file.ClosedFileSystemException when using Javadoc API's in JDK9
jjg
parents:
29780
diff
changeset
|
175 |
|
4548 | 176 |
protected ClassLoader getClassLoader(URL[] urls) { |
177 |
ClassLoader thisClassLoader = getClass().getClassLoader(); |
|
178 |
||
16796
53060909017b
7059170: Assume availablility of URLClassLoader.close
darcy
parents:
14801
diff
changeset
|
179 |
// Allow the following to specify a closeable classloader |
53060909017b
7059170: Assume availablility of URLClassLoader.close
darcy
parents:
14801
diff
changeset
|
180 |
// other than URLClassLoader. |
4548 | 181 |
|
182 |
// 1: Allow client to specify the class to use via hidden option |
|
183 |
if (classLoaderClass != null) { |
|
184 |
try { |
|
185 |
Class<? extends ClassLoader> loader = |
|
186 |
Class.forName(classLoaderClass).asSubclass(ClassLoader.class); |
|
187 |
Class<?>[] constrArgTypes = { URL[].class, ClassLoader.class }; |
|
188 |
Constructor<? extends ClassLoader> constr = loader.getConstructor(constrArgTypes); |
|
44458
cf6145299178
8175116: jtreg agentvms uses more virtual address space in langtool/test :tier1 runs
redestad
parents:
42408
diff
changeset
|
189 |
return constr.newInstance(urls, thisClassLoader); |
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
190 |
} catch (ReflectiveOperationException t) { |
4548 | 191 |
// ignore errors loading user-provided class loader, fall through |
192 |
} |
|
193 |
} |
|
44458
cf6145299178
8175116: jtreg agentvms uses more virtual address space in langtool/test :tier1 runs
redestad
parents:
42408
diff
changeset
|
194 |
return new URLClassLoader(urls, thisClassLoader); |
4548 | 195 |
} |
196 |
||
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
197 |
public boolean isDefaultBootClassPath() { |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
198 |
return locations.isDefaultBootClassPath(); |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
199 |
} |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
200 |
|
4548 | 201 |
// <editor-fold defaultstate="collapsed" desc="Option handling"> |
26266
2d24bda701dc
8056061: Mark implementations of public interfaces with an annotation
jlahoda
parents:
25874
diff
changeset
|
202 |
@Override @DefinedBy(Api.COMPILER) |
4548 | 203 |
public boolean handleOption(String current, Iterator<String> remaining) { |
11314 | 204 |
OptionHelper helper = new GrumpyHelper(log) { |
205 |
@Override |
|
206 |
public String get(Option option) { |
|
40308
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
207 |
return options.get(option); |
11314 | 208 |
} |
209 |
||
210 |
@Override |
|
211 |
public void put(String name, String value) { |
|
212 |
options.put(name, value); |
|
213 |
} |
|
214 |
||
215 |
@Override |
|
216 |
public void remove(String name) { |
|
217 |
options.remove(name); |
|
218 |
} |
|
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
219 |
|
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
220 |
@Override |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
221 |
public boolean handleFileManagerOption(Option option, String value) { |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
222 |
return handleOption(option, value); |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
223 |
} |
11314 | 224 |
}; |
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
225 |
|
40308
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
226 |
Option o = Option.lookup(current, javacFileManagerOptions); |
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
227 |
if (o == null) { |
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
228 |
return false; |
4548 | 229 |
} |
230 |
||
42260
2b4da2bf6660
8169676: boolean result of Option.process is often ignored
jjg
parents:
41637
diff
changeset
|
231 |
try { |
2b4da2bf6660
8169676: boolean result of Option.process is often ignored
jjg
parents:
41637
diff
changeset
|
232 |
o.handleOption(helper, current, remaining); |
2b4da2bf6660
8169676: boolean result of Option.process is often ignored
jjg
parents:
41637
diff
changeset
|
233 |
} catch (Option.InvalidValueException e) { |
2b4da2bf6660
8169676: boolean result of Option.process is often ignored
jjg
parents:
41637
diff
changeset
|
234 |
throw new IllegalArgumentException(e.getMessage(), e); |
2b4da2bf6660
8169676: boolean result of Option.process is often ignored
jjg
parents:
41637
diff
changeset
|
235 |
} |
40308
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
236 |
|
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
237 |
return true; |
4548 | 238 |
} |
239 |
// where |
|
14801
d66cab4ef397
8003967: detect and remove all mutable implicit static enum fields in langtools
vromero
parents:
11314
diff
changeset
|
240 |
private static final Set<Option> javacFileManagerOptions = |
11314 | 241 |
Option.getJavacFileManagerOptions(); |
4548 | 242 |
|
26266
2d24bda701dc
8056061: Mark implementations of public interfaces with an annotation
jlahoda
parents:
25874
diff
changeset
|
243 |
@Override @DefinedBy(Api.COMPILER) |
4548 | 244 |
public int isSupportedOption(String option) { |
40308
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
245 |
Option o = Option.lookup(option, javacFileManagerOptions); |
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
246 |
return (o == null) ? -1 : o.hasArg() ? 1 : 0; |
4548 | 247 |
} |
7335
8b390fd27190
6900037: javac should warn if earlier -source is used and bootclasspath not set
jjg
parents:
5520
diff
changeset
|
248 |
|
37394
c36230ee15d9
8149757: Implement Multi-Release JAR aware JavacFileManager for javac
jjg
parents:
36526
diff
changeset
|
249 |
protected String multiReleaseValue; |
c36230ee15d9
8149757: Implement Multi-Release JAR aware JavacFileManager for javac
jjg
parents:
36526
diff
changeset
|
250 |
|
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
251 |
/** |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
252 |
* Common back end for OptionHelper handleFileManagerOption. |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
253 |
* @param option the option whose value to be set |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
254 |
* @param value the value for the option |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
255 |
* @return true if successful, and false otherwise |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
256 |
*/ |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
257 |
public boolean handleOption(Option option, String value) { |
36155
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
258 |
switch (option) { |
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
259 |
case ENCODING: |
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
260 |
encodingName = value; |
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
261 |
return true; |
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
262 |
|
37394
c36230ee15d9
8149757: Implement Multi-Release JAR aware JavacFileManager for javac
jjg
parents:
36526
diff
changeset
|
263 |
case MULTIRELEASE: |
c36230ee15d9
8149757: Implement Multi-Release JAR aware JavacFileManager for javac
jjg
parents:
36526
diff
changeset
|
264 |
multiReleaseValue = value; |
41155
93dad90c22c1
8156568: Update javac to support compiling against a modular JAR that is a multi-release JAR
sadayapalam
parents:
40308
diff
changeset
|
265 |
locations.setMultiReleaseValue(value); |
37394
c36230ee15d9
8149757: Implement Multi-Release JAR aware JavacFileManager for javac
jjg
parents:
36526
diff
changeset
|
266 |
return true; |
c36230ee15d9
8149757: Implement Multi-Release JAR aware JavacFileManager for javac
jjg
parents:
36526
diff
changeset
|
267 |
|
36155
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
268 |
default: |
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
269 |
return locations.handleOption(option, value); |
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
270 |
} |
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
271 |
} |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
272 |
|
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
273 |
/** |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
274 |
* Call handleOption for collection of options and corresponding values. |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
275 |
* @param map a collection of options and corresponding values |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
276 |
* @return true if all the calls are successful |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
277 |
*/ |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
278 |
public boolean handleOptions(Map<Option, String> map) { |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
279 |
boolean ok = true; |
36526 | 280 |
for (Map.Entry<Option, String> e: map.entrySet()) { |
281 |
try { |
|
282 |
ok = ok & handleOption(e.getKey(), e.getValue()); |
|
283 |
} catch (IllegalArgumentException ex) { |
|
40308
274367a99f98
8136930: Simplify use of module-system options by custom launchers
jjg
parents:
39362
diff
changeset
|
284 |
log.error(Errors.IllegalArgumentForOption(e.getKey().getPrimaryName(), ex.getMessage())); |
36526 | 285 |
ok = false; |
286 |
} |
|
287 |
} |
|
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
288 |
return ok; |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
289 |
} |
7335
8b390fd27190
6900037: javac should warn if earlier -source is used and bootclasspath not set
jjg
parents:
5520
diff
changeset
|
290 |
|
4548 | 291 |
// </editor-fold> |
292 |
||
293 |
// <editor-fold defaultstate="collapsed" desc="Encoding"> |
|
36155
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
294 |
private String encodingName; |
4548 | 295 |
private String defaultEncodingName; |
296 |
private String getDefaultEncodingName() { |
|
297 |
if (defaultEncodingName == null) { |
|
39362
5ac5af2acb57
8132857: Historical name of default encoding shown on encoding mismatch
jlahoda
parents:
38511
diff
changeset
|
298 |
defaultEncodingName = Charset.defaultCharset().name(); |
4548 | 299 |
} |
300 |
return defaultEncodingName; |
|
301 |
} |
|
302 |
||
303 |
public String getEncodingName() { |
|
36155
1555ce1fcb4f
8149772: cleanup handling of -encoding in JavacFileManager
jjg
parents:
35807
diff
changeset
|
304 |
return (encodingName != null) ? encodingName : getDefaultEncodingName(); |
4548 | 305 |
} |
306 |
||
27318
4660a5da7d90
8062376: Suppress cast warnings when using NIO buffers
rwarburton
parents:
26266
diff
changeset
|
307 |
@SuppressWarnings("cast") |
4548 | 308 |
public CharBuffer decode(ByteBuffer inbuf, boolean ignoreEncodingErrors) { |
42407
f3702cff2933
8169069: Module system implementation refresh (11/2016)
alanb
parents:
41637
diff
changeset
|
309 |
String encName = getEncodingName(); |
4548 | 310 |
CharsetDecoder decoder; |
311 |
try { |
|
42407
f3702cff2933
8169069: Module system implementation refresh (11/2016)
alanb
parents:
41637
diff
changeset
|
312 |
decoder = getDecoder(encName, ignoreEncodingErrors); |
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
313 |
} catch (IllegalCharsetNameException | UnsupportedCharsetException e) { |
42407
f3702cff2933
8169069: Module system implementation refresh (11/2016)
alanb
parents:
41637
diff
changeset
|
314 |
log.error("unsupported.encoding", encName); |
4548 | 315 |
return (CharBuffer)CharBuffer.allocate(1).flip(); |
316 |
} |
|
317 |
||
318 |
// slightly overestimate the buffer size to avoid reallocation. |
|
319 |
float factor = |
|
320 |
decoder.averageCharsPerByte() * 0.8f + |
|
321 |
decoder.maxCharsPerByte() * 0.2f; |
|
322 |
CharBuffer dest = CharBuffer. |
|
323 |
allocate(10 + (int)(inbuf.remaining()*factor)); |
|
324 |
||
325 |
while (true) { |
|
326 |
CoderResult result = decoder.decode(inbuf, dest, true); |
|
327 |
dest.flip(); |
|
328 |
||
329 |
if (result.isUnderflow()) { // done reading |
|
330 |
// make sure there is at least one extra character |
|
331 |
if (dest.limit() == dest.capacity()) { |
|
332 |
dest = CharBuffer.allocate(dest.capacity()+1).put(dest); |
|
333 |
dest.flip(); |
|
334 |
} |
|
335 |
return dest; |
|
336 |
} else if (result.isOverflow()) { // buffer too small; expand |
|
337 |
int newCapacity = |
|
338 |
10 + dest.capacity() + |
|
339 |
(int)(inbuf.remaining()*decoder.maxCharsPerByte()); |
|
340 |
dest = CharBuffer.allocate(newCapacity).put(dest); |
|
341 |
} else if (result.isMalformed() || result.isUnmappable()) { |
|
342 |
// bad character in input |
|
38511
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
343 |
StringBuilder unmappable = new StringBuilder(); |
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
344 |
int len = result.length(); |
4548 | 345 |
|
38511
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
346 |
for (int i = 0; i < len; i++) { |
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
347 |
unmappable.append(String.format("%02X", inbuf.get())); |
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
348 |
} |
4548 | 349 |
|
42407
f3702cff2933
8169069: Module system implementation refresh (11/2016)
alanb
parents:
41637
diff
changeset
|
350 |
String charsetName = charset == null ? encName : charset.name(); |
38511
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
351 |
|
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
352 |
log.error(dest.limit(), |
d934635453ad
8078559: Update error message to indicate illegal character when encoding set to ascii
jlahoda
parents:
37394
diff
changeset
|
353 |
Errors.IllegalCharForEncoding(unmappable.toString(), charsetName)); |
4548 | 354 |
|
355 |
// undo the flip() to prepare the output buffer |
|
356 |
// for more translation |
|
357 |
dest.position(dest.limit()); |
|
358 |
dest.limit(dest.capacity()); |
|
359 |
dest.put((char)0xfffd); // backward compatible |
|
360 |
} else { |
|
361 |
throw new AssertionError(result); |
|
362 |
} |
|
363 |
} |
|
364 |
// unreached |
|
365 |
} |
|
366 |
||
367 |
public CharsetDecoder getDecoder(String encodingName, boolean ignoreEncodingErrors) { |
|
368 |
Charset cs = (this.charset == null) |
|
369 |
? Charset.forName(encodingName) |
|
370 |
: this.charset; |
|
371 |
CharsetDecoder decoder = cs.newDecoder(); |
|
372 |
||
373 |
CodingErrorAction action; |
|
374 |
if (ignoreEncodingErrors) |
|
375 |
action = CodingErrorAction.REPLACE; |
|
376 |
else |
|
377 |
action = CodingErrorAction.REPORT; |
|
378 |
||
379 |
return decoder |
|
380 |
.onMalformedInput(action) |
|
381 |
.onUnmappableCharacter(action); |
|
382 |
} |
|
383 |
// </editor-fold> |
|
384 |
||
385 |
// <editor-fold defaultstate="collapsed" desc="ByteBuffers"> |
|
386 |
/** |
|
387 |
* Make a byte buffer from an input stream. |
|
24897
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
388 |
* @param in the stream |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
389 |
* @return a byte buffer containing the contents of the stream |
655b72d7b96e
7026941: 199: path options ignored when reusing filemanager across tasks
jjg
parents:
22163
diff
changeset
|
390 |
* @throws IOException if an error occurred while reading the stream |
4548 | 391 |
*/ |
27318
4660a5da7d90
8062376: Suppress cast warnings when using NIO buffers
rwarburton
parents:
26266
diff
changeset
|
392 |
@SuppressWarnings("cast") |
4548 | 393 |
public ByteBuffer makeByteBuffer(InputStream in) |
394 |
throws IOException { |
|
395 |
int limit = in.available(); |
|
396 |
if (limit < 1024) limit = 1024; |
|
397 |
ByteBuffer result = byteBufferCache.get(limit); |
|
398 |
int position = 0; |
|
399 |
while (in.available() != 0) { |
|
400 |
if (position >= limit) |
|
401 |
// expand buffer |
|
402 |
result = ByteBuffer. |
|
403 |
allocate(limit <<= 1). |
|
404 |
put((ByteBuffer)result.flip()); |
|
405 |
int count = in.read(result.array(), |
|
406 |
position, |
|
407 |
limit - position); |
|
408 |
if (count < 0) break; |
|
409 |
result.position(position += count); |
|
410 |
} |
|
411 |
return (ByteBuffer)result.flip(); |
|
412 |
} |
|
413 |
||
414 |
public void recycleByteBuffer(ByteBuffer bb) { |
|
415 |
byteBufferCache.put(bb); |
|
416 |
} |
|
417 |
||
418 |
/** |
|
419 |
* A single-element cache of direct byte buffers. |
|
420 |
*/ |
|
27318
4660a5da7d90
8062376: Suppress cast warnings when using NIO buffers
rwarburton
parents:
26266
diff
changeset
|
421 |
@SuppressWarnings("cast") |
4548 | 422 |
private static class ByteBufferCache { |
423 |
private ByteBuffer cached; |
|
424 |
ByteBuffer get(int capacity) { |
|
425 |
if (capacity < 20480) capacity = 20480; |
|
426 |
ByteBuffer result = |
|
427 |
(cached != null && cached.capacity() >= capacity) |
|
428 |
? (ByteBuffer)cached.clear() |
|
429 |
: ByteBuffer.allocate(capacity + capacity>>1); |
|
430 |
cached = null; |
|
431 |
return result; |
|
432 |
} |
|
433 |
void put(ByteBuffer x) { |
|
434 |
cached = x; |
|
435 |
} |
|
436 |
} |
|
437 |
||
438 |
private final ByteBufferCache byteBufferCache; |
|
439 |
// </editor-fold> |
|
440 |
||
441 |
// <editor-fold defaultstate="collapsed" desc="Content cache"> |
|
442 |
public CharBuffer getCachedContent(JavaFileObject file) { |
|
10461
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
443 |
ContentCacheEntry e = contentCache.get(file); |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
444 |
if (e == null) |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
445 |
return null; |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
446 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
447 |
if (!e.isValid(file)) { |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
448 |
contentCache.remove(file); |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
449 |
return null; |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
450 |
} |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
451 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
452 |
return e.getValue(); |
4548 | 453 |
} |
454 |
||
455 |
public void cache(JavaFileObject file, CharBuffer cb) { |
|
10461
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
456 |
contentCache.put(file, new ContentCacheEntry(file, cb)); |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
457 |
} |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
458 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
459 |
public void flushCache(JavaFileObject file) { |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
460 |
contentCache.remove(file); |
4548 | 461 |
} |
462 |
||
22163 | 463 |
protected final Map<JavaFileObject, ContentCacheEntry> contentCache = new HashMap<>(); |
10461
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
464 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
465 |
protected static class ContentCacheEntry { |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
466 |
final long timestamp; |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
467 |
final SoftReference<CharBuffer> ref; |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
468 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
469 |
ContentCacheEntry(JavaFileObject file, CharBuffer cb) { |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
470 |
this.timestamp = file.getLastModified(); |
22163 | 471 |
this.ref = new SoftReference<>(cb); |
10461
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
472 |
} |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
473 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
474 |
boolean isValid(JavaFileObject file) { |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
475 |
return timestamp == file.getLastModified(); |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
476 |
} |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
477 |
|
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
478 |
CharBuffer getValue() { |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
479 |
return ref.get(); |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
480 |
} |
998e642f9811
7068451: Regression: javac compiles fixed sources against previous, not current, version of generated sources
jjg
parents:
7681
diff
changeset
|
481 |
} |
4548 | 482 |
// </editor-fold> |
483 |
||
27579 | 484 |
public static Kind getKind(Path path) { |
485 |
return getKind(path.getFileName().toString()); |
|
486 |
} |
|
487 |
||
4548 | 488 |
public static Kind getKind(String name) { |
489 |
if (name.endsWith(Kind.CLASS.extension)) |
|
490 |
return Kind.CLASS; |
|
491 |
else if (name.endsWith(Kind.SOURCE.extension)) |
|
492 |
return Kind.SOURCE; |
|
493 |
else if (name.endsWith(Kind.HTML.extension)) |
|
494 |
return Kind.HTML; |
|
495 |
else |
|
496 |
return Kind.OTHER; |
|
497 |
} |
|
498 |
||
499 |
protected static <T> T nullCheck(T o) { |
|
29291
076c277565f7
8073550: java* tools: replace obj.getClass hacks with Assert.checkNonNull or Objects.requireNonNull
mcimadamore
parents:
27579
diff
changeset
|
500 |
return Objects.requireNonNull(o); |
4548 | 501 |
} |
502 |
||
503 |
protected static <T> Collection<T> nullCheck(Collection<T> it) { |
|
504 |
for (T t : it) |
|
29291
076c277565f7
8073550: java* tools: replace obj.getClass hacks with Assert.checkNonNull or Objects.requireNonNull
mcimadamore
parents:
27579
diff
changeset
|
505 |
Objects.requireNonNull(t); |
4548 | 506 |
return it; |
507 |
} |
|
508 |
} |