/*
* 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.
*/
#include "ConfigDescription.h"
#include "Logger.h"
#include "NameMangler.h"
#include "ResourceTable.h"
#include "ResourceValues.h"
#include "Util.h"
#include <algorithm>
#include <androidfw/ResourceTypes.h>
#include <memory>
#include <string>
#include <tuple>
namespace aapt {
static bool compareConfigs(const ResourceConfigValue& lhs, const ConfigDescription& rhs) {
return lhs.config < rhs;
}
static bool lessThanType(const std::unique_ptr<ResourceTableType>& lhs, ResourceType rhs) {
return lhs->type < rhs;
}
static bool lessThanEntry(const std::unique_ptr<ResourceEntry>& lhs, const StringPiece16& rhs) {
return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0;
}
ResourceTable::ResourceTable() : mPackageId(kUnsetPackageId) {
// Make sure attrs always have type ID 1.
findOrCreateType(ResourceType::kAttr)->typeId = 1;
}
std::unique_ptr<ResourceTableType>& ResourceTable::findOrCreateType(ResourceType type) {
auto last = mTypes.end();
auto iter = std::lower_bound(mTypes.begin(), last, type, lessThanType);
if (iter != last) {
if ((*iter)->type == type) {
return *iter;
}
}
return *mTypes.emplace(iter, new ResourceTableType{ type });
}
std::unique_ptr<ResourceEntry>& ResourceTable::findOrCreateEntry(
std::unique_ptr<ResourceTableType>& type, const StringPiece16& name) {
auto last = type->entries.end();
auto iter = std::lower_bound(type->entries.begin(), last, name, lessThanEntry);
if (iter != last) {
if (name == (*iter)->name) {
return *iter;
}
}
return *type->entries.emplace(iter, new ResourceEntry{ name });
}
struct IsAttributeVisitor : ConstValueVisitor {
bool isAttribute = false;
void visit(const Attribute&, ValueVisitorArgs&) override {
isAttribute = true;
}
operator bool() {
return isAttribute;
}
};
/**
* The default handler for collisions. A return value of -1 means keep the
* existing value, 0 means fail, and +1 means take the incoming value.
*/
static int defaultCollisionHandler(const Value& existing, const Value& incoming) {
IsAttributeVisitor existingIsAttr, incomingIsAttr;
existing.accept(existingIsAttr, {});
incoming.accept(incomingIsAttr, {});
if (!incomingIsAttr) {
if (incoming.isWeak()) {
// We're trying to add a weak resource but a resource
// already exists. Keep the existing.
return -1;
} else if (existing.isWeak()) {
// Override the weak resource with the new strong resource.
return 1;
}
// The existing and incoming values are strong, this is an error
// if the values are not both attributes.
return 0;
}
if (!existingIsAttr) {
if (existing.isWeak()) {
// The existing value is not an attribute and it is weak,
// so take the incoming attribute value.
return 1;
}
// The existing value is not an attribute and it is strong,
// so the incoming attribute value is an error.
return 0;
}
//
// Attribute specific handling. At this point we know both
// values are attributes. Since we can declare and define
// attributes all-over, we do special handling to see
// which definition sticks.
//
const Attribute& existingAttr = static_cast<const Attribute&>(existing);
const Attribute& incomingAttr = static_cast<const Attribute&>(incoming);
if (existingAttr.typeMask == incomingAttr.typeMask) {
// The two attributes are both DECLs, but they are plain attributes
// with the same formats.
// Keep the strongest one.
return existingAttr.isWeak() ? 1 : -1;
}
if (existingAttr.isWeak() && existingAttr.typeMask == android::ResTable_map::TYPE_ANY) {
// Any incoming attribute is better than this.
return 1;
}
if (incomingAttr.isWeak() && incomingAttr.typeMask == android::ResTable_map::TYPE_ANY) {
// The incoming attribute may be a USE instead of a DECL.
// Keep the existing attribute.
return -1;
}
return 0;
}
static constexpr const char16_t* kValidNameChars = u"._-";
static constexpr const char16_t* kValidNameMangledChars = u"._-$";
bool ResourceTable::addResource(const ResourceNameRef& name, const ConfigDescription& config,
const SourceLine& source, std::unique_ptr<Value> value) {
return addResourceImpl(name, ResourceId{}, config, source, std::move(value), kValidNameChars);
}
bool ResourceTable::addResource(const ResourceNameRef& name, const ResourceId resId,
const ConfigDescription& config, const SourceLine& source,
std::unique_ptr<Value> value) {
return addResourceImpl(name, resId, config, source, std::move(value), kValidNameChars);
}
bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
const ConfigDescription& config,
const SourceLine& source,
std::unique_ptr<Value> value) {
return addResourceImpl(name, ResourceId{}, config, source, std::move(value),
kValidNameMangledChars);
}
bool ResourceTable::addResourceImpl(const ResourceNameRef& name, const ResourceId resId,
const ConfigDescription& config, const SourceLine& source,
std::unique_ptr<Value> value, const char16_t* validChars) {
if (!name.package.empty() && name.package != mPackage) {
Logger::error(source)
<< "resource '"
<< name
<< "' has incompatible package. Must be '"
<< mPackage
<< "'."
<< std::endl;
return false;
}
auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
if (badCharIter != name.entry.end()) {
Logger::error(source)
<< "resource '"
<< name
<< "' has invalid entry name '"
<< name.entry
<< "'. Invalid character '"
<< StringPiece16(badCharIter, 1)
<< "'."
<< std::endl;
return false;
}
std::unique_ptr<ResourceTableType>& type = findOrCreateType(name.type);
if (resId.isValid() && type->typeId != ResourceTableType::kUnsetTypeId &&
type->typeId != resId.typeId()) {
Logger::error(source)
<< "trying to add resource '"
<< name
<< "' with ID "
<< resId
<< " but type '"
<< type->type
<< "' already has ID "
<< std::hex << type->typeId << std::dec
<< "."
<< std::endl;
return false;
}
std::unique_ptr<ResourceEntry>& entry = findOrCreateEntry(type, name.entry);
if (resId.isValid() && entry->entryId != ResourceEntry::kUnsetEntryId &&
entry->entryId != resId.entryId()) {
Logger::error(source)
<< "trying to add resource '"
<< name
<< "' with ID "
<< resId
<< " but resource already has ID "
<< ResourceId(mPackageId, type->typeId, entry->entryId)
<< "."
<< std::endl;
return false;
}
const auto endIter = std::end(entry->values);
auto iter = std::lower_bound(std::begin(entry->values), endIter, config, compareConfigs);
if (iter == endIter || iter->config != config) {
// This resource did not exist before, add it.
entry->values.insert(iter, ResourceConfigValue{ config, source, {}, std::move(value) });
} else {
int collisionResult = defaultCollisionHandler(*iter->value, *value);
if (collisionResult > 0) {
// Take the incoming value.
*iter = ResourceConfigValue{ config, source, {}, std::move(value) };
} else if (collisionResult == 0) {
Logger::error(source)
<< "duplicate value for resource '" << name << "' "
<< "with config '" << iter->config << "'."
<< std::endl;
Logger::error(iter->source)
<< "resource previously defined here."
<< std::endl;
return false;
}
}
if (resId.isValid()) {
type->typeId = resId.typeId();
entry->entryId = resId.entryId();
}
return true;
}
bool ResourceTable::markPublic(const ResourceNameRef& name, const ResourceId resId,
const SourceLine& source) {
return markPublicImpl(name, resId, source, kValidNameChars);
}
bool ResourceTable::markPublicAllowMangled(const ResourceNameRef& name, const ResourceId resId,
const SourceLine& source) {
return markPublicImpl(name, resId, source, kValidNameMangledChars);
}
bool ResourceTable::markPublicImpl(const ResourceNameRef& name, const ResourceId resId,
const SourceLine& source, const char16_t* validChars) {
if (!name.package.empty() && name.package != mPackage) {
Logger::error(source)
<< "resource '"
<< name
<< "' has incompatible package. Must be '"
<< mPackage
<< "'."
<< std::endl;
return false;
}
auto badCharIter = util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
if (badCharIter != name.entry.end()) {
Logger::error(source)
<< "resource '"
<< name
<< "' has invalid entry name '"
<< name.entry
<< "'. Invalid character '"
<< StringPiece16(badCharIter, 1)
<< "'."
<< std::endl;
return false;
}
std::unique_ptr<ResourceTableType>& type = findOrCreateType(name.type);
if (resId.isValid() && type->typeId != ResourceTableType::kUnsetTypeId &&
type->typeId != resId.typeId()) {
Logger::error(source)
<< "trying to make resource '"
<< name
<< "' public with ID "
<< resId
<< " but type '"
<< type->type
<< "' already has ID "
<< std::hex << type->typeId << std::dec
<< "."
<< std::endl;
return false;
}
std::unique_ptr<ResourceEntry>& entry = findOrCreateEntry(type, name.entry);
if (resId.isValid() && entry->entryId != ResourceEntry::kUnsetEntryId &&
entry->entryId != resId.entryId()) {
Logger::error(source)
<< "trying to make resource '"
<< name
<< "' public with ID "
<< resId
<< " but resource already has ID "
<< ResourceId(mPackageId, type->typeId, entry->entryId)
<< "."
<< std::endl;
return false;
}
type->publicStatus.isPublic = true;
entry->publicStatus.isPublic = true;
entry->publicStatus.source = source;
if (resId.isValid()) {
type->typeId = resId.typeId();
entry->entryId = resId.entryId();
}
return true;
}
bool ResourceTable::merge(ResourceTable&& other) {
const bool mangleNames = mPackage != other.getPackage();
std::u16string mangledName;
for (auto& otherType : other) {
std::unique_ptr<ResourceTableType>& type = findOrCreateType(otherType->type);
if (otherType->publicStatus.isPublic) {
if (type->publicStatus.isPublic && type->typeId != otherType->typeId) {
Logger::error() << "can not merge type '" << type->type
<< "': conflicting public IDs "
<< "(" << type->typeId << " vs " << otherType->typeId << ")."
<< std::endl;
return false;
}
type->publicStatus = std::move(otherType->publicStatus);
type->typeId = otherType->typeId;
}
for (auto& otherEntry : otherType->entries) {
const std::u16string* nameToAdd = &otherEntry->name;
if (mangleNames) {
mangledName = otherEntry->name;
NameMangler::mangle(other.getPackage(), &mangledName);
nameToAdd = &mangledName;
}
std::unique_ptr<ResourceEntry>& entry = findOrCreateEntry(type, *nameToAdd);
if (otherEntry->publicStatus.isPublic) {
if (entry->publicStatus.isPublic && entry->entryId != otherEntry->entryId) {
Logger::error() << "can not merge entry '" << type->type << "/" << entry->name
<< "': conflicting public IDs "
<< "(" << entry->entryId << " vs " << entry->entryId << ")."
<< std::endl;
return false;
}
entry->publicStatus = std::move(otherEntry->publicStatus);
entry->entryId = otherEntry->entryId;
}
for (ResourceConfigValue& otherValue : otherEntry->values) {
auto iter = std::lower_bound(entry->values.begin(), entry->values.end(),
otherValue.config, compareConfigs);
if (iter != entry->values.end() && iter->config == otherValue.config) {
int collisionResult = defaultCollisionHandler(*iter->value, *otherValue.value);
if (collisionResult > 0) {
// Take the incoming value.
iter->source = std::move(otherValue.source);
iter->comment = std::move(otherValue.comment);
iter->value = std::unique_ptr<Value>(otherValue.value->clone(&mValuePool));
} else if (collisionResult == 0) {
ResourceNameRef resourceName = { mPackage, type->type, entry->name };
Logger::error(otherValue.source)
<< "resource '" << resourceName << "' has a conflicting value for "
<< "configuration (" << otherValue.config << ")."
<< std::endl;
Logger::note(iter->source) << "originally defined here." << std::endl;
return false;
}
} else {
entry->values.insert(iter, ResourceConfigValue{
otherValue.config,
std::move(otherValue.source),
std::move(otherValue.comment),
std::unique_ptr<Value>(otherValue.value->clone(&mValuePool)),
});
}
}
}
}
return true;
}
std::tuple<const ResourceTableType*, const ResourceEntry*>
ResourceTable::findResource(const ResourceNameRef& name) const {
if (name.package != mPackage) {
return {};
}
auto iter = std::lower_bound(mTypes.begin(), mTypes.end(), name.type, lessThanType);
if (iter == mTypes.end() || (*iter)->type != name.type) {
return {};
}
const std::unique_ptr<ResourceTableType>& type = *iter;
auto iter2 = std::lower_bound(type->entries.begin(), type->entries.end(), name.entry,
lessThanEntry);
if (iter2 == type->entries.end() || name.entry != (*iter2)->name) {
return {};
}
return std::make_tuple(iter->get(), iter2->get());
}
} // namespace aapt