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