1 /* 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 17 #include "AST.h" 18 19 #include "Annotation.h" 20 #include "Coordinator.h" 21 #include "Interface.h" 22 #include "Method.h" 23 #include "Scope.h" 24 25 #include <hidl-util/Formatter.h> 26 #include <android-base/logging.h> 27 #include <string> 28 #include <vector> 29 30 namespace android { 31 emitVtsTypeDeclarations(Formatter & out) const32status_t AST::emitVtsTypeDeclarations(Formatter &out) const { 33 std::string ifaceName; 34 if (AST::isInterface(&ifaceName)) { 35 const Interface *iface = mRootScope->getInterface(); 36 status_t status = iface->emitVtsAttributeDeclaration(out); 37 if (status != OK) { 38 return status; 39 } 40 } else { 41 for (const auto &type : mRootScope->getSubTypes()) { 42 // Skip for TypeDef as it is just an alias of a defined type. 43 if (type->isTypeDef()) { 44 continue; 45 } 46 out << "attribute: {\n"; 47 out.indent(); 48 status_t status = type->emitVtsTypeDeclarations(out); 49 if (status != OK) { 50 return status; 51 } 52 out.unindent(); 53 out << "}\n\n"; 54 } 55 } 56 return OK; 57 } 58 generateVts(const std::string & outputPath) const59status_t AST::generateVts(const std::string &outputPath) const { 60 std::string path = outputPath; 61 path.append(mCoordinator->convertPackageRootToPath(mPackage)); 62 path.append(mCoordinator->getPackagePath(mPackage, true /* relative */)); 63 64 std::string ifaceName; 65 std::string baseName; 66 67 bool isInterface = true; 68 if (!AST::isInterface(&ifaceName)) { 69 baseName = "types"; 70 isInterface = false; 71 } else { 72 const Interface *iface = mRootScope->getInterface(); 73 baseName = iface->getBaseName(); 74 } 75 76 path.append(baseName); 77 path.append(".vts"); 78 79 CHECK(Coordinator::MakeParentHierarchy(path)); 80 FILE *file = fopen(path.c_str(), "w"); 81 82 if (file == NULL) { 83 return -errno; 84 } 85 86 Formatter out(file); 87 88 out << "component_class: HAL_HIDL\n"; 89 out << "component_type_version: " << mPackage.version() 90 << "\n"; 91 out << "component_name: \"" 92 << (isInterface ? ifaceName : "types") 93 << "\"\n\n"; 94 95 out << "package: \"" << mPackage.package() << "\"\n\n"; 96 97 // Generate import statement for all imported interface/types. 98 std::set<FQName> allImportedNames; 99 getAllImportedNames(&allImportedNames); 100 for (const auto &name : allImportedNames) { 101 // ignore IBase. 102 if (name != gIBaseFqName) { 103 out << "import: \"" << name.string() << "\"\n"; 104 } 105 } 106 107 out << "\n"; 108 109 if (isInterface) { 110 const Interface *iface = mRootScope->getInterface(); 111 out << "interface: {\n"; 112 out.indent(); 113 114 std::vector<const Interface *> chain = iface->typeChain(); 115 116 // Generate all the attribute declarations first. 117 status_t status = emitVtsTypeDeclarations(out); 118 if (status != OK) { 119 return status; 120 } 121 // Generate all the method declarations. 122 for (auto it = chain.rbegin(); it != chain.rend(); ++it) { 123 const Interface *superInterface = *it; 124 status_t status = superInterface->emitVtsMethodDeclaration(out); 125 if (status != OK) { 126 return status; 127 } 128 } 129 130 out.unindent(); 131 out << "}\n"; 132 } else { 133 status_t status = emitVtsTypeDeclarations(out); 134 if (status != OK) { 135 return status; 136 } 137 } 138 return OK; 139 } 140 141 } // namespace android 142