c2hal/CompositeDeclaration.cpp

/*
 * Copyright (C) 2016 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "CompositeDeclaration.h"
#include "FunctionDeclaration.h"
#include "Declaration.h"

#include <algorithm>
#include <iostream>
#include <string>
#include <sstream>

namespace android {

static std::string capitalize(const std::string in) {
    std::string out{in};

    if(!out.empty()) {
        out[0] = toupper(out[0]);
    }

    return out;
}

static std::string snakeCaseToCamelCase(const std::string in) {
    std::istringstream ss(in);
    std::string word;
    std::string out;

    while (std::getline(ss, word, '_')) {
        out += capitalize(word);
    }

    return out;
}

CompositeDeclaration::CompositeDeclaration(
        const Type::Qualifier::Qualification qualifier,
        const std::string &name,
        std::vector<android::Declaration *> *fieldDeclarations)
    : Declaration(name), mQualifier(qualifier), mFieldDeclarations(fieldDeclarations)
    {}

CompositeDeclaration::~CompositeDeclaration() {
    if(mFieldDeclarations != NULL) {
        for(auto* decl : *mFieldDeclarations) {
            delete decl;
        }
    }
    delete mFieldDeclarations;
}


const Type::Qualifier::Qualification &CompositeDeclaration::getQualifier() const {
    return mQualifier;
}
const std::vector<android::Declaration *>*
    CompositeDeclaration::getFieldDeclarations() const {
    return mFieldDeclarations;
}

void CompositeDeclaration::generateInterface(Formatter &out) const {
    generateCommentText(out);
    out << "interface " << getInterfaceName() << " {\n\n";

    generateBody(out);

    out << "};\n";
}

void CompositeDeclaration::generateSource(Formatter &out) const {
    CHECK(mQualifier == Type::Qualifier::STRUCT ||
          mQualifier == Type::Qualifier::UNION ||
          mQualifier == Type::Qualifier::ENUM);

    out << Type::qualifierText(mQualifier) << " " << getName();

    if (mQualifier == Type::Qualifier::ENUM) {
        out << " : ";

        if (mEnumTypeName.empty()) {
            out << "int32_t /* NOTE: type is guessed */";
        } else {
            out << mEnumTypeName;
        }

    }

    out << " {\n";

    generateBody(out);

    out << "};\n";
}

void CompositeDeclaration::generateBody(Formatter &out) const {
    out.indent();

    for (auto *declaration : *mFieldDeclarations) {
        declaration->generateCommentText(out);
        declaration->generateSource(out);
        out << "\n";
    }

    out.unindent();
}

void CompositeDeclaration::processContents(AST &ast) {
    for (auto &declaration : *mFieldDeclarations) {
        declaration->processContents(ast);
    }

    if (isInterface()) {
        // move non function fields into a containing struct

        auto nonFpDecs = new std::vector<Declaration*>;

        auto it = mFieldDeclarations->begin();
        while (it != mFieldDeclarations->end()) {
            if((*it)->decType() != FunctionDeclaration::type()) {
                nonFpDecs->push_back(*it);
                it = mFieldDeclarations->erase(it);
            } else {
                it++;
            }
        }

        if (!nonFpDecs->empty()) {
            auto subStruct = new CompositeDeclaration(Type::Qualifier::STRUCT,
                                                      getName(),
                                                      nonFpDecs);

            mFieldDeclarations->insert(mFieldDeclarations->begin(), subStruct);
        }
    }
}

std::string CompositeDeclaration::getInterfaceName() const {
    std::string baseName{getName()};

    if (baseName.length() > 2 &&
        baseName.substr(baseName.length() - 2) == "_t") {

        baseName = baseName.substr(0, baseName.length() - 2);
    }

    return "I" + snakeCaseToCamelCase(baseName);
}

bool CompositeDeclaration::isInterface() const {
    if (mQualifier != Type::Qualifier::STRUCT) {
        return false;
    }

    for (auto &declaration : *mFieldDeclarations) {
        if (declaration->decType() == FunctionDeclaration::type()) {
            return true;
        }
    }
    return false;
}

void CompositeDeclaration::setEnumTypeName(const std::string &name) {
    CHECK(mQualifier == Type::Qualifier::ENUM);

    mEnumTypeName = name;
}

} //namespace android