1 /*
2 * Copyright (c) 2016, 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 package com.sun.tools.jdeps;
26
27 import com.sun.tools.classfile.Dependencies;
28 import com.sun.tools.classfile.Dependency;
29 import com.sun.tools.classfile.Dependency.Location;
30
31 import java.util.HashSet;
32 import java.util.Optional;
33 import java.util.Set;
34 import java.util.regex.Pattern;
35 import java.util.stream.Collectors;
36 import java.util.stream.Stream;
37
38 /*
39 * Filter configured based on the input jdeps option
40 * 1. -p and -regex to match target dependencies
41 * 2. -filter:package to filter out same-package dependencies
42 * This filter is applied when jdeps parses the class files
43 * and filtered dependencies are not stored in the Analyzer.
44 * 3. -requires specifies to match target dependence from the given module
45 * This gets expanded into package lists to be filtered.
46 * 4. -filter:archive to filter out same-archive dependencies
47 * This filter is applied later in the Analyzer as the
48 * containing archive of a target class may not be known until
49 * the entire archive
50 */
51 public class JdepsFilter implements Dependency.Filter, Analyzer.Filter {
52
53 public static final JdepsFilter DEFAULT_FILTER =
54 new JdepsFilter.Builder().filter(true, true).build();
55
56 private final Dependency.Filter filter;
57 private final Pattern filterPattern;
58 private final boolean filterSamePackage;
59 private final boolean filterSameArchive;
60 private final boolean findJDKInternals;
61 private final Pattern includePattern;
62 private final Pattern includeSystemModules;
63
64 private final Set<String> requires;
65
66 private JdepsFilter(Dependency.Filter filter,
67 Pattern filterPattern,
68 boolean filterSamePackage,
69 boolean filterSameArchive,
70 boolean findJDKInternals,
71 Pattern includePattern,
72 Pattern includeSystemModules,
73 Set<String> requires) {
74 this.filter = filter;
75 this.filterPattern = filterPattern;
76 this.filterSamePackage = filterSamePackage;
77 this.filterSameArchive = filterSameArchive;
78 this.findJDKInternals = findJDKInternals;
79 this.includePattern = includePattern;
80 this.includeSystemModules = includeSystemModules;
81 this.requires = requires;
82 }
83
84 /**
85 * Tests if the given class matches the pattern given in the -include option
86 *
87 * @param cn fully-qualified name
88 */
89 public boolean matches(String cn) {
90 if (includePattern == null)
91 return true;
92
93 if (includePattern != null)
94 return includePattern.matcher(cn).matches();
95
96 return false;
97 }
98
99 /**
100 * Tests if the given source includes classes specified in -include option
101 *
102 * This method can be used to determine if the given source should eagerly
103 * be processed.
104 */
105 public boolean matches(Archive source) {
106 if (includePattern != null) {
107 return source.reader().entries().stream()
108 .map(name -> name.replace('/', '.'))
109 .filter(name -> !name.equals("module-info.class"))
110 .anyMatch(this::matches);
111 }
112 return hasTargetFilter();
113 }
114
115 public boolean include(Archive source) {
116 Module module = source.getModule();
117 // skip system module by default; or if includeSystemModules is set
118 // only include the ones matching the pattern
119 return !module.isSystem() || (includeSystemModules != null &&
120 includeSystemModules.matcher(module.name()).matches());
121 }
122
123 public boolean hasIncludePattern() {
124 return includePattern != null || includeSystemModules != null;
125 }
126
127 public boolean hasTargetFilter() {
128 return filter != null;
129 }
130
131 public Set<String> requiresFilter() {
132 return requires;
133 }
134
135 // ----- Dependency.Filter -----
136
137 @Override
138 public boolean accepts(Dependency d) {
139 if (d.getOrigin().equals(d.getTarget()))
140 return false;
141
142 // filter same package dependency
143 String pn = d.getTarget().getPackageName();
144 if (filterSamePackage && d.getOrigin().getPackageName().equals(pn)) {
145 return false;
146 }
147
148 // filter if the target package matches the given filter
149 if (filterPattern != null && filterPattern.matcher(pn).matches()) {
150 return false;
151 }
152
153 // filter if the target matches the given filtered package name or regex
154 return filter != null ? filter.accepts(d) : true;
155 }
156
157 // ----- Analyzer.Filter ------
158
159 /**
160 * Filter depending on the containing archive or module
161 */
162 @Override
163 public boolean accepts(Location origin, Archive originArchive,
164 Location target, Archive targetArchive) {
165 if (findJDKInternals) {
166 // accepts target that is JDK class but not exported
167 Module module = targetArchive.getModule();
168 return originArchive != targetArchive &&
169 module.isJDK() && !module.isExported(target.getPackageName());
170 } else if (filterSameArchive) {
171 // accepts origin and target that from different archive
172 return originArchive != targetArchive;
173 }
174 return true;
175 }
176
177 @Override
178 public String toString() {
179 StringBuilder sb = new StringBuilder();
180 sb.append("include pattern: ").append(includePattern).append("\n");
181 sb.append("filter same archive: ").append(filterSameArchive).append("\n");
182 sb.append("filter same package: ").append(filterSamePackage).append("\n");
183 sb.append("requires: ").append(requires).append("\n");
184 return sb.toString();
185 }
186
187 public static class Builder {
188 static Pattern SYSTEM_MODULE_PATTERN = Pattern.compile("java\\..*|jdk\\..*|javafx\\..*");
189 Pattern filterPattern;
190 Pattern regex;
191 boolean filterSamePackage;
192 boolean filterSameArchive;
193 boolean findJDKInterals;
194 // source filters
195 Pattern includePattern;
196 Pattern includeSystemModules;
197 Set<String> requires = new HashSet<>();
198 Set<String> targetPackages = new HashSet<>();
199
200 public Builder packages(Set<String> packageNames) {
201 this.targetPackages.addAll(packageNames);
202 return this;
203 }
204 public Builder regex(Pattern regex) {
205 this.regex = regex;
206 return this;
207 }
208 public Builder filter(Pattern regex) {
209 this.filterPattern = regex;
210 return this;
211 }
212 public Builder filter(boolean samePackage, boolean sameArchive) {
213 this.filterSamePackage = samePackage;
214 this.filterSameArchive = sameArchive;
215 return this;
216 }
217 public Builder requires(String name, Set<String> packageNames) {
218 this.requires.add(name);
219 this.targetPackages.addAll(packageNames);
220
221 includeIfSystemModule(name);
222 return this;
223 }
224 public Builder findJDKInternals(boolean value) {
225 this.findJDKInterals = value;
226 return this;
227 }
228 public Builder includePattern(Pattern regex) {
229 this.includePattern = regex;
230 return this;
231 }
232 public Builder includeSystemModules(Pattern regex) {
233 this.includeSystemModules = regex;
234 return this;
235 }
236 public Builder includeIfSystemModule(String name) {
237 if (includeSystemModules == null &&
238 SYSTEM_MODULE_PATTERN.matcher(name).matches()) {
239 this.includeSystemModules = SYSTEM_MODULE_PATTERN;
240 }
241 return this;
242 }
243
244 public JdepsFilter build() {
245 Dependency.Filter filter = null;
246 if (regex != null)
247 filter = Dependencies.getRegexFilter(regex);
248 else if (!targetPackages.isEmpty()) {
249 filter = Dependencies.getPackageFilter(targetPackages, false);
250 }
251 return new JdepsFilter(filter,
252 filterPattern,
253 filterSamePackage,
254 filterSameArchive,
255 findJDKInterals,
256 includePattern,
257 includeSystemModules,
258 requires);
259 }
260
261 }
262 }