/*
|
* Copyright (C) 2015, 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.
|
*/
|
|
#pragma once
|
|
#include <memory>
|
#include <string>
|
|
#include <android-base/macros.h>
|
#include <android-base/stringprintf.h>
|
#include <android-base/strings.h>
|
|
#include "aidl_language.h"
|
#include "logging.h"
|
|
namespace android {
|
namespace aidl {
|
|
// Special reserved type names.
|
extern const char kAidlReservedTypePackage[];
|
extern const char kUtf8InCppStringClass[]; // UTF16 wire format, UTF8 in C++
|
|
// Helpful aliases defined to be <kAidlReservedTypePackage>.<class name>
|
extern const char kUtf8InCppStringCanonicalName[];
|
|
// We sometimes special case this class.
|
extern const char kStringCanonicalName[];
|
|
// Note that these aren't the strings recognized by the parser, we just keep
|
// here for the sake of logging a common string constant.
|
extern const char kUtf8InCppAnnotation[];
|
|
class ValidatableType {
|
public:
|
enum {
|
KIND_BUILT_IN,
|
KIND_PARCELABLE,
|
KIND_INTERFACE,
|
KIND_GENERATED,
|
};
|
|
ValidatableType(int kind,
|
const std::string& package, const std::string& type_name,
|
const std::string& decl_file, int decl_line);
|
virtual ~ValidatableType() = default;
|
|
virtual bool CanBeArray() const { return ArrayType() != nullptr; }
|
virtual bool CanWriteToParcel() const = 0;
|
|
virtual const ValidatableType* ArrayType() const = 0;
|
virtual const ValidatableType* NullableType() const = 0;
|
|
// ShortName() is the class name without a package.
|
std::string ShortName() const { return type_name_; }
|
// CanonicalName() returns the canonical AIDL type, with packages.
|
std::string CanonicalName() const { return canonical_name_; }
|
|
int Kind() const { return kind_; }
|
std::string HumanReadableKind() const;
|
std::string DeclFile() const { return origin_file_; }
|
int DeclLine() const { return origin_line_; }
|
|
private:
|
const int kind_;
|
const std::string type_name_;
|
const std::string canonical_name_;
|
const std::string origin_file_;
|
const int origin_line_;
|
|
DISALLOW_COPY_AND_ASSIGN(ValidatableType);
|
};
|
|
class TypeNamespace {
|
public:
|
// Load the TypeNamespace with built in types. Don't do work in the
|
// constructor because many of the useful methods are virtual.
|
virtual void Init() = 0;
|
|
bool AddDefinedTypes(vector<AidlDefinedType*>& types, const string& filename);
|
|
// Load this TypeNamespace with user defined types.
|
virtual bool AddParcelableType(const AidlParcelable& p,
|
const std::string& filename) = 0;
|
|
virtual bool AddBinderType(const AidlInterface& b,
|
const std::string& filename) = 0;
|
// Add a container type to this namespace. Returns false only
|
// on error. Silently discards requests to add non-container types.
|
virtual bool MaybeAddContainerType(const AidlTypeSpecifier& aidl_type) = 0;
|
|
// Returns true iff this has a type for |import|.
|
virtual bool HasImportType(const std::string& import) const = 0;
|
|
// Returns a pointer to a type corresponding to |raw_type| or nullptr
|
// if this is an invalid return type.
|
virtual const ValidatableType* GetReturnType(const AidlTypeSpecifier& raw_type,
|
const AidlDefinedType& context) const;
|
|
// Returns a pointer to a type corresponding to |a| or nullptr if |a|
|
// has an invalid argument type.
|
virtual const ValidatableType* GetArgType(const AidlArgument& a, int arg_index,
|
const AidlDefinedType& context) const;
|
|
// Returns a pointer to a type corresponding to |defined_type|.
|
virtual const ValidatableType* GetDefinedType(const AidlDefinedType& defined_type) const = 0;
|
|
AidlTypenames typenames_;
|
|
protected:
|
TypeNamespace() = default;
|
virtual ~TypeNamespace() = default;
|
|
virtual const ValidatableType* GetValidatableType(const AidlTypeSpecifier& type,
|
std::string* error_msg,
|
const AidlDefinedType& context) const = 0;
|
|
private:
|
DISALLOW_COPY_AND_ASSIGN(TypeNamespace);
|
};
|
|
template<typename T>
|
class LanguageTypeNamespace : public TypeNamespace {
|
public:
|
LanguageTypeNamespace() = default;
|
virtual ~LanguageTypeNamespace() = default;
|
|
// Get a pointer to an existing type. Searches first by fully-qualified
|
// name, and then class name (dropping package qualifiers).
|
const T* Find(const AidlTypeSpecifier& aidl_type) const;
|
|
// Find a type by its |name|. If |name| refers to a container type (e.g.
|
// List<String>) you must turn it into a canonical name first (e.g.
|
// java.util.List<java.lang.String>).
|
const T* FindTypeByCanonicalName(const std::string& name) const;
|
bool HasTypeByCanonicalName(const std::string& type_name) const {
|
return FindTypeByCanonicalName(type_name) != nullptr;
|
}
|
bool HasImportType(const std::string& import) const override {
|
return HasTypeByCanonicalName(import);
|
}
|
const ValidatableType* GetDefinedType(const AidlDefinedType& defined_type) const override {
|
return FindTypeByCanonicalName(defined_type.GetCanonicalName());
|
}
|
|
bool MaybeAddContainerType(const AidlTypeSpecifier& aidl_type) override;
|
// We dynamically create container types as we discover them in the parse
|
// tree. Returns false if the contained types cannot be canonicalized.
|
virtual bool AddListType(const std::string& contained_type_name) = 0;
|
virtual bool AddMapType(const std::string& key_type_name,
|
const std::string& value_type_name) = 0;
|
|
protected:
|
bool Add(std::unique_ptr<const T> type);
|
void AddAndSetMember(const T** member, std::unique_ptr<const T> type) {
|
const T* ptr_value = type.get();
|
CHECK(Add(std::move(type)));
|
*member = ptr_value;
|
}
|
|
private:
|
// Returns true iff the name can be canonicalized to a container type.
|
virtual bool CanonicalizeContainerType(const AidlTypeSpecifier& aidl_type,
|
std::vector<std::string>* container_class,
|
std::vector<std::string>* contained_type_names) const;
|
|
// Returns true if this is a container type, rather than a normal type.
|
bool IsContainerType(const std::string& type_name) const;
|
|
const ValidatableType* GetValidatableType(const AidlTypeSpecifier& type, std::string* error_msg,
|
const AidlDefinedType& context) const override;
|
|
std::vector<std::unique_ptr<const T>> types_;
|
|
DISALLOW_COPY_AND_ASSIGN(LanguageTypeNamespace);
|
}; // class LanguageTypeNamespace
|
|
template <typename T>
|
bool LanguageTypeNamespace<T>::Add(std::unique_ptr<const T> type) {
|
const T* existing = FindTypeByCanonicalName(type->CanonicalName());
|
if (!existing) {
|
types_.push_back(std::move(type));
|
return true;
|
}
|
|
if (existing->Kind() == ValidatableType::KIND_BUILT_IN) {
|
LOG(ERROR) << type->DeclFile() << ":" << type->DeclLine()
|
<< " attempt to redefine built in class "
|
<< type->CanonicalName();
|
return false;
|
}
|
|
if (type->Kind() != existing->Kind()) {
|
LOG(ERROR) << type->DeclFile() << ":" << type->DeclLine()
|
<< " attempt to redefine " << type->CanonicalName()
|
<< " as " << type->HumanReadableKind();
|
LOG(ERROR) << existing->DeclFile() << ":" << existing->DeclLine()
|
<< " previously defined here as "
|
<< existing->HumanReadableKind();
|
return false;
|
}
|
|
return true;
|
}
|
|
template <typename T>
|
const T* LanguageTypeNamespace<T>::Find(const AidlTypeSpecifier& aidl_type) const {
|
using std::string;
|
using std::vector;
|
using android::base::Join;
|
using android::base::Trim;
|
|
string name = Trim(aidl_type.IsArray() ? aidl_type.GetName() : aidl_type.ToString());
|
if (IsContainerType(name)) {
|
vector<string> container_class;
|
vector<string> contained_type_names;
|
if (!CanonicalizeContainerType(aidl_type, &container_class,
|
&contained_type_names)) {
|
return nullptr;
|
}
|
name = Join(container_class, '.') +
|
"<" + Join(contained_type_names, ',') + ">";
|
}
|
// Here, we know that we have the canonical name for this container.
|
return FindTypeByCanonicalName(name);
|
}
|
|
template<typename T>
|
const T* LanguageTypeNamespace<T>::FindTypeByCanonicalName(
|
const std::string& raw_name) const {
|
using android::base::Trim;
|
|
std::string name = Trim(raw_name);
|
const T* ret = nullptr;
|
for (const auto& type : types_) {
|
// Always prefer a exact match if possible.
|
// This works for primitives and class names qualified with a package.
|
if (type->CanonicalName() == name) {
|
ret = type.get();
|
break;
|
}
|
// We allow authors to drop packages when refering to a class name.
|
if (type->ShortName() == name) {
|
ret = type.get();
|
}
|
}
|
|
return ret;
|
}
|
|
template <typename T>
|
bool LanguageTypeNamespace<T>::MaybeAddContainerType(const AidlTypeSpecifier& aidl_type) {
|
using android::base::Join;
|
|
const std::string& type_name = aidl_type.ToString();
|
if (!IsContainerType(type_name)) {
|
return true;
|
}
|
|
std::vector<std::string> container_class;
|
std::vector<std::string> contained_type_names;
|
if (!CanonicalizeContainerType(aidl_type, &container_class,
|
&contained_type_names)) {
|
return false;
|
}
|
|
const std::string canonical_name = Join(container_class, ".") +
|
"<" + Join(contained_type_names, ",") + ">";
|
if (HasTypeByCanonicalName(canonical_name)) {
|
return true;
|
}
|
|
|
// We only support two types right now and this type is one of them.
|
switch (contained_type_names.size()) {
|
case 1:
|
return AddListType(contained_type_names[0]);
|
case 2:
|
return AddMapType(contained_type_names[0], contained_type_names[1]);
|
default:
|
break; // Should never get here, will FATAL below.
|
}
|
|
LOG(FATAL) << "aidl internal error";
|
return false;
|
}
|
|
template<typename T>
|
bool LanguageTypeNamespace<T>::IsContainerType(
|
const std::string& type_name) const {
|
const size_t opening_brace = type_name.find('<');
|
const size_t closing_brace = type_name.find('>');
|
if (opening_brace != std::string::npos ||
|
closing_brace != std::string::npos) {
|
return true; // Neither < nor > appear in normal AIDL types.
|
}
|
return false;
|
}
|
|
template <typename T>
|
bool LanguageTypeNamespace<T>::CanonicalizeContainerType(
|
const AidlTypeSpecifier& aidl_type, std::vector<std::string>* container_class,
|
std::vector<std::string>* contained_type_names) const {
|
std::string container = aidl_type.GetName();
|
std::vector<std::string> args;
|
for (auto& type_arg : aidl_type.GetTypeParameters()) {
|
if (type_arg->IsGeneric()) {
|
// nesting is not allowed yet.
|
LOG(ERROR) << "Nested template type '" << aidl_type.ToString() << "'";
|
}
|
|
std::string type_name = type_arg->ToString();
|
// Here, we are relying on FindTypeByCanonicalName to do its best when
|
// given a non-canonical name for non-compound type (i.e. not another
|
// container).
|
const T* arg_type = FindTypeByCanonicalName(type_name);
|
if (!arg_type) {
|
return false;
|
}
|
|
// Now get the canonical names for these contained types, remapping them if
|
// necessary.
|
type_name = arg_type->CanonicalName();
|
if (aidl_type.IsUtf8InCpp() && type_name == "java.lang.String") {
|
type_name = kUtf8InCppStringCanonicalName;
|
}
|
args.emplace_back(type_name);
|
}
|
|
// Map the container name to its canonical form for supported containers.
|
if ((container == "List" || container == "java.util.List") &&
|
args.size() == 1) {
|
*container_class = {"java", "util", "List"};
|
*contained_type_names = args;
|
return true;
|
}
|
if ((container == "Map" || container == "java.util.Map") &&
|
args.size() == 2) {
|
*container_class = {"java", "util", "Map"};
|
*contained_type_names = args;
|
return true;
|
}
|
|
LOG(ERROR) << "Unknown find container with name " << container << " and " << args.size()
|
<< " contained types.";
|
return false;
|
}
|
|
template <typename T>
|
const ValidatableType* LanguageTypeNamespace<T>::GetValidatableType(
|
const AidlTypeSpecifier& aidl_type, std::string* error_msg,
|
const AidlDefinedType& context) const {
|
using android::base::StringPrintf;
|
|
const ValidatableType* type = Find(aidl_type);
|
if (type == nullptr) {
|
*error_msg = "unknown type";
|
return nullptr;
|
}
|
|
if (aidl_type.GetName() == "void") {
|
if (aidl_type.IsArray()) {
|
*error_msg = "void type cannot be an array";
|
return nullptr;
|
}
|
if (aidl_type.IsNullable() || aidl_type.IsUtf8InCpp()) {
|
*error_msg = "void type cannot be annotated";
|
return nullptr;
|
}
|
// We have no more special handling for void.
|
return type;
|
}
|
|
bool utf8InCpp = aidl_type.IsUtf8InCpp();
|
|
// Strings inside containers get remapped to appropriate utf8 versions when
|
// we convert the container name to its canonical form and the look up the
|
// type. However, for non-compound types (i.e. those not in a container) we
|
// must patch them up here.
|
if (IsContainerType(type->CanonicalName())) {
|
utf8InCpp = false;
|
} else if (aidl_type.GetName() == "String" ||
|
aidl_type.GetName() == "java.lang.String") {
|
utf8InCpp = utf8InCpp || context.IsUtf8InCpp();
|
} else if (utf8InCpp) {
|
*error_msg = StringPrintf("type '%s' may not be annotated as %s.", aidl_type.GetName().c_str(),
|
kUtf8InCppAnnotation);
|
return nullptr;
|
}
|
|
if (utf8InCpp) {
|
type = FindTypeByCanonicalName(kUtf8InCppStringCanonicalName);
|
}
|
|
// One of our UTF8 transforms made type null
|
if (type == nullptr) {
|
*error_msg = StringPrintf("%s is unsupported when generating code for this language.",
|
kUtf8InCppAnnotation);
|
return nullptr;
|
}
|
|
if (!type->CanWriteToParcel()) {
|
*error_msg = "type cannot be marshalled";
|
return nullptr;
|
}
|
|
if (aidl_type.IsArray()) {
|
type = type->ArrayType();
|
if (!type) {
|
*error_msg = StringPrintf("type '%s' cannot be an array",
|
aidl_type.GetName().c_str());
|
return nullptr;
|
}
|
}
|
|
if (context.IsNullable()) {
|
const ValidatableType* nullableType = type->NullableType();
|
|
if (nullableType) {
|
return nullableType;
|
}
|
}
|
|
if (aidl_type.IsNullable()) {
|
type = type->NullableType();
|
if (!type) {
|
*error_msg = StringPrintf("type '%s%s' cannot be marked as possibly null",
|
aidl_type.GetName().c_str(),
|
(aidl_type.IsArray()) ? "[]" : "");
|
return nullptr;
|
}
|
}
|
|
return type;
|
}
|
|
} // namespace aidl
|
} // namespace android
|
