1 /*
2 * Copyright (c) 2015, 2017, 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.jar;
27
28 import java.io.File;
29 import java.io.PrintStream;
30 import java.io.PrintWriter;
31 import java.lang.module.ModuleFinder;
32 import java.lang.module.ModuleDescriptor.Version;
33 import java.nio.file.Path;
34 import java.nio.file.Paths;
35 import java.util.regex.Pattern;
36 import java.util.regex.PatternSyntaxException;
37
38 import jdk.internal.module.ModulePath;
39 import jdk.internal.module.ModuleResolution;
40
41 /**
42 * Parser for GNU Style Options.
43 */
44 class GNUStyleOptions {
45
46 static class BadArgs extends Exception {
47 static final long serialVersionUID = 0L;
48
49 boolean showUsage;
50
51 BadArgs(String key, String arg) { super(Main.formatMsg(key, arg)); }
52 BadArgs(String key) { super(Main.getMsg(key)); }
53
54 BadArgs showUsage(boolean b) {
55 showUsage = b;
56 return this;
57 }
58 }
59
60 static Option[] recognizedOptions = {
61 // Main operations
62 new Option(false, OptionType.MAIN_OPERATION, "--create", "-c") {
63 void process(Main tool, String opt, String arg) throws BadArgs {
64 if (tool.iflag || tool.tflag || tool.uflag || tool.xflag || tool.dflag)
65 throw new BadArgs("error.multiple.main.operations").showUsage(true);
66 tool.cflag = true;
67 }
68 },
69 new Option(true, OptionType.MAIN_OPERATION, "--generate-index", "-i") {
70 void process(Main tool, String opt, String arg) throws BadArgs {
71 if (tool.cflag || tool.tflag || tool.uflag || tool.xflag || tool.dflag)
72 throw new BadArgs("error.multiple.main.operations").showUsage(true);
73 tool.iflag = true;
74 tool.rootjar = arg;
75 }
76 },
77 new Option(false, OptionType.MAIN_OPERATION, "--list", "-t") {
78 void process(Main tool, String opt, String arg) throws BadArgs {
79 if (tool.cflag || tool.iflag || tool.uflag || tool.xflag || tool.dflag)
80 throw new BadArgs("error.multiple.main.operations").showUsage(true);
81 tool.tflag = true;
82 }
83 },
84 new Option(false, OptionType.MAIN_OPERATION, "--update", "-u") {
85 void process(Main tool, String opt, String arg) throws BadArgs {
86 if (tool.cflag || tool.iflag || tool.tflag || tool.xflag || tool.dflag)
87 throw new BadArgs("error.multiple.main.operations").showUsage(true);
88 tool.uflag = true;
89 }
90 },
91 new Option(false, OptionType.MAIN_OPERATION, "--extract", "-x") {
92 void process(Main tool, String opt, String arg) throws BadArgs {
93 if (tool.cflag || tool.iflag || tool.tflag || tool.uflag || tool.dflag)
94 throw new BadArgs("error.multiple.main.operations").showUsage(true);
95 tool.xflag = true;
96 }
97 },
98 new Option(false, OptionType.MAIN_OPERATION, "--print-module-descriptor", "-d") {
99 void process(Main tool, String opt, String arg) throws BadArgs {
100 if (tool.cflag || tool.iflag || tool.tflag || tool.uflag || tool.xflag)
101 throw new BadArgs("error.multiple.main.operations").showUsage(true);
102 tool.dflag = true;
103 }
104 },
105
106 // Additional options
107 new Option(true, OptionType.ANY, "--file", "-f") {
108 void process(Main jartool, String opt, String arg) {
109 jartool.fname = arg;
110 }
111 },
112 new Option(false, OptionType.ANY, "--verbose", "-v") {
113 void process(Main jartool, String opt, String arg) {
114 jartool.vflag = true;
115 }
116 },
117 new Option(false, OptionType.CREATE, "--normalize", "-n") {
118 void process(Main jartool, String opt, String arg) {
119 jartool.nflag = true;
120 }
121 boolean isHidden() { return true; }
122 },
123 new Option(true, OptionType.CREATE_UPDATE, "--main-class", "-e") {
124 void process(Main jartool, String opt, String arg) {
125 jartool.ename = arg;
126 }
127 },
128 new Option(true, OptionType.CREATE_UPDATE, "--manifest", "-m") {
129 void process(Main jartool, String opt, String arg) {
130 jartool.mname = arg;
131 }
132 },
133 new Option(false, OptionType.CREATE_UPDATE, "--no-manifest", "-M") {
134 void process(Main jartool, String opt, String arg) {
135 jartool.Mflag = true;
136 }
137 },
138 new Option(true, OptionType.CREATE_UPDATE, "--module-version") {
139 void process(Main jartool, String opt, String arg) {
140 jartool.moduleVersion = Version.parse(arg);
141 }
142 },
143 new Option(true, OptionType.CREATE_UPDATE, "--hash-modules") {
144 void process(Main jartool, String opt, String arg) throws BadArgs {
145 try {
146 jartool.modulesToHash = Pattern.compile(arg);
147 } catch (PatternSyntaxException e) {
148 throw new BadArgs("err.badpattern", arg).showUsage(true);
149 }
150 }
151 },
152 new Option(true, OptionType.CREATE_UPDATE, "--module-path", "-p") {
153 void process(Main jartool, String opt, String arg) {
154 String[] dirs = arg.split(File.pathSeparator);
155 Path[] paths = new Path[dirs.length];
156 int i = 0;
157 for (String dir : dirs) {
158 paths[i++] = Paths.get(dir);
159 }
160 jartool.moduleFinder =
161 new ModulePath(Runtime.version(), true, paths);
162 }
163 },
164 new Option(false, OptionType.CREATE_UPDATE, "--do-not-resolve-by-default") {
165 void process(Main jartool, String opt, String arg) {
166 ModuleResolution mres = jartool.moduleResolution;
167 jartool.moduleResolution = mres.withDoNotResolveByDefault();
168 }
169 boolean isExtra() { return true; }
170 },
171 new Option(true, OptionType.CREATE_UPDATE, "--warn-if-resolved") {
172 void process(Main jartool, String opt, String arg) throws BadArgs {
173 ModuleResolution mres = ModuleResolution.empty();
174 if (jartool.moduleResolution.doNotResolveByDefault()) {
175 mres.withDoNotResolveByDefault();
176 }
177 if (arg.equals("deprecated")) {
178 jartool.moduleResolution = mres.withDeprecated();
179 } else if (arg.equals("deprecated-for-removal")) {
180 jartool.moduleResolution = mres.withDeprecatedForRemoval();
181 } else if (arg.equals("incubating")) {
182 jartool.moduleResolution = mres.withIncubating();
183 } else {
184 throw new BadArgs("error.bad.reason", arg);
185 }
186 }
187 boolean isExtra() { return true; }
188 },
189 new Option(false, OptionType.CREATE_UPDATE_INDEX, "--no-compress", "-0") {
190 void process(Main jartool, String opt, String arg) {
191 jartool.flag0 = true;
192 }
193 },
194
195 // Hidden options
196 new Option(false, OptionType.OTHER, "-P") {
197 void process(Main jartool, String opt, String arg) {
198 jartool.pflag = true;
199 }
200 boolean isHidden() { return true; }
201 },
202
203 // Other options
204 new Option(true, true, OptionType.OTHER, "--help", "-h") {
205 void process(Main jartool, String opt, String arg) throws BadArgs {
206 if (jartool.info == null) {
207 if (arg == null) {
208 jartool.info = GNUStyleOptions::printHelp; // Main.Info.HELP;
209 return;
210 }
211 if (!arg.equals("compat"))
212 throw new BadArgs("error.illegal.option", arg).showUsage(true);
213 // jartool.info = Main.Info.COMPAT_HELP;
214 jartool.info = GNUStyleOptions::printCompatHelp;
215 }
216 }
217 },
218 new Option(false, OptionType.OTHER, "--help-extra") {
219 void process(Main jartool, String opt, String arg) throws BadArgs {
220 jartool.info = GNUStyleOptions::printHelpExtra;
221 }
222 },
223 new Option(false, OptionType.OTHER, "--version") {
224 void process(Main jartool, String opt, String arg) {
225 if (jartool.info == null)
226 jartool.info = GNUStyleOptions::printVersion;
227 }
228 }
229 };
230
231 enum OptionType {
232 MAIN_OPERATION("main"),
233 ANY("any"),
234 CREATE("create"),
235 CREATE_UPDATE("create.update"),
236 CREATE_UPDATE_INDEX("create.update.index"),
237 OTHER("other");
238
239 /** Resource lookup section prefix. */
240 final String name;
241
242 OptionType(String name) { this.name = name; }
243 }
244
245 static abstract class Option {
246 final boolean hasArg;
247 final boolean argIsOptional;
248 final String[] aliases;
249 final OptionType type;
250
251 Option(boolean hasArg, OptionType type, String... aliases) {
252 this(hasArg, false, type, aliases);
253 }
254
255 Option(boolean hasArg, boolean argIsOptional, OptionType type, String... aliases) {
256 this.hasArg = hasArg;
257 this.argIsOptional = argIsOptional;
258 this.type = type;
259 this.aliases = aliases;
260 }
261
262 boolean isHidden() { return false; }
263
264 boolean isExtra() { return false; }
265
266 boolean matches(String opt) {
267 for (String a : aliases) {
268 if (a.equals(opt)) {
269 return true;
270 } else if (opt.startsWith("--") && hasArg && opt.startsWith(a + "=")) {
271 return true;
272 } else if (opt.startsWith("--help") && opt.startsWith(a + ":")) {
273 return true;
274 }
275 }
276 return false;
277 }
278
279 abstract void process(Main jartool, String opt, String arg) throws BadArgs;
280 }
281
282 static int parseOptions(Main jartool, String[] args) throws BadArgs {
283 int count = 0;
284 if (args.length == 0) {
285 jartool.info = GNUStyleOptions::printUsageTryHelp; // never be here
286 return 0;
287 }
288
289 // process options
290 for (; count < args.length; count++) {
291 if (args[count].charAt(0) != '-' || args[count].equals("-C") ||
292 args[count].equals("--release"))
293 break;
294
295 String name = args[count];
296 Option option = getOption(name);
297 String param = null;
298 if (option.hasArg) {
299 if (name.startsWith("--help")) { // "special" optional separator
300 if (name.indexOf(':') > 0) {
301 param = name.substring(name.indexOf(':') + 1, name.length());
302 }
303 } else if (name.startsWith("--") && name.indexOf('=') > 0) {
304 param = name.substring(name.indexOf('=') + 1, name.length());
305 } else if (count + 1 < args.length) {
306 param = args[++count];
307 }
308 if (!option.argIsOptional &&
309 (param == null || param.isEmpty() || param.charAt(0) == '-')) {
310 throw new BadArgs("error.missing.arg", name).showUsage(true);
311 }
312 }
313 option.process(jartool, name, param);
314 }
315
316 return count;
317 }
318
319 private static Option getOption(String name) throws BadArgs {
320 for (Option o : recognizedOptions) {
321 if (o.matches(name)) {
322 return o;
323 }
324 }
325 throw new BadArgs("error.unrecognized.option", name).showUsage(true);
326 }
327
328 static void printHelpExtra(PrintWriter out) {
329 printHelp0(out, true);
330 }
331
332 static void printHelp(PrintWriter out) {
333 printHelp0(out, false);
334 }
335
336 private static void printHelp0(PrintWriter out, boolean printExtra) {
337 out.format("%s%n", Main.getMsg("main.help.preopt"));
338 for (OptionType type : OptionType.values()) {
339 boolean typeHeadingWritten = false;
340
341 for (Option o : recognizedOptions) {
342 if (!o.type.equals(type))
343 continue;
344 String name = o.aliases[0].substring(1); // there must always be at least one name
345 name = name.charAt(0) == '-' ? name.substring(1) : name;
346 if (o.isHidden() || name.equals("h")) {
347 continue;
348 }
349 if (o.isExtra() && !printExtra) {
350 continue;
351 }
352 if (!typeHeadingWritten) {
353 out.format("%n%s%n", Main.getMsg("main.help.opt." + type.name));
354 typeHeadingWritten = true;
355 }
356 out.format("%s%n", Main.getMsg("main.help.opt." + type.name + "." + name));
357 }
358 }
359 out.format("%n%s%n%n", Main.getMsg("main.help.postopt"));
360 }
361
362 static void printCompatHelp(PrintWriter out) {
363 out.format("%s%n", Main.getMsg("usage.compat"));
364 }
365
366 static void printUsageTryHelp(PrintWriter out) {
367 out.format("%s%n", Main.getMsg("main.usage.summary.try"));
368 }
369
370 static void printVersion(PrintWriter out) {
371 out.format("%s %s%n", "jar", System.getProperty("java.version"));
372 }
373 }