fa6058118e
When processing attributes in XML, quotes can't be used to mark a section as whitespace preserving, so the assumption should be that the entire string is whitespace preserving, which makes quote characters literals. Bug: 62840718 Bug: 62840406 Test: make aapt2_tests Change-Id: I4afff02148b5b8e78833abf1f323c2f5325d6155
360 lines
12 KiB
C++
360 lines
12 KiB
C++
/*
|
|
* 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 "flatten/XmlFlattener.h"
|
|
|
|
#include <algorithm>
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include "android-base/logging.h"
|
|
#include "android-base/macros.h"
|
|
#include "androidfw/ResourceTypes.h"
|
|
#include "utils/misc.h"
|
|
|
|
#include "SdkConstants.h"
|
|
#include "flatten/ChunkWriter.h"
|
|
#include "flatten/ResourceTypeExtensions.h"
|
|
#include "xml/XmlDom.h"
|
|
|
|
using namespace android;
|
|
|
|
namespace aapt {
|
|
|
|
namespace {
|
|
|
|
constexpr uint32_t kLowPriority = 0xffffffffu;
|
|
|
|
static bool cmp_xml_attribute_by_id(const xml::Attribute* a,
|
|
const xml::Attribute* b) {
|
|
if (a->compiled_attribute && a->compiled_attribute.value().id) {
|
|
if (b->compiled_attribute && b->compiled_attribute.value().id) {
|
|
return a->compiled_attribute.value().id.value() <
|
|
b->compiled_attribute.value().id.value();
|
|
}
|
|
return true;
|
|
} else if (!b->compiled_attribute) {
|
|
int diff = a->namespace_uri.compare(b->namespace_uri);
|
|
if (diff < 0) {
|
|
return true;
|
|
} else if (diff > 0) {
|
|
return false;
|
|
}
|
|
return a->name < b->name;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
class XmlFlattenerVisitor : public xml::Visitor {
|
|
public:
|
|
using xml::Visitor::Visit;
|
|
|
|
StringPool pool;
|
|
std::map<uint8_t, StringPool> package_pools;
|
|
|
|
struct StringFlattenDest {
|
|
StringPool::Ref ref;
|
|
ResStringPool_ref* dest;
|
|
};
|
|
|
|
std::vector<StringFlattenDest> string_refs;
|
|
|
|
XmlFlattenerVisitor(BigBuffer* buffer, XmlFlattenerOptions options)
|
|
: buffer_(buffer), options_(options) {}
|
|
|
|
void Visit(xml::Namespace* node) override {
|
|
if (node->namespace_uri == xml::kSchemaTools) {
|
|
// Skip dedicated tools namespace.
|
|
xml::Visitor::Visit(node);
|
|
} else {
|
|
WriteNamespace(node, android::RES_XML_START_NAMESPACE_TYPE);
|
|
xml::Visitor::Visit(node);
|
|
WriteNamespace(node, android::RES_XML_END_NAMESPACE_TYPE);
|
|
}
|
|
}
|
|
|
|
void Visit(xml::Text* node) override {
|
|
if (util::TrimWhitespace(node->text).empty()) {
|
|
// Skip whitespace only text nodes.
|
|
return;
|
|
}
|
|
|
|
ChunkWriter writer(buffer_);
|
|
ResXMLTree_node* flat_node =
|
|
writer.StartChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
|
|
flat_node->lineNumber = util::HostToDevice32(node->line_number);
|
|
flat_node->comment.index = util::HostToDevice32(-1);
|
|
|
|
ResXMLTree_cdataExt* flat_text = writer.NextBlock<ResXMLTree_cdataExt>();
|
|
|
|
// Process plain strings to make sure they get properly escaped.
|
|
util::StringBuilder builder;
|
|
builder.Append(node->text);
|
|
AddString(builder.ToString(), kLowPriority, &flat_text->data);
|
|
|
|
writer.Finish();
|
|
}
|
|
|
|
void Visit(xml::Element* node) override {
|
|
{
|
|
ChunkWriter start_writer(buffer_);
|
|
ResXMLTree_node* flat_node =
|
|
start_writer.StartChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
|
|
flat_node->lineNumber = util::HostToDevice32(node->line_number);
|
|
flat_node->comment.index = util::HostToDevice32(-1);
|
|
|
|
ResXMLTree_attrExt* flat_elem =
|
|
start_writer.NextBlock<ResXMLTree_attrExt>();
|
|
|
|
// A missing namespace must be null, not an empty string. Otherwise the
|
|
// runtime complains.
|
|
AddString(node->namespace_uri, kLowPriority, &flat_elem->ns,
|
|
true /* treat_empty_string_as_null */);
|
|
AddString(node->name, kLowPriority, &flat_elem->name,
|
|
true /* treat_empty_string_as_null */);
|
|
|
|
flat_elem->attributeStart = util::HostToDevice16(sizeof(*flat_elem));
|
|
flat_elem->attributeSize =
|
|
util::HostToDevice16(sizeof(ResXMLTree_attribute));
|
|
|
|
WriteAttributes(node, flat_elem, &start_writer);
|
|
|
|
start_writer.Finish();
|
|
}
|
|
|
|
xml::Visitor::Visit(node);
|
|
|
|
{
|
|
ChunkWriter end_writer(buffer_);
|
|
ResXMLTree_node* flat_end_node =
|
|
end_writer.StartChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
|
|
flat_end_node->lineNumber = util::HostToDevice32(node->line_number);
|
|
flat_end_node->comment.index = util::HostToDevice32(-1);
|
|
|
|
ResXMLTree_endElementExt* flat_end_elem =
|
|
end_writer.NextBlock<ResXMLTree_endElementExt>();
|
|
AddString(node->namespace_uri, kLowPriority, &flat_end_elem->ns,
|
|
true /* treat_empty_string_as_null */);
|
|
AddString(node->name, kLowPriority, &flat_end_elem->name);
|
|
|
|
end_writer.Finish();
|
|
}
|
|
}
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(XmlFlattenerVisitor);
|
|
|
|
void AddString(const StringPiece& str, uint32_t priority,
|
|
android::ResStringPool_ref* dest,
|
|
bool treat_empty_string_as_null = false) {
|
|
if (str.empty() && treat_empty_string_as_null) {
|
|
// Some parts of the runtime treat null differently than empty string.
|
|
dest->index = util::DeviceToHost32(-1);
|
|
} else {
|
|
string_refs.push_back(StringFlattenDest{
|
|
pool.MakeRef(str, StringPool::Context(priority)), dest});
|
|
}
|
|
}
|
|
|
|
void AddString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
|
|
string_refs.push_back(StringFlattenDest{ref, dest});
|
|
}
|
|
|
|
void WriteNamespace(xml::Namespace* node, uint16_t type) {
|
|
ChunkWriter writer(buffer_);
|
|
|
|
ResXMLTree_node* flatNode = writer.StartChunk<ResXMLTree_node>(type);
|
|
flatNode->lineNumber = util::HostToDevice32(node->line_number);
|
|
flatNode->comment.index = util::HostToDevice32(-1);
|
|
|
|
ResXMLTree_namespaceExt* flat_ns =
|
|
writer.NextBlock<ResXMLTree_namespaceExt>();
|
|
AddString(node->namespace_prefix, kLowPriority, &flat_ns->prefix);
|
|
AddString(node->namespace_uri, kLowPriority, &flat_ns->uri);
|
|
|
|
writer.Finish();
|
|
}
|
|
|
|
void WriteAttributes(xml::Element* node, ResXMLTree_attrExt* flat_elem, ChunkWriter* writer) {
|
|
filtered_attrs_.clear();
|
|
filtered_attrs_.reserve(node->attributes.size());
|
|
|
|
// Filter the attributes.
|
|
for (xml::Attribute& attr : node->attributes) {
|
|
if (attr.namespace_uri != xml::kSchemaTools) {
|
|
filtered_attrs_.push_back(&attr);
|
|
}
|
|
}
|
|
|
|
if (filtered_attrs_.empty()) {
|
|
return;
|
|
}
|
|
|
|
const ResourceId kIdAttr(0x010100d0);
|
|
|
|
std::sort(filtered_attrs_.begin(), filtered_attrs_.end(), cmp_xml_attribute_by_id);
|
|
|
|
flat_elem->attributeCount = util::HostToDevice16(filtered_attrs_.size());
|
|
|
|
ResXMLTree_attribute* flat_attr =
|
|
writer->NextBlock<ResXMLTree_attribute>(filtered_attrs_.size());
|
|
uint16_t attribute_index = 1;
|
|
for (const xml::Attribute* xml_attr : filtered_attrs_) {
|
|
// Assign the indices for specific attributes.
|
|
if (xml_attr->compiled_attribute &&
|
|
xml_attr->compiled_attribute.value().id &&
|
|
xml_attr->compiled_attribute.value().id.value() == kIdAttr) {
|
|
flat_elem->idIndex = util::HostToDevice16(attribute_index);
|
|
} else if (xml_attr->namespace_uri.empty()) {
|
|
if (xml_attr->name == "class") {
|
|
flat_elem->classIndex = util::HostToDevice16(attribute_index);
|
|
} else if (xml_attr->name == "style") {
|
|
flat_elem->styleIndex = util::HostToDevice16(attribute_index);
|
|
}
|
|
}
|
|
attribute_index++;
|
|
|
|
// Add the namespaceUri to the list of StringRefs to encode. Use null if the namespace
|
|
// is empty (doesn't exist).
|
|
AddString(xml_attr->namespace_uri, kLowPriority, &flat_attr->ns,
|
|
true /* treat_empty_string_as_null */);
|
|
|
|
flat_attr->rawValue.index = util::HostToDevice32(-1);
|
|
|
|
if (!xml_attr->compiled_attribute || !xml_attr->compiled_attribute.value().id) {
|
|
// The attribute has no associated ResourceID, so the string order doesn't matter.
|
|
AddString(xml_attr->name, kLowPriority, &flat_attr->name);
|
|
} else {
|
|
// Attribute names are stored without packages, but we use
|
|
// their StringPool index to lookup their resource IDs.
|
|
// This will cause collisions, so we can't dedupe
|
|
// attribute names from different packages. We use separate
|
|
// pools that we later combine.
|
|
//
|
|
// Lookup the StringPool for this package and make the reference there.
|
|
const xml::AaptAttribute& aapt_attr = xml_attr->compiled_attribute.value();
|
|
|
|
StringPool::Ref name_ref =
|
|
package_pools[aapt_attr.id.value().package_id()].MakeRef(
|
|
xml_attr->name, StringPool::Context(aapt_attr.id.value().id));
|
|
|
|
// Add it to the list of strings to flatten.
|
|
AddString(name_ref, &flat_attr->name);
|
|
}
|
|
|
|
// Process plain strings to make sure they get properly escaped.
|
|
StringPiece raw_value = xml_attr->value;
|
|
|
|
util::StringBuilder str_builder(true /*preserve_spaces*/);
|
|
str_builder.Append(xml_attr->value);
|
|
|
|
if (!options_.keep_raw_values) {
|
|
raw_value = str_builder.ToString();
|
|
}
|
|
|
|
if (options_.keep_raw_values || !xml_attr->compiled_value) {
|
|
// Keep raw values if the value is not compiled or
|
|
// if we're building a static library (need symbols).
|
|
AddString(raw_value, kLowPriority, &flat_attr->rawValue);
|
|
}
|
|
|
|
if (xml_attr->compiled_value) {
|
|
CHECK(xml_attr->compiled_value->Flatten(&flat_attr->typedValue));
|
|
} else {
|
|
// Flatten as a regular string type.
|
|
flat_attr->typedValue.dataType = android::Res_value::TYPE_STRING;
|
|
|
|
AddString(str_builder.ToString(), kLowPriority,
|
|
(ResStringPool_ref*) &flat_attr->typedValue.data);
|
|
}
|
|
|
|
flat_attr->typedValue.size = util::HostToDevice16(sizeof(flat_attr->typedValue));
|
|
flat_attr++;
|
|
}
|
|
}
|
|
|
|
BigBuffer* buffer_;
|
|
XmlFlattenerOptions options_;
|
|
|
|
// Scratch vector to filter attributes. We avoid allocations
|
|
// making this a member.
|
|
std::vector<xml::Attribute*> filtered_attrs_;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
bool XmlFlattener::Flatten(IAaptContext* context, xml::Node* node) {
|
|
BigBuffer node_buffer(1024);
|
|
XmlFlattenerVisitor visitor(&node_buffer, options_);
|
|
node->Accept(&visitor);
|
|
|
|
// Merge the package pools into the main pool.
|
|
for (auto& package_pool_entry : visitor.package_pools) {
|
|
visitor.pool.Merge(std::move(package_pool_entry.second));
|
|
}
|
|
|
|
// Sort the string pool so that attribute resource IDs show up first.
|
|
visitor.pool.Sort(
|
|
[](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
|
|
return a.context.priority < b.context.priority;
|
|
});
|
|
|
|
// Now we flatten the string pool references into the correct places.
|
|
for (const auto& ref_entry : visitor.string_refs) {
|
|
ref_entry.dest->index = util::HostToDevice32(ref_entry.ref.index());
|
|
}
|
|
|
|
// Write the XML header.
|
|
ChunkWriter xml_header_writer(buffer_);
|
|
xml_header_writer.StartChunk<ResXMLTree_header>(RES_XML_TYPE);
|
|
|
|
// Flatten the StringPool.
|
|
StringPool::FlattenUtf8(buffer_, visitor.pool);
|
|
|
|
{
|
|
// Write the array of resource IDs, indexed by StringPool order.
|
|
ChunkWriter res_id_map_writer(buffer_);
|
|
res_id_map_writer.StartChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
|
|
for (const auto& str : visitor.pool) {
|
|
ResourceId id = {str->context.priority};
|
|
if (id.id == kLowPriority || !id.is_valid()) {
|
|
// When we see the first non-resource ID,
|
|
// we're done.
|
|
break;
|
|
}
|
|
|
|
*res_id_map_writer.NextBlock<uint32_t>() = id.id;
|
|
}
|
|
res_id_map_writer.Finish();
|
|
}
|
|
|
|
// Move the nodeBuffer and append it to the out buffer.
|
|
buffer_->AppendBuffer(std::move(node_buffer));
|
|
|
|
// Finish the xml header.
|
|
xml_header_writer.Finish();
|
|
return true;
|
|
}
|
|
|
|
bool XmlFlattener::Consume(IAaptContext* context, xml::XmlResource* resource) {
|
|
if (!resource->root) {
|
|
return false;
|
|
}
|
|
return Flatten(context, resource->root.get());
|
|
}
|
|
|
|
} // namespace aapt
|