1 /*
2 * Copyright (c) 2015, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package com.sun.tools.jextract;
24
25 import jdk.internal.joptsimple.OptionException;
26 import jdk.internal.joptsimple.OptionParser;
27 import jdk.internal.joptsimple.OptionSet;
28 import jdk.internal.joptsimple.util.KeyValuePair;
29
30 import java.io.File;
31 import java.io.IOException;
32 import java.io.PrintWriter;
33 import java.nio.file.Files;
34 import java.nio.file.Path;
35 import java.nio.file.Paths;
36 import java.text.MessageFormat;
37 import java.util.List;
38 import java.util.Locale;
39 import java.util.ResourceBundle;
40 import java.util.logging.ConsoleHandler;
41 import java.util.logging.Level;
42 import java.util.logging.Logger;
43 import java.util.logging.SimpleFormatter;
44 import java.util.regex.PatternSyntaxException;
45 import java.util.spi.ToolProvider;
46
47 public final class Main {
48 public static final boolean DEBUG = Boolean.getBoolean("jextract.debug");
49
50 // FIXME: Remove this if/when the macros support is deemed stable
51 public static boolean INCLUDE_MACROS = Boolean.parseBoolean(System.getProperty("jextract.INCLUDE_MACROS", "true"));
52
53 private static final String MESSAGES_RESOURCE = "com.sun.tools.jextract.resources.Messages";
54
55 private static final ResourceBundle MESSAGES_BUNDLE;
56 static {
57 MESSAGES_BUNDLE = ResourceBundle.getBundle(MESSAGES_RESOURCE, Locale.getDefault());
58 }
59
60 public static String format(String msgId, Object... args) {
61 return new MessageFormat(MESSAGES_BUNDLE.getString(msgId)).format(args);
62 }
63
64 private final Context ctx;
65 private String targetPackage;
66
67 public Main(Context ctx) {
68 this.ctx = ctx;
69 }
70
71 private void processPackageMapping(Object arg) {
72 String str = (String) arg;
73 Path p = null;
74 String pkgName;
75 if (str.indexOf('=') == -1) {
76 pkgName = str;
77 } else {
78 KeyValuePair kv = KeyValuePair.valueOf(str);
79 p = Paths.get(kv.key);
80 pkgName = kv.value;
81
82 if (!Files.isDirectory(p)) {
83 throw new IllegalArgumentException(format("not.a.directory", kv.key));
84 }
85 }
86
87 Utils.validPackageName(pkgName);
88 ctx.usePackageForFolder(p, pkgName);
89 }
90
91 private void processHeader(Object header) {
92 Path p = Paths.get((String) header);
93 if (!Files.isReadable(p)) {
94 throw new IllegalArgumentException(format("cannot.read.header.file", header));
95 }
96 p = p.toAbsolutePath();
97 ctx.usePackageForFolder(p.getParent(), targetPackage);
98 ctx.addSource(p);
99 }
100
101 private void setupLogging(Level level) {
102 Logger logger = ctx.logger;
103 logger.setUseParentHandlers(false);
104 ConsoleHandler log = new ConsoleHandler();
105 System.setProperty("java.util.logging.SimpleFormatter.format", "%4$s: %5$s%n");
106 log.setFormatter(new SimpleFormatter());
107 logger.setLevel(level);
108 log.setLevel(level);
109 logger.addHandler(log);
110 }
111
112 private void printHelp(OptionParser parser) {
113 try {
114 parser.printHelpOn(ctx.err);
115 } catch (IOException ex) {
116 if (Main.DEBUG) {
117 ex.printStackTrace(ctx.err);
118 }
119 }
120 }
121
122 public int run(String[] args) {
123 OptionParser parser = new OptionParser();
124 parser.accepts("dry-run", format("help.dry_run"));
125 parser.accepts("I", format("help.I")).withRequiredArg();
126 // option is expected to specify paths to load shared libraries
127 // to check & warn missing symbols during jextract session.
128 parser.accepts("L", format("help.L")).withRequiredArg();
129 parser.accepts("l", format("help.l")).withRequiredArg();
130 parser.accepts("d", format("help.d")).withRequiredArg();
131 parser.acceptsAll(List.of("o", "jar"), format("help.o")).withRequiredArg();
132 parser.acceptsAll(List.of("t", "target-package"), format("help.t")).withRequiredArg();
133 parser.acceptsAll(List.of("m", "package-map"), format("help.m")).withRequiredArg();
134 parser.acceptsAll(List.of("?", "h", "help"), format("help.h")).forHelp();
135 parser.accepts("C", format("help.C")).withRequiredArg();
136 parser.accepts("include-symbols", format("help.include_symbols")).withRequiredArg();
137 parser.accepts("log", format("help.log")).withRequiredArg();
138 parser.accepts("exclude-symbols", format("help.exclude_symbols")).withRequiredArg();
139 parser.accepts("rpath", format("help.rpath")).withRequiredArg();
140 parser.accepts("infer-rpath", format("help.infer.rpath"));
141 parser.accepts("static-forwarder", format("help.static.forwarder")).
142 withRequiredArg().ofType(boolean.class);
143 parser.nonOptions(format("help.non.option"));
144
145 OptionSet options = null;
146 try {
147 options = parser.parse(args);
148 } catch (OptionException oe) {
149 ctx.err.println(oe.getMessage());
150 if (Main.DEBUG) {
151 oe.printStackTrace(ctx.err);
152 }
153 printHelp(parser);
154 return 1;
155 }
156
157 if (args.length == 0 || options.has("h")) {
158 printHelp(parser);
159 return args.length == 0? 1 : 0;
160 }
161
162 if (options.nonOptionArguments().isEmpty()) {
163 ctx.err.println(format("err.no.input.files"));
164 return 2;
165 }
166
167 if (options.has("log")) {
168 setupLogging(Level.parse((String) options.valueOf("log")));
169 } else {
170 setupLogging(Level.WARNING);
171 }
172
173 if (options.has("I")) {
174 options.valuesOf("I").forEach(p -> ctx.addClangArg("-I" + p));
175 }
176
177 // append the built-in headers directory
178 ctx.addClangArg("-I" + getBuiltinHeadersDir());
179
180 if (options.has("C")) {
181 options.valuesOf("C").forEach(p -> ctx.addClangArg((String) p));
182 }
183
184 if (options.has("l")) {
185 for (Object arg : options.valuesOf("l")) {
186 String lib = (String)arg;
187 if (lib.indexOf(File.separatorChar) != -1) {
188 ctx.err.println(format("l.name.should.not.be.path", lib));
189 return 1;
190 }
191 ctx.addLibraryName(lib);
192 }
193 }
194
195 boolean infer_rpath = options.has("infer-rpath");
196 if (options.has("rpath")) {
197 if (infer_rpath) {
198 //conflicting rpaths options
199 ctx.err.println(format("warn.rpath.auto.conflict"));
200 infer_rpath = false;
201 }
202
203 // "rpath" with no "l" option!
204 if (options.has("l")) {
205 options.valuesOf("rpath").forEach(p -> ctx.addLibraryPath((String) p));
206 } else {
207 ctx.err.println(format("warn.rpath.without.l"));
208 }
209 }
210
211 // generate static forwarder class if user specified -l option
212 boolean staticForwarder = true;
213 if (options.has("static-forwarder")) {
214 staticForwarder = (boolean)options.valueOf("static-forwarder");
215 }
216 ctx.setGenStaticForwarder(staticForwarder && options.has("l"));
217
218 if (options.has("include-symbols")) {
219 try {
220 options.valuesOf("include-symbols").forEach(sym -> ctx.addIncludeSymbols((String) sym));
221 } catch (PatternSyntaxException pse) {
222 ctx.err.println(format("include.symbols.pattern.error", pse.getMessage()));
223 }
224 }
225
226 if (options.has("exclude-symbols")) {
227 try {
228 options.valuesOf("exclude-symbols").forEach(sym -> ctx.addExcludeSymbols((String) sym));
229 } catch (PatternSyntaxException pse) {
230 ctx.err.println(format("exclude.symbols.pattern.error", pse.getMessage()));
231 }
232 }
233
234 if (options.has("L")) {
235 List<?> libpaths = options.valuesOf("L");
236 // "L" with no "l" option!
237 if (options.has("l")) {
238 libpaths.forEach(p -> ctx.addLinkCheckPath((String) p));
239 if (infer_rpath) {
240 libpaths.forEach(p -> ctx.addLibraryPath((String) p));
241 }
242 } else {
243 ctx.err.println(format("warn.L.without.l"));
244 }
245 } else if (infer_rpath) {
246 ctx.err.println(format("warn.rpath.auto.without.L"));
247 }
248
249 targetPackage = options.has("t") ? (String) options.valueOf("t") : "";
250 if (!targetPackage.isEmpty()) {
251 Utils.validPackageName(targetPackage);
252 }
253
254 if (options.has("m")) {
255 options.valuesOf("m").forEach(this::processPackageMapping);
256 }
257
258 try {
259 options.nonOptionArguments().stream().forEach(this::processHeader);
260 ctx.parse();
261 } catch (RuntimeException re) {
262 ctx.err.println(re.getMessage());
263 if (Main.DEBUG) {
264 re.printStackTrace(ctx.err);
265 }
266 return 2;
267 }
268
269 if (options.has("dry-run")) {
270 return 0;
271 }
272
273 boolean hasOutput = false;
274
275 if (options.has("d")) {
276 hasOutput = true;
277 Path dest = Paths.get((String) options.valueOf("d"));
278 dest = dest.toAbsolutePath();
279 try {
280 if (!Files.exists(dest)) {
281 Files.createDirectories(dest);
282 } else if (!Files.isDirectory(dest)) {
283 ctx.err.println(format("not.a.directory", dest));
284 return 4;
285 }
286 ctx.collectClassFiles(dest, args, targetPackage);
287 } catch (IOException ex) {
288 ctx.err.println(format("cannot.write.class.file", dest, ex));
289 if (Main.DEBUG) {
290 ex.printStackTrace(ctx.err);
291 }
292 return 5;
293 }
294 }
295
296 String outputName;
297 if (options.has("o")) {
298 outputName = (String) options.valueOf("o");
299 } else if (hasOutput) {
300 return 0;
301 } else {
302 outputName = Paths.get((String)options.nonOptionArguments().get(0)).getFileName() + ".jar";
303 }
304
305 try {
306 ctx.collectJarFile(Paths.get(outputName), args, targetPackage);
307 } catch (IOException ex) {
308 ctx.err.println(format("cannot.write.jar.file", outputName, ex));
309 if (Main.DEBUG) {
310 ex.printStackTrace(ctx.err);
311 }
312 return 3;
313 }
314
315 return 0;
316 }
317
318 private static Path getBuiltinHeadersDir() {
319 return Paths.get(System.getProperty("java.home"), "conf", "jextract");
320 }
321
322 public static void main(String... args) {
323 Main instance = new Main(new Context());
324
325 System.exit(instance.run(args));
326 }
327
328 public static class JextractToolProvider implements ToolProvider {
329 @Override
330 public String name() {
331 return "jextract";
332 }
333
334 @Override
335 public int run(PrintWriter out, PrintWriter err, String... args) {
336 // defensive check to throw security exception early.
337 // Note that the successful run of jextract under security
338 // manager would require far more permissions like loading
339 // library (clang), file system access etc.
340 if (System.getSecurityManager() != null) {
341 System.getSecurityManager().
342 checkPermission(new RuntimePermission("jextract"));
343 }
344
345 Main instance = new Main(new Context(out, err));
346 return instance.run(args);
347 }
348 }
349 }