1 /*
2 * Copyright (C) 2015, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "options.h"
18 #include "logging.h"
19 #include "os.h"
20
21 #include <getopt.h>
22 #include <stdlib.h>
23 #include <unistd.h>
24 #include <algorithm>
25 #include <iostream>
26 #include <sstream>
27 #include <string>
28
29 #include <android-base/strings.h>
30 #include "aidl_language.h"
31
32 using android::base::Split;
33 using android::base::Trim;
34 using std::endl;
35 using std::string;
36
37 #ifndef PLATFORM_SDK_VERSION
38 #define PLATFORM_SDK_VERSION "<UNKNOWN>"
39 #endif
40
41 namespace android {
42 namespace aidl {
43
GetUsage() const44 string Options::GetUsage() const {
45 std::ostringstream sstr;
46 sstr << "AIDL Compiler: built for platform SDK version " << PLATFORM_SDK_VERSION << endl;
47 sstr << "usage:" << endl
48 << myname_ << " --lang={java|cpp|ndk|rust} [OPTION]... INPUT..." << endl
49 << " Generate Java, C++ or Rust files for AIDL file(s)." << endl
50 << endl
51 << myname_ << " --preprocess OUTPUT INPUT..." << endl
52 << " Create an AIDL file having declarations of AIDL file(s)." << endl
53 << endl
54 #ifndef _WIN32
55 << myname_ << " --dumpapi --out=DIR INPUT..." << endl
56 << " Dump API signature of AIDL file(s) to DIR." << endl
57 << endl
58 << myname_ << " --checkapi[={compatible|equal}] OLD_DIR NEW_DIR" << endl
59 << " Check whether NEW_DIR API dump is {compatible|equal} extension " << endl
60 << " of the API dump OLD_DIR. Default: compatible" << endl
61 #endif
62 << endl;
63
64 // Legacy option formats
65 if (language_ == Options::Language::JAVA) {
66 sstr << myname_ << " [OPTION]... INPUT [OUTPUT]" << endl
67 << " Generate a Java file for an AIDL file." << endl
68 << endl;
69 } else if (language_ == Options::Language::CPP) {
70 sstr << myname_ << " [OPTION]... INPUT HEADER_DIR OUTPUT" << endl
71 << " Generate C++ headers and source for an AIDL file." << endl
72 << endl;
73 } else if (language_ == Options::Language::RUST) {
74 sstr << myname_ << " [OPTION]... INPUT [OUTPUT]" << endl
75 << " Generate Rust file for an AIDL file." << endl
76 << endl;
77 }
78
79 sstr << "OPTION:" << endl
80 << " -I DIR, --include=DIR" << endl
81 << " Use DIR as a search path for import statements." << endl
82 << " -m FILE, --import=FILE" << endl
83 << " Import FILE directly without searching in the search paths." << endl
84 << " -p FILE, --preprocessed=FILE" << endl
85 << " Include FILE which is created by --preprocess." << endl
86 << " -d FILE, --dep=FILE" << endl
87 << " Generate dependency file as FILE. Don't use this when" << endl
88 << " there are multiple input files. Use -a then." << endl
89 << " -o DIR, --out=DIR" << endl
90 << " Use DIR as the base output directory for generated files." << endl
91 << " -h DIR, --header_out=DIR" << endl
92 << " Generate C++ headers under DIR." << endl
93 << " -a" << endl
94 << " Generate dependency file next to the output file with the" << endl
95 << " name based on the input file." << endl
96 << " -b" << endl
97 << " Trigger fail when trying to compile a parcelable." << endl
98 << " --ninja" << endl
99 << " Generate dependency file in a format ninja understands." << endl
100 << " --structured" << endl
101 << " Whether this interface is defined exclusively in AIDL." << endl
102 << " It is therefore a candidate for stabilization." << endl
103 << " --stability=<level>" << endl
104 << " The stability requirement of this interface." << endl
105 << " -t, --trace" << endl
106 << " Include tracing code for systrace. Note that if either" << endl
107 << " the client or service code is not auto-generated by this" << endl
108 << " tool, that part will not be traced." << endl
109 << " --transaction_names" << endl
110 << " Generate transaction names." << endl
111 << " --apimapping" << endl
112 << " Generates a mapping of declared aidl method signatures to" << endl
113 << " the original line number. e.g.: " << endl
114 << " If line 39 of foo/bar/IFoo.aidl contains:"
115 << " void doFoo(int bar, String baz);" << endl
116 << " Then the result would be:" << endl
117 << " foo.bar.Baz|doFoo|int,String,|void" << endl
118 << " foo/bar/IFoo.aidl:39" << endl
119 << " -v VER, --version=VER" << endl
120 << " Set the version of the interface and parcelable to VER." << endl
121 << " VER must be an interger greater than 0." << endl
122 << " --hash=HASH" << endl
123 << " Set the interface hash to HASH." << endl
124 << " --log" << endl
125 << " Information about the transaction, e.g., method name, argument" << endl
126 << " values, execution time, etc., is provided via callback." << endl
127 << " -Werror" << endl
128 << " Turn warnings into errors." << endl
129 << " -Wno-error=<warning>" << endl
130 << " Turn the specified warning into a warning even if -Werror is specified."
131 << endl
132 << " -W<warning>" << endl
133 << " Enable the specified warning." << endl
134 << " -Wno-<warning>" << endl
135 << " Disable the specified warning." << endl
136 << " -w" << endl
137 << " Disable all diagnostics. -w wins -Weverything" << endl
138 << " -Weverything" << endl
139 << " Enable all diagnostics." << endl
140 << " --help" << endl
141 << " Show this help." << endl
142 << endl
143 << "INPUT:" << endl
144 << " An AIDL file." << endl
145 << endl
146 << "OUTPUT:" << endl
147 << " Path to the generated Java or C++ source file. This is ignored when" << endl
148 << " -o or --out is specified or the number of the input files are" << endl
149 << " more than one." << endl
150 << " For Java, if omitted, Java source file is generated at the same" << endl
151 << " place as the input AIDL file," << endl
152 << endl
153 << "HEADER_DIR:" << endl
154 << " Path to where C++ headers are generated." << endl;
155 return sstr.str();
156 }
157
to_string(Options::Language language)158 string to_string(Options::Language language) {
159 switch (language) {
160 case Options::Language::CPP:
161 return "cpp";
162 case Options::Language::JAVA:
163 return "java";
164 case Options::Language::NDK:
165 return "ndk";
166 case Options::Language::RUST:
167 return "rust";
168 case Options::Language::UNSPECIFIED:
169 return "unspecified";
170 default:
171 AIDL_FATAL(AIDL_LOCATION_HERE)
172 << "Unexpected Options::Language enumerator: " << static_cast<size_t>(language);
173 }
174 }
175
StabilityFromString(const std::string & stability,Stability * out_stability)176 bool Options::StabilityFromString(const std::string& stability, Stability* out_stability) {
177 if (stability == "vintf") {
178 *out_stability = Stability::VINTF;
179 return true;
180 }
181 return false;
182 }
183
From(const string & cmdline)184 Options Options::From(const string& cmdline) {
185 vector<string> args = Split(cmdline, " ");
186 return From(args);
187 }
188
From(const vector<string> & args)189 Options Options::From(const vector<string>& args) {
190 Options::Language lang = Options::Language::JAVA;
191 int argc = args.size();
192 if (argc >= 1 && args.at(0) == "aidl-cpp") {
193 lang = Options::Language::CPP;
194 }
195 const char* argv[argc + 1];
196 for (int i = 0; i < argc; i++) {
197 argv[i] = args.at(i).c_str();
198 }
199 argv[argc] = nullptr;
200
201 return Options(argc, argv, lang);
202 }
203
Options(int argc,const char * const raw_argv[],Options::Language default_lang)204 Options::Options(int argc, const char* const raw_argv[], Options::Language default_lang)
205 : myname_(raw_argv[0]), language_(default_lang) {
206 std::vector<const char*> argv = warning_options_.Parse(argc, raw_argv, error_message_);
207 if (!Ok()) return;
208 argc = argv.size();
209
210 bool lang_option_found = false;
211 optind = 0;
212 while (true) {
213 static struct option long_options[] = {
214 {"lang", required_argument, 0, 'l'},
215 {"preprocess", no_argument, 0, 's'},
216 #ifndef _WIN32
217 {"dumpapi", no_argument, 0, 'u'},
218 {"no_license", no_argument, 0, 'x'},
219 {"checkapi", optional_argument, 0, 'A'},
220 #endif
221 {"apimapping", required_argument, 0, 'i'},
222 {"include", required_argument, 0, 'I'},
223 {"import", required_argument, 0, 'm'},
224 {"preprocessed", required_argument, 0, 'p'},
225 {"dep", required_argument, 0, 'd'},
226 {"out", required_argument, 0, 'o'},
227 {"header_out", required_argument, 0, 'h'},
228 {"ninja", no_argument, 0, 'n'},
229 {"stability", required_argument, 0, 'Y'},
230 {"structured", no_argument, 0, 'S'},
231 {"trace", no_argument, 0, 't'},
232 {"transaction_names", no_argument, 0, 'c'},
233 {"version", required_argument, 0, 'v'},
234 {"log", no_argument, 0, 'L'},
235 {"hash", required_argument, 0, 'H'},
236 {"help", no_argument, 0, 'e'},
237 {0, 0, 0, 0},
238 };
239 const int c = getopt_long(argc, const_cast<char* const*>(argv.data()),
240 "I:m:p:d:o:h:abtv:", long_options, nullptr);
241 if (c == -1) {
242 // no more options
243 break;
244 }
245 switch (c) {
246 case 'l':
247 if (language_ == Options::Language::CPP) {
248 // aidl-cpp can't set language. aidl-cpp exists only for backwards
249 // compatibility.
250 error_message_ << "aidl-cpp does not support --lang." << endl;
251 return;
252 } else {
253 lang_option_found = true;
254 string lang = Trim(optarg);
255 if (lang == "java") {
256 language_ = Options::Language::JAVA;
257 task_ = Options::Task::COMPILE;
258 } else if (lang == "cpp") {
259 language_ = Options::Language::CPP;
260 task_ = Options::Task::COMPILE;
261 } else if (lang == "ndk") {
262 language_ = Options::Language::NDK;
263 task_ = Options::Task::COMPILE;
264 } else if (lang == "rust") {
265 language_ = Options::Language::RUST;
266 task_ = Options::Task::COMPILE;
267 } else {
268 error_message_ << "Unsupported language: '" << lang << "'" << endl;
269 return;
270 }
271 }
272 break;
273 case 's':
274 if (task_ != Options::Task::UNSPECIFIED) {
275 task_ = Options::Task::PREPROCESS;
276 }
277 break;
278 #ifndef _WIN32
279 case 'u':
280 if (task_ != Options::Task::UNSPECIFIED) {
281 task_ = Options::Task::DUMP_API;
282 }
283 break;
284 case 'x':
285 dump_no_license_ = true;
286 break;
287 case 'A':
288 if (task_ != Options::Task::UNSPECIFIED) {
289 task_ = Options::Task::CHECK_API;
290 // to ensure that all parcelables in the api dumpes are structured
291 structured_ = true;
292 if (optarg) {
293 if (strcmp(optarg, "compatible") == 0)
294 check_api_level_ = CheckApiLevel::COMPATIBLE;
295 else if (strcmp(optarg, "equal") == 0)
296 check_api_level_ = CheckApiLevel::EQUAL;
297 else {
298 error_message_ << "Unsupported --checkapi level: '" << optarg << "'" << endl;
299 return;
300 }
301 }
302 }
303 break;
304 #endif
305 case 'I': {
306 import_dirs_.emplace(Trim(optarg));
307 break;
308 }
309 case 'm': {
310 import_files_.emplace(Trim(optarg));
311 break;
312 }
313 case 'p':
314 preprocessed_files_.emplace_back(Trim(optarg));
315 break;
316 case 'd':
317 dependency_file_ = Trim(optarg);
318 break;
319 case 'o':
320 output_dir_ = Trim(optarg);
321 if (output_dir_.back() != OS_PATH_SEPARATOR) {
322 output_dir_.push_back(OS_PATH_SEPARATOR);
323 }
324 break;
325 case 'h':
326 output_header_dir_ = Trim(optarg);
327 if (output_header_dir_.back() != OS_PATH_SEPARATOR) {
328 output_header_dir_.push_back(OS_PATH_SEPARATOR);
329 }
330 break;
331 case 'n':
332 dependency_file_ninja_ = true;
333 break;
334 case 'S':
335 structured_ = true;
336 break;
337 case 'Y': {
338 const string stability_str = Trim(optarg);
339 if (!StabilityFromString(stability_str, &stability_)) {
340 error_message_ << "Unrecognized stability level: '" << stability_str
341 << "'. Must be vintf." << endl;
342 return;
343 }
344 break;
345 }
346 case 't':
347 gen_traces_ = true;
348 break;
349 case 'a':
350 auto_dep_file_ = true;
351 break;
352 case 'b':
353 fail_on_parcelable_ = true;
354 break;
355 case 'c':
356 gen_transaction_names_ = true;
357 break;
358 case 'v': {
359 const string ver_str = Trim(optarg);
360 int ver = atoi(ver_str.c_str());
361 if (ver > 0) {
362 version_ = ver;
363 } else {
364 error_message_ << "Invalid version number: '" << ver_str << "'. "
365 << "Version must be a positive natural number." << endl;
366 return;
367 }
368 break;
369 }
370 case 'H':
371 hash_ = Trim(optarg);
372 break;
373 case 'L':
374 gen_log_ = true;
375 break;
376 case 'e':
377 std::cerr << GetUsage();
378 exit(0);
379 case 'i':
380 output_file_ = Trim(optarg);
381 task_ = Task::DUMP_MAPPINGS;
382 break;
383 default:
384 std::cerr << GetUsage();
385 exit(1);
386 }
387 } // while
388
389 // Positional arguments
390 if (!lang_option_found && task_ == Options::Task::COMPILE) {
391 // the legacy arguments format
392 if (argc - optind <= 0) {
393 error_message_ << "No input file" << endl;
394 return;
395 }
396 if (language_ == Options::Language::JAVA || language_ == Options::Language::RUST) {
397 input_files_.emplace_back(argv[optind++]);
398 if (argc - optind >= 1) {
399 output_file_ = argv[optind++];
400 } else if (output_dir_.empty()) {
401 // when output is omitted and -o option isn't set, the output is by
402 // default set to the input file path with .aidl is replaced to .java.
403 // If -o option is set, the output path is calculated by
404 // GetOutputFilePath which returns "<output_dir>/<package/name>/
405 // <typename>.java"
406 output_file_ = input_files_.front();
407 if (android::base::EndsWith(output_file_, ".aidl")) {
408 output_file_ = output_file_.substr(0, output_file_.length() - strlen(".aidl"));
409 }
410 output_file_ += (language_ == Options::Language::JAVA) ? ".java" : ".rs";
411 }
412 } else if (IsCppOutput()) {
413 input_files_.emplace_back(argv[optind++]);
414 if (argc - optind < 2) {
415 error_message_ << "No HEADER_DIR or OUTPUT." << endl;
416 return;
417 }
418 output_header_dir_ = argv[optind++];
419 if (output_header_dir_.back() != OS_PATH_SEPARATOR) {
420 output_header_dir_.push_back(OS_PATH_SEPARATOR);
421 }
422 output_file_ = argv[optind++];
423 }
424 if (argc - optind > 0) {
425 error_message_ << "Too many arguments: ";
426 for (int i = optind; i < argc; i++) {
427 error_message_ << " " << argv[i];
428 }
429 error_message_ << endl;
430 }
431 } else {
432 // the new arguments format
433 if (task_ == Options::Task::COMPILE || task_ == Options::Task::DUMP_API) {
434 if (argc - optind < 1) {
435 error_message_ << "No input file." << endl;
436 return;
437 }
438 } else {
439 if (argc - optind < 2) {
440 error_message_ << "Insufficient arguments. At least 2 required, but "
441 << "got " << (argc - optind) << "." << endl;
442 return;
443 }
444 if (task_ != Options::Task::CHECK_API && task_ != Options::Task::DUMP_MAPPINGS) {
445 output_file_ = argv[optind++];
446 }
447 }
448 while (optind < argc) {
449 input_files_.emplace_back(argv[optind++]);
450 }
451 }
452
453 // filter out invalid combinations
454 if (lang_option_found) {
455 if (IsCppOutput() && task_ == Options::Task::COMPILE) {
456 if (output_dir_.empty()) {
457 error_message_ << "Output directory is not set. Set with --out." << endl;
458 return;
459 }
460 if (output_header_dir_.empty()) {
461 error_message_ << "Header output directory is not set. Set with "
462 << "--header_out." << endl;
463 return;
464 }
465 }
466 if (language_ == Options::Language::JAVA && task_ == Options::Task::COMPILE) {
467 if (output_dir_.empty()) {
468 error_message_ << "Output directory is not set. Set with --out." << endl;
469 return;
470 }
471 if (!output_header_dir_.empty()) {
472 error_message_ << "Header output directory is set, which does not make "
473 << "sense for Java." << endl;
474 return;
475 }
476 }
477 if (language_ == Options::Language::RUST && task_ == Options::Task::COMPILE) {
478 if (output_dir_.empty()) {
479 error_message_ << "Output directory is not set. Set with --out." << endl;
480 return;
481 }
482 if (!output_header_dir_.empty()) {
483 error_message_ << "Header output directory is set, which does not make "
484 << "sense for Rust." << endl;
485 return;
486 }
487 }
488 }
489 if (task_ == Options::Task::COMPILE) {
490 for (const string& input : input_files_) {
491 if (!android::base::EndsWith(input, ".aidl")) {
492 error_message_ << "Expected .aidl file for input but got '" << input << "'" << endl;
493 return;
494 }
495 }
496 if (!output_file_.empty() && input_files_.size() > 1) {
497 error_message_ << "Multiple AIDL files can't be compiled to a single "
498 << "output file '" << output_file_ << "'. "
499 << "Use --out=DIR instead for output files." << endl;
500 return;
501 }
502 if (!dependency_file_.empty() && input_files_.size() > 1) {
503 error_message_ << "-d or --dep doesn't work when compiling multiple AIDL "
504 << "files. Use '-a' to generate dependency file next to "
505 << "the output file with the name based on the input "
506 << "file." << endl;
507 return;
508 }
509 if (gen_log_ && (language_ != Options::Language::CPP && language_ != Options::Language::NDK)) {
510 error_message_ << "--log is currently supported for either --lang=cpp or --lang=ndk" << endl;
511 return;
512 }
513 }
514 if (task_ == Options::Task::PREPROCESS) {
515 if (version_ > 0) {
516 error_message_ << "--version should not be used with '--preprocess'." << endl;
517 return;
518 }
519 }
520 if (task_ == Options::Task::CHECK_API) {
521 if (input_files_.size() != 2) {
522 error_message_ << "--checkapi requires two inputs for comparing, "
523 << "but got " << input_files_.size() << "." << endl;
524 return;
525 }
526 }
527 if (task_ == Options::Task::DUMP_API) {
528 if (output_dir_.empty()) {
529 error_message_ << "--dumpapi requires output directory. Use --out." << endl;
530 return;
531 }
532 }
533
534 AIDL_FATAL_IF(!output_dir_.empty() && output_dir_.back() != OS_PATH_SEPARATOR, output_dir_);
535 AIDL_FATAL_IF(!output_header_dir_.empty() && output_header_dir_.back() != OS_PATH_SEPARATOR,
536 output_header_dir_);
537 }
538
Parse(int argc,const char * const raw_argv[],ErrorMessage & error_message)539 std::vector<const char*> WarningOptions::Parse(int argc, const char* const raw_argv[],
540 ErrorMessage& error_message) {
541 std::vector<const char*> remains;
542 for (int i = 0; i < argc; i++) {
543 auto arg = raw_argv[i];
544 if (strcmp(arg, "-Weverything") == 0) {
545 enable_all_ = true;
546 } else if (strcmp(arg, "-Werror") == 0) {
547 as_errors_ = true;
548 } else if (strcmp(arg, "-w") == 0) {
549 disable_all_ = true;
550 } else if (base::StartsWith(arg, "-Wno-error=")) {
551 no_errors_.insert(arg + strlen("-Wno-error="));
552 } else if (base::StartsWith(arg, "-Wno-")) {
553 disabled_.insert(arg + strlen("-Wno-"));
554 } else if (base::StartsWith(arg, "-W")) {
555 enabled_.insert(arg + strlen("-W"));
556 } else {
557 remains.push_back(arg);
558 }
559 }
560
561 for (const auto& names : {no_errors_, disabled_, enabled_}) {
562 for (const auto& name : names) {
563 if (kAllDiagnostics.count(name) == 0) {
564 error_message << "unknown warning: " << name << "\n";
565 return {};
566 }
567 }
568 }
569
570 return remains;
571 }
572
GetDiagnosticMapping() const573 DiagnosticMapping WarningOptions::GetDiagnosticMapping() const {
574 DiagnosticMapping mapping;
575 for (const auto& [_, d] : kAllDiagnostics) {
576 bool enabled = d.default_enabled;
577 if (enable_all_ || enabled_.find(d.name) != enabled_.end()) {
578 enabled = true;
579 }
580 if (disable_all_ || disabled_.find(d.name) != disabled_.end()) {
581 enabled = false;
582 }
583
584 DiagnosticSeverity severity = DiagnosticSeverity::DISABLED;
585 if (enabled) {
586 severity = DiagnosticSeverity::WARNING;
587 if (as_errors_ && no_errors_.find(d.name) == no_errors_.end()) {
588 severity = DiagnosticSeverity::ERROR;
589 }
590 }
591 mapping.Severity(d.id, severity);
592 }
593 return mapping;
594 }
595
596 } // namespace aidl
597 } // namespace android
598