You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
303 lines
8.5 KiB
303 lines
8.5 KiB
/*
|
|
* 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 "Scope.h"
|
|
|
|
#include "Annotation.h"
|
|
#include "ConstantExpression.h"
|
|
#include "Interface.h"
|
|
|
|
#include <android-base/logging.h>
|
|
#include <hidl-util/Formatter.h>
|
|
#include <hidl-util/StringHelper.h>
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace android {
|
|
|
|
Scope::Scope(const std::string& localName, const FQName& fullName, const Location& location,
|
|
Scope* parent)
|
|
: NamedType(localName, fullName, location, parent) {}
|
|
Scope::~Scope(){}
|
|
|
|
void Scope::addType(NamedType* type) {
|
|
size_t index = mTypes.size();
|
|
mTypes.push_back(type);
|
|
mTypeIndexByName[type->definedName()] = index;
|
|
}
|
|
|
|
status_t Scope::validate() const {
|
|
status_t status = validateAnnotations();
|
|
if (status != OK) return status;
|
|
|
|
return NamedType::validate();
|
|
}
|
|
|
|
status_t Scope::validateUniqueNames() const {
|
|
for (const auto* type : mTypes) {
|
|
if (mTypes[mTypeIndexByName.at(type->definedName())] != type) {
|
|
std::cerr << "ERROR: A type named '" << type->definedName()
|
|
<< "' is already declared in the scope at " << type->location() << std::endl;
|
|
return UNKNOWN_ERROR;
|
|
}
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t Scope::validateAnnotations() const {
|
|
for (const Annotation* annotation : annotations()) {
|
|
std::cerr << "WARNING: Unrecognized annotation '" << annotation->name() << "' at "
|
|
<< location() << ". No annotations are supported here." << std::endl;
|
|
// This is a warning to avoid breaking downstream unnecessarily.
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
NamedType *Scope::lookupType(const FQName &fqName) const {
|
|
CHECK(fqName.package().empty() && fqName.version().empty());
|
|
if (!fqName.valueName().empty()) {
|
|
std::cerr << "ERROR: " << fqName.string() << " does not refer to a type." << std::endl;
|
|
return nullptr;
|
|
}
|
|
std::vector<std::string> names = fqName.names();
|
|
CHECK_GT(names.size(), 0u);
|
|
auto it = mTypeIndexByName.find(names[0]);
|
|
|
|
if (it == mTypeIndexByName.end()) {
|
|
return nullptr;
|
|
}
|
|
|
|
NamedType *outerType = mTypes[it->second];
|
|
if (names.size() == 1) {
|
|
return outerType;
|
|
}
|
|
if (!outerType->isScope()) {
|
|
// more than one names, but the first name is not a scope
|
|
return nullptr;
|
|
}
|
|
Scope *outerScope = static_cast<Scope *>(outerType);
|
|
// *slowly* pop first element
|
|
names.erase(names.begin());
|
|
FQName innerName;
|
|
CHECK(FQName::parse(StringHelper::JoinStrings(names, "."), &innerName));
|
|
return outerScope->lookupType(innerName);
|
|
}
|
|
|
|
LocalIdentifier *Scope::lookupIdentifier(const std::string & /*name*/) const {
|
|
return nullptr;
|
|
}
|
|
|
|
bool Scope::isScope() const {
|
|
return true;
|
|
}
|
|
|
|
Interface *Scope::getInterface() const {
|
|
if (mTypes.size() == 1 && mTypes[0]->isInterface()) {
|
|
return static_cast<Interface *>(mTypes[0]);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
bool Scope::definesInterfaces() const {
|
|
for (const NamedType *type : mTypes) {
|
|
if (type->isInterface()) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const std::vector<Annotation*>& Scope::annotations() const {
|
|
return mAnnotations;
|
|
}
|
|
|
|
void Scope::setAnnotations(std::vector<Annotation*>* annotations) {
|
|
CHECK(mAnnotations.empty());
|
|
CHECK(annotations != nullptr);
|
|
mAnnotations = *annotations;
|
|
}
|
|
|
|
std::vector<const Type*> Scope::getDefinedTypes() const {
|
|
std::vector<const Type*> ret;
|
|
ret.insert(ret.end(), mTypes.begin(), mTypes.end());
|
|
return ret;
|
|
}
|
|
|
|
std::vector<const NamedType*> Scope::getSortedDefinedTypes() const {
|
|
std::vector<const NamedType*> ret;
|
|
ret.insert(ret.end(), mTypes.begin(), mTypes.end());
|
|
|
|
std::sort(ret.begin(), ret.end(), [](const NamedType* lhs, const NamedType* rhs) -> bool {
|
|
return lhs->location() < rhs->location();
|
|
});
|
|
return ret;
|
|
}
|
|
|
|
void Scope::topologicalReorder(const std::unordered_map<const Type*, size_t>& reversedOrder) {
|
|
auto less = [&](const Type* lhs, const Type* rhs) {
|
|
return reversedOrder.at(lhs) < reversedOrder.at(rhs);
|
|
};
|
|
|
|
if (std::is_sorted(mTypes.begin(), mTypes.end(), less)) return;
|
|
|
|
mTypeOrderChanged = true;
|
|
std::sort(mTypes.begin(), mTypes.end(), less);
|
|
|
|
for (size_t i = 0; i != mTypes.size(); ++i) {
|
|
mTypeIndexByName.at(mTypes[i]->definedName()) = i;
|
|
}
|
|
}
|
|
|
|
void Scope::emitHidlDefinition(Formatter& out) const {
|
|
const std::vector<const NamedType*>& definedTypes = getSortedDefinedTypes();
|
|
out.join(definedTypes.begin(), definedTypes.end(), "\n",
|
|
[&](auto t) { t->emitHidlDefinition(out); });
|
|
}
|
|
|
|
void Scope::emitTypeDeclarations(Formatter& out) const {
|
|
if (mTypes.empty()) return;
|
|
|
|
out << "// Forward declaration for forward reference support:\n";
|
|
for (const Type* type : mTypes) {
|
|
type->emitTypeForwardDeclaration(out);
|
|
}
|
|
out << "\n";
|
|
|
|
if (mTypeOrderChanged) {
|
|
out << "// Order of inner types was changed for forward reference support.\n\n";
|
|
}
|
|
|
|
for (const Type* type : mTypes) {
|
|
type->emitDocComment(out);
|
|
type->emitTypeDeclarations(out);
|
|
}
|
|
}
|
|
|
|
void Scope::emitGlobalTypeDeclarations(Formatter& out) const {
|
|
for (const Type* type : mTypes) {
|
|
type->emitGlobalTypeDeclarations(out);
|
|
}
|
|
}
|
|
|
|
void Scope::emitPackageTypeDeclarations(Formatter& out) const {
|
|
for (const Type* type : mTypes) {
|
|
type->emitPackageTypeDeclarations(out);
|
|
}
|
|
}
|
|
|
|
void Scope::emitPackageTypeHeaderDefinitions(Formatter& out) const {
|
|
for (const Type* type : mTypes) {
|
|
type->emitPackageTypeHeaderDefinitions(out);
|
|
}
|
|
}
|
|
|
|
void Scope::emitPackageHwDeclarations(Formatter& out) const {
|
|
for (const Type* type : mTypes) {
|
|
type->emitPackageHwDeclarations(out);
|
|
}
|
|
}
|
|
|
|
void Scope::emitJavaTypeDeclarations(Formatter& out, bool atTopLevel) const {
|
|
if (mTypeOrderChanged) {
|
|
out << "// Order of inner types was changed for forward reference support.\n\n";
|
|
}
|
|
|
|
for (const Type* type : mTypes) {
|
|
type->emitDocComment(out);
|
|
type->emitJavaTypeDeclarations(out, atTopLevel);
|
|
}
|
|
}
|
|
|
|
void Scope::emitTypeDefinitions(Formatter& out, const std::string& prefix) const {
|
|
for (const Type* type : mTypes) {
|
|
type->emitTypeDefinitions(out, prefix);
|
|
}
|
|
}
|
|
|
|
const std::vector<NamedType *> &Scope::getSubTypes() const {
|
|
return mTypes;
|
|
}
|
|
|
|
void Scope::emitVtsTypeDeclarations(Formatter& out) const {
|
|
for (const Type* type : mTypes) {
|
|
type->emitVtsTypeDeclarations(out);
|
|
}
|
|
}
|
|
|
|
bool Scope::deepIsJavaCompatible(std::unordered_set<const Type*>* visited) const {
|
|
for (const Type* type : mTypes) {
|
|
// Java compatibility focuses on types that are actually used by interfaces.
|
|
// Declarations of java-incompatible types are simply omitted from
|
|
// corresponding Java libraries.
|
|
if (type->isInterface() && !type->isJavaCompatible(visited)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return Type::deepIsJavaCompatible(visited);
|
|
}
|
|
|
|
void Scope::appendToExportedTypesVector(
|
|
std::vector<const Type *> *exportedTypes) const {
|
|
for (const Type* type : mTypes) {
|
|
type->appendToExportedTypesVector(exportedTypes);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
RootScope::RootScope(const char* localName, const FQName& fullName, const Location& location,
|
|
Scope* parent)
|
|
: Scope(localName, fullName, location, parent) {}
|
|
RootScope::~RootScope() {}
|
|
|
|
std::string RootScope::typeName() const {
|
|
return "(root scope)";
|
|
}
|
|
|
|
status_t RootScope::validate() const {
|
|
CHECK(annotations().empty());
|
|
return Scope::validate();
|
|
}
|
|
|
|
////////////////////////////////////////
|
|
|
|
LocalIdentifier::LocalIdentifier(){}
|
|
LocalIdentifier::~LocalIdentifier(){}
|
|
|
|
bool LocalIdentifier::isEnumValue() const {
|
|
return false;
|
|
}
|
|
|
|
const LocalIdentifier* LocalIdentifier::resolve() const {
|
|
return this;
|
|
}
|
|
|
|
LocalIdentifier* LocalIdentifier::resolve() {
|
|
return this;
|
|
}
|
|
|
|
ConstantExpression* LocalIdentifier::constExpr() const {
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace android
|
|
|