diff options
Diffstat (limited to 'tools/aapt2/unflatten/BinaryResourceParser.cpp')
| -rw-r--r-- | tools/aapt2/unflatten/BinaryResourceParser.cpp | 854 |
1 files changed, 854 insertions, 0 deletions
diff --git a/tools/aapt2/unflatten/BinaryResourceParser.cpp b/tools/aapt2/unflatten/BinaryResourceParser.cpp new file mode 100644 index 000000000000..304833481be0 --- /dev/null +++ b/tools/aapt2/unflatten/BinaryResourceParser.cpp @@ -0,0 +1,854 @@ +/* + * 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 |