android_frameworks_base/tools/aapt2/compile/InlineXmlFormatParser.cpp

/*
 * Copyright (C) 2016 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 "Debug.h"
#include "ResourceUtils.h"
#include "compile/InlineXmlFormatParser.h"
#include "util/Util.h"
#include "xml/XmlDom.h"
#include "xml/XmlUtil.h"

#include <android-base/macros.h>
#include <sstream>
#include <string>

namespace aapt {

namespace {

/**
 * XML Visitor that will find all <aapt:attr> elements for extraction.
 */
class Visitor : public xml::PackageAwareVisitor {
public:
    using xml::PackageAwareVisitor::visit;

    struct InlineDeclaration {
        xml::Element* el;
        std::string attrNamespaceUri;
        std::string attrName;
    };

    explicit Visitor(IAaptContext* context, xml::XmlResource* xmlResource) :
            mContext(context), mXmlResource(xmlResource) {
    }

    void visit(xml::Element* el) override {
        if (el->namespaceUri != xml::kSchemaAapt || el->name != "attr") {
            xml::PackageAwareVisitor::visit(el);
            return;
        }

        const Source& src = mXmlResource->file.source.withLine(el->lineNumber);

        xml::Attribute* attr = el->findAttribute({}, "name");
        if (!attr) {
            mContext->getDiagnostics()->error(DiagMessage(src) << "missing 'name' attribute");
            mError = true;
            return;
        }

        Maybe<Reference> ref = ResourceUtils::parseXmlAttributeName(attr->value);
        if (!ref) {
            mContext->getDiagnostics()->error(DiagMessage(src) << "invalid XML attribute '"
                                              << attr->value << "'");
            mError = true;
            return;
        }

        const ResourceName& name = ref.value().name.value();

        // Use an empty string for the compilation package because we don't want to default to
        // the local package if the user specified name="style" or something. This should just
        // be the default namespace.
        Maybe<xml::ExtractedPackage> maybePkg = transformPackageAlias(name.package, {});
        if (!maybePkg) {
            mContext->getDiagnostics()->error(DiagMessage(src) << "invalid namespace prefix '"
                                              << name.package << "'");
            mError = true;
            return;
        }

        const xml::ExtractedPackage& pkg = maybePkg.value();
        const bool privateNamespace = pkg.privateNamespace || ref.value().privateReference;

        InlineDeclaration decl;
        decl.el = el;
        decl.attrName = name.entry;
        if (!pkg.package.empty()) {
            decl.attrNamespaceUri = xml::buildPackageNamespace(pkg.package, privateNamespace);
        }

        mInlineDeclarations.push_back(std::move(decl));
    }

    const std::vector<InlineDeclaration>& getInlineDeclarations() const {
        return mInlineDeclarations;
    }

    bool hasError() const {
        return mError;
    }

private:
    DISALLOW_COPY_AND_ASSIGN(Visitor);

    IAaptContext* mContext;
    xml::XmlResource* mXmlResource;
    std::vector<InlineDeclaration> mInlineDeclarations;
    bool mError = false;
};

} // namespace

bool InlineXmlFormatParser::consume(IAaptContext* context, xml::XmlResource* doc) {
    Visitor visitor(context, doc);
    doc->root->accept(&visitor);
    if (visitor.hasError()) {
        return false;
    }

    size_t nameSuffixCounter = 0;
    for (const Visitor::InlineDeclaration& decl : visitor.getInlineDeclarations()) {
        auto newDoc = util::make_unique<xml::XmlResource>();
        newDoc->file.config = doc->file.config;
        newDoc->file.source = doc->file.source.withLine(decl.el->lineNumber);
        newDoc->file.name = doc->file.name;

        // Modify the new entry name. We need to suffix the entry with a number to avoid
        // local collisions, then mangle it with the empty package, such that it won't show up
        // in R.java.

        newDoc->file.name.entry = NameMangler::mangleEntry(
                {}, newDoc->file.name.entry + "__" + std::to_string(nameSuffixCounter));

        // Extracted elements must be the only child of <aapt:attr>.
        // Make sure there is one root node in the children (ignore empty text).
        for (auto& child : decl.el->children) {
            const Source childSource = doc->file.source.withLine(child->lineNumber);
            if (xml::Text* t = xml::nodeCast<xml::Text>(child.get())) {
                if (!util::trimWhitespace(t->text).empty()) {
                    context->getDiagnostics()->error(DiagMessage(childSource)
                                                     << "can't extract text into its own resource");
                    return false;
                }
            } else if (newDoc->root) {
                context->getDiagnostics()->error(DiagMessage(childSource)
                                                 << "inline XML resources must have a single root");
                return false;
            } else {
                newDoc->root = std::move(child);
                newDoc->root->parent = nullptr;
            }
        }

        // Walk up and find the parent element.
        xml::Node* node = decl.el;
        xml::Element* parentEl = nullptr;
        while (node->parent && (parentEl = xml::nodeCast<xml::Element>(node->parent)) == nullptr) {
            node = node->parent;
        }

        if (!parentEl) {
            context->getDiagnostics()->error(DiagMessage(newDoc->file.source)
                                             << "no suitable parent for inheriting attribute");
            return false;
        }

        // Add the inline attribute to the parent.
        parentEl->attributes.push_back(xml::Attribute{
                decl.attrNamespaceUri, decl.attrName, "@" + newDoc->file.name.toString() });

        // Delete the subtree.
        for (auto iter = parentEl->children.begin(); iter != parentEl->children.end(); ++iter) {
            if (iter->get() == node) {
                parentEl->children.erase(iter);
                break;
            }
        }

        mQueue.push_back(std::move(newDoc));

        nameSuffixCounter++;
    }
    return true;
}

} // namespace aapt