tools/aapt2/unflatten/BinaryResourceParser.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 "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
#include "Source.h"
#include "ValueVisitor.h"

#include "flatten/ResourceTypeExtensions.h"
#include "unflatten/BinaryResourceParser.h"
#include "unflatten/ResChunkPullParser.h"
#include "util/Util.h"

#include <androidfw/ResourceTypes.h>
#include <androidfw/TypeWrappers.h>
#include <base/macros.h>

#include <map>
#include <string>

namespace aapt {

using namespace android;

/*
 * Visitor that converts a reference's resource ID to a resource name,
 * given a mapping from resource ID to resource name.
 */
class ReferenceIdToNameVisitor : public ValueVisitor {
private:
    const std::map<ResourceId, ResourceName>* mMapping;

public:
    using ValueVisitor::visit;

    ReferenceIdToNameVisitor(const std::map<ResourceId, ResourceName>* mapping) :
            mMapping(mapping) {
        assert(mMapping);
    }

    void visit(Reference* reference) override {
        if (!reference->id || !reference->id.value().isValid()) {
            return;
        }

        ResourceId id = reference->id.value();
        auto cacheIter = mMapping->find(id);
        if (cacheIter != mMapping->end()) {
            reference->name = cacheIter->second;
            reference->id = {};
        }
    }
};

BinaryResourceParser::BinaryResourceParser(IAaptContext* context, ResourceTable* table,
                                           const Source& source, const void* data, size_t len) :
        mContext(context), mTable(table), mSource(source), mData(data), mDataLen(len) {
}

bool BinaryResourceParser::parse() {
    ResChunkPullParser parser(mData, mDataLen);

    bool error = false;
    while(ResChunkPullParser::isGoodEvent(parser.next())) {
        if (parser.getChunk()->type != android::RES_TABLE_TYPE) {
            mContext->getDiagnostics()->warn(DiagMessage(mSource)
                                             << "unknown chunk of type '"
                                             << (int) parser.getChunk()->type << "'");
            continue;
        }

        if (!parseTable(parser.getChunk())) {
            error = true;
        }
    }

    if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt resource table: "
                                          << parser.getLastError());
        return false;
    }
    return !error;
}

bool BinaryResourceParser::getSymbol(const void* data, ResourceNameRef* outSymbol) {
    if (!mSymbolEntries || mSymbolEntryCount == 0) {
        return false;
    }

    if ((uintptr_t) data < (uintptr_t) mData) {
        return false;
    }

    // We only support 32 bit offsets right now.
    const uintptr_t offset = (uintptr_t) data - (uintptr_t) mData;
    if (offset > std::numeric_limits<uint32_t>::max()) {
        return false;
    }

    for (size_t i = 0; i < mSymbolEntryCount; i++) {
        if (util::deviceToHost32(mSymbolEntries[i].offset) == offset) {
            // This offset is a symbol!
            const StringPiece16 str = util::getString(
                    mSymbolPool, util::deviceToHost32(mSymbolEntries[i].name.index));

            StringPiece16 typeStr;
            ResourceUtils::extractResourceName(str, &outSymbol->package, &typeStr,
                                               &outSymbol->entry);
            const ResourceType* type = parseResourceType(typeStr);
            if (!type) {
                return false;
            }

            outSymbol->type = *type;

            // Since we scan the symbol table in order, we can start looking for the
            // next symbol from this point.
            mSymbolEntryCount -= i + 1;
            mSymbolEntries += i + 1;
            return true;
        }
    }
    return false;
}

/**
 * Parses the SymbolTable_header, which is present on non-final resource tables
 * after the compile phase.
 *
 * | SymbolTable_header |
 * |--------------------|
 * |SymbolTable_entry 0 |
 * |SymbolTable_entry 1 |
 * | ...                |
 * |SymbolTable_entry n |
 * |--------------------|
 *
 */
bool BinaryResourceParser::parseSymbolTable(const ResChunk_header* chunk) {
    const SymbolTable_header* header = convertTo<SymbolTable_header>(chunk);
    if (!header) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt SymbolTable_header");
        return false;
    }

    const uint32_t entrySizeBytes =
            util::deviceToHost32(header->count) * sizeof(SymbolTable_entry);
    if (entrySizeBytes > getChunkDataLen(&header->header)) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "SymbolTable_header data section too long");
        return false;
    }

    mSymbolEntries = (const SymbolTable_entry*) getChunkData(&header->header);
    mSymbolEntryCount = util::deviceToHost32(header->count);

    // Skip over the symbol entries and parse the StringPool chunk that should be next.
    ResChunkPullParser parser(getChunkData(&header->header) + entrySizeBytes,
                              getChunkDataLen(&header->header) - entrySizeBytes);
    if (!ResChunkPullParser::isGoodEvent(parser.next())) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "failed to parse chunk in SymbolTable: "
                                          << parser.getLastError());
        return false;
    }

    const ResChunk_header* nextChunk = parser.getChunk();
    if (util::deviceToHost16(nextChunk->type) != android::RES_STRING_POOL_TYPE) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "expected string pool in SymbolTable but got "
                                          << "chunk of type "
                                          << (int) util::deviceToHost16(nextChunk->type));
        return false;
    }

    if (mSymbolPool.setTo(nextChunk, util::deviceToHost32(nextChunk->size)) != NO_ERROR) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt string pool in SymbolTable: "
                                          << mSymbolPool.getError());
        return false;
    }
    return true;
}

/**
 * Parses the resource table, which contains all the packages, types, and entries.
 */
bool BinaryResourceParser::parseTable(const ResChunk_header* chunk) {
    const ResTable_header* tableHeader = convertTo<ResTable_header>(chunk);
    if (!tableHeader) {
        mContext->getDiagnostics()->error(DiagMessage(mSource) << "corrupt ResTable_header chunk");
        return false;
    }

    ResChunkPullParser parser(getChunkData(&tableHeader->header),
                              getChunkDataLen(&tableHeader->header));
    while (ResChunkPullParser::isGoodEvent(parser.next())) {
        switch (util::deviceToHost16(parser.getChunk()->type)) {
        case android::RES_STRING_POOL_TYPE:
            if (mValuePool.getError() == NO_INIT) {
                status_t err = mValuePool.setTo(parser.getChunk(),
                                                util::deviceToHost32(parser.getChunk()->size));
                if (err != NO_ERROR) {
                    mContext->getDiagnostics()->error(DiagMessage(mSource)
                                                      << "corrupt string pool in ResTable: "
                                                      << mValuePool.getError());
                    return false;
                }

                // Reserve some space for the strings we are going to add.
                mTable->stringPool.hintWillAdd(mValuePool.size(), mValuePool.styleCount());
            } else {
                mContext->getDiagnostics()->warn(DiagMessage(mSource)
                                                 << "unexpected string pool in ResTable");
            }
            break;

        case RES_TABLE_SYMBOL_TABLE_TYPE:
            if (!parseSymbolTable(parser.getChunk())) {
                return false;
            }
            break;

        case RES_TABLE_SOURCE_POOL_TYPE: {
            status_t err = mSourcePool.setTo(getChunkData(parser.getChunk()),
                                             getChunkDataLen(parser.getChunk()));
            if (err != NO_ERROR) {
                mContext->getDiagnostics()->error(DiagMessage(mSource)
                                                  << "corrupt source string pool in ResTable: "
                                                  << mSourcePool.getError());
                return false;
            }
            break;
        }

        case android::RES_TABLE_PACKAGE_TYPE:
            if (!parsePackage(parser.getChunk())) {
                return false;
            }
            break;

        default:
            mContext->getDiagnostics()
                    ->warn(DiagMessage(mSource)
                           << "unexpected chunk type "
                           << (int) util::deviceToHost16(parser.getChunk()->type));
            break;
        }
    }

    if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt resource table: " << parser.getLastError());
        return false;
    }
    return true;
}


bool BinaryResourceParser::parsePackage(const ResChunk_header* chunk) {
    const ResTable_package* packageHeader = convertTo<ResTable_package>(chunk);
    if (!packageHeader) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt ResTable_package chunk");
        return false;
    }

    uint32_t packageId = util::deviceToHost32(packageHeader->id);
    if (packageId > std::numeric_limits<uint8_t>::max()) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "package ID is too big (" << packageId << ")");
        return false;
    }

    // Extract the package name.
    size_t len = strnlen16((const char16_t*) packageHeader->name, arraysize(packageHeader->name));
    std::u16string packageName;
    packageName.resize(len);
    for (size_t i = 0; i < len; i++) {
        packageName[i] = util::deviceToHost16(packageHeader->name[i]);
    }

    ResourceTablePackage* package = mTable->createPackage(packageName, (uint8_t) packageId);
    if (!package) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "incompatible package '" << packageName
                                          << "' with ID " << packageId);
        return false;
    }

    // There can be multiple packages in a table, so
    // clear the type and key pool in case they were set from a previous package.
    mTypePool.uninit();
    mKeyPool.uninit();

    ResChunkPullParser parser(getChunkData(&packageHeader->header),
                              getChunkDataLen(&packageHeader->header));
    while (ResChunkPullParser::isGoodEvent(parser.next())) {
        switch (util::deviceToHost16(parser.getChunk()->type)) {
        case android::RES_STRING_POOL_TYPE:
            if (mTypePool.getError() == NO_INIT) {
                status_t err = mTypePool.setTo(parser.getChunk(),
                                               util::deviceToHost32(parser.getChunk()->size));
                if (err != NO_ERROR) {
                    mContext->getDiagnostics()->error(DiagMessage(mSource)
                                                      << "corrupt type string pool in "
                                                      << "ResTable_package: "
                                                      << mTypePool.getError());
                    return false;
                }
            } else if (mKeyPool.getError() == NO_INIT) {
                status_t err = mKeyPool.setTo(parser.getChunk(),
                                              util::deviceToHost32(parser.getChunk()->size));
                if (err != NO_ERROR) {
                    mContext->getDiagnostics()->error(DiagMessage(mSource)
                                                      << "corrupt key string pool in "
                                                      << "ResTable_package: "
                                                      << mKeyPool.getError());
                    return false;
                }
            } else {
                mContext->getDiagnostics()->warn(DiagMessage(mSource) << "unexpected string pool");
            }
            break;

        case android::RES_TABLE_TYPE_SPEC_TYPE:
            if (!parseTypeSpec(parser.getChunk())) {
                return false;
            }
            break;

        case android::RES_TABLE_TYPE_TYPE:
            if (!parseType(package, parser.getChunk())) {
                return false;
            }
            break;

        case RES_TABLE_PUBLIC_TYPE:
            if (!parsePublic(package, parser.getChunk())) {
                return false;
            }
            break;

        default:
            mContext->getDiagnostics()
                    ->warn(DiagMessage(mSource)
                           << "unexpected chunk type "
                           << (int) util::deviceToHost16(parser.getChunk()->type));
            break;
        }
    }

    if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt ResTable_package: "
                                          << parser.getLastError());
        return false;
    }

    // Now go through the table and change local resource ID references to
    // symbolic references.
    ReferenceIdToNameVisitor visitor(&mIdIndex);
    for (auto& package : mTable->packages) {
        for (auto& type : package->types) {
            for (auto& entry : type->entries) {
                for (auto& configValue : entry->values) {
                    configValue.value->accept(&visitor);
                }
            }
        }
    }
    return true;
}

bool BinaryResourceParser::parsePublic(const ResourceTablePackage* package,
                                       const ResChunk_header* chunk) {
    const Public_header* header = convertTo<Public_header>(chunk);
    if (!header) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt Public_header chunk");
        return false;
    }

    if (header->typeId == 0) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "invalid type ID "
                                          << (int) header->typeId);
        return false;
    }

    StringPiece16 typeStr16 = util::getString(mTypePool, header->typeId - 1);
    const ResourceType* parsedType = parseResourceType(typeStr16);
    if (!parsedType) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "invalid type '" << typeStr16 << "'");
        return false;
    }

    const uintptr_t chunkEnd = (uintptr_t) chunk + util::deviceToHost32(chunk->size);
    const Public_entry* entry = (const Public_entry*) getChunkData(&header->header);
    for (uint32_t i = 0; i < util::deviceToHost32(header->count); i++) {
        if ((uintptr_t) entry + sizeof(*entry) > chunkEnd) {
            mContext->getDiagnostics()->error(DiagMessage(mSource)
                                              << "Public_entry data section is too long");
            return false;
        }

        const ResourceId resId(package->id.value(), header->typeId,
                               util::deviceToHost16(entry->entryId));

        const ResourceName name(package->name, *parsedType,
                                util::getString(mKeyPool, entry->key.index).toString());

        Symbol symbol;
        if (mSourcePool.getError() == NO_ERROR) {
            symbol.source.path = util::utf16ToUtf8(util::getString(
                    mSourcePool, util::deviceToHost32(entry->source.path.index)));
            symbol.source.line = util::deviceToHost32(entry->source.line);
        }

        StringPiece16 comment = util::getString(mSourcePool,
                                                util::deviceToHost32(entry->source.comment.index));
        if (!comment.empty()) {
            symbol.comment = comment.toString();
        }

        switch (util::deviceToHost16(entry->state)) {
        case Public_entry::kPrivate:
            symbol.state = SymbolState::kPrivate;
            break;

        case Public_entry::kPublic:
            symbol.state = SymbolState::kPublic;
            break;
        }

        if (!mTable->setSymbolStateAllowMangled(name, resId, symbol, mContext->getDiagnostics())) {
            return false;
        }

        // Add this resource name->id mapping to the index so
        // that we can resolve all ID references to name references.
        auto cacheIter = mIdIndex.find(resId);
        if (cacheIter == mIdIndex.end()) {
            mIdIndex.insert({ resId, name });
        }

        entry++;
    }
    return true;
}

bool BinaryResourceParser::parseTypeSpec(const ResChunk_header* chunk) {
    if (mTypePool.getError() != NO_ERROR) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "missing type string pool");
        return false;
    }

    const ResTable_typeSpec* typeSpec = convertTo<ResTable_typeSpec>(chunk);
    if (!typeSpec) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt ResTable_typeSpec chunk");
        return false;
    }

    if (typeSpec->id == 0) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "ResTable_typeSpec has invalid id: " << typeSpec->id);
        return false;
    }
    return true;
}

bool BinaryResourceParser::parseType(const ResourceTablePackage* package,
                                     const ResChunk_header* chunk) {
    if (mTypePool.getError() != NO_ERROR) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "missing type string pool");
        return false;
    }

    if (mKeyPool.getError() != NO_ERROR) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "missing key string pool");
        return false;
    }

    const ResTable_type* type = convertTo<ResTable_type>(chunk);
    if (!type) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "corrupt ResTable_type chunk");
        return false;
    }

    if (type->id == 0) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "ResTable_type has invalid id: " << (int) type->id);
        return false;
    }

    ConfigDescription config;
    config.copyFromDtoH(type->config);

    StringPiece16 typeStr16 = util::getString(mTypePool, type->id - 1);

    const ResourceType* parsedType = parseResourceType(typeStr16);
    if (!parsedType) {
        mContext->getDiagnostics()->error(DiagMessage(mSource)
                                          << "invalid type name '" << typeStr16
                                          << "' for type with ID " << (int) type->id);
        return false;
    }

    TypeVariant tv(type);
    for (auto it = tv.beginEntries(); it != tv.endEntries(); ++it) {
        const ResTable_entry* entry = *it;
        if (!entry) {
            continue;
        }

        const ResourceName name(package->name, *parsedType,
                                util::getString(mKeyPool,
                                                util::deviceToHost32(entry->key.index)).toString());

        const ResourceId resId(package->id.value(), type->id, static_cast<uint16_t>(it.index()));

        std::unique_ptr<Value> resourceValue;
        const ResTable_entry_source* sourceBlock = nullptr;

        if (entry->flags & ResTable_entry::FLAG_COMPLEX) {
            const ResTable_map_entry* mapEntry = static_cast<const ResTable_map_entry*>(entry);
            if (util::deviceToHost32(mapEntry->size) - sizeof(*mapEntry) == sizeof(*sourceBlock)) {
                const uint8_t* data = (const uint8_t*) mapEntry;
                data += util::deviceToHost32(mapEntry->size) - sizeof(*sourceBlock);
                sourceBlock = (const ResTable_entry_source*) data;
            }

            // TODO(adamlesinski): Check that the entry count is valid.
            resourceValue = parseMapEntry(name, config, mapEntry);
        } else {
            if (util::deviceToHost32(entry->size) - sizeof(*entry) == sizeof(*sourceBlock)) {
                const uint8_t* data = (const uint8_t*) entry;
                data += util::deviceToHost32(entry->size) - sizeof(*sourceBlock);
                sourceBlock = (const ResTable_entry_source*) data;
            }

            const Res_value* value = (const Res_value*)(
                    (const uint8_t*) entry + util::deviceToHost32(entry->size));
            resourceValue = parseValue(name, config, value, entry->flags);
        }

        assert(resourceValue && "failed to interpret valid resource");

        Source source = mSource;
        if (sourceBlock) {
            size_t len;
            const char* str = mSourcePool.string8At(util::deviceToHost32(sourceBlock->path.index),
                                                    &len);
            if (str) {
                source.path.assign(str, len);
            }
            source.line = util::deviceToHost32(sourceBlock->line);
        }

        StringPiece16 comment = util::getString(mSourcePool,
                                                util::deviceToHost32(sourceBlock->comment.index));
        if (!comment.empty()) {
            resourceValue->setComment(comment);
        }

        resourceValue->setSource(source);
        if (!mTable->addResourceAllowMangled(name, config, std::move(resourceValue),
                                             mContext->getDiagnostics())) {
            return false;
        }

        if ((entry->flags & ResTable_entry::FLAG_PUBLIC) != 0) {
            Symbol symbol;
            symbol.state = SymbolState::kPublic;
            symbol.source = mSource.withLine(0);
            if (!mTable->setSymbolStateAllowMangled(name, resId, symbol,
                                                    mContext->getDiagnostics())) {
                return false;
            }
        }

        // Add this resource name->id mapping to the index so
        // that we can resolve all ID references to name references.
        auto cacheIter = mIdIndex.find(resId);
        if (cacheIter == mIdIndex.end()) {
            mIdIndex.insert({ resId, name });
        }
    }
    return true;
}

std::unique_ptr<Item> BinaryResourceParser::parseValue(const ResourceNameRef& name,
                                                       const ConfigDescription& config,
                                                       const Res_value* value,
                                                       uint16_t flags) {
    if (name.type == ResourceType::kId) {
        return util::make_unique<Id>();
    }

    const uint32_t data = util::deviceToHost32(value->data);

    if (value->dataType == Res_value::TYPE_STRING) {
        StringPiece16 str = util::getString(mValuePool, data);

        const ResStringPool_span* spans = mValuePool.styleAt(data);

        // Check if the string has a valid style associated with it.
        if (spans != nullptr && spans->name.index != ResStringPool_span::END) {
            StyleString styleStr = { str.toString() };
            while (spans->name.index != ResStringPool_span::END) {
                styleStr.spans.push_back(Span{
                        util::getString(mValuePool, spans->name.index).toString(),
                        spans->firstChar,
                        spans->lastChar
                });
                spans++;
            }
            return util::make_unique<StyledString>(mTable->stringPool.makeRef(
                    styleStr, StringPool::Context{1, config}));
        } else {
            if (name.type != ResourceType::kString &&
                    util::stringStartsWith<char16_t>(str, u"res/")) {
                // This must be a FileReference.
                return util::make_unique<FileReference>(mTable->stringPool.makeRef(
                            str, StringPool::Context{ 0, config }));
            }

            // There are no styles associated with this string, so treat it as
            // a simple string.
            return util::make_unique<String>(mTable->stringPool.makeRef(
                    str, StringPool::Context{1, config}));
        }
    }

    if (value->dataType == Res_value::TYPE_REFERENCE ||
            value->dataType == Res_value::TYPE_ATTRIBUTE) {
        const Reference::Type type = (value->dataType == Res_value::TYPE_REFERENCE) ?
                    Reference::Type::kResource : Reference::Type::kAttribute;

        if (data != 0) {
            // This is a normal reference.
            return util::make_unique<Reference>(data, type);
        }

        // This reference has an invalid ID. Check if it is an unresolved symbol.
        ResourceNameRef symbol;
        if (getSymbol(&value->data, &symbol)) {
            return util::make_unique<Reference>(symbol, type);
        }

        // This is not an unresolved symbol, so it must be the magic @null reference.
        Res_value nullType = {};
        nullType.dataType = Res_value::TYPE_REFERENCE;
        return util::make_unique<BinaryPrimitive>(nullType);
    }

    if (value->dataType == ExtendedTypes::TYPE_RAW_STRING) {
        return util::make_unique<RawString>(mTable->stringPool.makeRef(
                util::getString(mValuePool, data), StringPool::Context{ 1, config }));
    }

    // Treat this as a raw binary primitive.
    return util::make_unique<BinaryPrimitive>(*value);
}

std::unique_ptr<Value> BinaryResourceParser::parseMapEntry(const ResourceNameRef& name,
                                                           const ConfigDescription& config,
                                                           const ResTable_map_entry* map) {
    switch (name.type) {
        case ResourceType::kStyle:
            return parseStyle(name, config, map);
        case ResourceType::kAttrPrivate:
            // fallthrough
        case ResourceType::kAttr:
            return parseAttr(name, config, map);
        case ResourceType::kArray:
            return parseArray(name, config, map);
        case ResourceType::kStyleable:
            return parseStyleable(name, config, map);
        case ResourceType::kPlurals:
            return parsePlural(name, config, map);
        default:
            assert(false && "unknown map type");
            break;
    }
    return {};
}

std::unique_ptr<Style> BinaryResourceParser::parseStyle(const ResourceNameRef& name,
                                                        const ConfigDescription& config,
                                                        const ResTable_map_entry* map) {
    std::unique_ptr<Style> style = util::make_unique<Style>();
    if (util::deviceToHost32(map->parent.ident) == 0) {
        // The parent is either not set or it is an unresolved symbol.
        // Check to see if it is a symbol.
        ResourceNameRef symbol;
        if (getSymbol(&map->parent.ident, &symbol)) {
            style->parent = Reference(symbol.toResourceName());
        }
    } else {
         // The parent is a regular reference to a resource.
        style->parent = Reference(util::deviceToHost32(map->parent.ident));
    }

    for (const ResTable_map& mapEntry : map) {
        style->entries.emplace_back();
        Style::Entry& styleEntry = style->entries.back();

        if (util::deviceToHost32(mapEntry.name.ident) == 0) {
            // The map entry's key (attribute) is not set. This must be
            // a symbol reference, so resolve it.
            ResourceNameRef symbol;
            bool result = getSymbol(&mapEntry.name.ident, &symbol);
            assert(result);
            styleEntry.key.name = symbol.toResourceName();
        } else {
            // The map entry's key (attribute) is a regular reference.
            styleEntry.key.id = ResourceId(util::deviceToHost32(mapEntry.name.ident));
        }

        // Parse the attribute's value.
        styleEntry.value = parseValue(name, config, &mapEntry.value, 0);
        assert(styleEntry.value);
    }
    return style;
}

std::unique_ptr<Attribute> BinaryResourceParser::parseAttr(const ResourceNameRef& name,
                                                           const ConfigDescription& config,
                                                           const ResTable_map_entry* map) {
    const bool isWeak = (util::deviceToHost16(map->flags) & ResTable_entry::FLAG_WEAK) != 0;
    std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(isWeak);

    // First we must discover what type of attribute this is. Find the type mask.
    auto typeMaskIter = std::find_if(begin(map), end(map), [](const ResTable_map& entry) -> bool {
        return util::deviceToHost32(entry.name.ident) == ResTable_map::ATTR_TYPE;
    });

    if (typeMaskIter != end(map)) {
        attr->typeMask = util::deviceToHost32(typeMaskIter->value.data);
    }

    if (attr->typeMask & (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) {
        for (const ResTable_map& mapEntry : map) {
            if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
                continue;
            }

            Attribute::Symbol symbol;
            symbol.value = util::deviceToHost32(mapEntry.value.data);
            if (util::deviceToHost32(mapEntry.name.ident) == 0) {
                // The map entry's key (id) is not set. This must be
                // a symbol reference, so resolve it.
                ResourceNameRef symbolName;
                bool result = getSymbol(&mapEntry.name.ident, &symbolName);
                assert(result);
                symbol.symbol.name = symbolName.toResourceName();
            } else {
                // The map entry's key (id) is a regular reference.
                symbol.symbol.id = ResourceId(util::deviceToHost32(mapEntry.name.ident));
            }

            attr->symbols.push_back(std::move(symbol));
        }
    }

    // TODO(adamlesinski): Find min, max, i80n, etc attributes.
    return attr;
}

std::unique_ptr<Array> BinaryResourceParser::parseArray(const ResourceNameRef& name,
                                                        const ConfigDescription& config,
                                                        const ResTable_map_entry* map) {
    std::unique_ptr<Array> array = util::make_unique<Array>();
    for (const ResTable_map& mapEntry : map) {
        array->items.push_back(parseValue(name, config, &mapEntry.value, 0));
    }
    return array;
}

std::unique_ptr<Styleable> BinaryResourceParser::parseStyleable(const ResourceNameRef& name,
                                                                const ConfigDescription& config,
                                                                const ResTable_map_entry* map) {
    std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>();
    for (const ResTable_map& mapEntry : map) {
        if (util::deviceToHost32(mapEntry.name.ident) == 0) {
            // The map entry's key (attribute) is not set. This must be
            // a symbol reference, so resolve it.
            ResourceNameRef symbol;
            bool result = getSymbol(&mapEntry.name.ident, &symbol);
            assert(result);
            styleable->entries.emplace_back(symbol);
        } else {
            // The map entry's key (attribute) is a regular reference.
            styleable->entries.emplace_back(util::deviceToHost32(mapEntry.name.ident));
        }
    }
    return styleable;
}

std::unique_ptr<Plural> BinaryResourceParser::parsePlural(const ResourceNameRef& name,
                                                          const ConfigDescription& config,
                                                          const ResTable_map_entry* map) {
    std::unique_ptr<Plural> plural = util::make_unique<Plural>();
    for (const ResTable_map& mapEntry : map) {
        std::unique_ptr<Item> item = parseValue(name, config, &mapEntry.value, 0);

        switch (util::deviceToHost32(mapEntry.name.ident)) {
            case android::ResTable_map::ATTR_ZERO:
                plural->values[Plural::Zero] = std::move(item);
                break;
            case android::ResTable_map::ATTR_ONE:
                plural->values[Plural::One] = std::move(item);
                break;
            case android::ResTable_map::ATTR_TWO:
                plural->values[Plural::Two] = std::move(item);
                break;
            case android::ResTable_map::ATTR_FEW:
                plural->values[Plural::Few] = std::move(item);
                break;
            case android::ResTable_map::ATTR_MANY:
                plural->values[Plural::Many] = std::move(item);
                break;
            case android::ResTable_map::ATTR_OTHER:
                plural->values[Plural::Other] = std::move(item);
                break;
        }
    }
    return plural;
}

} // namespace aapt