Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 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 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 17 | #include "ResourceTable.h" |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 18 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 19 | #include <algorithm> |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 20 | #include <memory> |
| 21 | #include <string> |
| 22 | #include <tuple> |
| 23 | |
Adam Lesinski | 66ea840 | 2017-06-28 11:44:11 -0700 | [diff] [blame] | 24 | #include "android-base/logging.h" |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 25 | #include "android-base/stringprintf.h" |
Mårten Kongstad | 24c9aa6 | 2018-06-20 08:46:41 +0200 | [diff] [blame] | 26 | #include "androidfw/ConfigDescription.h" |
Adam Lesinski | 66ea840 | 2017-06-28 11:44:11 -0700 | [diff] [blame] | 27 | #include "androidfw/ResourceTypes.h" |
| 28 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 29 | #include "Debug.h" |
Adam Lesinski | 66ea840 | 2017-06-28 11:44:11 -0700 | [diff] [blame] | 30 | #include "NameMangler.h" |
| 31 | #include "ResourceValues.h" |
| 32 | #include "ValueVisitor.h" |
Fabien Sanglard | 2d34e76 | 2019-02-21 15:13:29 -0800 | [diff] [blame] | 33 | #include "trace/TraceBuffer.h" |
Adam Lesinski | 66ea840 | 2017-06-28 11:44:11 -0700 | [diff] [blame] | 34 | #include "text/Unicode.h" |
| 35 | #include "util/Util.h" |
| 36 | |
| 37 | using ::aapt::text::IsValidResourceEntryName; |
Mårten Kongstad | 24c9aa6 | 2018-06-20 08:46:41 +0200 | [diff] [blame] | 38 | using ::android::ConfigDescription; |
Adam Lesinski | 66ea840 | 2017-06-28 11:44:11 -0700 | [diff] [blame] | 39 | using ::android::StringPiece; |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 40 | using ::android::base::StringPrintf; |
Adam Lesinski | d5083f6 | 2017-01-16 15:07:21 -0800 | [diff] [blame] | 41 | |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 42 | namespace aapt { |
| 43 | |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 44 | const char* Overlayable::kActorScheme = "overlay"; |
| 45 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 46 | static bool less_than_type_and_id(const std::unique_ptr<ResourceTableType>& lhs, |
| 47 | const std::pair<ResourceType, Maybe<uint8_t>>& rhs) { |
| 48 | return lhs->type < rhs.first || (lhs->type == rhs.first && rhs.second && lhs->id < rhs.second); |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 49 | } |
| 50 | |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 51 | template <typename T> |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 52 | static bool less_than_struct_with_name(const std::unique_ptr<T>& lhs, const StringPiece& rhs) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 53 | return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 54 | } |
| 55 | |
David Chaloupka | e3c1a4a | 2018-01-18 13:44:36 +0000 | [diff] [blame] | 56 | template <typename T> |
| 57 | static bool less_than_struct_with_name_and_id(const std::unique_ptr<T>& lhs, |
Ryan Mitchell | 8d4ee97 | 2018-08-27 11:24:04 -0700 | [diff] [blame] | 58 | const std::pair<StringPiece, Maybe<uint16_t>>& rhs) { |
David Chaloupka | e3c1a4a | 2018-01-18 13:44:36 +0000 | [diff] [blame] | 59 | int name_cmp = lhs->name.compare(0, lhs->name.size(), rhs.first.data(), rhs.first.size()); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 60 | return name_cmp < 0 || (name_cmp == 0 && rhs.second && lhs->id < rhs.second); |
David Chaloupka | e3c1a4a | 2018-01-18 13:44:36 +0000 | [diff] [blame] | 61 | } |
| 62 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 63 | ResourceTablePackage* ResourceTable::FindPackage(const StringPiece& name) const { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 64 | const auto last = packages.end(); |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 65 | auto iter = std::lower_bound(packages.begin(), last, name, |
| 66 | less_than_struct_with_name<ResourceTablePackage>); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 67 | if (iter != last && name == (*iter)->name) { |
| 68 | return iter->get(); |
| 69 | } |
| 70 | return nullptr; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 71 | } |
| 72 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 73 | ResourceTablePackage* ResourceTable::FindPackageById(uint8_t id) const { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 74 | for (auto& package : packages) { |
| 75 | if (package->id && package->id.value() == id) { |
| 76 | return package.get(); |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 77 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 78 | } |
| 79 | return nullptr; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 80 | } |
| 81 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 82 | ResourceTablePackage* ResourceTable::CreatePackage(const StringPiece& name, Maybe<uint8_t> id) { |
Fabien Sanglard | 2d34e76 | 2019-02-21 15:13:29 -0800 | [diff] [blame] | 83 | TRACE_CALL(); |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 84 | ResourceTablePackage* package = FindOrCreatePackage(name); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 85 | if (id && !package->id) { |
| 86 | package->id = id; |
Adam Lesinski | 9ba47d8 | 2015-10-13 11:37:10 -0700 | [diff] [blame] | 87 | return package; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | if (id && package->id && package->id.value() != id.value()) { |
| 91 | return nullptr; |
| 92 | } |
| 93 | return package; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 94 | } |
| 95 | |
David Chaloupka | e3c1a4a | 2018-01-18 13:44:36 +0000 | [diff] [blame] | 96 | ResourceTablePackage* ResourceTable::CreatePackageAllowingDuplicateNames(const StringPiece& name, |
| 97 | const Maybe<uint8_t> id) { |
| 98 | const auto last = packages.end(); |
| 99 | auto iter = std::lower_bound(packages.begin(), last, std::make_pair(name, id), |
| 100 | less_than_struct_with_name_and_id<ResourceTablePackage>); |
| 101 | |
| 102 | if (iter != last && name == (*iter)->name && id == (*iter)->id) { |
| 103 | return iter->get(); |
| 104 | } |
| 105 | |
| 106 | std::unique_ptr<ResourceTablePackage> new_package = util::make_unique<ResourceTablePackage>(); |
| 107 | new_package->name = name.to_string(); |
| 108 | new_package->id = id; |
| 109 | return packages.emplace(iter, std::move(new_package))->get(); |
| 110 | } |
| 111 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 112 | ResourceTablePackage* ResourceTable::FindOrCreatePackage(const StringPiece& name) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 113 | const auto last = packages.end(); |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 114 | auto iter = std::lower_bound(packages.begin(), last, name, |
| 115 | less_than_struct_with_name<ResourceTablePackage>); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 116 | if (iter != last && name == (*iter)->name) { |
| 117 | return iter->get(); |
| 118 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 119 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 120 | std::unique_ptr<ResourceTablePackage> new_package = util::make_unique<ResourceTablePackage>(); |
Adam Lesinski | d5083f6 | 2017-01-16 15:07:21 -0800 | [diff] [blame] | 121 | new_package->name = name.to_string(); |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 122 | return packages.emplace(iter, std::move(new_package))->get(); |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 123 | } |
| 124 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 125 | ResourceTableType* ResourceTablePackage::FindType(ResourceType type, const Maybe<uint8_t> id) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 126 | const auto last = types.end(); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 127 | auto iter = std::lower_bound(types.begin(), last, std::make_pair(type, id), |
| 128 | less_than_type_and_id); |
| 129 | if (iter != last && (*iter)->type == type && (!id || id == (*iter)->id)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 130 | return iter->get(); |
| 131 | } |
| 132 | return nullptr; |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 133 | } |
| 134 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 135 | ResourceTableType* ResourceTablePackage::FindOrCreateType(ResourceType type, |
| 136 | const Maybe<uint8_t> id) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 137 | const auto last = types.end(); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 138 | auto iter = std::lower_bound(types.begin(), last, std::make_pair(type, id), |
| 139 | less_than_type_and_id); |
| 140 | if (iter != last && (*iter)->type == type && (!id || id == (*iter)->id)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 141 | return iter->get(); |
| 142 | } |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 143 | |
| 144 | auto new_type = new ResourceTableType(type); |
| 145 | new_type->id = id; |
| 146 | return types.emplace(iter, std::move(new_type))->get(); |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Ryan Mitchell | 8d4ee97 | 2018-08-27 11:24:04 -0700 | [diff] [blame] | 149 | ResourceEntry* ResourceTableType::FindEntry(const StringPiece& name, const Maybe<uint16_t> id) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 150 | const auto last = entries.end(); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 151 | auto iter = std::lower_bound(entries.begin(), last, std::make_pair(name, id), |
| 152 | less_than_struct_with_name_and_id<ResourceEntry>); |
| 153 | if (iter != last && name == (*iter)->name && (!id || id == (*iter)->id)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 154 | return iter->get(); |
| 155 | } |
| 156 | return nullptr; |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 157 | } |
| 158 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 159 | ResourceEntry* ResourceTableType::FindOrCreateEntry(const StringPiece& name, |
Ryan Mitchell | 8d4ee97 | 2018-08-27 11:24:04 -0700 | [diff] [blame] | 160 | const Maybe<uint16_t > id) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 161 | auto last = entries.end(); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 162 | auto iter = std::lower_bound(entries.begin(), last, std::make_pair(name, id), |
| 163 | less_than_struct_with_name_and_id<ResourceEntry>); |
| 164 | if (iter != last && name == (*iter)->name && (!id || id == (*iter)->id)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 165 | return iter->get(); |
| 166 | } |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 167 | |
| 168 | auto new_entry = new ResourceEntry(name); |
| 169 | new_entry->id = id; |
| 170 | return entries.emplace(iter, std::move(new_entry))->get(); |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 171 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 172 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 173 | ResourceConfigValue* ResourceEntry::FindValue(const ConfigDescription& config) { |
| 174 | return FindValue(config, StringPiece()); |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | struct ConfigKey { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 178 | const ConfigDescription* config; |
| 179 | const StringPiece& product; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 180 | }; |
| 181 | |
Adam Lesinski | 34a1687 | 2018-02-23 16:18:10 -0800 | [diff] [blame] | 182 | bool lt_config_key_ref(const std::unique_ptr<ResourceConfigValue>& lhs, const ConfigKey& rhs) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 183 | int cmp = lhs->config.compare(*rhs.config); |
| 184 | if (cmp == 0) { |
| 185 | cmp = StringPiece(lhs->product).compare(rhs.product); |
| 186 | } |
| 187 | return cmp < 0; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 188 | } |
| 189 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 190 | ResourceConfigValue* ResourceEntry::FindValue(const ConfigDescription& config, |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 191 | const StringPiece& product) { |
Adam Lesinski | 34a1687 | 2018-02-23 16:18:10 -0800 | [diff] [blame] | 192 | auto iter = std::lower_bound(values.begin(), values.end(), ConfigKey{&config, product}, |
| 193 | lt_config_key_ref); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 194 | if (iter != values.end()) { |
| 195 | ResourceConfigValue* value = iter->get(); |
| 196 | if (value->config == config && StringPiece(value->product) == product) { |
| 197 | return value; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 198 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 199 | } |
| 200 | return nullptr; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 201 | } |
| 202 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 203 | ResourceConfigValue* ResourceEntry::FindOrCreateValue(const ConfigDescription& config, |
| 204 | const StringPiece& product) { |
Adam Lesinski | 34a1687 | 2018-02-23 16:18:10 -0800 | [diff] [blame] | 205 | auto iter = std::lower_bound(values.begin(), values.end(), ConfigKey{&config, product}, |
| 206 | lt_config_key_ref); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 207 | if (iter != values.end()) { |
| 208 | ResourceConfigValue* value = iter->get(); |
| 209 | if (value->config == config && StringPiece(value->product) == product) { |
| 210 | return value; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 211 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 212 | } |
| 213 | ResourceConfigValue* newValue = |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 214 | values.insert(iter, util::make_unique<ResourceConfigValue>(config, product))->get(); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 215 | return newValue; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 216 | } |
| 217 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 218 | std::vector<ResourceConfigValue*> ResourceEntry::FindAllValues(const ConfigDescription& config) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 219 | std::vector<ResourceConfigValue*> results; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 220 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 221 | auto iter = values.begin(); |
| 222 | for (; iter != values.end(); ++iter) { |
| 223 | ResourceConfigValue* value = iter->get(); |
| 224 | if (value->config == config) { |
| 225 | results.push_back(value); |
| 226 | ++iter; |
| 227 | break; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 228 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 229 | } |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 230 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 231 | for (; iter != values.end(); ++iter) { |
| 232 | ResourceConfigValue* value = iter->get(); |
| 233 | if (value->config == config) { |
| 234 | results.push_back(value); |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 235 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 236 | } |
| 237 | return results; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 238 | } |
| 239 | |
Adam Lesinski | 34a1687 | 2018-02-23 16:18:10 -0800 | [diff] [blame] | 240 | bool ResourceEntry::HasDefaultValue() const { |
| 241 | const ConfigDescription& default_config = ConfigDescription::DefaultConfig(); |
| 242 | |
| 243 | // The default config should be at the top of the list, since the list is sorted. |
| 244 | for (auto& config_value : values) { |
| 245 | if (config_value->config == default_config) { |
| 246 | return true; |
Adam Lesinski | 458b877 | 2016-04-25 14:20:21 -0700 | [diff] [blame] | 247 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 248 | } |
Adam Lesinski | 34a1687 | 2018-02-23 16:18:10 -0800 | [diff] [blame] | 249 | return false; |
Adam Lesinski | 458b877 | 2016-04-25 14:20:21 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 252 | // The default handler for collisions. |
| 253 | // |
| 254 | // Typically, a weak value will be overridden by a strong value. An existing weak |
| 255 | // value will not be overridden by an incoming weak value. |
| 256 | // |
| 257 | // There are some exceptions: |
| 258 | // |
| 259 | // Attributes: There are two types of Attribute values: USE and DECL. |
| 260 | // |
| 261 | // USE is anywhere an Attribute is declared without a format, and in a place that would |
| 262 | // be legal to declare if the Attribute already existed. This is typically in a |
| 263 | // <declare-styleable> tag. Attributes defined in a <declare-styleable> are also weak. |
| 264 | // |
| 265 | // DECL is an absolute declaration of an Attribute and specifies an explicit format. |
| 266 | // |
| 267 | // A DECL will override a USE without error. Two DECLs must match in their format for there to be |
| 268 | // no error. |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 269 | ResourceTable::CollisionResult ResourceTable::ResolveValueCollision(Value* existing, |
Ryan Mitchell | b435101 | 2019-03-26 16:07:23 -0700 | [diff] [blame] | 270 | Value* incoming, |
| 271 | bool overlay) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 272 | Attribute* existing_attr = ValueCast<Attribute>(existing); |
| 273 | Attribute* incoming_attr = ValueCast<Attribute>(incoming); |
| 274 | if (!incoming_attr) { |
| 275 | if (incoming->IsWeak()) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 276 | // We're trying to add a weak resource but a resource |
| 277 | // already exists. Keep the existing. |
| 278 | return CollisionResult::kKeepOriginal; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 279 | } else if (existing->IsWeak()) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 280 | // Override the weak resource with the new strong resource. |
| 281 | return CollisionResult::kTakeNew; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 282 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 283 | // The existing and incoming values are strong, this is an error |
| 284 | // if the values are not both attributes. |
Ryan Mitchell | b435101 | 2019-03-26 16:07:23 -0700 | [diff] [blame] | 285 | return overlay ? CollisionResult::kTakeNew : CollisionResult::kConflict; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 286 | } |
| 287 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 288 | if (!existing_attr) { |
| 289 | if (existing->IsWeak()) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 290 | // The existing value is not an attribute and it is weak, |
| 291 | // so take the incoming attribute value. |
| 292 | return CollisionResult::kTakeNew; |
| 293 | } |
| 294 | // The existing value is not an attribute and it is strong, |
| 295 | // so the incoming attribute value is an error. |
Ryan Mitchell | b435101 | 2019-03-26 16:07:23 -0700 | [diff] [blame] | 296 | return overlay ? CollisionResult::kTakeNew : CollisionResult::kConflict; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 297 | } |
| 298 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 299 | CHECK(incoming_attr != nullptr && existing_attr != nullptr); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 300 | |
| 301 | // |
| 302 | // Attribute specific handling. At this point we know both |
| 303 | // values are attributes. Since we can declare and define |
| 304 | // attributes all-over, we do special handling to see |
| 305 | // which definition sticks. |
| 306 | // |
Adam Lesinski | 73bff1e | 2017-12-08 16:06:10 -0800 | [diff] [blame] | 307 | if (existing_attr->IsCompatibleWith(*incoming_attr)) { |
| 308 | // The two attributes are both DECLs, but they are plain attributes with compatible formats. |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 309 | // Keep the strongest one. |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 310 | return existing_attr->IsWeak() ? CollisionResult::kTakeNew : CollisionResult::kKeepOriginal; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 311 | } |
| 312 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 313 | if (existing_attr->IsWeak() && existing_attr->type_mask == android::ResTable_map::TYPE_ANY) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 314 | // Any incoming attribute is better than this. |
| 315 | return CollisionResult::kTakeNew; |
| 316 | } |
| 317 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 318 | if (incoming_attr->IsWeak() && incoming_attr->type_mask == android::ResTable_map::TYPE_ANY) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 319 | // The incoming attribute may be a USE instead of a DECL. |
| 320 | // Keep the existing attribute. |
| 321 | return CollisionResult::kKeepOriginal; |
| 322 | } |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 323 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 324 | return CollisionResult::kConflict; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 325 | } |
| 326 | |
Ryan Mitchell | b435101 | 2019-03-26 16:07:23 -0700 | [diff] [blame] | 327 | ResourceTable::CollisionResult ResourceTable::IgnoreCollision(Value* /* existing */, |
| 328 | Value* /* incoming */, |
| 329 | bool /* overlay */) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 330 | return CollisionResult::kKeepBoth; |
| 331 | } |
| 332 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 333 | static StringPiece ResourceNameValidator(const StringPiece& name) { |
Adam Lesinski | 66ea840 | 2017-06-28 11:44:11 -0700 | [diff] [blame] | 334 | if (!IsValidResourceEntryName(name)) { |
| 335 | return name; |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 336 | } |
| 337 | return {}; |
| 338 | } |
| 339 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 340 | static StringPiece SkipNameValidator(const StringPiece& /*name*/) { |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 341 | return {}; |
| 342 | } |
Adam Lesinski | 330edcd | 2015-05-04 17:40:56 -0700 | [diff] [blame] | 343 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 344 | bool ResourceTable::AddResource(const ResourceNameRef& name, |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 345 | const ConfigDescription& config, |
| 346 | const StringPiece& product, |
| 347 | std::unique_ptr<Value> value, |
Adam Lesinski | e78fd61 | 2015-10-22 12:48:43 -0700 | [diff] [blame] | 348 | IDiagnostics* diag) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 349 | return AddResourceImpl(name, ResourceId{}, config, product, std::move(value), |
| 350 | (validate_resources_ ? ResourceNameValidator : SkipNameValidator), |
| 351 | (validate_resources_ ? ResolveValueCollision : IgnoreCollision), diag); |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 352 | } |
| 353 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 354 | bool ResourceTable::AddResourceWithId(const ResourceNameRef& name, const ResourceId& res_id, |
| 355 | const ConfigDescription& config, const StringPiece& product, |
| 356 | std::unique_ptr<Value> value, IDiagnostics* diag) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 357 | return AddResourceImpl(name, res_id, config, product, std::move(value), |
| 358 | (validate_resources_ ? ResourceNameValidator : SkipNameValidator), |
| 359 | (validate_resources_ ? ResolveValueCollision : IgnoreCollision), diag); |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 360 | } |
| 361 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 362 | bool ResourceTable::AddResourceMangled(const ResourceNameRef& name, const ConfigDescription& config, |
| 363 | const StringPiece& product, std::unique_ptr<Value> value, |
| 364 | IDiagnostics* diag) { |
| 365 | return AddResourceImpl(name, ResourceId{}, config, product, std::move(value), SkipNameValidator, |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 366 | (validate_resources_ ? ResolveValueCollision : IgnoreCollision), diag); |
Adam Lesinski | 330edcd | 2015-05-04 17:40:56 -0700 | [diff] [blame] | 367 | } |
| 368 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 369 | bool ResourceTable::AddResourceWithIdMangled(const ResourceNameRef& name, const ResourceId& id, |
| 370 | const ConfigDescription& config, |
| 371 | const StringPiece& product, |
| 372 | std::unique_ptr<Value> value, IDiagnostics* diag) { |
| 373 | return AddResourceImpl(name, id, config, product, std::move(value), SkipNameValidator, |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 374 | (validate_resources_ ? ResolveValueCollision : IgnoreCollision), diag); |
Adam Lesinski | 9e10ac7 | 2015-10-16 14:37:48 -0700 | [diff] [blame] | 375 | } |
| 376 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 377 | bool ResourceTable::ValidateName(NameValidator name_validator, const ResourceNameRef& name, |
| 378 | const Source& source, IDiagnostics* diag) { |
| 379 | const StringPiece bad_char = name_validator(name.entry); |
| 380 | if (!bad_char.empty()) { |
| 381 | diag->Error(DiagMessage(source) << "resource '" << name << "' has invalid entry name '" |
| 382 | << name.entry << "'. Invalid character '" << bad_char << "'"); |
| 383 | return false; |
| 384 | } |
| 385 | return true; |
| 386 | } |
| 387 | |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 388 | bool ResourceTable::AddResourceImpl(const ResourceNameRef& name, const ResourceId& res_id, |
| 389 | const ConfigDescription& config, const StringPiece& product, |
| 390 | std::unique_ptr<Value> value, NameValidator name_validator, |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 391 | const CollisionResolverFunc& conflict_resolver, |
Adam Lesinski | b1afa07 | 2017-03-29 13:52:38 -0700 | [diff] [blame] | 392 | IDiagnostics* diag) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 393 | CHECK(value != nullptr); |
| 394 | CHECK(diag != nullptr); |
Adam Lesinski | e78fd61 | 2015-10-22 12:48:43 -0700 | [diff] [blame] | 395 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 396 | const Source& source = value->GetSource(); |
| 397 | if (!ValidateName(name_validator, name, source, diag)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 398 | return false; |
| 399 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 400 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 401 | // Check for package names appearing twice with two different package ids |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 402 | ResourceTablePackage* package = FindOrCreatePackage(name.package); |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 403 | if (res_id.is_valid_dynamic() && package->id && package->id.value() != res_id.package_id()) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 404 | diag->Error(DiagMessage(source) |
| 405 | << "trying to add resource '" << name << "' with ID " << res_id |
| 406 | << " but package '" << package->name << "' already has ID " |
| 407 | << StringPrintf("%02x", package->id.value())); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 408 | return false; |
| 409 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 410 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 411 | // Whether or not to error on duplicate resources |
| 412 | bool check_id = validate_resources_ && res_id.is_valid_dynamic(); |
| 413 | // Whether or not to create a duplicate resource if the id does not match |
| 414 | bool use_id = !validate_resources_ && res_id.is_valid_dynamic(); |
| 415 | |
| 416 | ResourceTableType* type = package->FindOrCreateType(name.type, use_id ? res_id.type_id() |
| 417 | : Maybe<uint8_t>()); |
| 418 | |
| 419 | // Check for types appearing twice with two different type ids |
| 420 | if (check_id && type->id && type->id.value() != res_id.type_id()) { |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 421 | diag->Error(DiagMessage(source) |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 422 | << "trying to add resource '" << name << "' with ID " << res_id |
| 423 | << " but type '" << type->type << "' already has ID " |
| 424 | << StringPrintf("%02x", type->id.value())); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 425 | return false; |
| 426 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 427 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 428 | ResourceEntry* entry = type->FindOrCreateEntry(name.entry, use_id ? res_id.entry_id() |
Ryan Mitchell | 8d4ee97 | 2018-08-27 11:24:04 -0700 | [diff] [blame] | 429 | : Maybe<uint16_t>()); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 430 | |
| 431 | // Check for entries appearing twice with two different entry ids |
| 432 | if (check_id && entry->id && entry->id.value() != res_id.entry_id()) { |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 433 | diag->Error(DiagMessage(source) |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 434 | << "trying to add resource '" << name << "' with ID " << res_id |
| 435 | << " but resource already has ID " |
| 436 | << ResourceId(package->id.value(), type->id.value(), entry->id.value())); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 437 | return false; |
| 438 | } |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 439 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 440 | ResourceConfigValue* config_value = entry->FindOrCreateValue(config, product); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 441 | if (!config_value->value) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 442 | // Resource does not exist, add it now. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 443 | config_value->value = std::move(value); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 444 | } else { |
Ryan Mitchell | b435101 | 2019-03-26 16:07:23 -0700 | [diff] [blame] | 445 | switch (conflict_resolver(config_value->value.get(), value.get(), false /* overlay */)) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 446 | case CollisionResult::kKeepBoth: |
| 447 | // Insert the value ignoring for duplicate configurations |
| 448 | entry->values.push_back(util::make_unique<ResourceConfigValue>(config, product)); |
| 449 | entry->values.back()->value = std::move(value); |
| 450 | break; |
| 451 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 452 | case CollisionResult::kTakeNew: |
| 453 | // Take the incoming value. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 454 | config_value->value = std::move(value); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 455 | break; |
Adam Lesinski | e4bb9eb | 2016-02-12 22:18:51 -0800 | [diff] [blame] | 456 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 457 | case CollisionResult::kConflict: |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 458 | diag->Error(DiagMessage(source) << "duplicate value for resource '" << name << "' " |
| 459 | << "with config '" << config << "'"); |
| 460 | diag->Error(DiagMessage(source) << "resource previously defined here"); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 461 | return false; |
Adam Lesinski | 5c3464c | 2016-08-24 16:03:48 -0700 | [diff] [blame] | 462 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 463 | case CollisionResult::kKeepOriginal: |
| 464 | break; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 465 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 466 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 467 | |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 468 | if (res_id.is_valid_dynamic()) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 469 | package->id = res_id.package_id(); |
| 470 | type->id = res_id.type_id(); |
| 471 | entry->id = res_id.entry_id(); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 472 | } |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 473 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 474 | return true; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 475 | } |
| 476 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 477 | bool ResourceTable::GetValidateResources() { |
| 478 | return validate_resources_; |
| 479 | } |
| 480 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 481 | bool ResourceTable::SetVisibility(const ResourceNameRef& name, const Visibility& visibility, |
| 482 | IDiagnostics* diag) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 483 | return SetVisibilityImpl(name, visibility, {}, ResourceNameValidator, diag); |
Adam Lesinski | 330edcd | 2015-05-04 17:40:56 -0700 | [diff] [blame] | 484 | } |
| 485 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 486 | bool ResourceTable::SetVisibilityWithId(const ResourceNameRef& name, const Visibility& visibility, |
| 487 | const ResourceId& res_id, IDiagnostics* diag) { |
| 488 | return SetVisibilityImpl(name, visibility, res_id, ResourceNameValidator, diag); |
| 489 | } |
| 490 | |
| 491 | bool ResourceTable::SetVisibilityWithIdMangled(const ResourceNameRef& name, |
| 492 | const Visibility& visibility, |
| 493 | const ResourceId& res_id, IDiagnostics* diag) { |
| 494 | return SetVisibilityImpl(name, visibility, res_id, SkipNameValidator, diag); |
| 495 | } |
| 496 | |
| 497 | bool ResourceTable::SetVisibilityImpl(const ResourceNameRef& name, const Visibility& visibility, |
| 498 | const ResourceId& res_id, NameValidator name_validator, |
| 499 | IDiagnostics* diag) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 500 | CHECK(diag != nullptr); |
Adam Lesinski | e78fd61 | 2015-10-22 12:48:43 -0700 | [diff] [blame] | 501 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 502 | const Source& source = visibility.source; |
| 503 | if (!ValidateName(name_validator, name, source, diag)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 504 | return false; |
| 505 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 506 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 507 | // Check for package names appearing twice with two different package ids |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 508 | ResourceTablePackage* package = FindOrCreatePackage(name.package); |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 509 | if (res_id.is_valid_dynamic() && package->id && package->id.value() != res_id.package_id()) { |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 510 | diag->Error(DiagMessage(source) |
| 511 | << "trying to add resource '" << name << "' with ID " << res_id |
| 512 | << " but package '" << package->name << "' already has ID " |
| 513 | << StringPrintf("%02x", package->id.value())); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 514 | return false; |
| 515 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 516 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 517 | // Whether or not to error on duplicate resources |
| 518 | bool check_id = validate_resources_ && res_id.is_valid_dynamic(); |
| 519 | // Whether or not to create a duplicate resource if the id does not match |
| 520 | bool use_id = !validate_resources_ && res_id.is_valid_dynamic(); |
| 521 | |
| 522 | ResourceTableType* type = package->FindOrCreateType(name.type, use_id ? res_id.type_id() |
| 523 | : Maybe<uint8_t>()); |
| 524 | |
| 525 | // Check for types appearing twice with two different type ids |
| 526 | if (check_id && type->id && type->id.value() != res_id.type_id()) { |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 527 | diag->Error(DiagMessage(source) |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 528 | << "trying to add resource '" << name << "' with ID " << res_id |
| 529 | << " but type '" << type->type << "' already has ID " |
| 530 | << StringPrintf("%02x", type->id.value())); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 531 | return false; |
| 532 | } |
Adam Lesinski | 1ab598f | 2015-08-14 14:26:04 -0700 | [diff] [blame] | 533 | |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 534 | ResourceEntry* entry = type->FindOrCreateEntry(name.entry, use_id ? res_id.entry_id() |
Ryan Mitchell | 8d4ee97 | 2018-08-27 11:24:04 -0700 | [diff] [blame] | 535 | : Maybe<uint16_t>()); |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 536 | |
| 537 | // Check for entries appearing twice with two different entry ids |
| 538 | if (check_id && entry->id && entry->id.value() != res_id.entry_id()) { |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 539 | diag->Error(DiagMessage(source) |
Ryan Mitchell | 83a37ad | 2018-08-06 16:32:24 -0700 | [diff] [blame] | 540 | << "trying to add resource '" << name << "' with ID " << res_id |
| 541 | << " but resource already has ID " |
| 542 | << ResourceId(package->id.value(), type->id.value(), entry->id.value())); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 543 | return false; |
| 544 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 545 | |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 546 | if (res_id.is_valid_dynamic()) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 547 | package->id = res_id.package_id(); |
| 548 | type->id = res_id.type_id(); |
| 549 | entry->id = res_id.entry_id(); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 550 | } |
Adam Lesinski | a6fe345 | 2015-12-09 15:20:52 -0800 | [diff] [blame] | 551 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 552 | // Only mark the type visibility level as public, it doesn't care about being private. |
| 553 | if (visibility.level == Visibility::Level::kPublic) { |
| 554 | type->visibility_level = Visibility::Level::kPublic; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 555 | } |
Adam Lesinski | a6fe345 | 2015-12-09 15:20:52 -0800 | [diff] [blame] | 556 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 557 | if (visibility.level == Visibility::Level::kUndefined && |
| 558 | entry->visibility.level != Visibility::Level::kUndefined) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 559 | // We can't undefine a symbol (remove its visibility). Ignore. |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 560 | return true; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 561 | } |
| 562 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 563 | if (visibility.level < entry->visibility.level) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 564 | // We can't downgrade public to private. Ignore. |
| 565 | return true; |
| 566 | } |
| 567 | |
Adam Lesinski | 4488f1c | 2017-05-26 17:33:38 -0700 | [diff] [blame] | 568 | // This symbol definition takes precedence, replace. |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 569 | entry->visibility = visibility; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 570 | return true; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 571 | } |
| 572 | |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 573 | bool ResourceTable::SetAllowNew(const ResourceNameRef& name, const AllowNew& allow_new, |
| 574 | IDiagnostics* diag) { |
| 575 | return SetAllowNewImpl(name, allow_new, ResourceNameValidator, diag); |
| 576 | } |
| 577 | |
| 578 | bool ResourceTable::SetAllowNewMangled(const ResourceNameRef& name, const AllowNew& allow_new, |
| 579 | IDiagnostics* diag) { |
| 580 | return SetAllowNewImpl(name, allow_new, SkipNameValidator, diag); |
| 581 | } |
| 582 | |
| 583 | bool ResourceTable::SetAllowNewImpl(const ResourceNameRef& name, const AllowNew& allow_new, |
| 584 | NameValidator name_validator, IDiagnostics* diag) { |
| 585 | CHECK(diag != nullptr); |
| 586 | |
| 587 | if (!ValidateName(name_validator, name, allow_new.source, diag)) { |
| 588 | return false; |
| 589 | } |
| 590 | |
| 591 | ResourceTablePackage* package = FindOrCreatePackage(name.package); |
| 592 | ResourceTableType* type = package->FindOrCreateType(name.type); |
| 593 | ResourceEntry* entry = type->FindOrCreateEntry(name.entry); |
| 594 | entry->allow_new = allow_new; |
| 595 | return true; |
| 596 | } |
| 597 | |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 598 | bool ResourceTable::SetOverlayable(const ResourceNameRef& name, const OverlayableItem& overlayable, |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 599 | IDiagnostics* diag) { |
Ryan Mitchell | 1bb1fe0 | 2018-11-16 11:21:41 -0800 | [diff] [blame] | 600 | return SetOverlayableImpl(name, overlayable, ResourceNameValidator, diag); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 601 | } |
| 602 | |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 603 | bool ResourceTable::SetOverlayableImpl(const ResourceNameRef& name, |
| 604 | const OverlayableItem& overlayable, |
Ryan Mitchell | 1bb1fe0 | 2018-11-16 11:21:41 -0800 | [diff] [blame] | 605 | NameValidator name_validator, IDiagnostics *diag) { |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 606 | CHECK(diag != nullptr); |
| 607 | |
| 608 | if (!ValidateName(name_validator, name, overlayable.source, diag)) { |
| 609 | return false; |
| 610 | } |
| 611 | |
| 612 | ResourceTablePackage* package = FindOrCreatePackage(name.package); |
| 613 | ResourceTableType* type = package->FindOrCreateType(name.type); |
| 614 | ResourceEntry* entry = type->FindOrCreateEntry(name.entry); |
Ryan Mitchell | e4e989c | 2018-10-29 02:21:50 -0700 | [diff] [blame] | 615 | |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 616 | if (entry->overlayable_item) { |
Ryan Mitchell | 1bb1fe0 | 2018-11-16 11:21:41 -0800 | [diff] [blame] | 617 | diag->Error(DiagMessage(overlayable.source) |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 618 | << "duplicate overlayable declaration for resource '" << name << "'"); |
| 619 | diag->Error(DiagMessage(entry->overlayable_item.value().source) |
| 620 | << "previous declaration here"); |
Ryan Mitchell | 1bb1fe0 | 2018-11-16 11:21:41 -0800 | [diff] [blame] | 621 | return false; |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 622 | } |
Ryan Mitchell | e4e989c | 2018-10-29 02:21:50 -0700 | [diff] [blame] | 623 | |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 624 | entry->overlayable_item = overlayable; |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 625 | return true; |
| 626 | } |
| 627 | |
| 628 | Maybe<ResourceTable::SearchResult> ResourceTable::FindResource(const ResourceNameRef& name) const { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 629 | ResourceTablePackage* package = FindPackage(name.package); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 630 | if (package == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 631 | return {}; |
| 632 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 633 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 634 | ResourceTableType* type = package->FindType(name.type); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 635 | if (type == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 636 | return {}; |
| 637 | } |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 638 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 639 | ResourceEntry* entry = type->FindEntry(name.entry); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 640 | if (entry == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 641 | return {}; |
| 642 | } |
| 643 | return SearchResult{package, type, entry}; |
Adam Lesinski | 6f6ceb7 | 2014-11-14 14:48:12 -0800 | [diff] [blame] | 644 | } |
| 645 | |
Shane Farmer | 0a5b201 | 2017-06-22 12:24:12 -0700 | [diff] [blame] | 646 | std::unique_ptr<ResourceTable> ResourceTable::Clone() const { |
| 647 | std::unique_ptr<ResourceTable> new_table = util::make_unique<ResourceTable>(); |
| 648 | for (const auto& pkg : packages) { |
| 649 | ResourceTablePackage* new_pkg = new_table->CreatePackage(pkg->name, pkg->id); |
| 650 | for (const auto& type : pkg->types) { |
| 651 | ResourceTableType* new_type = new_pkg->FindOrCreateType(type->type); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 652 | new_type->id = type->id; |
| 653 | new_type->visibility_level = type->visibility_level; |
Shane Farmer | 0a5b201 | 2017-06-22 12:24:12 -0700 | [diff] [blame] | 654 | |
| 655 | for (const auto& entry : type->entries) { |
| 656 | ResourceEntry* new_entry = new_type->FindOrCreateEntry(entry->name); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 657 | new_entry->id = entry->id; |
| 658 | new_entry->visibility = entry->visibility; |
| 659 | new_entry->allow_new = entry->allow_new; |
Ryan Mitchell | 54237ff | 2018-12-13 15:44:29 -0800 | [diff] [blame] | 660 | new_entry->overlayable_item = entry->overlayable_item; |
Shane Farmer | 0a5b201 | 2017-06-22 12:24:12 -0700 | [diff] [blame] | 661 | |
| 662 | for (const auto& config_value : entry->values) { |
| 663 | ResourceConfigValue* new_value = |
| 664 | new_entry->FindOrCreateValue(config_value->config, config_value->product); |
Adam Lesinski | 71be705 | 2017-12-12 16:48:07 -0800 | [diff] [blame] | 665 | new_value->value.reset(config_value->value->Clone(&new_table->string_pool)); |
Shane Farmer | 0a5b201 | 2017-06-22 12:24:12 -0700 | [diff] [blame] | 666 | } |
| 667 | } |
| 668 | } |
| 669 | } |
| 670 | return new_table; |
| 671 | } |
| 672 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 673 | } // namespace aapt |