drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/tools/aapt2/unflatten/BinaryResourceParser.cpp
Adam Lesinski 803c7c8079 AAPT2: Enable windows build and make sure it builds 
Mingw32 4.8 is kind of picky with macros and some complicated template
stuff. Luckily there was another way to represent the
SFINAE code that works on all platforms. Yay!

Change-Id: Idc2e38f47bfdc57b394550bfa0f53cc0b825df25
2016-04-06 16:24:02 -07:00

574 lines
22 KiB
C++
Raw Blame History

/*
* 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 "unflatten/BinaryResourceParser.h"
#include "unflatten/ResChunkPullParser.h"
#include "util/Util.h"
#include <androidfw/ResourceTypes.h>
#include <androidfw/TypeWrappers.h>
#include <android-base/macros.h>
#include <algorithm>
#include <map>
#include <string>
namespace aapt {
using namespace android;
namespace {
/*
* 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 = {};
}
}
};
} // namespace
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;
}
/**
* 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 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;
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);
visitAllValuesInTable(mTable, &visitor);
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;
if (entry->flags & ResTable_entry::FLAG_COMPLEX) {
const ResTable_map_entry* mapEntry = static_cast<const ResTable_map_entry*>(entry);
// TODO(adamlesinski): Check that the entry count is valid.
resourceValue = parseMapEntry(name, config, mapEntry);
} else {
const Res_value* value = (const Res_value*)(
(const uint8_t*) entry + util::deviceToHost32(entry->size));
resourceValue = parseValue(name, config, value, entry->flags);
}
if (!resourceValue) {
mContext->getDiagnostics()->error(DiagMessage(mSource)
<< "failed to parse value for resource " << name
<< " (" << resId << ") with configuration '"
<< config << "'");
return false;
}
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) {
// A reference of 0, must be the magic @null reference.
Res_value nullType = {};
nullType.dataType = Res_value::TYPE_REFERENCE;
return util::make_unique<BinaryPrimitive>(nullType);
}
// This is a normal reference.
return util::make_unique<Reference>(data, type);
}
// 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::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 a regular reference to a resource.
style->parent = Reference(util::deviceToHost32(map->parent.ident));
}
for (const ResTable_map& mapEntry : map) {
if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
continue;
}
Style::Entry styleEntry;
styleEntry.key = Reference(util::deviceToHost32(mapEntry.name.ident));
styleEntry.value = parseValue(name, config, &mapEntry.value, 0);
if (!styleEntry.value) {
return {};
}
style->entries.push_back(std::move(styleEntry));
}
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);
}
for (const ResTable_map& mapEntry : map) {
if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
switch (util::deviceToHost32(mapEntry.name.ident)) {
case ResTable_map::ATTR_MIN:
attr->minInt = static_cast<int32_t>(mapEntry.value.data);
break;
case ResTable_map::ATTR_MAX:
attr->maxInt = static_cast<int32_t>(mapEntry.value.data);
break;
}
continue;
}
if (attr->typeMask & (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) {
Attribute::Symbol symbol;
symbol.value = util::deviceToHost32(mapEntry.value.data);
symbol.symbol = Reference(util::deviceToHost32(mapEntry.name.ident));
attr->symbols.push_back(std::move(symbol));
}
}
// TODO(adamlesinski): Find i80n, 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<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);
if (!item) {
return {};
}
switch (util::deviceToHost32(mapEntry.name.ident)) {
case ResTable_map::ATTR_ZERO:
plural->values[Plural::Zero] = std::move(item);
break;
case ResTable_map::ATTR_ONE:
plural->values[Plural::One] = std::move(item);
break;
case ResTable_map::ATTR_TWO:
plural->values[Plural::Two] = std::move(item);
break;
case ResTable_map::ATTR_FEW:
plural->values[Plural::Few] = std::move(item);
break;
case ResTable_map::ATTR_MANY:
plural->values[Plural::Many] = std::move(item);
break;
case ResTable_map::ATTR_OTHER:
plural->values[Plural::Other] = std::move(item);
break;
}
}
return plural;
}
} // namespace aapt
Reference in New Issue View Git Blame Copy Permalink