Christopher Wiley | 89eaab5 | 2015-09-15 14:46:46 -0700 | [diff] [blame] | 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 | */ |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 16 | |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 17 | #include "aidl.h" |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 18 | |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 19 | #include <fcntl.h> |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 20 | #include <stdio.h> |
| 21 | #include <stdlib.h> |
| 22 | #include <string.h> |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 23 | #include <sys/param.h> |
| 24 | #include <sys/stat.h> |
| 25 | #include <unistd.h> |
Jiyong Park | 02da742 | 2018-07-16 16:00:26 +0900 | [diff] [blame] | 26 | #include <algorithm> |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 27 | #include <iostream> |
| 28 | #include <map> |
| 29 | #include <memory> |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 30 | |
Elliott Hughes | 549b6e2 | 2015-08-17 12:41:46 -0700 | [diff] [blame] | 31 | #ifdef _WIN32 |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 32 | #include <io.h> |
Andrew Hsieh | 15ce994 | 2014-05-07 20:14:30 +0800 | [diff] [blame] | 33 | #include <direct.h> |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 34 | #include <sys/stat.h> |
| 35 | #endif |
| 36 | |
Elliott Hughes | 0a62067 | 2015-12-04 13:53:18 -0800 | [diff] [blame] | 37 | #include <android-base/strings.h> |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 38 | |
Steven Moreland | 3981d9e | 2020-03-31 14:11:44 -0700 | [diff] [blame] | 39 | #include "aidl_checkapi.h" |
Jooyung Han | 1f56b70 | 2021-02-11 13:16:15 +0900 | [diff] [blame] | 40 | #include "aidl_dumpapi.h" |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 41 | #include "aidl_language.h" |
Jiyong Park | e05195e | 2018-10-08 18:24:23 +0900 | [diff] [blame] | 42 | #include "aidl_typenames.h" |
Jooyung Han | 74406c5 | 2021-11-06 06:17:36 +0900 | [diff] [blame] | 43 | #include "check_valid.h" |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 44 | #include "generate_aidl_mappings.h" |
Christopher Wiley | eb1acc1 | 2015-09-16 11:25:13 -0700 | [diff] [blame] | 45 | #include "generate_cpp.h" |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 46 | #include "generate_java.h" |
Steven Moreland | c26d814 | 2018-09-17 14:25:33 -0700 | [diff] [blame] | 47 | #include "generate_ndk.h" |
Andrei Homescu | b62afd9 | 2020-05-11 19:24:59 -0700 | [diff] [blame] | 48 | #include "generate_rust.h" |
Christopher Wiley | 72877ac | 2015-10-06 14:41:42 -0700 | [diff] [blame] | 49 | #include "import_resolver.h" |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 50 | #include "logging.h" |
| 51 | #include "options.h" |
| 52 | #include "os.h" |
Jiyong Park | e5c4529 | 2020-05-26 19:06:24 +0900 | [diff] [blame] | 53 | #include "parser.h" |
Jooyung Han | 93f48f0 | 2021-06-05 00:11:16 +0900 | [diff] [blame] | 54 | #include "preprocess.h" |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 55 | |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 56 | #ifndef O_BINARY |
| 57 | # define O_BINARY 0 |
| 58 | #endif |
| 59 | |
Christopher Wiley | 3a9911c | 2016-01-19 12:59:09 -0800 | [diff] [blame] | 60 | using android::base::Join; |
Christopher Wiley | d76067c | 2015-10-19 17:00:13 -0700 | [diff] [blame] | 61 | using android::base::Split; |
Christopher Wiley | 9f4c7ae | 2015-08-24 14:07:32 -0700 | [diff] [blame] | 62 | using std::set; |
| 63 | using std::string; |
Christopher Wiley | 84c1eac | 2015-09-23 13:29:28 -0700 | [diff] [blame] | 64 | using std::unique_ptr; |
Jooyung Han | d25527a | 2020-12-30 12:29:31 +0900 | [diff] [blame] | 65 | using std::unordered_set; |
Christopher Wiley | 9f4c7ae | 2015-08-24 14:07:32 -0700 | [diff] [blame] | 66 | using std::vector; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 67 | |
Christopher Wiley | f690be5 | 2015-09-14 15:19:10 -0700 | [diff] [blame] | 68 | namespace android { |
| 69 | namespace aidl { |
| 70 | namespace { |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 71 | |
Jiyong Park | 965c5b9 | 2018-11-21 13:37:15 +0900 | [diff] [blame] | 72 | // Copied from android.is.IBinder.[FIRST|LAST]_CALL_TRANSACTION |
| 73 | const int kFirstCallTransaction = 1; |
| 74 | const int kLastCallTransaction = 0x00ffffff; |
| 75 | |
| 76 | // Following IDs are all offsets from kFirstCallTransaction |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 77 | |
| 78 | // IDs for meta transactions. Most of the meta transactions are implemented in |
| 79 | // the framework side (Binder.java or Binder.cpp). But these are the ones that |
| 80 | // are auto-implemented by the AIDL compiler. |
Jiyong Park | 965c5b9 | 2018-11-21 13:37:15 +0900 | [diff] [blame] | 81 | const int kFirstMetaMethodId = kLastCallTransaction - kFirstCallTransaction; |
| 82 | const int kGetInterfaceVersionId = kFirstMetaMethodId; |
Paul Trautrim | b77048c | 2020-01-21 16:39:32 +0900 | [diff] [blame] | 83 | const int kGetInterfaceHashId = kFirstMetaMethodId - 1; |
Jiyong Park | 965c5b9 | 2018-11-21 13:37:15 +0900 | [diff] [blame] | 84 | // Additional meta transactions implemented by AIDL should use |
| 85 | // kFirstMetaMethodId -1, -2, ...and so on. |
| 86 | |
| 87 | // Reserve 100 IDs for meta methods, which is more than enough. If we don't reserve, |
| 88 | // in the future, a newly added meta transaction ID will have a chance to |
| 89 | // collide with the user-defined methods that were added in the past. So, |
| 90 | // let's prevent users from using IDs in this range from the beginning. |
| 91 | const int kLastMetaMethodId = kFirstMetaMethodId - 99; |
| 92 | |
| 93 | // Range of IDs that is allowed for user-defined methods. |
| 94 | const int kMinUserSetMethodId = 0; |
| 95 | const int kMaxUserSetMethodId = kLastMetaMethodId - 1; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 96 | |
Steven Moreland | 92c55f1 | 2018-07-31 14:08:37 -0700 | [diff] [blame] | 97 | bool check_filename(const std::string& filename, const AidlDefinedType& defined_type) { |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 98 | const char* p; |
| 99 | string expected; |
| 100 | string fn; |
| 101 | size_t len; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 102 | bool valid = false; |
| 103 | |
Christopher Wiley | bc2df69 | 2016-06-02 16:27:26 -0700 | [diff] [blame] | 104 | if (!IoDelegate::GetAbsolutePath(filename, &fn)) { |
| 105 | return false; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 106 | } |
| 107 | |
Steven Moreland | 92c55f1 | 2018-07-31 14:08:37 -0700 | [diff] [blame] | 108 | const std::string package = defined_type.GetPackage(); |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 109 | if (!package.empty()) { |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 110 | expected = package; |
| 111 | expected += '.'; |
| 112 | } |
| 113 | |
| 114 | len = expected.length(); |
| 115 | for (size_t i=0; i<len; i++) { |
| 116 | if (expected[i] == '.') { |
| 117 | expected[i] = OS_PATH_SEPARATOR; |
| 118 | } |
| 119 | } |
| 120 | |
Steven Moreland | 92c55f1 | 2018-07-31 14:08:37 -0700 | [diff] [blame] | 121 | const std::string name = defined_type.GetName(); |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 122 | expected.append(name, 0, name.find('.')); |
Christopher Wiley | 8f8cc9b | 2015-09-14 13:47:40 -0700 | [diff] [blame] | 123 | |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 124 | expected += ".aidl"; |
| 125 | |
| 126 | len = fn.length(); |
| 127 | valid = (len >= expected.length()); |
| 128 | |
| 129 | if (valid) { |
| 130 | p = fn.c_str() + (len - expected.length()); |
| 131 | |
Elliott Hughes | ce310da | 2015-07-29 08:44:17 -0700 | [diff] [blame] | 132 | #ifdef _WIN32 |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 133 | if (OS_PATH_SEPARATOR != '/') { |
| 134 | // Input filename under cygwin most likely has / separators |
| 135 | // whereas the expected string uses \\ separators. Adjust |
| 136 | // them accordingly. |
| 137 | for (char *c = const_cast<char *>(p); *c; ++c) { |
| 138 | if (*c == '/') *c = OS_PATH_SEPARATOR; |
| 139 | } |
| 140 | } |
| 141 | #endif |
| 142 | |
Yabin Cui | 482eefb | 2014-11-10 15:01:43 -0800 | [diff] [blame] | 143 | // aidl assumes case-insensitivity on Mac Os and Windows. |
| 144 | #if defined(__linux__) |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 145 | valid = (expected == p); |
| 146 | #else |
| 147 | valid = !strcasecmp(expected.c_str(), p); |
| 148 | #endif |
| 149 | } |
| 150 | |
| 151 | if (!valid) { |
Steven Moreland | 92c55f1 | 2018-07-31 14:08:37 -0700 | [diff] [blame] | 152 | AIDL_ERROR(defined_type) << name << " should be declared in a file called " << expected; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 153 | } |
| 154 | |
Casey Dahlin | 42727f8 | 2015-10-12 19:23:40 -0700 | [diff] [blame] | 155 | return valid; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 156 | } |
| 157 | |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 158 | bool write_dep_file(const Options& options, const AidlDefinedType& defined_type, |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 159 | const vector<string>& imports, const IoDelegate& io_delegate, |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 160 | const string& input_file, const string& output_file) { |
| 161 | string dep_file_name = options.DependencyFile(); |
| 162 | if (dep_file_name.empty() && options.AutoDepFile()) { |
| 163 | dep_file_name = output_file + ".d"; |
| 164 | } |
| 165 | |
| 166 | if (dep_file_name.empty()) { |
| 167 | return true; // nothing to do |
| 168 | } |
Jiyong Park | 0546373 | 2018-08-09 16:03:02 +0900 | [diff] [blame] | 169 | |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 170 | CodeWriterPtr writer = io_delegate.GetCodeWriter(dep_file_name); |
| 171 | if (!writer) { |
Steven Moreland | 2178081 | 2020-09-11 01:29:45 +0000 | [diff] [blame] | 172 | AIDL_ERROR(dep_file_name) << "Could not open dependency file."; |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 173 | return false; |
| 174 | } |
| 175 | |
| 176 | vector<string> source_aidl = {input_file}; |
| 177 | for (const auto& import : imports) { |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 178 | source_aidl.push_back(import); |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 179 | } |
| 180 | |
Christopher Wiley | 3a9911c | 2016-01-19 12:59:09 -0800 | [diff] [blame] | 181 | // Encode that the output file depends on aidl input files. |
Jiyong Park | df20212 | 2019-09-30 20:48:35 +0900 | [diff] [blame] | 182 | if (defined_type.AsUnstructuredParcelable() != nullptr && |
| 183 | options.TargetLanguage() == Options::Language::JAVA) { |
| 184 | // Legacy behavior. For parcelable declarations in Java, don't emit output file as |
| 185 | // the dependency target. b/141372861 |
| 186 | writer->Write(" : \\\n"); |
| 187 | } else { |
| 188 | writer->Write("%s : \\\n", output_file.c_str()); |
| 189 | } |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 190 | writer->Write(" %s", Join(source_aidl, " \\\n ").c_str()); |
Dan Willemsen | 93298ee | 2016-11-10 23:55:55 -0800 | [diff] [blame] | 191 | writer->Write("\n"); |
Christopher Wiley | a30a45e | 2015-10-17 10:56:59 -0700 | [diff] [blame] | 192 | |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 193 | if (!options.DependencyFileNinja()) { |
Dan Willemsen | 93298ee | 2016-11-10 23:55:55 -0800 | [diff] [blame] | 194 | writer->Write("\n"); |
| 195 | // Output "<input_aidl_file>: " so make won't fail if the input .aidl file |
| 196 | // has been deleted, moved or renamed in incremental build. |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 197 | for (const auto& src : source_aidl) { |
Dan Willemsen | 93298ee | 2016-11-10 23:55:55 -0800 | [diff] [blame] | 198 | writer->Write("%s :\n", src.c_str()); |
| 199 | } |
Christopher Wiley | 3a9911c | 2016-01-19 12:59:09 -0800 | [diff] [blame] | 200 | } |
Christopher Wiley | a30a45e | 2015-10-17 10:56:59 -0700 | [diff] [blame] | 201 | |
Steven Moreland | c26d814 | 2018-09-17 14:25:33 -0700 | [diff] [blame] | 202 | if (options.IsCppOutput()) { |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 203 | if (!options.DependencyFileNinja()) { |
| 204 | using ::android::aidl::cpp::ClassNames; |
| 205 | using ::android::aidl::cpp::HeaderFile; |
| 206 | vector<string> headers; |
Jiyong Park | 5b7e532 | 2019-04-03 20:05:01 +0900 | [diff] [blame] | 207 | for (ClassNames c : {ClassNames::CLIENT, ClassNames::SERVER, ClassNames::RAW}) { |
Jiyong Park | 0546373 | 2018-08-09 16:03:02 +0900 | [diff] [blame] | 208 | headers.push_back(options.OutputHeaderDir() + |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 209 | HeaderFile(defined_type, c, false /* use_os_sep */)); |
| 210 | } |
Christopher Wiley | 3a9911c | 2016-01-19 12:59:09 -0800 | [diff] [blame] | 211 | |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 212 | writer->Write("\n"); |
| 213 | |
| 214 | // Generated headers also depend on the source aidl files. |
| 215 | writer->Write("%s : \\\n %s\n", Join(headers, " \\\n ").c_str(), |
| 216 | Join(source_aidl, " \\\n ").c_str()); |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 217 | } |
Christopher Wiley | a30a45e | 2015-10-17 10:56:59 -0700 | [diff] [blame] | 218 | } |
Christopher Wiley | 3a9911c | 2016-01-19 12:59:09 -0800 | [diff] [blame] | 219 | |
Christopher Wiley | 3a9911c | 2016-01-19 12:59:09 -0800 | [diff] [blame] | 220 | return true; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 221 | } |
| 222 | |
Jooyung Han | b3cd63f | 2021-01-05 13:38:46 +0900 | [diff] [blame] | 223 | // Returns the path to the destination file of `defined_type`. |
| 224 | string GetOutputFilePath(const Options& options, const AidlDefinedType& defined_type) { |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 225 | string result = options.OutputDir(); |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 226 | |
Jooyung Han | b3cd63f | 2021-01-05 13:38:46 +0900 | [diff] [blame] | 227 | // add the package |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 228 | string package = defined_type.GetPackage(); |
Jooyung Han | b3cd63f | 2021-01-05 13:38:46 +0900 | [diff] [blame] | 229 | if (!package.empty()) { |
| 230 | for (auto& c : package) { |
| 231 | if (c == '.') { |
| 232 | c = OS_PATH_SEPARATOR; |
| 233 | } |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 234 | } |
Jooyung Han | b3cd63f | 2021-01-05 13:38:46 +0900 | [diff] [blame] | 235 | result += package; |
| 236 | result += OS_PATH_SEPARATOR; |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 237 | } |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 238 | |
Jooyung Han | b3cd63f | 2021-01-05 13:38:46 +0900 | [diff] [blame] | 239 | // add the filename |
| 240 | result += defined_type.GetName(); |
Jiyong Park | b03551f | 2018-08-06 19:20:51 +0900 | [diff] [blame] | 241 | if (options.TargetLanguage() == Options::Language::JAVA) { |
| 242 | result += ".java"; |
Steven Moreland | c26d814 | 2018-09-17 14:25:33 -0700 | [diff] [blame] | 243 | } else if (options.IsCppOutput()) { |
Jiyong Park | b03551f | 2018-08-06 19:20:51 +0900 | [diff] [blame] | 244 | result += ".cpp"; |
Andrei Homescu | b62afd9 | 2020-05-11 19:24:59 -0700 | [diff] [blame] | 245 | } else if (options.TargetLanguage() == Options::Language::RUST) { |
| 246 | result += ".rs"; |
Jiyong Park | b03551f | 2018-08-06 19:20:51 +0900 | [diff] [blame] | 247 | } else { |
Steven Moreland | 2178081 | 2020-09-11 01:29:45 +0000 | [diff] [blame] | 248 | AIDL_FATAL("Unknown target language"); |
Jiyong Park | b03551f | 2018-08-06 19:20:51 +0900 | [diff] [blame] | 249 | return ""; |
| 250 | } |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 251 | |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 252 | return result; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 253 | } |
| 254 | |
Jooyung Han | 2a86ba8 | 2021-12-02 01:41:19 +0900 | [diff] [blame] | 255 | bool CheckAndAssignMethodIDs(const std::vector<std::unique_ptr<AidlMethod>>& items) { |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 256 | // Check whether there are any methods with manually assigned id's and any |
| 257 | // that are not. Either all method id's must be manually assigned or all of |
| 258 | // them must not. Also, check for uplicates of user set ID's and that the |
| 259 | // ID's are within the proper bounds. |
| 260 | set<int> usedIds; |
| 261 | bool hasUnassignedIds = false; |
| 262 | bool hasAssignedIds = false; |
Steven Moreland | ec6f469 | 2019-08-13 10:03:24 -0700 | [diff] [blame] | 263 | int newId = kMinUserSetMethodId; |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 264 | for (const auto& item : items) { |
| 265 | // However, meta transactions that are added by the AIDL compiler are |
| 266 | // exceptions. They have fixed IDs but allowed to be with user-defined |
| 267 | // methods having auto-assigned IDs. This is because the Ids of the meta |
| 268 | // transactions must be stable during the entire lifetime of an interface. |
| 269 | // In other words, their IDs must be the same even when new user-defined |
| 270 | // methods are added. |
Jiyong Park | 3633b72 | 2019-04-11 15:38:26 +0900 | [diff] [blame] | 271 | if (!item->IsUserDefined()) { |
| 272 | continue; |
| 273 | } |
| 274 | if (item->HasId()) { |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 275 | hasAssignedIds = true; |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 276 | } else { |
Steven Moreland | ec6f469 | 2019-08-13 10:03:24 -0700 | [diff] [blame] | 277 | item->SetId(newId++); |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 278 | hasUnassignedIds = true; |
| 279 | } |
Steven Moreland | ec6f469 | 2019-08-13 10:03:24 -0700 | [diff] [blame] | 280 | |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 281 | if (hasAssignedIds && hasUnassignedIds) { |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 282 | AIDL_ERROR(item) << "You must either assign id's to all methods or to none of them."; |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 283 | return false; |
| 284 | } |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 285 | |
Steven Moreland | ec6f469 | 2019-08-13 10:03:24 -0700 | [diff] [blame] | 286 | // Ensure that the user set id is not duplicated. |
| 287 | if (usedIds.find(item->GetId()) != usedIds.end()) { |
| 288 | // We found a duplicate id, so throw an error. |
| 289 | AIDL_ERROR(item) << "Found duplicate method id (" << item->GetId() << ") for method " |
| 290 | << item->GetName(); |
| 291 | return false; |
| 292 | } |
| 293 | usedIds.insert(item->GetId()); |
| 294 | |
| 295 | // Ensure that the user set id is within the appropriate limits |
| 296 | if (item->GetId() < kMinUserSetMethodId || item->GetId() > kMaxUserSetMethodId) { |
| 297 | AIDL_ERROR(item) << "Found out of bounds id (" << item->GetId() << ") for method " |
| 298 | << item->GetName() << ". Value for id must be between " |
| 299 | << kMinUserSetMethodId << " and " << kMaxUserSetMethodId << " inclusive."; |
| 300 | return false; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 301 | } |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 302 | } |
Steven Moreland | ec6f469 | 2019-08-13 10:03:24 -0700 | [diff] [blame] | 303 | |
Jiyong Park | 309668e | 2018-07-28 16:55:44 +0900 | [diff] [blame] | 304 | return true; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 305 | } |
| 306 | |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 307 | bool ValidateAnnotationContext(const AidlDocument& doc) { |
| 308 | struct AnnotationValidator : AidlVisitor { |
| 309 | bool success = true; |
| 310 | |
| 311 | void Check(const AidlAnnotatable& annotatable, AidlAnnotation::TargetContext context) { |
| 312 | for (const auto& annot : annotatable.GetAnnotations()) { |
Steven Moreland | a7560e8 | 2021-10-08 16:24:39 -0700 | [diff] [blame] | 313 | if (!annot->CheckContext(context)) { |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 314 | success = false; |
| 315 | } |
| 316 | } |
| 317 | } |
| 318 | void Visit(const AidlInterface& m) override { |
| 319 | Check(m, AidlAnnotation::CONTEXT_TYPE_INTERFACE); |
| 320 | } |
| 321 | void Visit(const AidlParcelable& m) override { |
| 322 | Check(m, AidlAnnotation::CONTEXT_TYPE_UNSTRUCTURED_PARCELABLE); |
| 323 | } |
| 324 | void Visit(const AidlStructuredParcelable& m) override { |
| 325 | Check(m, AidlAnnotation::CONTEXT_TYPE_STRUCTURED_PARCELABLE); |
| 326 | } |
| 327 | void Visit(const AidlEnumDeclaration& m) override { |
| 328 | Check(m, AidlAnnotation::CONTEXT_TYPE_ENUM); |
| 329 | } |
| 330 | void Visit(const AidlUnionDecl& m) override { Check(m, AidlAnnotation::CONTEXT_TYPE_UNION); } |
| 331 | void Visit(const AidlMethod& m) override { |
| 332 | Check(m.GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER | AidlAnnotation::CONTEXT_METHOD); |
| 333 | for (const auto& arg : m.GetArguments()) { |
| 334 | Check(arg->GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER); |
| 335 | } |
| 336 | } |
| 337 | void Visit(const AidlConstantDeclaration& m) override { |
| 338 | Check(m.GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER | AidlAnnotation::CONTEXT_CONST); |
| 339 | } |
| 340 | void Visit(const AidlVariableDeclaration& m) override { |
| 341 | Check(m.GetType(), AidlAnnotation::CONTEXT_TYPE_SPECIFIER | AidlAnnotation::CONTEXT_FIELD); |
| 342 | } |
| 343 | void Visit(const AidlTypeSpecifier& m) override { |
| 344 | // nested generic type parameters are checked as well |
| 345 | if (m.IsGeneric()) { |
| 346 | for (const auto& tp : m.GetTypeParameters()) { |
| 347 | Check(*tp, AidlAnnotation::CONTEXT_TYPE_SPECIFIER); |
| 348 | } |
| 349 | } |
| 350 | } |
| 351 | }; |
| 352 | |
| 353 | AnnotationValidator validator; |
| 354 | VisitTopDown(validator, doc); |
| 355 | return validator.success; |
| 356 | } |
| 357 | |
Jooyung Han | 2cb8ecd | 2021-07-28 18:41:30 +0900 | [diff] [blame] | 358 | bool ValidateCppHeader(const AidlDocument& doc) { |
| 359 | struct CppHeaderVisitor : AidlVisitor { |
| 360 | bool success = true; |
| 361 | void Visit(const AidlParcelable& p) override { |
| 362 | if (p.GetCppHeader().empty()) { |
| 363 | AIDL_ERROR(p) << "Unstructured parcelable \"" << p.GetName() |
| 364 | << "\" must have C++ header defined."; |
| 365 | success = false; |
| 366 | } |
| 367 | } |
| 368 | void Visit(const AidlTypeSpecifier& m) override { |
| 369 | auto type = m.GetDefinedType(); |
| 370 | if (type) { |
| 371 | auto unstructured = type->AsUnstructuredParcelable(); |
| 372 | if (unstructured && unstructured->GetCppHeader().empty()) { |
| 373 | AIDL_ERROR(m) << "Unstructured parcelable \"" << m.GetUnresolvedName() |
| 374 | << "\" must have C++ header defined."; |
| 375 | success = false; |
| 376 | } |
| 377 | } |
| 378 | } |
| 379 | }; |
| 380 | |
| 381 | CppHeaderVisitor validator; |
| 382 | VisitTopDown(validator, doc); |
| 383 | return validator.success; |
| 384 | } |
| 385 | |
Christopher Wiley | 4a2884b | 2015-10-07 11:27:45 -0700 | [diff] [blame] | 386 | } // namespace |
| 387 | |
| 388 | namespace internals { |
| 389 | |
Jiyong Park | fbbfa93 | 2018-07-30 21:44:10 +0900 | [diff] [blame] | 390 | AidlError load_and_validate_aidl(const std::string& input_file_name, const Options& options, |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 391 | const IoDelegate& io_delegate, AidlTypenames* typenames, |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 392 | vector<string>* imported_files) { |
Christopher Wiley | 632801d | 2015-11-05 14:15:49 -0800 | [diff] [blame] | 393 | AidlError err = AidlError::OK; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 394 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 395 | ////////////////////////////////////////////////////////////////////////// |
| 396 | // Loading phase |
| 397 | ////////////////////////////////////////////////////////////////////////// |
Jiyong Park | fbbfa93 | 2018-07-30 21:44:10 +0900 | [diff] [blame] | 398 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 399 | // Parse the main input file |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 400 | const AidlDocument* document = Parser::Parse(input_file_name, io_delegate, *typenames); |
| 401 | if (document == nullptr) { |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 402 | return AidlError::PARSE_ERROR; |
| 403 | } |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 404 | int num_top_level_decls = 0; |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 405 | for (const auto& type : document->DefinedTypes()) { |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 406 | if (type->AsUnstructuredParcelable() == nullptr) { |
| 407 | num_top_level_decls++; |
| 408 | if (num_top_level_decls > 1) { |
Devin Moore | 5de18ed | 2020-04-02 13:52:29 -0700 | [diff] [blame] | 409 | AIDL_ERROR(*type) << "You must declare only one type per file."; |
| 410 | return AidlError::BAD_TYPE; |
| 411 | } |
Jiyong Park | da8c693 | 2019-08-12 19:56:08 +0900 | [diff] [blame] | 412 | } |
| 413 | } |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 414 | |
| 415 | // Import the preprocessed file |
Jooyung Han | 93f48f0 | 2021-06-05 00:11:16 +0900 | [diff] [blame] | 416 | for (const string& filename : options.PreprocessedFiles()) { |
| 417 | auto preprocessed = Parser::Parse(filename, io_delegate, *typenames, /*is_preprocessed=*/true); |
| 418 | if (!preprocessed) { |
| 419 | return AidlError::BAD_PRE_PROCESSED_FILE; |
Christopher Wiley | ef14093 | 2015-11-03 09:29:19 -0800 | [diff] [blame] | 420 | } |
Christopher Wiley | 3a9d158 | 2015-09-16 12:42:14 -0700 | [diff] [blame] | 421 | } |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 422 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 423 | // Find files to import and parse them |
Jiyong Park | e59c368 | 2018-09-11 23:10:25 +0900 | [diff] [blame] | 424 | vector<string> import_paths; |
Jooyung Han | 6529b82 | 2021-06-11 22:05:26 +0900 | [diff] [blame] | 425 | ImportResolver import_resolver{io_delegate, input_file_name, options.ImportDirs()}; |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 426 | for (const auto& import : document->Imports()) { |
Jooyung Han | cdf89ec | 2021-10-29 14:08:30 +0900 | [diff] [blame] | 427 | if (typenames->IsIgnorableImport(import)) { |
Christopher Wiley | fb4b22d | 2015-09-25 15:16:13 -0700 | [diff] [blame] | 428 | // There are places in the Android tree where an import doesn't resolve, |
| 429 | // but we'll pick the type up through the preprocessed types. |
| 430 | // This seems like an error, but legacy support demands we support it... |
Christopher Wiley | c16e5e7 | 2015-09-16 10:49:40 -0700 | [diff] [blame] | 431 | continue; |
| 432 | } |
Jooyung Han | cdf89ec | 2021-10-29 14:08:30 +0900 | [diff] [blame] | 433 | string import_path = import_resolver.FindImportFile(import); |
Christopher Wiley | 72877ac | 2015-10-06 14:41:42 -0700 | [diff] [blame] | 434 | if (import_path.empty()) { |
Jooyung Han | cdf89ec | 2021-10-29 14:08:30 +0900 | [diff] [blame] | 435 | AIDL_ERROR(input_file_name) << "Couldn't find import for class " << import; |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 436 | err = AidlError::BAD_IMPORT; |
Christopher Wiley | c16e5e7 | 2015-09-16 10:49:40 -0700 | [diff] [blame] | 437 | continue; |
| 438 | } |
Casey Dahlin | 2cc9316 | 2015-10-02 16:14:17 -0700 | [diff] [blame] | 439 | |
Jiyong Park | e59c368 | 2018-09-11 23:10:25 +0900 | [diff] [blame] | 440 | import_paths.emplace_back(import_path); |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 441 | |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 442 | auto imported_doc = Parser::Parse(import_path, io_delegate, *typenames); |
| 443 | if (imported_doc == nullptr) { |
Jooyung Han | cdf89ec | 2021-10-29 14:08:30 +0900 | [diff] [blame] | 444 | AIDL_ERROR(import_path) << "error while importing " << import_path << " for " << import; |
Christopher Wiley | 632801d | 2015-11-05 14:15:49 -0800 | [diff] [blame] | 445 | err = AidlError::BAD_IMPORT; |
Christopher Wiley | c16e5e7 | 2015-09-16 10:49:40 -0700 | [diff] [blame] | 446 | continue; |
| 447 | } |
Christopher Wiley | c16e5e7 | 2015-09-16 10:49:40 -0700 | [diff] [blame] | 448 | } |
Christopher Wiley | 632801d | 2015-11-05 14:15:49 -0800 | [diff] [blame] | 449 | if (err != AidlError::OK) { |
Christopher Wiley | c16e5e7 | 2015-09-16 10:49:40 -0700 | [diff] [blame] | 450 | return err; |
Christopher Wiley | 3a9d158 | 2015-09-16 12:42:14 -0700 | [diff] [blame] | 451 | } |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 452 | |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 453 | TypeResolver resolver = [&](const AidlDefinedType* scope, AidlTypeSpecifier* type) { |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 454 | // resolve with already loaded types |
| 455 | if (type->Resolve(*typenames, scope)) { |
| 456 | return true; |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 457 | } |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 458 | const string import_path = import_resolver.FindImportFile(scope->ResolveName(type->GetName())); |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 459 | if (import_path.empty()) { |
| 460 | return false; |
| 461 | } |
| 462 | import_paths.push_back(import_path); |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 463 | auto imported_doc = Parser::Parse(import_path, io_delegate, *typenames); |
| 464 | if (imported_doc == nullptr) { |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 465 | AIDL_ERROR(import_path) << "error while importing " << import_path << " for " << import_path; |
| 466 | return false; |
| 467 | } |
Jooyung Han | 13f1fa5 | 2021-06-11 18:06:12 +0900 | [diff] [blame] | 468 | |
| 469 | // now, try to resolve it again |
| 470 | if (!type->Resolve(*typenames, scope)) { |
Jooyung Han | 2981384 | 2020-12-08 01:28:03 +0900 | [diff] [blame] | 471 | AIDL_ERROR(type) << "Can't resolve " << type->GetName(); |
| 472 | return false; |
| 473 | } |
| 474 | return true; |
| 475 | }; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 476 | |
Jooyung Han | 8e3b72c | 2021-05-22 02:54:37 +0900 | [diff] [blame] | 477 | // Resolve the unresolved references |
| 478 | if (!ResolveReferences(*document, resolver)) { |
Jiyong Park | 1deecc3 | 2018-07-17 01:14:41 +0900 | [diff] [blame] | 479 | return AidlError::BAD_TYPE; |
| 480 | } |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 481 | |
Jooyung Han | 672557b | 2020-12-24 05:18:00 +0900 | [diff] [blame] | 482 | if (!typenames->Autofill()) { |
| 483 | return AidlError::BAD_TYPE; |
Steven Moreland | 59e53e4 | 2019-11-26 20:38:08 -0800 | [diff] [blame] | 484 | } |
Daniel Norman | 85aed54 | 2019-08-21 12:01:14 -0700 | [diff] [blame] | 485 | |
Jeongik Cha | db0f59e | 2018-11-01 18:11:21 +0900 | [diff] [blame] | 486 | ////////////////////////////////////////////////////////////////////////// |
| 487 | // Validation phase |
| 488 | ////////////////////////////////////////////////////////////////////////// |
| 489 | |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 490 | const auto& types = document->DefinedTypes(); |
Jiyong Park | 6251551 | 2020-06-08 15:57:11 +0900 | [diff] [blame] | 491 | const int num_defined_types = types.size(); |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 492 | for (const auto& defined_type : types) { |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 493 | AIDL_FATAL_IF(defined_type == nullptr, document); |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 494 | |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 495 | // Ensure type is exactly one of the following: |
| 496 | AidlInterface* interface = defined_type->AsInterface(); |
| 497 | AidlStructuredParcelable* parcelable = defined_type->AsStructuredParcelable(); |
| 498 | AidlParcelable* unstructured_parcelable = defined_type->AsUnstructuredParcelable(); |
| 499 | AidlEnumDeclaration* enum_decl = defined_type->AsEnumDeclaration(); |
Jooyung Han | 2946afc | 2020-10-05 20:29:16 +0900 | [diff] [blame] | 500 | AidlUnionDecl* union_decl = defined_type->AsUnionDeclaration(); |
| 501 | AIDL_FATAL_IF( |
| 502 | !!interface + !!parcelable + !!unstructured_parcelable + !!enum_decl + !!union_decl != 1, |
| 503 | defined_type); |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 504 | |
| 505 | // Ensure that foo.bar.IFoo is defined in <some_path>/foo/bar/IFoo.aidl |
| 506 | if (num_defined_types == 1 && !check_filename(input_file_name, *defined_type)) { |
| 507 | return AidlError::BAD_PACKAGE; |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 508 | } |
| 509 | |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 510 | { |
| 511 | bool valid_type = true; |
| 512 | |
Jooyung Han | 8e3b72c | 2021-05-22 02:54:37 +0900 | [diff] [blame] | 513 | if (!defined_type->CheckValid(*typenames)) { |
| 514 | valid_type = false; |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 515 | } |
| 516 | |
Jooyung Han | b4997aa | 2021-10-16 03:26:12 +0900 | [diff] [blame] | 517 | if (!defined_type->LanguageSpecificCheckValid(options.TargetLanguage())) { |
Jooyung Han | 8e3b72c | 2021-05-22 02:54:37 +0900 | [diff] [blame] | 518 | valid_type = false; |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 519 | } |
| 520 | |
| 521 | if (!valid_type) { |
Jeongik Cha | 82317dd | 2019-02-27 20:26:11 +0900 | [diff] [blame] | 522 | return AidlError::BAD_TYPE; |
| 523 | } |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 524 | } |
| 525 | |
| 526 | if (unstructured_parcelable != nullptr) { |
Jooyung Han | a97b588 | 2021-11-02 10:32:54 +0900 | [diff] [blame] | 527 | auto lang = options.TargetLanguage(); |
| 528 | bool isStable = unstructured_parcelable->IsStableApiParcelable(lang); |
Jeongik Cha | 82317dd | 2019-02-27 20:26:11 +0900 | [diff] [blame] | 529 | if (options.IsStructured() && !isStable) { |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 530 | AIDL_ERROR(unstructured_parcelable) |
Jooyung Han | 2cb8ecd | 2021-07-28 18:41:30 +0900 | [diff] [blame] | 531 | << "Cannot declare unstructured parcelable in a --structured interface. Parcelable " |
| 532 | "must be defined in AIDL directly."; |
Steven Moreland | 2a9a7d6 | 2019-02-05 16:11:54 -0800 | [diff] [blame] | 533 | return AidlError::NOT_STRUCTURED; |
| 534 | } |
Jooyung Han | a97b588 | 2021-11-02 10:32:54 +0900 | [diff] [blame] | 535 | if (options.FailOnParcelable() || lang == Options::Language::NDK || |
| 536 | lang == Options::Language::RUST) { |
Steven Moreland | ebc3c5d | 2020-09-30 23:40:33 +0000 | [diff] [blame] | 537 | AIDL_ERROR(unstructured_parcelable) |
Steven Moreland | 2a9a7d6 | 2019-02-05 16:11:54 -0800 | [diff] [blame] | 538 | << "Refusing to generate code with unstructured parcelables. Declared parcelables " |
| 539 | "should be in their own file and/or cannot be used with --structured interfaces."; |
Jooyung Han | 05a532a | 2021-08-18 10:41:40 +0900 | [diff] [blame] | 540 | return AidlError::FOUND_PARCELABLE; |
Steven Moreland | 2a9a7d6 | 2019-02-05 16:11:54 -0800 | [diff] [blame] | 541 | } |
Steven Moreland | e2c64b4 | 2018-09-18 15:06:37 -0700 | [diff] [blame] | 542 | } |
| 543 | |
Devin Moore | 0d0e3f6 | 2020-03-30 17:45:39 -0700 | [diff] [blame] | 544 | if (defined_type->IsVintfStability()) { |
| 545 | bool success = true; |
| 546 | if (options.GetStability() != Options::Stability::VINTF) { |
| 547 | AIDL_ERROR(defined_type) |
| 548 | << "Must compile @VintfStability type w/ aidl_interface 'stability: \"vintf\"'"; |
| 549 | success = false; |
| 550 | } |
| 551 | if (!options.IsStructured()) { |
| 552 | AIDL_ERROR(defined_type) |
| 553 | << "Must compile @VintfStability type w/ aidl_interface --structured"; |
| 554 | success = false; |
| 555 | } |
| 556 | if (!success) return AidlError::NOT_STRUCTURED; |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 557 | } |
| 558 | |
Jooyung Han | 2a86ba8 | 2021-12-02 01:41:19 +0900 | [diff] [blame] | 559 | // Verify the var/const declarations. |
| 560 | // const expressions should be non-empty when evaluated with the var/const type. |
| 561 | for (const auto& constant : defined_type->GetConstantDeclarations()) { |
| 562 | if (constant->ValueString(AidlConstantValueDecorator).empty()) { |
| 563 | return AidlError::BAD_TYPE; |
| 564 | } |
| 565 | } |
| 566 | for (const auto& var : defined_type->GetFields()) { |
| 567 | if (var->GetDefaultValue() && var->ValueString(AidlConstantValueDecorator).empty()) { |
| 568 | return AidlError::BAD_TYPE; |
| 569 | } |
| 570 | } |
| 571 | } |
| 572 | |
| 573 | // Add meta methods and assign method IDs to each interface |
| 574 | typenames->IterateTypes([&](const AidlDefinedType& type) { |
| 575 | auto interface = const_cast<AidlInterface*>(type.AsInterface()); |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 576 | if (interface != nullptr) { |
| 577 | // add the meta-method 'int getInterfaceVersion()' if version is specified. |
| 578 | if (options.Version() > 0) { |
Jooyung Han | accd919 | 2021-10-14 15:57:28 +0900 | [diff] [blame] | 579 | auto ret = typenames->MakeResolvedType(AIDL_LOCATION_HERE, "int", false); |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 580 | vector<unique_ptr<AidlArgument>>* args = new vector<unique_ptr<AidlArgument>>(); |
Jooyung Han | ae01675 | 2022-02-26 21:33:43 +0900 | [diff] [blame] | 581 | auto method = std::make_unique<AidlMethod>(AIDL_LOCATION_HERE, false, ret.release(), |
| 582 | "getInterfaceVersion", args, Comments{}, |
| 583 | kGetInterfaceVersionId); |
Jooyung Han | 3f347ca | 2020-12-01 12:41:50 +0900 | [diff] [blame] | 584 | interface->AddMethod(std::move(method)); |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 585 | } |
Paul Trautrim | b77048c | 2020-01-21 16:39:32 +0900 | [diff] [blame] | 586 | // add the meta-method 'string getInterfaceHash()' if hash is specified. |
| 587 | if (!options.Hash().empty()) { |
Jooyung Han | accd919 | 2021-10-14 15:57:28 +0900 | [diff] [blame] | 588 | auto ret = typenames->MakeResolvedType(AIDL_LOCATION_HERE, "String", false); |
Paul Trautrim | b77048c | 2020-01-21 16:39:32 +0900 | [diff] [blame] | 589 | vector<unique_ptr<AidlArgument>>* args = new vector<unique_ptr<AidlArgument>>(); |
Jooyung Han | ae01675 | 2022-02-26 21:33:43 +0900 | [diff] [blame] | 590 | auto method = |
| 591 | std::make_unique<AidlMethod>(AIDL_LOCATION_HERE, false, ret.release(), |
| 592 | kGetInterfaceHash, args, Comments{}, kGetInterfaceHashId); |
Jooyung Han | 3f347ca | 2020-12-01 12:41:50 +0900 | [diff] [blame] | 593 | interface->AddMethod(std::move(method)); |
Paul Trautrim | b77048c | 2020-01-21 16:39:32 +0900 | [diff] [blame] | 594 | } |
Jooyung Han | 2a86ba8 | 2021-12-02 01:41:19 +0900 | [diff] [blame] | 595 | if (!CheckAndAssignMethodIDs(interface->GetMethods())) { |
| 596 | err = AidlError::BAD_METHOD_ID; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 597 | } |
Jooyung Han | cfe0800 | 2020-12-04 12:56:35 +0900 | [diff] [blame] | 598 | } |
Jooyung Han | 2a86ba8 | 2021-12-02 01:41:19 +0900 | [diff] [blame] | 599 | }); |
| 600 | if (err != AidlError::OK) { |
| 601 | return err; |
Christopher Wiley | 632801d | 2015-11-05 14:15:49 -0800 | [diff] [blame] | 602 | } |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 603 | |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 604 | for (const auto& doc : typenames->AllDocuments()) { |
| 605 | VisitTopDown([](const AidlNode& n) { n.MarkVisited(); }, *doc); |
| 606 | } |
| 607 | |
Jooyung Han | 74406c5 | 2021-11-06 06:17:36 +0900 | [diff] [blame] | 608 | if (!CheckValid(*document, options)) { |
| 609 | return AidlError::BAD_TYPE; |
| 610 | } |
| 611 | |
Jooyung Han | ce6733e | 2021-05-22 02:44:17 +0900 | [diff] [blame] | 612 | if (!ValidateAnnotationContext(*document)) { |
Jooyung Han | 2d6b5c4 | 2021-01-09 01:01:06 +0900 | [diff] [blame] | 613 | return AidlError::BAD_TYPE; |
| 614 | } |
| 615 | |
Jooyung Han | 2cb8ecd | 2021-07-28 18:41:30 +0900 | [diff] [blame] | 616 | if ((options.TargetLanguage() == Options::Language::CPP || |
| 617 | options.TargetLanguage() == Options::Language::NDK) && |
| 618 | !ValidateCppHeader(*document)) { |
| 619 | return AidlError::BAD_TYPE; |
| 620 | } |
| 621 | |
Jooyung Han | 8e3b72c | 2021-05-22 02:54:37 +0900 | [diff] [blame] | 622 | if (!Diagnose(*document, options.GetDiagnosticMapping())) { |
Jiyong Park | d911332 | 2020-12-31 03:20:33 +0900 | [diff] [blame] | 623 | return AidlError::BAD_TYPE; |
Jooyung Han | 888c5bc | 2020-12-22 17:28:47 +0900 | [diff] [blame] | 624 | } |
| 625 | |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 626 | typenames->IterateTypes([&](const AidlDefinedType& type) { |
Jooyung Han | b4997aa | 2021-10-16 03:26:12 +0900 | [diff] [blame] | 627 | if (!type.LanguageSpecificCheckValid(options.TargetLanguage())) { |
Steven Moreland | 58d402b | 2021-07-27 18:35:07 -0700 | [diff] [blame] | 628 | err = AidlError::BAD_TYPE; |
| 629 | } |
| 630 | |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 631 | if (options.IsStructured() && type.AsUnstructuredParcelable() != nullptr && |
Jeongik Cha | 88f95a8 | 2020-01-15 13:02:16 +0900 | [diff] [blame] | 632 | !type.AsUnstructuredParcelable()->IsStableApiParcelable(options.TargetLanguage())) { |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 633 | err = AidlError::NOT_STRUCTURED; |
Devin Moore | 097a3ab | 2020-03-11 16:08:44 -0700 | [diff] [blame] | 634 | AIDL_ERROR(type) << type.GetCanonicalName() |
| 635 | << " is not structured, but this is a structured interface."; |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 636 | } |
| 637 | if (options.GetStability() == Options::Stability::VINTF && !type.IsVintfStability()) { |
| 638 | err = AidlError::NOT_STRUCTURED; |
Devin Moore | 097a3ab | 2020-03-11 16:08:44 -0700 | [diff] [blame] | 639 | AIDL_ERROR(type) << type.GetCanonicalName() |
| 640 | << " does not have VINTF level stability, but this interface requires it."; |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 641 | } |
Jiyong Park | f8d5361 | 2020-05-04 14:06:13 +0900 | [diff] [blame] | 642 | |
Jeongik Cha | ef44e62 | 2020-10-23 16:00:52 +0900 | [diff] [blame] | 643 | // Ensure that untyped List/Map is not used in a parcelable, a union and a stable interface. |
Jiyong Park | f8d5361 | 2020-05-04 14:06:13 +0900 | [diff] [blame] | 644 | |
Jeongik Cha | ef44e62 | 2020-10-23 16:00:52 +0900 | [diff] [blame] | 645 | std::function<void(const AidlTypeSpecifier&, const AidlNode*)> check_untyped_container = |
| 646 | [&err, &check_untyped_container](const AidlTypeSpecifier& type, const AidlNode* node) { |
| 647 | if (type.IsGeneric()) { |
| 648 | std::for_each(type.GetTypeParameters().begin(), type.GetTypeParameters().end(), |
| 649 | [&node, &check_untyped_container](auto& nested) { |
| 650 | check_untyped_container(*nested, node); |
| 651 | }); |
| 652 | return; |
Jiyong Park | f8d5361 | 2020-05-04 14:06:13 +0900 | [diff] [blame] | 653 | } |
Jeongik Cha | ef44e62 | 2020-10-23 16:00:52 +0900 | [diff] [blame] | 654 | if (type.GetName() == "List" || type.GetName() == "Map") { |
| 655 | err = AidlError::BAD_TYPE; |
| 656 | AIDL_ERROR(node) |
| 657 | << "Encountered an untyped List or Map. The use of untyped List/Map is prohibited " |
| 658 | << "because it is not guaranteed that the objects in the list are recognizable in " |
| 659 | << "the receiving side. Consider switching to an array or a generic List/Map."; |
| 660 | } |
| 661 | }; |
Jeongik Cha | ef44e62 | 2020-10-23 16:00:52 +0900 | [diff] [blame] | 662 | |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 663 | if (type.AsInterface() && options.IsStructured()) { |
| 664 | for (const auto& method : type.GetMethods()) { |
Jeongik Cha | ef44e62 | 2020-10-23 16:00:52 +0900 | [diff] [blame] | 665 | check_untyped_container(method->GetType(), method.get()); |
| 666 | for (const auto& arg : method->GetArguments()) { |
| 667 | check_untyped_container(arg->GetType(), method.get()); |
Jiyong Park | f8d5361 | 2020-05-04 14:06:13 +0900 | [diff] [blame] | 668 | } |
Jeongik Cha | ef44e62 | 2020-10-23 16:00:52 +0900 | [diff] [blame] | 669 | } |
Jooyung Han | 829ec7c | 2020-12-02 12:07:36 +0900 | [diff] [blame] | 670 | } |
| 671 | for (const auto& field : type.GetFields()) { |
| 672 | check_untyped_container(field->GetType(), field.get()); |
Jiyong Park | f8d5361 | 2020-05-04 14:06:13 +0900 | [diff] [blame] | 673 | } |
Steven Moreland | a57d0a6 | 2019-07-30 09:41:14 -0700 | [diff] [blame] | 674 | }); |
| 675 | |
Steven Moreland | 6cee348 | 2018-07-18 14:39:58 -0700 | [diff] [blame] | 676 | if (err != AidlError::OK) { |
| 677 | return err; |
| 678 | } |
| 679 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 680 | if (imported_files != nullptr) { |
Jiyong Park | e59c368 | 2018-09-11 23:10:25 +0900 | [diff] [blame] | 681 | *imported_files = import_paths; |
Christopher Wiley | 3a9d158 | 2015-09-16 12:42:14 -0700 | [diff] [blame] | 682 | } |
Casey Dahlin | 0edf342 | 2015-10-07 12:34:59 -0700 | [diff] [blame] | 683 | |
Christopher Wiley | 632801d | 2015-11-05 14:15:49 -0800 | [diff] [blame] | 684 | return AidlError::OK; |
Christopher Wiley | eb1acc1 | 2015-09-16 11:25:13 -0700 | [diff] [blame] | 685 | } |
| 686 | |
Casey Dahlin | 2cc9316 | 2015-10-02 16:14:17 -0700 | [diff] [blame] | 687 | } // namespace internals |
| 688 | |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 689 | bool compile_aidl(const Options& options, const IoDelegate& io_delegate) { |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 690 | const Options::Language lang = options.TargetLanguage(); |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 691 | for (const string& input_file : options.InputFiles()) { |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 692 | AidlTypenames typenames; |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 693 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 694 | vector<string> imported_files; |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 695 | |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 696 | AidlError aidl_err = internals::load_and_validate_aidl(input_file, options, io_delegate, |
| 697 | &typenames, &imported_files); |
Jooyung Han | 05a532a | 2021-08-18 10:41:40 +0900 | [diff] [blame] | 698 | if (aidl_err != AidlError::OK) { |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 699 | return false; |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 700 | } |
Christopher Wiley | eb1acc1 | 2015-09-16 11:25:13 -0700 | [diff] [blame] | 701 | |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 702 | for (const auto& defined_type : typenames.MainDocument().DefinedTypes()) { |
Steven Moreland | 2178081 | 2020-09-11 01:29:45 +0000 | [diff] [blame] | 703 | AIDL_FATAL_IF(defined_type == nullptr, input_file); |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 704 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 705 | string output_file_name = options.OutputFile(); |
| 706 | // if needed, generate the output file name from the base folder |
| 707 | if (output_file_name.empty() && !options.OutputDir().empty()) { |
Jooyung Han | b3cd63f | 2021-01-05 13:38:46 +0900 | [diff] [blame] | 708 | output_file_name = GetOutputFilePath(options, *defined_type); |
Jiyong Park | b03551f | 2018-08-06 19:20:51 +0900 | [diff] [blame] | 709 | if (output_file_name.empty()) { |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 710 | return false; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 711 | } |
| 712 | } |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 713 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 714 | if (!write_dep_file(options, *defined_type, imported_files, io_delegate, input_file, |
| 715 | output_file_name)) { |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 716 | return false; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 717 | } |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 718 | |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 719 | bool success = false; |
| 720 | if (lang == Options::Language::CPP) { |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 721 | success = |
| 722 | cpp::GenerateCpp(output_file_name, options, typenames, *defined_type, io_delegate); |
Steven Moreland | c26d814 | 2018-09-17 14:25:33 -0700 | [diff] [blame] | 723 | } else if (lang == Options::Language::NDK) { |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 724 | ndk::GenerateNdk(output_file_name, options, typenames, *defined_type, io_delegate); |
Steven Moreland | c26d814 | 2018-09-17 14:25:33 -0700 | [diff] [blame] | 725 | success = true; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 726 | } else if (lang == Options::Language::JAVA) { |
Jiyong Park | 9ca5c7e | 2019-10-17 15:01:14 +0900 | [diff] [blame] | 727 | if (defined_type->AsUnstructuredParcelable() != nullptr) { |
| 728 | // Legacy behavior. For parcelable declarations in Java, don't generate output file. |
| 729 | success = true; |
| 730 | } else { |
Jooyung Han | 7445d28 | 2021-10-07 18:16:22 +0900 | [diff] [blame] | 731 | java::GenerateJava(output_file_name, options, typenames, *defined_type, io_delegate); |
| 732 | success = true; |
Jiyong Park | 9ca5c7e | 2019-10-17 15:01:14 +0900 | [diff] [blame] | 733 | } |
Andrei Homescu | b62afd9 | 2020-05-11 19:24:59 -0700 | [diff] [blame] | 734 | } else if (lang == Options::Language::RUST) { |
Jooyung Han | 9e3dae3 | 2021-10-08 02:32:24 +0900 | [diff] [blame] | 735 | rust::GenerateRust(output_file_name, options, typenames, *defined_type, io_delegate); |
| 736 | success = true; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 737 | } else { |
Steven Moreland | 2178081 | 2020-09-11 01:29:45 +0000 | [diff] [blame] | 738 | AIDL_FATAL(input_file) << "Should not reach here."; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 739 | } |
| 740 | if (!success) { |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 741 | return false; |
Jiyong Park | b034bf0 | 2018-07-30 17:44:33 +0900 | [diff] [blame] | 742 | } |
Jiyong Park | 74595c1 | 2018-07-23 15:22:50 +0900 | [diff] [blame] | 743 | } |
Christopher Wiley | 3a9d158 | 2015-09-16 12:42:14 -0700 | [diff] [blame] | 744 | } |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 745 | return true; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 746 | } |
| 747 | |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 748 | bool dump_mappings(const Options& options, const IoDelegate& io_delegate) { |
| 749 | android::aidl::mappings::SignatureMap all_mappings; |
| 750 | for (const string& input_file : options.InputFiles()) { |
Jeongik Cha | 047c5ee | 2019-08-07 23:16:49 +0900 | [diff] [blame] | 751 | AidlTypenames typenames; |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 752 | vector<string> imported_files; |
| 753 | |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 754 | AidlError aidl_err = internals::load_and_validate_aidl(input_file, options, io_delegate, |
| 755 | &typenames, &imported_files); |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 756 | if (aidl_err != AidlError::OK) { |
Jiyong Park | 3a06039 | 2020-04-11 21:02:19 +0900 | [diff] [blame] | 757 | return false; |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 758 | } |
Jiyong Park | 8e79b7f | 2020-07-20 20:52:38 +0900 | [diff] [blame] | 759 | for (const auto& defined_type : typenames.MainDocument().DefinedTypes()) { |
Jooyung Han | 2ca04f5 | 2021-11-26 15:11:45 +0900 | [diff] [blame] | 760 | auto mappings = mappings::generate_mappings(defined_type.get()); |
Andrei Onea | 8714b02 | 2019-02-01 18:55:54 +0000 | [diff] [blame] | 761 | all_mappings.insert(mappings.begin(), mappings.end()); |
| 762 | } |
| 763 | } |
| 764 | std::stringstream mappings_str; |
| 765 | for (const auto& mapping : all_mappings) { |
| 766 | mappings_str << mapping.first << "\n" << mapping.second << "\n"; |
| 767 | } |
| 768 | auto code_writer = io_delegate.GetCodeWriter(options.OutputFile()); |
| 769 | code_writer->Write("%s", mappings_str.str().c_str()); |
| 770 | return true; |
| 771 | } |
| 772 | |
Steven Moreland | 3981d9e | 2020-03-31 14:11:44 -0700 | [diff] [blame] | 773 | int aidl_entry(const Options& options, const IoDelegate& io_delegate) { |
Steven Moreland | 33efcf6 | 2020-04-10 16:40:43 -0700 | [diff] [blame] | 774 | AidlErrorLog::clearError(); |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 775 | AidlNode::ClearUnvisitedNodes(); |
Steven Moreland | 33efcf6 | 2020-04-10 16:40:43 -0700 | [diff] [blame] | 776 | |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 777 | bool success = false; |
Steven Moreland | f9b398b | 2021-08-11 13:43:48 -0700 | [diff] [blame] | 778 | if (options.Ok()) { |
| 779 | switch (options.GetTask()) { |
| 780 | case Options::Task::HELP: |
| 781 | success = true; |
| 782 | break; |
| 783 | case Options::Task::COMPILE: |
| 784 | success = android::aidl::compile_aidl(options, io_delegate); |
| 785 | break; |
| 786 | case Options::Task::PREPROCESS: |
| 787 | success = android::aidl::Preprocess(options, io_delegate); |
| 788 | break; |
| 789 | case Options::Task::DUMP_API: |
| 790 | success = android::aidl::dump_api(options, io_delegate); |
| 791 | break; |
| 792 | case Options::Task::CHECK_API: |
| 793 | success = android::aidl::check_api(options, io_delegate); |
| 794 | break; |
| 795 | case Options::Task::DUMP_MAPPINGS: |
| 796 | success = android::aidl::dump_mappings(options, io_delegate); |
| 797 | break; |
| 798 | default: |
| 799 | AIDL_FATAL(AIDL_LOCATION_HERE) |
| 800 | << "Unrecognized task: " << static_cast<size_t>(options.GetTask()); |
| 801 | } |
| 802 | } else { |
| 803 | AIDL_ERROR(options.GetErrorMessage()) << options.GetUsage(); |
Steven Moreland | 3981d9e | 2020-03-31 14:11:44 -0700 | [diff] [blame] | 804 | } |
| 805 | |
Steven Moreland | 2178081 | 2020-09-11 01:29:45 +0000 | [diff] [blame] | 806 | const bool reportedError = AidlErrorLog::hadError(); |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 807 | AIDL_FATAL_IF(success == reportedError, AIDL_LOCATION_HERE) |
| 808 | << "Compiler returned success " << success << " but did" << (reportedError ? "" : " not") |
Steven Moreland | 2178081 | 2020-09-11 01:29:45 +0000 | [diff] [blame] | 809 | << " emit error logs"; |
Steven Moreland | 3981d9e | 2020-03-31 14:11:44 -0700 | [diff] [blame] | 810 | |
Jooyung Han | 2b3cd2a | 2021-10-15 06:54:55 +0900 | [diff] [blame] | 811 | if (success) { |
| 812 | auto locations = AidlNode::GetLocationsOfUnvisitedNodes(); |
| 813 | if (!locations.empty()) { |
| 814 | for (const auto& location : locations) { |
| 815 | AIDL_ERROR(location) << "AidlNode at location was not visited!"; |
| 816 | } |
| 817 | AIDL_FATAL(AIDL_LOCATION_HERE) |
| 818 | << "The AIDL AST was not processed fully. Please report an issue."; |
| 819 | } |
| 820 | } |
| 821 | |
Steven Moreland | 4e05913 | 2021-08-11 13:36:30 -0700 | [diff] [blame] | 822 | return success ? 0 : 1; |
Steven Moreland | 3981d9e | 2020-03-31 14:11:44 -0700 | [diff] [blame] | 823 | } |
| 824 | |
Christopher Wiley | fdeb0f4 | 2015-09-11 15:38:22 -0700 | [diff] [blame] | 825 | } // namespace aidl |
Steven Moreland | f4c64df | 2019-07-29 19:54:04 -0700 | [diff] [blame] | 826 | } // namespace android |