| /* |
| * Copyright (C) 2018, 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 "aidl_typenames.h" |
| #include "aidl_language.h" |
| #include "logging.h" |
| |
| #include <android-base/strings.h> |
| |
| #include <map> |
| #include <memory> |
| #include <set> |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| using android::base::Split; |
| |
| using std::make_pair; |
| using std::map; |
| using std::pair; |
| using std::set; |
| using std::string; |
| using std::unique_ptr; |
| using std::vector; |
| |
| namespace android { |
| namespace aidl { |
| |
| // The built-in AIDL types.. |
| static const set<string> kBuiltinTypes = { |
| "void", "boolean", "byte", "char", "int", |
| "long", "float", "double", "String", "List", |
| "Map", "IBinder", "FileDescriptor", "CharSequence", "ParcelFileDescriptor"}; |
| |
| static const set<string> kPrimitiveTypes = {"void", "boolean", "byte", "char", |
| "int", "long", "float", "double"}; |
| |
| // Note: these types may look wrong because they look like Java |
| // types, but they have long been supported from the time when Java |
| // was the only target language of this compiler. They are added here for |
| // backwards compatibility, but we internally treat them as List and Map, |
| // respectively. |
| static const map<string, string> kJavaLikeTypeToAidlType = { |
| {"java.util.List", "List"}, |
| {"java.util.Map", "Map"}, |
| {"android.os.ParcelFileDescriptor", "ParcelFileDescriptor"}, |
| }; |
| |
| // Package name and type name can't be one of these as they are keywords |
| // in Java and C++. Using these names will eventually cause compilation error, |
| // so checking this here is not a must have, but early detection of errors |
| // is always better. |
| static const set<string> kInvalidNames = { |
| "break", "case", "catch", "char", "class", "continue", "default", |
| "do", "double", "else", "enum", "false", "float", "for", |
| "goto", "if", "int", "long", "new", "private", "protected", |
| "public", "return", "short", "static", "switch", "this", "throw", |
| "true", "try", "void", "volatile", "while"}; |
| |
| static bool IsValidName(const string& name) { |
| vector<string> pieces = Split(name, "."); |
| for (const auto& piece : pieces) { |
| if (kInvalidNames.find(piece) != kInvalidNames.end()) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool AidlTypenames::AddDefinedType(unique_ptr<AidlDefinedType> type) { |
| const string name = type->GetCanonicalName(); |
| if (defined_types_.find(name) != defined_types_.end()) { |
| return false; |
| } |
| if (!IsValidName(type->GetPackage()) || !IsValidName(type->GetName())) { |
| return false; |
| } |
| defined_types_.emplace(name, std::move(type)); |
| return true; |
| } |
| |
| bool AidlTypenames::AddPreprocessedType(unique_ptr<AidlDefinedType> type) { |
| const string name = type->GetCanonicalName(); |
| if (preprocessed_types_.find(name) != preprocessed_types_.end()) { |
| return false; |
| } |
| if (!IsValidName(type->GetPackage()) || !IsValidName(type->GetName())) { |
| return false; |
| } |
| preprocessed_types_.insert(make_pair(name, std::move(type))); |
| return true; |
| } |
| |
| bool AidlTypenames::IsBuiltinTypename(const string& type_name) { |
| return kBuiltinTypes.find(type_name) != kBuiltinTypes.end() || |
| kJavaLikeTypeToAidlType.find(type_name) != kJavaLikeTypeToAidlType.end(); |
| } |
| |
| bool AidlTypenames::IsPrimitiveTypename(const string& type_name) { |
| return kPrimitiveTypes.find(type_name) != kPrimitiveTypes.end(); |
| } |
| |
| const AidlDefinedType* AidlTypenames::TryGetDefinedType(const string& type_name) const { |
| // Do the exact match first. |
| auto found_def = defined_types_.find(type_name); |
| if (found_def != defined_types_.end()) { |
| return found_def->second.get(); |
| } |
| |
| auto found_prep = preprocessed_types_.find(type_name); |
| if (found_prep != preprocessed_types_.end()) { |
| return found_prep->second.get(); |
| } |
| |
| // Then match with the class name. Defined types has higher priority than |
| // types from the preprocessed file. |
| for (auto it = defined_types_.begin(); it != defined_types_.end(); it++) { |
| if (it->second->GetName() == type_name) { |
| return it->second.get(); |
| } |
| } |
| |
| for (auto it = preprocessed_types_.begin(); it != preprocessed_types_.end(); it++) { |
| if (it->second->GetName() == type_name) { |
| return it->second.get(); |
| } |
| } |
| |
| return nullptr; |
| } |
| |
| pair<string, bool> AidlTypenames::ResolveTypename(const string& type_name) const { |
| if (IsBuiltinTypename(type_name)) { |
| auto found = kJavaLikeTypeToAidlType.find(type_name); |
| if (found != kJavaLikeTypeToAidlType.end()) { |
| return make_pair(found->second, true); |
| } |
| return make_pair(type_name, true); |
| } |
| const AidlDefinedType* defined_type = TryGetDefinedType(type_name); |
| if (defined_type != nullptr) { |
| return make_pair(defined_type->GetCanonicalName(), true); |
| } else { |
| return make_pair(type_name, false); |
| } |
| } |
| |
| // Only T[], List, Map, ParcelFileDescriptor and Parcelable can be an out parameter. |
| bool AidlTypenames::CanBeOutParameter(const AidlTypeSpecifier& type) const { |
| const string& name = type.GetName(); |
| if (IsBuiltinTypename(name)) { |
| return type.IsArray() || type.GetName() == "List" || type.GetName() == "Map" || |
| type.GetName() == "ParcelFileDescriptor"; |
| } |
| const AidlDefinedType* t = TryGetDefinedType(type.GetName()); |
| CHECK(t != nullptr) << "Unrecognized type: '" << type.GetName() << "'"; |
| return t->AsParcelable() != nullptr; |
| } |
| |
| void AidlTypenames::IterateTypes(const std::function<void(const AidlDefinedType&)>& body) const { |
| for (const auto& kv : defined_types_) { |
| body(*kv.second); |
| } |
| for (const auto& kv : preprocessed_types_) { |
| body(*kv.second); |
| } |
| } |
| |
| void AidlTypenames::Reset() { |
| defined_types_.clear(); |
| preprocessed_types_.clear(); |
| } |
| |
| } // namespace aidl |
| } // namespace android |