1 /*
2 * Copyright (c) 2012, 2013, 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 com.sun.tools.sjavac;
27
28 import java.io.File;
29 import java.net.URI;
30 import java.util.ArrayList;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.HashSet;
34 import java.util.Iterator;
35 import java.util.List;
36 import java.util.Map;
37 import java.util.Set;
38
39 /**
40 * The Package class maintains meta information about a package.
41 * For example its sources, dependents,its pubapi and its artifacts.
42 *
43 * It might look odd that we track dependents/pubapi/artifacts on
44 * a package level, but it makes sense since recompiling a full package
45 * takes as long as recompiling a single java file in that package,
46 * if you take into account the startup time of the jvm.
47 *
48 * Also the dependency information will be much smaller (good for the javac_state file size)
49 * and it simplifies tracking artifact generation, you do not always know from which
50 * source a class file was generated, but you always know which package it belongs to.
51 *
52 * It is also educational to see package dependencies triggering recompilation of
53 * other packages. Even though the recompilation was perhaps not necessary,
54 * the visible recompilation of the dependent packages indicates how much circular
55 * dependencies your code has.
56 *
57 * <p><b>This is NOT part of any supported API.
58 * If you write code that depends on this, you do so at your own
59 * risk. This code and its internal interfaces are subject to change
60 * or deletion without notice.</b></p>
61 */
62 public class Package implements Comparable<Package> {
63 // The module this package belongs to. (There is a legacy module with an empty string name,
64 // used for all legacy sources.)
65 private Module mod;
66 // Name of this package, module:pkg
67 // ex1 jdk.base:java.lang
68 // ex2 :java.lang (when in legacy mode)
69 private String name;
70 // The directory path to the package. If the package belongs to a module,
71 // then that module's file system name is part of the path.
72 private String dirname;
73 // This package depends on these packages.
74 private Set<String> dependencies = new HashSet<>();
75 // This package has the following dependents, that depend on this package.
76 private Set<String> dependents = new HashSet<>();
77 // This is the public api of this package.
78 private List<String> pubapi = new ArrayList<>();
79 // Map from source file name to Source info object.
80 private Map<String,Source> sources = new HashMap<>();
81 // This package generated these artifacts.
82 private Map<String,File> artifacts = new HashMap<>();
83
84 public Package(Module m, String n) {
85 int c = n.indexOf(":");
86 assert(c != -1);
87 String mn = n.substring(0,c);
88 assert(m.name().equals(m.name()));
89 name = n;
90 dirname = n.replace('.', File.separatorChar);
91 if (m.name().length() > 0) {
92 // There is a module here, prefix the module dir name to the path.
93 dirname = m.dirname()+File.separatorChar+dirname;
94 }
95 }
96
97 public Module mod() { return mod; }
98 public String name() { return name; }
99 public String dirname() { return dirname; }
100 public Map<String,Source> sources() { return sources; }
101 public Map<String,File> artifacts() { return artifacts; }
102 public List<String> pubapi() { return pubapi; }
103
104 public Set<String> dependencies() { return dependencies; }
105 public Set<String> dependents() { return dependents; }
106
107 @Override
108 public boolean equals(Object o) {
109 return (o instanceof Package) && name.equals(((Package)o).name);
110 }
111
112 @Override
113 public int hashCode() {
114 return name.hashCode();
115 }
116
117 @Override
118 public int compareTo(Package o) {
119 return name.compareTo(o.name);
120 }
121
122 public void addSource(Source s) {
123 sources.put(s.file().getPath(), s);
124 }
125
126 public void addDependency(String d) {
127 dependencies.add(d);
128 }
129
130 public void addDependent(String d) {
131 dependents.add(d);
132 }
133
134 public void addPubapi(String p) {
135 pubapi.add(p);
136 }
137
138 /**
139 * Check if we have knowledge in the javac state that
140 * describe the results of compiling this package before.
141 */
142 public boolean existsInJavacState() {
143 return artifacts.size() > 0 || pubapi.size() > 0;
144 }
145
146 public static List<String> pubapiToList(String ps)
147 {
148 String[] lines = ps.split("\n");
149 List<String> r = new ArrayList<>();
150 for (String l : lines) {
151 r.add(l);
152 }
153 return r;
154 }
155
156 public boolean hasPubapiChanged(List<String> ps) {
157 Iterator<String> i = ps.iterator();
158 Iterator<String> j = pubapi.iterator();
159 int line = 0;
160 while (i.hasNext() && j.hasNext()) {
161 String is = i.next();
162 String js = j.next();
163 if (!is.equals(js)) {
164 Log.debug("Change in pubapi for package "+name+" line "+line);
165 Log.debug("Old: "+js);
166 Log.debug("New: "+is);
167 return true;
168 }
169 line++;
170 }
171 if ((i.hasNext() && !j.hasNext() ) ||
172 (!i.hasNext() && j.hasNext())) {
173 Log.debug("Change in pubapi for package "+name);
174 if (i.hasNext()) {
175 Log.debug("New has more lines!");
176 } else {
177 Log.debug("Old has more lines!");
178 }
179 return true;
180 }
181 return false;
182 }
183
184 public void setPubapi(List<String> ps) {
185 pubapi = ps;
186 }
187
188 public void setDependencies(Set<String> ds) {
189 dependencies = ds;
190 }
191
192 public void save(StringBuilder b) {
193 b.append("P ").append(name).append("\n");
194 Source.saveSources(sources, b);
195 saveDependencies(b);
196 savePubapi(b);
197 saveArtifacts(b);
198 }
199
200 static public Package load(Module module, String l) {
201 String name = l.substring(2);
202 return new Package(module, name);
203 }
204
205 public void loadDependency(String l) {
206 String n = l.substring(2);
207 addDependency(n);
208 }
209
210 public void loadPubapi(String l) {
211 String pi = l.substring(2);
212 addPubapi(pi);
213 }
214
215 public void saveDependencies(StringBuilder b) {
216 List<String> sorted_dependencies = new ArrayList<>();
217 for (String key : dependencies) {
218 sorted_dependencies.add(key);
219 }
220 Collections.sort(sorted_dependencies);
221 for (String a : sorted_dependencies) {
222 b.append("D "+a+"\n");
223 }
224 }
225
226 public void savePubapi(StringBuilder b) {
227 for (String l : pubapi) {
228 b.append("I "+l+"\n");
229 }
230 }
231
232 public static void savePackages(Map<String,Package> packages, StringBuilder b) {
233 List<String> sorted_packages = new ArrayList<>();
234 for (String key : packages.keySet() ) {
235 sorted_packages.add(key);
236 }
237 Collections.sort(sorted_packages);
238 for (String s : sorted_packages) {
239 Package p = packages.get(s);
240 p.save(b);
241 }
242 }
243
244 public void addArtifact(String a) {
245 artifacts.put(a, new File(a));
246 }
247
248 public void addArtifact(File f) {
249 artifacts.put(f.getPath(), f);
250 }
251
252 public void addArtifacts(Set<URI> as) {
253 for (URI u : as) {
254 addArtifact(new File(u));
255 }
256 }
257
258 public void setArtifacts(Set<URI> as) {
259 assert(!artifacts.isEmpty());
260 artifacts = new HashMap<>();
261 addArtifacts(as);
262 }
263
264 public void loadArtifact(String l) {
265 // Find next space after "A ".
266 int dp = l.indexOf(' ',2);
267 String fn = l.substring(2,dp);
268 long last_modified = Long.parseLong(l.substring(dp+1));
269 File f = new File(fn);
270 if (f.exists() && f.lastModified() != last_modified) {
271 // Hmm, the artifact on disk does not have the same last modified
272 // timestamp as the information from the build database.
273 // We no longer trust the artifact on disk. Delete it.
274 // The smart javac wrapper will then rebuild the artifact.
275 Log.debug("Removing "+f.getPath()+" since its timestamp does not match javac_state.");
276 f.delete();
277 }
278 artifacts.put(f.getPath(), f);
279 }
280
281 public void saveArtifacts(StringBuilder b) {
282 List<File> sorted_artifacts = new ArrayList<>();
283 for (File f : artifacts.values()) {
284 sorted_artifacts.add(f);
285 }
286 Collections.sort(sorted_artifacts);
287 for (File f : sorted_artifacts) {
288 // The last modified information is only used
289 // to detect tampering with the output dir.
290 // If the outputdir has been modified, not by javac,
291 // then a mismatch will be detected in the last modified
292 // timestamps stored in the build database compared
293 // to the timestamps on disk and the artifact will be deleted.
294
295 b.append("A "+f.getPath()+" "+f.lastModified()+"\n");
296 }
297 }
298
299 /**
300 * Always clean out a tainted package before it is recompiled.
301 */
302 public void deleteArtifacts() {
303 for (File a : artifacts.values()) {
304 a.delete();
305 }
306 }
307 }