tools/aapt2/ResourceTable.cpp

/*
 * 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