blob: 03ae26eb8bc034f2a53ffc96d0462b9ca7657dca [file] [log] [blame]
Andreas Huber1aec3972016-08-26 09:26:32 -07001/*
2 * Copyright (C) 2016 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
Andreas Huberc9410c72016-07-28 12:18:40 -070017#include "AST.h"
Andreas Huber5345ec22016-07-29 13:33:27 -070018#include "Coordinator.h"
Andreas Huber0fa9e392016-08-31 09:05:44 -070019#include "Scope.h"
Andreas Huberc9410c72016-07-28 12:18:40 -070020
Steven Moreland5bdfa702017-04-18 23:20:39 -070021#include <hidl-hash/Hash.h>
Iliyan Malcheva72e0d22016-09-09 11:03:08 -070022#include <hidl-util/Formatter.h>
Steven Moreland7ae3d542017-01-18 16:46:01 -080023#include <hidl-util/FQName.h>
Steven Morelandd177b122016-12-12 09:15:37 -080024#include <hidl-util/StringHelper.h>
Andreas Huber68f24592016-07-29 14:53:48 -070025#include <android-base/logging.h>
Iliyan Malchev5bb14022016-08-09 15:04:39 -070026#include <set>
Andreas Huberc9410c72016-07-28 12:18:40 -070027#include <stdio.h>
Andreas Huberdca261f2016-08-04 13:47:51 -070028#include <string>
Andreas Huberb82318c2016-08-02 14:45:54 -070029#include <unistd.h>
Andreas Huberdca261f2016-08-04 13:47:51 -070030#include <vector>
Andreas Huberc9410c72016-07-28 12:18:40 -070031
32using namespace android;
33
Iliyan Malchev5bb14022016-08-09 15:04:39 -070034struct OutputHandler {
35 std::string mKey;
Andreas Huber019d21d2016-10-03 12:59:47 -070036 enum OutputMode {
37 NEEDS_DIR,
38 NEEDS_FILE,
39 NOT_NEEDED
40 } mOutputMode;
41
Iliyan Malchev5bb14022016-08-09 15:04:39 -070042 enum ValRes {
43 FAILED,
44 PASS_PACKAGE,
45 PASS_FULL
46 };
Steven Morelanddd583842017-04-19 13:09:57 -070047 const std::string& name() { return mKey; }
Steven Morelandbbbbeb82017-05-09 14:20:50 -070048
49 using ValidationFunction = std::function<ValRes(const FQName &, const std::string &language)>;
50 using GenerationFunction = std::function<status_t(const FQName &fqName,
51 const char *hidl_gen,
52 Coordinator *coordinator,
53 const std::string &outputDir)>;
54
55 ValidationFunction validate;
56 GenerationFunction generate;
Iliyan Malchev5bb14022016-08-09 15:04:39 -070057};
Andreas Huberdca261f2016-08-04 13:47:51 -070058
Iliyan Malchev5bb14022016-08-09 15:04:39 -070059static status_t generateSourcesForFile(
60 const FQName &fqName,
61 const char *,
62 Coordinator *coordinator,
Andreas Huber2831d512016-08-15 09:33:47 -070063 const std::string &outputDir,
Zhuoyao Zhang5158db42016-08-10 10:25:20 -070064 const std::string &lang) {
Iliyan Malchev5bb14022016-08-09 15:04:39 -070065 CHECK(fqName.isFullyQualified());
66
Andreas Huber0fa9e392016-08-31 09:05:44 -070067 AST *ast;
Andreas Huberd29724f2016-09-14 09:33:13 -070068 std::string limitToType;
Andreas Huber0fa9e392016-08-31 09:05:44 -070069
70 if (fqName.name().find("types.") == 0) {
71 CHECK(lang == "java"); // Already verified in validate().
72
Andreas Huberd29724f2016-09-14 09:33:13 -070073 limitToType = fqName.name().substr(strlen("types."));
Andreas Huber0fa9e392016-08-31 09:05:44 -070074
Yifan Hongfece6ec2017-01-12 17:04:04 -080075 FQName typesName = fqName.getTypesForPackage();
Andreas Huber0fa9e392016-08-31 09:05:44 -070076 ast = coordinator->parse(typesName);
77 } else {
78 ast = coordinator->parse(fqName);
79 }
Iliyan Malchev5bb14022016-08-09 15:04:39 -070080
81 if (ast == NULL) {
82 fprintf(stderr,
Andreas Huber70a59e12016-08-16 12:57:01 -070083 "ERROR: Could not parse %s. Aborting.\n",
Iliyan Malchev5bb14022016-08-09 15:04:39 -070084 fqName.string().c_str());
85
86 return UNKNOWN_ERROR;
87 }
88
Steven Moreland3b1ce262017-04-21 14:19:59 -070089 if (lang == "check") {
90 return OK; // only parsing, not generating
91 }
Zhuoyao Zhang5158db42016-08-10 10:25:20 -070092 if (lang == "c++") {
93 return ast->generateCpp(outputDir);
94 }
Steven Moreland1cbf0362017-05-09 14:32:53 -070095 if (lang == "c++-headers") {
96 return ast->generateCppHeaders(outputDir);
97 }
98 if (lang == "c++-sources") {
99 return ast->generateCppSources(outputDir);
100 }
Steven Moreland9c387612016-09-07 09:54:26 -0700101 if (lang == "c++-impl") {
102 return ast->generateCppImpl(outputDir);
103 }
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700104 if (lang == "java") {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700105 return ast->generateJava(outputDir, limitToType);
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700106 }
107 if (lang == "vts") {
108 return ast->generateVts(outputDir);
109 }
110 // Unknown language.
111 return UNKNOWN_ERROR;
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700112}
113
114static status_t generateSourcesForPackage(
115 const FQName &packageFQName,
116 const char *hidl_gen,
117 Coordinator *coordinator,
Andreas Huber2831d512016-08-15 09:33:47 -0700118 const std::string &outputDir,
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700119 const std::string &lang) {
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700120 CHECK(packageFQName.isValid() &&
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700121 !packageFQName.isFullyQualified() &&
122 packageFQName.name().empty());
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700123
124 std::vector<FQName> packageInterfaces;
125
126 status_t err =
Steven Morelandaa186832016-09-26 13:51:43 -0700127 coordinator->appendPackageInterfacesToVector(packageFQName,
128 &packageInterfaces);
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700129
130 if (err != OK) {
131 return err;
132 }
133
134 for (const auto &fqName : packageInterfaces) {
Andreas Huber2831d512016-08-15 09:33:47 -0700135 err = generateSourcesForFile(
Zhuoyao Zhang5158db42016-08-10 10:25:20 -0700136 fqName, hidl_gen, coordinator, outputDir, lang);
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700137 if (err != OK) {
138 return err;
139 }
140 }
141
142 return OK;
Andreas Huberb82318c2016-08-02 14:45:54 -0700143}
144
Steven Morelandbbbbeb82017-05-09 14:20:50 -0700145OutputHandler::GenerationFunction generationFunctionForFileOrPackage(const std::string &language) {
146 return [language](const FQName &fqName,
147 const char *hidl_gen, Coordinator *coordinator,
148 const std::string &outputDir) -> status_t {
149 if (fqName.isFullyQualified()) {
150 return generateSourcesForFile(fqName,
151 hidl_gen,
152 coordinator,
153 outputDir,
154 language);
155 } else {
156 return generateSourcesForPackage(fqName,
157 hidl_gen,
158 coordinator,
159 outputDir,
160 language);
161 }
162 };
163}
164
Andreas Huberd2943e12016-08-05 11:59:31 -0700165static std::string makeLibraryName(const FQName &packageFQName) {
Iliyan Malcheve2c595a2016-08-07 21:20:04 -0700166 return packageFQName.string();
Andreas Huberd2943e12016-08-05 11:59:31 -0700167}
168
Andreas Huberaa573272017-04-13 09:58:06 -0700169static std::string makeJavaLibraryName(const FQName &packageFQName) {
170 std::string out;
171 out = packageFQName.package();
172 out += "-V";
173 out += packageFQName.version();
174 return out;
175}
176
Steven Moreland5715fed2017-01-16 11:06:47 -0800177static void generatePackagePathsSection(
178 Formatter &out,
179 Coordinator *coordinator,
180 const FQName &packageFQName,
181 const std::set<FQName> &importedPackages,
182 bool forMakefiles = false) {
183 std::set<std::string> options{};
184 for (const auto &interface : importedPackages) {
185 options.insert(coordinator->getPackageRootOption(interface));
186 }
187 options.insert(coordinator->getPackageRootOption(packageFQName));
188 options.insert(coordinator->getPackageRootOption(gIBasePackageFqName));
189 for (const auto &option : options) {
190 out << "-r"
191 << option
192 << " ";
193 if (forMakefiles) {
194 out << "\\\n";
195 }
196 }
197}
198
Dan Willemsen676abdc2016-09-28 19:42:22 -0700199static void generateMakefileSectionForType(
Andreas Huber0fa9e392016-08-31 09:05:44 -0700200 Formatter &out,
201 Coordinator *coordinator,
202 const FQName &packageFQName,
203 const FQName &fqName,
Steven Moreland5715fed2017-01-16 11:06:47 -0800204 const std::set<FQName> &importedPackages,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700205 const char *typeName) {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700206 out << "\n"
207 << "\n#"
208 << "\n# Build " << fqName.name() << ".hal";
209
Dan Willemsen676abdc2016-09-28 19:42:22 -0700210 if (typeName != nullptr) {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700211 out << " (" << typeName << ")";
212 }
213
214 out << "\n#"
215 << "\nGEN := $(intermediates)/"
216 << coordinator->convertPackageRootToPath(packageFQName)
Yifan Hong97288ac2016-12-12 16:03:51 -0800217 << coordinator->getPackagePath(packageFQName, true /* relative */,
218 true /* sanitized */);
Dan Willemsen676abdc2016-09-28 19:42:22 -0700219 if (typeName == nullptr) {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700220 out << fqName.name() << ".java";
221 } else {
222 out << typeName << ".java";
223 }
224
225 out << "\n$(GEN): $(HIDL)";
226 out << "\n$(GEN): PRIVATE_HIDL := $(HIDL)";
227 out << "\n$(GEN): PRIVATE_DEPS := $(LOCAL_PATH)/"
228 << fqName.name() << ".hal";
Iliyan Malchevb9819132016-09-07 12:38:31 -0700229
230 {
231 AST *ast = coordinator->parse(fqName);
232 CHECK(ast != nullptr);
233 const std::set<FQName>& refs = ast->getImportedNames();
234 for (auto depFQName : refs) {
235 // If the package of depFQName is the same as this fqName's package,
236 // then add it explicitly as a .hal dependency within the same
237 // package.
238 if (fqName.package() == depFQName.package() &&
239 fqName.version() == depFQName.version()) {
240 // PRIVATE_DEPS is not actually being used in the
241 // auto-generated file, but is necessary if the build rule
242 // ever needs to use the dependency information, since the
243 // built-in Make variables are not supported in the Android
244 // build system.
245 out << "\n$(GEN): PRIVATE_DEPS += $(LOCAL_PATH)/"
246 << depFQName.name() << ".hal";
247 // This is the actual dependency.
248 out << "\n$(GEN): $(LOCAL_PATH)/"
249 << depFQName.name() << ".hal";
250 }
251 }
252 }
253
Andreas Huber0fa9e392016-08-31 09:05:44 -0700254 out << "\n$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)"
255 << "\n$(GEN): PRIVATE_CUSTOM_TOOL = \\";
256 out.indent();
257 out.indent();
258 out << "\n$(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \\"
Steven Moreland5715fed2017-01-16 11:06:47 -0800259 << "\n-Ljava \\\n";
260
261 generatePackagePathsSection(out, coordinator, packageFQName, importedPackages, true /* forJava */);
Andreas Huber0fa9e392016-08-31 09:05:44 -0700262
263 out << packageFQName.string()
264 << "::"
265 << fqName.name();
266
Dan Willemsen676abdc2016-09-28 19:42:22 -0700267 if (typeName != nullptr) {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700268 out << "." << typeName;
269 }
270
271 out << "\n";
272
273 out.unindent();
274 out.unindent();
275
276 out << "\n$(GEN): $(LOCAL_PATH)/" << fqName.name() << ".hal";
277 out << "\n\t$(transform-generated-source)";
278 out << "\nLOCAL_GENERATED_SOURCES += $(GEN)";
279}
280
Dan Willemsen676abdc2016-09-28 19:42:22 -0700281static void generateMakefileSection(
Andreas Huber0fa9e392016-08-31 09:05:44 -0700282 Formatter &out,
283 Coordinator *coordinator,
284 const FQName &packageFQName,
285 const std::vector<FQName> &packageInterfaces,
Steven Moreland5715fed2017-01-16 11:06:47 -0800286 const std::set<FQName> &importedPackages,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700287 AST *typesAST) {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700288 for (const auto &fqName : packageInterfaces) {
Dan Willemsen676abdc2016-09-28 19:42:22 -0700289 if (fqName.name() == "types") {
Andreas Huber0fa9e392016-08-31 09:05:44 -0700290 CHECK(typesAST != nullptr);
291
292 Scope *rootScope = typesAST->scope();
Andreas Huber0fa9e392016-08-31 09:05:44 -0700293
Andreas Huberb747bd92016-09-26 15:55:31 -0700294 std::vector<NamedType *> subTypes = rootScope->getSubTypes();
295 std::sort(
296 subTypes.begin(),
297 subTypes.end(),
298 [](const NamedType *a, const NamedType *b) -> bool {
299 return a->fqName() < b->fqName();
300 });
301
302 for (const auto &type : subTypes) {
Andreas Huberdda25cc2016-09-22 10:39:47 -0700303 if (type->isTypeDef()) {
304 continue;
305 }
306
Dan Willemsen676abdc2016-09-28 19:42:22 -0700307 generateMakefileSectionForType(
Andreas Huber0fa9e392016-08-31 09:05:44 -0700308 out,
309 coordinator,
310 packageFQName,
311 fqName,
Steven Moreland5715fed2017-01-16 11:06:47 -0800312 importedPackages,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700313 type->localName().c_str());
Andreas Huber0fa9e392016-08-31 09:05:44 -0700314 }
315
316 continue;
317 }
318
Dan Willemsen676abdc2016-09-28 19:42:22 -0700319 generateMakefileSectionForType(
Andreas Huber0fa9e392016-08-31 09:05:44 -0700320 out,
321 coordinator,
322 packageFQName,
323 fqName,
Steven Moreland5715fed2017-01-16 11:06:47 -0800324 importedPackages,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700325 nullptr /* typeName */);
Andreas Huber0fa9e392016-08-31 09:05:44 -0700326 }
327}
328
Andreas Huber75ae95d2016-10-12 16:08:26 -0700329static status_t isPackageJavaCompatible(
330 const FQName &packageFQName,
331 Coordinator *coordinator,
332 bool *compatible) {
333 std::vector<FQName> todo;
334 status_t err =
335 coordinator->appendPackageInterfacesToVector(packageFQName, &todo);
336
337 if (err != OK) {
338 return err;
339 }
340
341 std::set<FQName> seen;
342 for (const auto &iface : todo) {
343 seen.insert(iface);
344 }
345
346 // Form the transitive closure of all imported interfaces (and types.hal-s)
347 // If any one of them is not java compatible, this package isn't either.
348 while (!todo.empty()) {
349 const FQName fqName = todo.back();
350 todo.pop_back();
351
352 AST *ast = coordinator->parse(fqName);
353
354 if (ast == nullptr) {
355 return UNKNOWN_ERROR;
356 }
357
358 if (!ast->isJavaCompatible()) {
359 *compatible = false;
360 return OK;
361 }
362
363 std::set<FQName> importedPackages;
364 ast->getImportedPackages(&importedPackages);
365
366 for (const auto &package : importedPackages) {
367 std::vector<FQName> packageInterfaces;
368 status_t err = coordinator->appendPackageInterfacesToVector(
369 package, &packageInterfaces);
370
371 if (err != OK) {
372 return err;
373 }
374
375 for (const auto &iface : packageInterfaces) {
376 if (seen.find(iface) != seen.end()) {
377 continue;
378 }
379
380 todo.push_back(iface);
381 seen.insert(iface);
382 }
383 }
384 }
385
386 *compatible = true;
387 return OK;
388}
389
Andreas Huber5a9fe2c2016-10-13 15:31:10 -0700390static bool packageNeedsJavaCode(
391 const std::vector<FQName> &packageInterfaces, AST *typesAST) {
392 // If there is more than just a types.hal file to this package we'll
393 // definitely need to generate Java code.
394 if (packageInterfaces.size() > 1
395 || packageInterfaces[0].name() != "types") {
396 return true;
397 }
398
399 CHECK(typesAST != nullptr);
400
401 // We'll have to generate Java code if types.hal contains any non-typedef
402 // type declarations.
403
404 Scope *rootScope = typesAST->scope();
405 std::vector<NamedType *> subTypes = rootScope->getSubTypes();
406
407 for (const auto &subType : subTypes) {
408 if (!subType->isTypeDef()) {
409 return true;
410 }
411 }
412
413 return false;
414}
415
Andreas Huber1c507272016-10-05 14:33:21 -0700416static void generateMakefileSectionForJavaConstants(
417 Formatter &out,
418 Coordinator *coordinator,
419 const FQName &packageFQName,
Steven Moreland5715fed2017-01-16 11:06:47 -0800420 const std::vector<FQName> &packageInterfaces,
421 const std::set<FQName> &importedPackages) {
Andreas Huber1c507272016-10-05 14:33:21 -0700422 out << "\n#"
423 << "\nGEN := $(intermediates)/"
424 << coordinator->convertPackageRootToPath(packageFQName)
Yifan Hong97288ac2016-12-12 16:03:51 -0800425 << coordinator->getPackagePath(packageFQName, true /* relative */, true /* sanitized */)
Andreas Huber1c507272016-10-05 14:33:21 -0700426 << "Constants.java";
427
428 out << "\n$(GEN): $(HIDL)\n";
429 for (const auto &iface : packageInterfaces) {
430 out << "$(GEN): $(LOCAL_PATH)/" << iface.name() << ".hal\n";
431 }
432 out << "\n$(GEN): PRIVATE_HIDL := $(HIDL)";
433 out << "\n$(GEN): PRIVATE_OUTPUT_DIR := $(intermediates)"
434 << "\n$(GEN): PRIVATE_CUSTOM_TOOL = \\";
435 out.indent();
436 out.indent();
437 out << "\n$(PRIVATE_HIDL) -o $(PRIVATE_OUTPUT_DIR) \\"
Steven Moreland5715fed2017-01-16 11:06:47 -0800438 << "\n-Ljava-constants \\\n";
439
440 generatePackagePathsSection(out, coordinator, packageFQName, importedPackages, true /* forJava */);
Andreas Huber1c507272016-10-05 14:33:21 -0700441
442 out << packageFQName.string();
443 out << "\n";
444
445 out.unindent();
446 out.unindent();
447
448 out << "\n$(GEN):";
449 out << "\n\t$(transform-generated-source)";
450 out << "\nLOCAL_GENERATED_SOURCES += $(GEN)";
451}
452
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700453static status_t generateMakefileForPackage(
454 const FQName &packageFQName,
Iliyan Malchevb66c3992016-08-07 21:18:13 -0700455 const char *hidl_gen,
Andreas Huberd2943e12016-08-05 11:59:31 -0700456 Coordinator *coordinator,
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700457 const std::string &) {
458
459 CHECK(packageFQName.isValid() &&
460 !packageFQName.isFullyQualified() &&
461 packageFQName.name().empty());
462
Andreas Huberd2943e12016-08-05 11:59:31 -0700463 std::vector<FQName> packageInterfaces;
464
465 status_t err =
Steven Morelandaa186832016-09-26 13:51:43 -0700466 coordinator->appendPackageInterfacesToVector(packageFQName,
467 &packageInterfaces);
Andreas Huberd2943e12016-08-05 11:59:31 -0700468
469 if (err != OK) {
470 return err;
471 }
472
473 std::set<FQName> importedPackages;
Andreas Huber0fa9e392016-08-31 09:05:44 -0700474 AST *typesAST = nullptr;
Andreas Huber1c507272016-10-05 14:33:21 -0700475 std::vector<const Type *> exportedTypes;
Andreas Huber0fa9e392016-08-31 09:05:44 -0700476
Andreas Huberd2943e12016-08-05 11:59:31 -0700477 for (const auto &fqName : packageInterfaces) {
478 AST *ast = coordinator->parse(fqName);
479
480 if (ast == NULL) {
481 fprintf(stderr,
Andreas Huber70a59e12016-08-16 12:57:01 -0700482 "ERROR: Could not parse %s. Aborting.\n",
Andreas Huberd2943e12016-08-05 11:59:31 -0700483 fqName.string().c_str());
484
485 return UNKNOWN_ERROR;
486 }
487
Andreas Huber0fa9e392016-08-31 09:05:44 -0700488 if (fqName.name() == "types") {
489 typesAST = ast;
490 }
491
Yifan Hong40a373d2016-11-30 15:16:47 -0800492 ast->getImportedPackagesHierarchy(&importedPackages);
Andreas Huber1c507272016-10-05 14:33:21 -0700493 ast->appendToExportedTypesVector(&exportedTypes);
Andreas Huberd2943e12016-08-05 11:59:31 -0700494 }
495
Andreas Huber75ae95d2016-10-12 16:08:26 -0700496 bool packageIsJavaCompatible;
497 err = isPackageJavaCompatible(
498 packageFQName, coordinator, &packageIsJavaCompatible);
499
500 if (err != OK) {
501 return err;
502 }
503
Andreas Huber1c507272016-10-05 14:33:21 -0700504 bool haveJavaConstants = !exportedTypes.empty();
505
506 if (!packageIsJavaCompatible && !haveJavaConstants) {
Steven Moreland81979932016-12-07 15:11:06 -0800507 // TODO(b/33420795)
508 fprintf(stderr,
509 "WARNING: %s is not java compatible. No java makefile created.\n",
510 packageFQName.string().c_str());
Dan Willemsen676abdc2016-09-28 19:42:22 -0700511 return OK;
512 }
513
Andreas Huber5a9fe2c2016-10-13 15:31:10 -0700514 if (!packageNeedsJavaCode(packageInterfaces, typesAST)) {
515 return OK;
516 }
517
Andreas Huberd2943e12016-08-05 11:59:31 -0700518 std::string path =
519 coordinator->getPackagePath(packageFQName, false /* relative */);
520
521 path.append("Android.mk");
522
523 CHECK(Coordinator::MakeParentHierarchy(path));
524 FILE *file = fopen(path.c_str(), "w");
525
526 if (file == NULL) {
527 return -errno;
528 }
529
Andreas Huberaa573272017-04-13 09:58:06 -0700530 const std::string libraryName = makeJavaLibraryName(packageFQName);
Andreas Huberd2943e12016-08-05 11:59:31 -0700531
532 Formatter out(file);
533
Dan Willemsen676abdc2016-09-28 19:42:22 -0700534 out << "# This file is autogenerated by hidl-gen. Do not edit manually.\n\n";
535 out << "LOCAL_PATH := $(call my-dir)\n";
Andreas Huberd2943e12016-08-05 11:59:31 -0700536
Dan Willemsen676abdc2016-09-28 19:42:22 -0700537 enum LibraryStyle {
538 LIBRARY_STYLE_REGULAR,
539 LIBRARY_STYLE_STATIC,
540 LIBRARY_STYLE_END,
541 };
Andreas Huberd2943e12016-08-05 11:59:31 -0700542
Andreas Huber1c507272016-10-05 14:33:21 -0700543 for (int style = LIBRARY_STYLE_REGULAR;
544 (packageIsJavaCompatible && style != LIBRARY_STYLE_END);
Dan Willemsen676abdc2016-09-28 19:42:22 -0700545 ++style) {
546 const std::string staticSuffix =
547 (style == LIBRARY_STYLE_STATIC) ? "-static" : "";
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700548
Dan Willemsen676abdc2016-09-28 19:42:22 -0700549 out << "\n"
550 << "########################################"
551 << "########################################\n\n";
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700552
Dan Willemsen676abdc2016-09-28 19:42:22 -0700553 out << "include $(CLEAR_VARS)\n"
554 << "LOCAL_MODULE := "
555 << libraryName
556 << "-java"
557 << staticSuffix
558 << "\nLOCAL_MODULE_CLASS := JAVA_LIBRARIES\n\n"
Andreas Huber177a8b12017-02-09 10:08:48 -0800559 << "intermediates := $(call local-generated-sources-dir, COMMON)"
560 << "\n\n"
Dan Willemsen676abdc2016-09-28 19:42:22 -0700561 << "HIDL := $(HOST_OUT_EXECUTABLES)/"
562 << hidl_gen
563 << "$(HOST_EXECUTABLE_SUFFIX)";
Andreas Huberd2943e12016-08-05 11:59:31 -0700564
Dan Willemsen676abdc2016-09-28 19:42:22 -0700565 if (!importedPackages.empty()) {
Iliyan Malchev800273d2016-09-02 15:25:07 -0700566 out << "\n"
Dan Willemsen676abdc2016-09-28 19:42:22 -0700567 << "\nLOCAL_"
Andreas Huber782d45e2016-09-22 13:25:14 -0700568 << ((style == LIBRARY_STYLE_STATIC) ? "STATIC_" : "")
Dan Willemsen676abdc2016-09-28 19:42:22 -0700569 << "JAVA_LIBRARIES := \\";
570
571 out.indent();
572 for (const auto &importedPackage : importedPackages) {
573 out << "\n"
Andreas Huberaa573272017-04-13 09:58:06 -0700574 << makeJavaLibraryName(importedPackage)
Dan Willemsen676abdc2016-09-28 19:42:22 -0700575 << "-java"
576 << staticSuffix
577 << " \\";
578 }
579 out << "\n";
580 out.unindent();
Iliyan Malchev800273d2016-09-02 15:25:07 -0700581 }
Dan Willemsen676abdc2016-09-28 19:42:22 -0700582
583 generateMakefileSection(
584 out,
585 coordinator,
586 packageFQName,
587 packageInterfaces,
Steven Moreland5715fed2017-01-16 11:06:47 -0800588 importedPackages,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700589 typesAST);
590
591 out << "\ninclude $(BUILD_"
592 << ((style == LIBRARY_STYLE_STATIC) ? "STATIC_" : "")
593 << "JAVA_LIBRARY)\n\n";
Andreas Huber0fa9e392016-08-31 09:05:44 -0700594 }
595
Andreas Huber1c507272016-10-05 14:33:21 -0700596 if (haveJavaConstants) {
597 out << "\n"
598 << "########################################"
599 << "########################################\n\n";
600
601 out << "include $(CLEAR_VARS)\n"
602 << "LOCAL_MODULE := "
603 << libraryName
604 << "-java-constants"
605 << "\nLOCAL_MODULE_CLASS := JAVA_LIBRARIES\n\n"
Andreas Huber177a8b12017-02-09 10:08:48 -0800606 << "intermediates := $(call local-generated-sources-dir, COMMON)"
607 << "\n\n"
Andreas Huber1c507272016-10-05 14:33:21 -0700608 << "HIDL := $(HOST_OUT_EXECUTABLES)/"
609 << hidl_gen
610 << "$(HOST_EXECUTABLE_SUFFIX)";
611
612 generateMakefileSectionForJavaConstants(
Steven Moreland5715fed2017-01-16 11:06:47 -0800613 out, coordinator, packageFQName, packageInterfaces, importedPackages);
Andreas Huber1c507272016-10-05 14:33:21 -0700614
615 out << "\n# Avoid dependency cycle of framework.jar -> this-library "
616 << "-> framework.jar\n"
617 << "LOCAL_NO_STANDARD_LIBRARIES := true\n"
618 << "LOCAL_JAVA_LIBRARIES := core-oj\n\n"
619 << "include $(BUILD_STATIC_JAVA_LIBRARY)\n\n";
620 }
621
Iliyan Malchev8be09552016-09-22 16:20:33 -0700622 out << "\n\n"
623 << "include $(call all-makefiles-under,$(LOCAL_PATH))\n";
624
Andreas Huberd2943e12016-08-05 11:59:31 -0700625 return OK;
626}
627
Andreas Huber0fa9e392016-08-31 09:05:44 -0700628OutputHandler::ValRes validateForMakefile(
629 const FQName &fqName, const std::string & /* language */) {
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700630 if (fqName.package().empty()) {
Andreas Huber70a59e12016-08-16 12:57:01 -0700631 fprintf(stderr, "ERROR: Expecting package name\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700632 return OutputHandler::FAILED;
633 }
634
635 if (fqName.version().empty()) {
Andreas Huber70a59e12016-08-16 12:57:01 -0700636 fprintf(stderr, "ERROR: Expecting package version\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700637 return OutputHandler::FAILED;
638 }
639
640 if (!fqName.name().empty()) {
641 fprintf(stderr,
Andreas Huber70a59e12016-08-16 12:57:01 -0700642 "ERROR: Expecting only package name and version.\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700643 return OutputHandler::FAILED;
644 }
645
646 return OutputHandler::PASS_PACKAGE;
647}
648
Dan Willemsen676abdc2016-09-28 19:42:22 -0700649static void generateAndroidBpGenSection(
650 Formatter &out,
651 const FQName &packageFQName,
652 const char *hidl_gen,
653 Coordinator *coordinator,
Tri Vo6a827fa2017-02-08 10:24:42 -0800654 const std::string &halFilegroupName,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700655 const std::string &genName,
656 const char *language,
657 const std::vector<FQName> &packageInterfaces,
Steven Moreland5715fed2017-01-16 11:06:47 -0800658 const std::set<FQName> &importedPackages,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700659 const std::function<void(Formatter&, const FQName)> outputFn) {
660
661 out << "genrule {\n";
662 out.indent();
663 out << "name: \"" << genName << "\",\n"
Colin Crossd5419bd2016-11-04 15:05:54 -0700664 << "tools: [\"" << hidl_gen << "\"],\n";
Dan Willemsen676abdc2016-09-28 19:42:22 -0700665
Colin Crossd5419bd2016-11-04 15:05:54 -0700666 out << "cmd: \"$(location " << hidl_gen << ") -o $(genDir)"
Steven Moreland5715fed2017-01-16 11:06:47 -0800667 << " -L" << language << " ";
668
669 generatePackagePathsSection(out, coordinator, packageFQName, importedPackages);
670
671 out << packageFQName.string() << "\",\n";
Dan Willemsen676abdc2016-09-28 19:42:22 -0700672
673 out << "srcs: [\n";
674 out.indent();
Tri Vo6a827fa2017-02-08 10:24:42 -0800675 out << "\":" << halFilegroupName << "\",\n";
Dan Willemsen676abdc2016-09-28 19:42:22 -0700676 out.unindent();
677 out << "],\n";
678
679 out << "out: [\n";
680 out.indent();
681 for (const auto &fqName : packageInterfaces) {
682 outputFn(out, fqName);
683 }
684 out.unindent();
685 out << "],\n";
686
687 out.unindent();
688 out << "}\n\n";
689}
690
Steven Moreland1b2167b2017-05-01 10:06:21 -0700691bool isHidlTransportPackage(const FQName &package) {
692 return package == gIBasePackageFqName ||
693 package == gIManagerPackageFqName;
694}
695
Dan Willemsen676abdc2016-09-28 19:42:22 -0700696static status_t generateAndroidBpForPackage(
697 const FQName &packageFQName,
698 const char *hidl_gen,
699 Coordinator *coordinator,
700 const std::string &) {
701
702 CHECK(packageFQName.isValid() &&
703 !packageFQName.isFullyQualified() &&
704 packageFQName.name().empty());
705
706 std::vector<FQName> packageInterfaces;
707
708 status_t err =
709 coordinator->appendPackageInterfacesToVector(packageFQName,
710 &packageInterfaces);
711
712 if (err != OK) {
713 return err;
714 }
715
Steven Morelandff5262b2017-03-20 06:59:03 -0700716 std::set<FQName> importedPackagesHierarchy;
Dan Willemsen676abdc2016-09-28 19:42:22 -0700717 AST *typesAST = nullptr;
718
719 for (const auto &fqName : packageInterfaces) {
720 AST *ast = coordinator->parse(fqName);
721
722 if (ast == NULL) {
723 fprintf(stderr,
724 "ERROR: Could not parse %s. Aborting.\n",
725 fqName.string().c_str());
726
727 return UNKNOWN_ERROR;
728 }
729
730 if (fqName.name() == "types") {
731 typesAST = ast;
732 }
733
Steven Morelandff5262b2017-03-20 06:59:03 -0700734 ast->getImportedPackagesHierarchy(&importedPackagesHierarchy);
Dan Willemsen676abdc2016-09-28 19:42:22 -0700735 }
736
737 std::string path =
738 coordinator->getPackagePath(packageFQName, false /* relative */);
739
740 path.append("Android.bp");
741
742 CHECK(Coordinator::MakeParentHierarchy(path));
743 FILE *file = fopen(path.c_str(), "w");
744
745 if (file == NULL) {
746 return -errno;
747 }
748
749 const std::string libraryName = makeLibraryName(packageFQName);
Tri Vo15052c62017-02-06 10:04:07 -0800750 const std::string halFilegroupName = libraryName + "_hal";
Dan Willemsen676abdc2016-09-28 19:42:22 -0700751 const std::string genSourceName = libraryName + "_genc++";
752 const std::string genHeaderName = libraryName + "_genc++_headers";
753 const std::string pathPrefix =
754 coordinator->convertPackageRootToPath(packageFQName) +
755 coordinator->getPackagePath(packageFQName, true /* relative */);
756
757 Formatter out(file);
758
759 out << "// This file is autogenerated by hidl-gen. Do not edit manually.\n\n";
760
Tri Vo15052c62017-02-06 10:04:07 -0800761 // Rule to generate .hal filegroup
762 out << "filegroup {\n";
763 out.indent();
764 out << "name: \"" << halFilegroupName << "\",\n";
765 out << "srcs: [\n";
766 out.indent();
767 for (const auto &fqName : packageInterfaces) {
768 out << "\"" << fqName.name() << ".hal\",\n";
769 }
770 out.unindent();
771 out << "],\n";
772 out.unindent();
773 out << "}\n\n";
774
Dan Willemsen676abdc2016-09-28 19:42:22 -0700775 // Rule to generate the C++ source files
776 generateAndroidBpGenSection(
777 out,
778 packageFQName,
779 hidl_gen,
780 coordinator,
Tri Vo6a827fa2017-02-08 10:24:42 -0800781 halFilegroupName,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700782 genSourceName,
Steven Moreland1cbf0362017-05-09 14:32:53 -0700783 "c++-sources",
Dan Willemsen676abdc2016-09-28 19:42:22 -0700784 packageInterfaces,
Steven Morelandff5262b2017-03-20 06:59:03 -0700785 importedPackagesHierarchy,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700786 [&pathPrefix](Formatter &out, const FQName &fqName) {
787 if (fqName.name() == "types") {
788 out << "\"" << pathPrefix << "types.cpp\",\n";
789 } else {
790 out << "\"" << pathPrefix << fqName.name().substr(1) << "All.cpp\",\n";
791 }
792 });
793
794 // Rule to generate the C++ header files
795 generateAndroidBpGenSection(
796 out,
797 packageFQName,
798 hidl_gen,
799 coordinator,
Tri Vo6a827fa2017-02-08 10:24:42 -0800800 halFilegroupName,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700801 genHeaderName,
Steven Moreland1cbf0362017-05-09 14:32:53 -0700802 "c++-headers",
Dan Willemsen676abdc2016-09-28 19:42:22 -0700803 packageInterfaces,
Steven Morelandff5262b2017-03-20 06:59:03 -0700804 importedPackagesHierarchy,
Dan Willemsen676abdc2016-09-28 19:42:22 -0700805 [&pathPrefix](Formatter &out, const FQName &fqName) {
806 out << "\"" << pathPrefix << fqName.name() << ".h\",\n";
807 if (fqName.name() != "types") {
Yifan Hongeefe4f22017-01-04 15:32:42 -0800808 out << "\"" << pathPrefix << fqName.getInterfaceHwName() << ".h\",\n";
809 out << "\"" << pathPrefix << fqName.getInterfaceStubName() << ".h\",\n";
810 out << "\"" << pathPrefix << fqName.getInterfaceProxyName() << ".h\",\n";
811 out << "\"" << pathPrefix << fqName.getInterfacePassthroughName() << ".h\",\n";
Steven Moreland9774d622017-03-24 21:51:45 -0700812 } else {
813 out << "\"" << pathPrefix << "hwtypes.h\",\n";
Dan Willemsen676abdc2016-09-28 19:42:22 -0700814 }
815 });
816
Steven Morelandf5f593f2017-05-02 13:13:00 -0700817 if (isHidlTransportPackage(packageFQName)) {
818 out << "// " << packageFQName.string() << " is exported from libhidltransport\n";
Steven Moreland0e875df2017-04-25 13:24:17 -0700819 } else {
Steven Morelandf5f593f2017-05-02 13:13:00 -0700820 // C++ library definition
821 out << "cc_library_shared {\n";
822 out.indent();
823 out << "name: \"" << libraryName << "\",\n"
824 << "generated_sources: [\"" << genSourceName << "\"],\n"
825 << "generated_headers: [\"" << genHeaderName << "\"],\n"
826 << "export_generated_headers: [\"" << genHeaderName << "\"],\n";
Dan Willemsen676abdc2016-09-28 19:42:22 -0700827
Steven Morelandf5f593f2017-05-02 13:13:00 -0700828 // TODO(b/35813011): make always vendor_available
829 // Explicitly mark libraries vendor until BOARD_VNDK_VERSION can
830 // be enabled.
831 if (packageFQName.inPackage("android.hidl") ||
832 packageFQName.inPackage("android.system") ||
833 packageFQName.inPackage("android.frameworks") ||
834 packageFQName.inPackage("android.hardware")) {
835 out << "vendor_available: true,\n";
836 } else {
837 out << "vendor: true,\n";
Steven Moreland1b2167b2017-05-01 10:06:21 -0700838 }
Steven Morelandf5f593f2017-05-02 13:13:00 -0700839 out << "shared_libs: [\n";
Steven Moreland1b2167b2017-05-01 10:06:21 -0700840
Steven Morelandf5f593f2017-05-02 13:13:00 -0700841 out.indent();
842 out << "\"libhidlbase\",\n"
843 << "\"libhidltransport\",\n"
844 << "\"libhwbinder\",\n"
845 << "\"liblog\",\n"
846 << "\"libutils\",\n"
847 << "\"libcutils\",\n";
848 for (const auto &importedPackage : importedPackagesHierarchy) {
849 if (isHidlTransportPackage(importedPackage)) {
850 continue;
851 }
Dan Willemsen676abdc2016-09-28 19:42:22 -0700852
Steven Morelandf5f593f2017-05-02 13:13:00 -0700853 out << "\"" << makeLibraryName(importedPackage) << "\",\n";
Steven Moreland1b2167b2017-05-01 10:06:21 -0700854 }
Steven Morelandf5f593f2017-05-02 13:13:00 -0700855 out.unindent();
Steven Moreland1b2167b2017-05-01 10:06:21 -0700856
Steven Morelandf5f593f2017-05-02 13:13:00 -0700857 out << "],\n";
858
859 out << "export_shared_lib_headers: [\n";
860 out.indent();
861 out << "\"libhidlbase\",\n"
862 << "\"libhidltransport\",\n"
863 << "\"libhwbinder\",\n"
864 << "\"libutils\",\n";
865 for (const auto &importedPackage : importedPackagesHierarchy) {
866 if (isHidlTransportPackage(importedPackage)) {
867 continue;
868 }
869
870 out << "\"" << makeLibraryName(importedPackage) << "\",\n";
871 }
872 out.unindent();
873 out << "],\n";
874 out.unindent();
875
876 out << "}\n";
Yifan Hongc1f9b8d2016-11-07 14:35:44 -0800877 }
Dan Willemsen676abdc2016-09-28 19:42:22 -0700878
Zhuoyao Zhangb85e8c22016-12-21 10:24:16 -0800879 return OK;
Dan Willemsen676abdc2016-09-28 19:42:22 -0700880}
881
Yifan Hong958ee462016-12-06 17:09:51 -0800882static status_t generateAndroidBpImplForPackage(
Steven Moreland197d56c2016-09-09 10:03:58 -0700883 const FQName &packageFQName,
884 const char *,
885 Coordinator *coordinator,
886 const std::string &outputDir) {
887
Iliyan Malchev4923f932016-09-09 13:04:59 -0700888 const std::string libraryName = makeLibraryName(packageFQName) + "-impl";
Steven Moreland197d56c2016-09-09 10:03:58 -0700889
890 std::vector<FQName> packageInterfaces;
891
892 status_t err =
Steven Morelandaa186832016-09-26 13:51:43 -0700893 coordinator->appendPackageInterfacesToVector(packageFQName,
894 &packageInterfaces);
Steven Moreland197d56c2016-09-09 10:03:58 -0700895
896 if (err != OK) {
897 return err;
898 }
899
900 std::set<FQName> importedPackages;
901
902 for (const auto &fqName : packageInterfaces) {
903 AST *ast = coordinator->parse(fqName);
904
905 if (ast == NULL) {
906 fprintf(stderr,
907 "ERROR: Could not parse %s. Aborting.\n",
908 fqName.string().c_str());
909
910 return UNKNOWN_ERROR;
911 }
912
913 ast->getImportedPackages(&importedPackages);
914 }
915
Yifan Hongaafed702016-12-14 12:59:47 -0800916 std::string path = outputDir + "Android.bp";
Steven Moreland197d56c2016-09-09 10:03:58 -0700917
918 CHECK(Coordinator::MakeParentHierarchy(path));
919 FILE *file = fopen(path.c_str(), "w");
920
921 if (file == NULL) {
922 return -errno;
923 }
924
925 Formatter out(file);
926
Yifan Hong958ee462016-12-06 17:09:51 -0800927 out << "cc_library_shared {\n";
Yifan Hong33223ca2016-12-13 15:07:35 -0800928 out.indent([&] {
Yifan Hong958ee462016-12-06 17:09:51 -0800929 out << "name: \"" << libraryName << "\",\n"
930 << "relative_install_path: \"hw\",\n"
Steven Morelandf8a22e92017-02-15 18:46:04 -0800931 << "proprietary: true,\n"
Yifan Hong958ee462016-12-06 17:09:51 -0800932 << "srcs: [\n";
Yifan Hong33223ca2016-12-13 15:07:35 -0800933 out.indent([&] {
Yifan Hong958ee462016-12-06 17:09:51 -0800934 for (const auto &fqName : packageInterfaces) {
935 if (fqName.name() == "types") {
936 continue;
937 }
938 out << "\"" << fqName.getInterfaceBaseName() << ".cpp\",\n";
939 }
940 });
941 out << "],\n"
942 << "shared_libs: [\n";
Yifan Hong33223ca2016-12-13 15:07:35 -0800943 out.indent([&] {
Yifan Hong958ee462016-12-06 17:09:51 -0800944 out << "\"libhidlbase\",\n"
945 << "\"libhidltransport\",\n"
Yifan Hong958ee462016-12-06 17:09:51 -0800946 << "\"libutils\",\n"
947 << "\"" << makeLibraryName(packageFQName) << "\",\n";
Yifan Honge0f7d692016-10-20 17:51:33 -0700948
Yifan Hong958ee462016-12-06 17:09:51 -0800949 for (const auto &importedPackage : importedPackages) {
Steven Morelanddadd1842017-05-09 13:24:54 -0700950 if (isHidlTransportPackage(importedPackage)) {
951 continue;
952 }
953
Yifan Hong958ee462016-12-06 17:09:51 -0800954 out << "\"" << makeLibraryName(importedPackage) << "\",\n";
955 }
956 });
957 out << "],\n";
958 });
959 out << "}\n";
Steven Moreland197d56c2016-09-09 10:03:58 -0700960
961 return OK;
962}
963
Andreas Huber0fa9e392016-08-31 09:05:44 -0700964OutputHandler::ValRes validateForSource(
965 const FQName &fqName, const std::string &language) {
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700966 if (fqName.package().empty()) {
Andreas Huber70a59e12016-08-16 12:57:01 -0700967 fprintf(stderr, "ERROR: Expecting package name\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700968 return OutputHandler::FAILED;
969 }
970
971 if (fqName.version().empty()) {
Andreas Huber70a59e12016-08-16 12:57:01 -0700972 fprintf(stderr, "ERROR: Expecting package version\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700973 return OutputHandler::FAILED;
974 }
975
Andreas Huber0fa9e392016-08-31 09:05:44 -0700976 const std::string &name = fqName.name();
977 if (!name.empty()) {
978 if (name.find('.') == std::string::npos) {
979 return OutputHandler::PASS_FULL;
980 }
981
982 if (language != "java" || name.find("types.") != 0) {
983 // When generating java sources for "types.hal", output can be
984 // constrained to just one of the top-level types declared
985 // by using the extended syntax
986 // android.hardware.Foo@1.0::types.TopLevelTypeName.
987 // In all other cases (different language, not 'types') the dot
988 // notation in the name is illegal in this context.
989 return OutputHandler::FAILED;
990 }
991
992 return OutputHandler::PASS_FULL;
993 }
994
995 return OutputHandler::PASS_PACKAGE;
Iliyan Malchev5bb14022016-08-09 15:04:39 -0700996}
997
Andreas Huber019d21d2016-10-03 12:59:47 -0700998OutputHandler::ValRes validateForExportHeader(
999 const FQName &fqName, const std::string & /* language */) {
1000 if (fqName.package().empty()) {
1001 fprintf(stderr, "ERROR: Expecting package name\n");
1002 return OutputHandler::FAILED;
1003 }
1004
1005 if (fqName.version().empty()) {
1006 fprintf(stderr, "ERROR: Expecting package version\n");
1007 return OutputHandler::FAILED;
1008 }
1009
1010 if (!fqName.name().empty()) {
1011 fprintf(stderr,
1012 "ERROR: Expecting only package name and version.\n");
1013 return OutputHandler::FAILED;
1014 }
1015
1016 return OutputHandler::PASS_PACKAGE;
1017}
1018
1019
1020static status_t generateExportHeaderForPackage(
1021 const FQName &packageFQName,
1022 const char * /* hidl_gen */,
1023 Coordinator *coordinator,
Andreas Huber1c507272016-10-05 14:33:21 -07001024 const std::string &outputPath,
1025 bool forJava) {
Andreas Huber019d21d2016-10-03 12:59:47 -07001026
1027 CHECK(packageFQName.isValid()
1028 && !packageFQName.isFullyQualified()
1029 && packageFQName.name().empty());
1030
1031 std::vector<FQName> packageInterfaces;
1032
1033 status_t err = coordinator->appendPackageInterfacesToVector(
1034 packageFQName, &packageInterfaces);
1035
1036 if (err != OK) {
1037 return err;
1038 }
1039
1040 std::vector<const Type *> exportedTypes;
1041
1042 for (const auto &fqName : packageInterfaces) {
1043 AST *ast = coordinator->parse(fqName);
1044
1045 if (ast == NULL) {
1046 fprintf(stderr,
1047 "ERROR: Could not parse %s. Aborting.\n",
1048 fqName.string().c_str());
1049
1050 return UNKNOWN_ERROR;
1051 }
1052
1053 ast->appendToExportedTypesVector(&exportedTypes);
1054 }
1055
1056 if (exportedTypes.empty()) {
1057 return OK;
1058 }
1059
Andreas Huber1c507272016-10-05 14:33:21 -07001060 std::string path = outputPath;
1061
1062 if (forJava) {
1063 path.append(coordinator->convertPackageRootToPath(packageFQName));
1064
1065 path.append(coordinator->getPackagePath(
Yifan Hong97288ac2016-12-12 16:03:51 -08001066 packageFQName, true /* relative */, true /* sanitized */));
Andreas Huber1c507272016-10-05 14:33:21 -07001067
1068 path.append("Constants.java");
1069 }
1070
1071 CHECK(Coordinator::MakeParentHierarchy(path));
1072 FILE *file = fopen(path.c_str(), "w");
Andreas Huber019d21d2016-10-03 12:59:47 -07001073
1074 if (file == nullptr) {
1075 return -errno;
1076 }
1077
1078 Formatter out(file);
1079
Steven Morelandd177b122016-12-12 09:15:37 -08001080 out << "// This file is autogenerated by hidl-gen. Do not edit manually.\n"
Glenn Kastend18c3ba2017-02-23 16:35:24 -08001081 << "// Source: " << packageFQName.string() << "\n"
1082 << "// Root: " << coordinator->getPackageRootOption(packageFQName) << "\n\n";
Andreas Huber019d21d2016-10-03 12:59:47 -07001083
Andreas Huber1c507272016-10-05 14:33:21 -07001084 std::string guard;
1085 if (forJava) {
1086 out << "package " << packageFQName.javaPackage() << ";\n\n";
1087 out << "public class Constants {\n";
1088 out.indent();
1089 } else {
1090 guard = "HIDL_GENERATED_";
Steven Morelandd177b122016-12-12 09:15:37 -08001091 guard += StringHelper::Uppercase(packageFQName.tokenName());
Andreas Huber1c507272016-10-05 14:33:21 -07001092 guard += "_";
1093 guard += "EXPORTED_CONSTANTS_H_";
Andreas Huber019d21d2016-10-03 12:59:47 -07001094
Andreas Huber1c507272016-10-05 14:33:21 -07001095 out << "#ifndef "
1096 << guard
1097 << "\n#define "
1098 << guard
1099 << "\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n";
Andreas Huber019d21d2016-10-03 12:59:47 -07001100 }
1101
Andreas Huber1c507272016-10-05 14:33:21 -07001102 for (const auto &type : exportedTypes) {
1103 type->emitExportedHeader(out, forJava);
1104 }
1105
1106 if (forJava) {
1107 out.unindent();
1108 out << "}\n";
1109 } else {
1110 out << "#ifdef __cplusplus\n}\n#endif\n\n#endif // "
1111 << guard
1112 << "\n";
1113 }
Andreas Huber019d21d2016-10-03 12:59:47 -07001114
1115 return OK;
1116}
1117
Steven Morelandf2e44692017-04-18 20:19:09 -07001118static status_t generateHashOutput(const FQName &fqName,
1119 const char* /*hidl_gen*/,
1120 Coordinator *coordinator,
1121 const std::string & /*outputDir*/) {
1122
1123 status_t err;
1124 std::vector<FQName> packageInterfaces;
1125
1126 if (fqName.isFullyQualified()) {
1127 packageInterfaces = {fqName};
1128 } else {
1129 err = coordinator->appendPackageInterfacesToVector(
1130 fqName, &packageInterfaces);
1131 if (err != OK) {
1132 return err;
1133 }
1134 }
1135
1136 for (const auto &currentFqName : packageInterfaces) {
1137 AST *ast = coordinator->parse(currentFqName);
1138
1139 if (ast == NULL) {
1140 fprintf(stderr,
1141 "ERROR: Could not parse %s. Aborting.\n",
1142 currentFqName.string().c_str());
1143
1144 return UNKNOWN_ERROR;
1145 }
1146
1147 printf("%s %s\n",
1148 Hash::getHash(ast->getFilename()).hexString().c_str(),
1149 currentFqName.string().c_str());
1150 }
1151
1152 return OK;
1153}
1154
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001155static std::vector<OutputHandler> formats = {
Steven Moreland3b1ce262017-04-21 14:19:59 -07001156 {"check",
1157 OutputHandler::NOT_NEEDED /* mOutputMode */,
1158 validateForSource,
Steven Morelandbbbbeb82017-05-09 14:20:50 -07001159 generationFunctionForFileOrPackage("check")
Steven Moreland3b1ce262017-04-21 14:19:59 -07001160 },
1161
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001162 {"c++",
Andreas Huber019d21d2016-10-03 12:59:47 -07001163 OutputHandler::NEEDS_DIR /* mOutputMode */,
Zhuoyao Zhang5158db42016-08-10 10:25:20 -07001164 validateForSource,
Steven Morelandbbbbeb82017-05-09 14:20:50 -07001165 generationFunctionForFileOrPackage("c++")
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001166 },
1167
Steven Moreland1cbf0362017-05-09 14:32:53 -07001168 {"c++-headers",
1169 OutputHandler::NEEDS_DIR /* mOutputMode */,
1170 validateForSource,
1171 generationFunctionForFileOrPackage("c++-headers")
1172 },
1173
1174 {"c++-sources",
1175 OutputHandler::NEEDS_DIR /* mOutputMode */,
1176 validateForSource,
1177 generationFunctionForFileOrPackage("c++-sources")
1178 },
1179
Andreas Huber019d21d2016-10-03 12:59:47 -07001180 {"export-header",
1181 OutputHandler::NEEDS_FILE /* mOutputMode */,
1182 validateForExportHeader,
1183 [](const FQName &fqName,
1184 const char *hidl_gen,
1185 Coordinator *coordinator,
1186 const std::string &outputPath) -> status_t {
1187 CHECK(!fqName.isFullyQualified());
1188
1189 return generateExportHeaderForPackage(
1190 fqName,
1191 hidl_gen,
1192 coordinator,
Andreas Huber1c507272016-10-05 14:33:21 -07001193 outputPath,
1194 false /* forJava */);
Andreas Huber019d21d2016-10-03 12:59:47 -07001195 }
1196 },
1197
Steven Moreland9c387612016-09-07 09:54:26 -07001198 {"c++-impl",
Andreas Huber019d21d2016-10-03 12:59:47 -07001199 OutputHandler::NEEDS_DIR /* mOutputMode */,
Steven Moreland9c387612016-09-07 09:54:26 -07001200 validateForSource,
Steven Morelandbbbbeb82017-05-09 14:20:50 -07001201 generationFunctionForFileOrPackage("c++-impl")
Steven Moreland9c387612016-09-07 09:54:26 -07001202 },
1203
1204
Andreas Huber2831d512016-08-15 09:33:47 -07001205 {"java",
Andreas Huber019d21d2016-10-03 12:59:47 -07001206 OutputHandler::NEEDS_DIR /* mOutputMode */,
Zhuoyao Zhang5158db42016-08-10 10:25:20 -07001207 validateForSource,
Steven Morelandbbbbeb82017-05-09 14:20:50 -07001208 generationFunctionForFileOrPackage("java")
Andreas Huber2831d512016-08-15 09:33:47 -07001209 },
1210
Andreas Huber1c507272016-10-05 14:33:21 -07001211 {"java-constants",
1212 OutputHandler::NEEDS_DIR /* mOutputMode */,
1213 validateForExportHeader,
1214 [](const FQName &fqName,
1215 const char *hidl_gen, Coordinator *coordinator,
1216 const std::string &outputDir) -> status_t {
1217 CHECK(!fqName.isFullyQualified());
1218 return generateExportHeaderForPackage(
1219 fqName,
1220 hidl_gen,
1221 coordinator,
1222 outputDir,
1223 true /* forJava */);
1224 }
1225 },
1226
Zhuoyao Zhang5158db42016-08-10 10:25:20 -07001227 {"vts",
Andreas Huber019d21d2016-10-03 12:59:47 -07001228 OutputHandler::NEEDS_DIR /* mOutputMode */,
Zhuoyao Zhang5158db42016-08-10 10:25:20 -07001229 validateForSource,
Steven Morelandbbbbeb82017-05-09 14:20:50 -07001230 generationFunctionForFileOrPackage("vts")
Zhuoyao Zhang5158db42016-08-10 10:25:20 -07001231 },
1232
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001233 {"makefile",
Andreas Huber019d21d2016-10-03 12:59:47 -07001234 OutputHandler::NOT_NEEDED /* mOutputMode */,
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001235 validateForMakefile,
1236 generateMakefileForPackage,
1237 },
Steven Moreland197d56c2016-09-09 10:03:58 -07001238
Dan Willemsen676abdc2016-09-28 19:42:22 -07001239 {"androidbp",
Andreas Huber019d21d2016-10-03 12:59:47 -07001240 OutputHandler::NOT_NEEDED /* mOutputMode */,
Dan Willemsen676abdc2016-09-28 19:42:22 -07001241 validateForMakefile,
1242 generateAndroidBpForPackage,
1243 },
1244
Yifan Hong958ee462016-12-06 17:09:51 -08001245 {"androidbp-impl",
Yifan Hong94bcea02016-10-06 13:51:31 -07001246 OutputHandler::NEEDS_DIR /* mOutputMode */,
Steven Moreland197d56c2016-09-09 10:03:58 -07001247 validateForMakefile,
Yifan Hong958ee462016-12-06 17:09:51 -08001248 generateAndroidBpImplForPackage,
Steven Morelandf2e44692017-04-18 20:19:09 -07001249 },
1250
1251 {"hash",
1252 OutputHandler::NOT_NEEDED /* mOutputMode */,
1253 validateForSource,
1254 generateHashOutput,
1255 },
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001256};
1257
1258static void usage(const char *me) {
1259 fprintf(stderr,
1260 "usage: %s -o output-path -L <language> (-r interface-root)+ fqname+\n",
1261 me);
1262
1263 fprintf(stderr, " -o output path\n");
1264
1265 fprintf(stderr, " -L <language> (one of");
1266 for (auto &e : formats) {
Steven Morelanddd583842017-04-19 13:09:57 -07001267 fprintf(stderr, " %s", e.name().c_str());
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001268 }
1269 fprintf(stderr, ")\n");
1270
1271 fprintf(stderr,
1272 " -r package:path root "
1273 "(e.g., android.hardware:hardware/interfaces)\n");
1274}
1275
Andreas Gampec4ce9262017-04-27 21:03:20 -07001276// hidl is intentionally leaky. Turn off LeakSanitizer by default.
1277extern "C" const char *__asan_default_options() {
1278 return "detect_leaks=0";
1279}
1280
Andreas Huberb82318c2016-08-02 14:45:54 -07001281int main(int argc, char **argv) {
Andreas Huber019d21d2016-10-03 12:59:47 -07001282 std::string outputPath;
Andreas Huberdca261f2016-08-04 13:47:51 -07001283 std::vector<std::string> packageRootPaths;
1284 std::vector<std::string> packageRoots;
Andreas Huberb82318c2016-08-02 14:45:54 -07001285
Andreas Huber737080b2016-08-02 15:38:04 -07001286 const char *me = argv[0];
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001287 OutputHandler *outputFormat = nullptr;
Andreas Huber737080b2016-08-02 15:38:04 -07001288
Andreas Huberb82318c2016-08-02 14:45:54 -07001289 int res;
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001290 while ((res = getopt(argc, argv, "ho:r:L:")) >= 0) {
Andreas Huberb82318c2016-08-02 14:45:54 -07001291 switch (res) {
1292 case 'o':
1293 {
Andreas Huber019d21d2016-10-03 12:59:47 -07001294 outputPath = optarg;
Andreas Huberb82318c2016-08-02 14:45:54 -07001295 break;
1296 }
1297
Andreas Huberdca261f2016-08-04 13:47:51 -07001298 case 'r':
1299 {
1300 std::string val(optarg);
1301 auto index = val.find_first_of(':');
Steven Moreland4ff74202017-04-21 14:24:47 -07001302 if (index == std::string::npos) {
1303 fprintf(stderr, "ERROR: -r option must contain ':': %s\n", val.c_str());
1304 exit(1);
1305 }
Andreas Huberdca261f2016-08-04 13:47:51 -07001306
1307 auto package = val.substr(0, index);
1308 auto path = val.substr(index + 1);
1309 packageRootPaths.push_back(path);
1310 packageRoots.push_back(package);
1311 break;
1312 }
1313
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001314 case 'L':
1315 {
Steven Morelanddd583842017-04-19 13:09:57 -07001316 if (outputFormat != nullptr) {
1317 fprintf(stderr,
1318 "ERROR: only one -L option allowed. \"%s\" already specified.\n",
1319 outputFormat->name().c_str());
1320 exit(1);
1321 }
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001322 for (auto &e : formats) {
Steven Morelanddd583842017-04-19 13:09:57 -07001323 if (e.name() == optarg) {
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001324 outputFormat = &e;
1325 break;
1326 }
1327 }
Steven Morelanddd583842017-04-19 13:09:57 -07001328 if (outputFormat == nullptr) {
1329 fprintf(stderr,
1330 "ERROR: unrecognized -L option: \"%s\".\n",
1331 optarg);
1332 exit(1);
1333 }
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001334 break;
1335 }
1336
Andreas Huberb82318c2016-08-02 14:45:54 -07001337 case '?':
1338 case 'h':
1339 default:
1340 {
Andreas Huber737080b2016-08-02 15:38:04 -07001341 usage(me);
Andreas Huberb82318c2016-08-02 14:45:54 -07001342 exit(1);
1343 break;
1344 }
1345 }
1346 }
1347
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001348 if (outputFormat == nullptr) {
Steven Morelanddd583842017-04-19 13:09:57 -07001349 fprintf(stderr,
1350 "ERROR: no -L option provided.\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001351 exit(1);
1352 }
1353
Andreas Huberb82318c2016-08-02 14:45:54 -07001354 argc -= optind;
1355 argv += optind;
1356
Andreas Huberdca261f2016-08-04 13:47:51 -07001357 if (packageRootPaths.empty()) {
1358 // Pick reasonable defaults.
1359
1360 packageRoots.push_back("android.hardware");
1361
1362 const char *TOP = getenv("TOP");
Steven Morelandaf330382016-11-09 15:48:03 -08001363 if (TOP == nullptr) {
1364 fprintf(stderr,
1365 "ERROR: No root path (-r) specified"
1366 " and $TOP environment variable not set.\n");
1367 exit(1);
1368 }
Andreas Huberdca261f2016-08-04 13:47:51 -07001369
1370 std::string path = TOP;
1371 path.append("/hardware/interfaces");
1372
1373 packageRootPaths.push_back(path);
1374 }
1375
Andreas Huber737080b2016-08-02 15:38:04 -07001376 // Valid options are now in argv[0] .. argv[argc - 1].
1377
Andreas Huber019d21d2016-10-03 12:59:47 -07001378 switch (outputFormat->mOutputMode) {
1379 case OutputHandler::NEEDS_DIR:
1380 case OutputHandler::NEEDS_FILE:
1381 {
1382 if (outputPath.empty()) {
1383 usage(me);
1384 exit(1);
1385 }
1386
1387 if (outputFormat->mOutputMode == OutputHandler::NEEDS_DIR) {
1388 const size_t len = outputPath.size();
1389 if (outputPath[len - 1] != '/') {
1390 outputPath += "/";
1391 }
1392 }
1393 break;
Andreas Huberb82318c2016-08-02 14:45:54 -07001394 }
Andreas Huber019d21d2016-10-03 12:59:47 -07001395
1396 default:
1397 outputPath.clear(); // Unused.
1398 break;
Andreas Huberb82318c2016-08-02 14:45:54 -07001399 }
1400
Andreas Huberdca261f2016-08-04 13:47:51 -07001401 Coordinator coordinator(packageRootPaths, packageRoots);
Andreas Huber5345ec22016-07-29 13:33:27 -07001402
Andreas Huber737080b2016-08-02 15:38:04 -07001403 for (int i = 0; i < argc; ++i) {
Andreas Huber68f24592016-07-29 14:53:48 -07001404 FQName fqName(argv[i]);
Andreas Huber68f24592016-07-29 14:53:48 -07001405
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001406 if (!fqName.isValid()) {
Andreas Hubere61e3f72016-08-03 10:22:03 -07001407 fprintf(stderr,
Andreas Huber70a59e12016-08-16 12:57:01 -07001408 "ERROR: Invalid fully-qualified name.\n");
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001409 exit(1);
1410 }
Andreas Huber881227d2016-08-02 14:20:21 -07001411
Andreas Huber0fa9e392016-08-31 09:05:44 -07001412 OutputHandler::ValRes valid =
Steven Morelanddd583842017-04-19 13:09:57 -07001413 outputFormat->validate(fqName, outputFormat->name());
Andreas Huber0fa9e392016-08-31 09:05:44 -07001414
Iliyan Malchev5bb14022016-08-09 15:04:39 -07001415 if (valid == OutputHandler::FAILED) {
Steven Morelandf2e44692017-04-18 20:19:09 -07001416 fprintf(stderr,
1417 "ERROR: output handler failed.\n");
Andreas Hubere61e3f72016-08-03 10:22:03 -07001418 exit(1);
1419 }
Andreas Huberd2943e12016-08-05 11:59:31 -07001420
1421 status_t err =
Andreas Huber019d21d2016-10-03 12:59:47 -07001422 outputFormat->generate(fqName, me, &coordinator, outputPath);
Andreas Huberd2943e12016-08-05 11:59:31 -07001423
1424 if (err != OK) {
Steven Moreland261370a2016-08-29 15:36:59 -07001425 exit(1);
Andreas Huberd2943e12016-08-05 11:59:31 -07001426 }
Andreas Hubereb1081f2016-07-28 13:13:24 -07001427 }
Andreas Huberc9410c72016-07-28 12:18:40 -07001428
Andreas Huberd2943e12016-08-05 11:59:31 -07001429 return 0;
Andreas Huberc9410c72016-07-28 12:18:40 -07001430}