275 lines
8 KiB
C++
275 lines
8 KiB
C++
/*
|
|
* Copyright (C) 2015, The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "options.h"
|
|
|
|
#include <cstring>
|
|
#include <iostream>
|
|
#include <stdio.h>
|
|
|
|
#include "logging.h"
|
|
#include "os.h"
|
|
|
|
using std::cerr;
|
|
using std::endl;
|
|
using std::string;
|
|
using std::unique_ptr;
|
|
using std::vector;
|
|
|
|
namespace android {
|
|
namespace aidl {
|
|
namespace {
|
|
|
|
unique_ptr<JavaOptions> java_usage() {
|
|
fprintf(stderr,
|
|
"usage: aidl OPTIONS INPUT [OUTPUT]\n"
|
|
" aidl --preprocess OUTPUT INPUT...\n"
|
|
"\n"
|
|
"OPTIONS:\n"
|
|
" -I<DIR> search path for import statements.\n"
|
|
" -d<FILE> generate dependency file.\n"
|
|
" -a generate dependency file next to the output file with "
|
|
"the name based on the input file.\n"
|
|
" -ninja generate dependency file in a format ninja "
|
|
"understands.\n"
|
|
" -p<FILE> file created by --preprocess to import.\n"
|
|
" -o<FOLDER> base output folder for generated files.\n"
|
|
" -b fail when trying to compile a parcelable.\n"
|
|
"\n"
|
|
"INPUT:\n"
|
|
" An aidl interface file.\n"
|
|
"\n"
|
|
"OUTPUT:\n"
|
|
" The generated interface files.\n"
|
|
" If omitted and the -o option is not used, the input filename is "
|
|
"used, with the .aidl extension changed to a .java extension.\n"
|
|
" If the -o option is used, the generated files will be placed in "
|
|
"the base output folder, under their package folder\n");
|
|
return unique_ptr<JavaOptions>(nullptr);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
unique_ptr<JavaOptions> JavaOptions::Parse(int argc, const char* const* argv) {
|
|
unique_ptr<JavaOptions> options(new JavaOptions());
|
|
int i = 1;
|
|
|
|
if (argc >= 2 && 0 == strcmp(argv[1], "--preprocess")) {
|
|
if (argc < 4) {
|
|
return java_usage();
|
|
}
|
|
options->output_file_name_ = argv[2];
|
|
for (int i = 3; i < argc; i++) {
|
|
options->files_to_preprocess_.push_back(argv[i]);
|
|
}
|
|
options->task = PREPROCESS_AIDL;
|
|
return options;
|
|
}
|
|
|
|
options->task = COMPILE_AIDL_TO_JAVA;
|
|
// OPTIONS
|
|
while (i < argc) {
|
|
const char* s = argv[i];
|
|
const size_t len = strlen(s);
|
|
if (s[0] != '-') {
|
|
break;
|
|
}
|
|
if (len <= 1) {
|
|
fprintf(stderr, "unknown option (%d): %s\n", i, s);
|
|
return java_usage();
|
|
}
|
|
// -I<system-import-path>
|
|
if (s[1] == 'I') {
|
|
if (len > 2) {
|
|
options->import_paths_.push_back(s + 2);
|
|
} else {
|
|
fprintf(stderr, "-I option (%d) requires a path.\n", i);
|
|
return java_usage();
|
|
}
|
|
} else if (s[1] == 'd') {
|
|
if (len > 2) {
|
|
options->dep_file_name_ = s + 2;
|
|
} else {
|
|
fprintf(stderr, "-d option (%d) requires a file.\n", i);
|
|
return java_usage();
|
|
}
|
|
} else if (strcmp(s, "-a") == 0) {
|
|
options->auto_dep_file_ = true;
|
|
} else if (s[1] == 'p') {
|
|
if (len > 2) {
|
|
options->preprocessed_files_.push_back(s + 2);
|
|
} else {
|
|
fprintf(stderr, "-p option (%d) requires a file.\n", i);
|
|
return java_usage();
|
|
}
|
|
} else if (s[1] == 'o') {
|
|
if (len > 2) {
|
|
options->output_base_folder_= s + 2;
|
|
} else {
|
|
fprintf(stderr, "-o option (%d) requires a path.\n", i);
|
|
return java_usage();
|
|
}
|
|
} else if (strcmp(s, "-b") == 0) {
|
|
options->fail_on_parcelable_ = true;
|
|
} else if (strcmp(s, "-ninja") == 0) {
|
|
options->dep_file_ninja_ = true;
|
|
} else {
|
|
// s[1] is not known
|
|
fprintf(stderr, "unknown option (%d): %s\n", i, s);
|
|
return java_usage();
|
|
}
|
|
i++;
|
|
}
|
|
// INPUT
|
|
if (i < argc) {
|
|
options->input_file_name_ = argv[i];
|
|
i++;
|
|
} else {
|
|
fprintf(stderr, "INPUT required\n");
|
|
return java_usage();
|
|
}
|
|
if (!EndsWith(options->input_file_name_, ".aidl")) {
|
|
cerr << "Expected .aidl file for input but got "
|
|
<< options->input_file_name_ << endl;
|
|
return java_usage();
|
|
}
|
|
|
|
// OUTPUT
|
|
if (i < argc) {
|
|
options->output_file_name_ = argv[i];
|
|
i++;
|
|
} else if (options->output_base_folder_.empty()) {
|
|
// copy input into output and change the extension from .aidl to .java
|
|
options->output_file_name_= options->input_file_name_;
|
|
if (!ReplaceSuffix(".aidl", ".java", &options->output_file_name_)) {
|
|
// we should never get here since we validated the suffix.
|
|
LOG(FATAL) << "Internal aidl error.";
|
|
return java_usage();
|
|
}
|
|
}
|
|
|
|
// anything remaining?
|
|
if (i != argc) {
|
|
fprintf(stderr, "unknown option%s:",
|
|
(i == argc - 1 ? (const char*)"" : (const char*)"s"));
|
|
for (; i < argc - 1; i++) {
|
|
fprintf(stderr, " %s", argv[i]);
|
|
}
|
|
fprintf(stderr, "\n");
|
|
return java_usage();
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
string JavaOptions::DependencyFilePath() const {
|
|
if (auto_dep_file_) {
|
|
return output_file_name_ + ".d";
|
|
}
|
|
return dep_file_name_;
|
|
}
|
|
|
|
namespace {
|
|
|
|
unique_ptr<CppOptions> cpp_usage() {
|
|
cerr << "usage: aidl-cpp INPUT_FILE HEADER_DIR OUTPUT_FILE" << endl
|
|
<< endl
|
|
<< "OPTIONS:" << endl
|
|
<< " -I<DIR> search path for import statements" << endl
|
|
<< " -d<FILE> generate dependency file" << endl
|
|
<< " -ninja generate dependency file in a format ninja "
|
|
"understands" << endl
|
|
<< endl
|
|
<< "INPUT_FILE:" << endl
|
|
<< " an aidl interface file" << endl
|
|
<< "HEADER_DIR:" << endl
|
|
<< " empty directory to put generated headers" << endl
|
|
<< "OUTPUT_FILE:" << endl
|
|
<< " path to write generated .cpp code" << endl;
|
|
return unique_ptr<CppOptions>(nullptr);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
unique_ptr<CppOptions> CppOptions::Parse(int argc, const char* const* argv) {
|
|
unique_ptr<CppOptions> options(new CppOptions());
|
|
int i = 1;
|
|
|
|
// Parse flags, all of which start with '-'
|
|
for ( ; i < argc; ++i) {
|
|
const size_t len = strlen(argv[i]);
|
|
const char *s = argv[i];
|
|
if (s[0] != '-') {
|
|
break; // On to the positional arguments.
|
|
}
|
|
if (len < 2) {
|
|
cerr << "Invalid argument '" << s << "'." << endl;
|
|
return cpp_usage();
|
|
}
|
|
const string the_rest = s + 2;
|
|
if (s[1] == 'I') {
|
|
options->import_paths_.push_back(the_rest);
|
|
} else if (s[1] == 'd') {
|
|
options->dep_file_name_ = the_rest;
|
|
} else if (strcmp(s, "-ninja") == 0) {
|
|
options->dep_file_ninja_ = true;
|
|
} else {
|
|
cerr << "Invalid argument '" << s << "'." << endl;
|
|
return cpp_usage();
|
|
}
|
|
}
|
|
|
|
// There are exactly three positional arguments.
|
|
const int remaining_args = argc - i;
|
|
if (remaining_args != 3) {
|
|
cerr << "Expected 3 positional arguments but got " << remaining_args << "." << endl;
|
|
return cpp_usage();
|
|
}
|
|
|
|
options->input_file_name_ = argv[i];
|
|
options->output_header_dir_ = argv[i + 1];
|
|
options->output_file_name_ = argv[i + 2];
|
|
|
|
if (!EndsWith(options->input_file_name_, ".aidl")) {
|
|
cerr << "Expected .aidl file for input but got " << options->input_file_name_ << endl;
|
|
return cpp_usage();
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
bool EndsWith(const string& str, const string& suffix) {
|
|
if (str.length() < suffix.length()) {
|
|
return false;
|
|
}
|
|
return std::equal(str.crbegin(), str.crbegin() + suffix.length(),
|
|
suffix.crbegin());
|
|
}
|
|
|
|
bool ReplaceSuffix(const string& old_suffix,
|
|
const string& new_suffix,
|
|
string* str) {
|
|
if (!EndsWith(*str, old_suffix)) return false;
|
|
str->replace(str->length() - old_suffix.length(),
|
|
old_suffix.length(),
|
|
new_suffix);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
} // namespace android
|
|
} // namespace aidl
|