xref: /frameworks/base/tools/aapt2/xml/XmlDom.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 "XmlDom.h"

#include <expat.h>

#include <memory>
#include <stack>
#include <string>
#include <tuple>

#include "android-base/logging.h"

#include "XmlPullParser.h"
#include "util/Util.h"

using android::StringPiece;
using android::StringPiece16;

namespace aapt {
namespace xml {

constexpr char kXmlNamespaceSep = 1;

struct Stack {
  std::unique_ptr<xml::Node> root;
  std::stack<xml::Node*> node_stack;
  std::string pending_comment;
  std::unique_ptr<xml::Text> last_text_node;
  util::StringBuilder pending_text;
};

/**
 * Extracts the namespace and name of an expanded element or attribute name.
 */
static void SplitName(const char* name, std::string* out_ns,
                      std::string* out_name) {
  const char* p = name;
  while (*p != 0 && *p != kXmlNamespaceSep) {
    p++;
  }

  if (*p == 0) {
    out_ns->clear();
    out_name->assign(name);
  } else {
    out_ns->assign(name, (p - name));
    out_name->assign(p + 1);
  }
}

static void FinishPendingText(Stack* stack) {
  if (stack->last_text_node != nullptr) {
    if (!stack->pending_text.IsEmpty()) {
      stack->last_text_node->text = stack->pending_text.ToString();
      stack->pending_text = {};
      stack->node_stack.top()->AppendChild(std::move(stack->last_text_node));
    } else {
      // Drop an empty text node.
      stack->last_text_node = nullptr;
    }
  }
}

static void AddToStack(Stack* stack, XML_Parser parser,
                       std::unique_ptr<Node> node) {
  node->line_number = XML_GetCurrentLineNumber(parser);
  node->column_number = XML_GetCurrentColumnNumber(parser);

  Node* this_node = node.get();
  if (!stack->node_stack.empty()) {
    stack->node_stack.top()->AppendChild(std::move(node));
  } else {
    stack->root = std::move(node);
  }

  if (!NodeCast<Text>(this_node)) {
    stack->node_stack.push(this_node);
  }
}

static void XMLCALL StartNamespaceHandler(void* user_data, const char* prefix,
                                          const char* uri) {
  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
  FinishPendingText(stack);

  std::unique_ptr<Namespace> ns = util::make_unique<Namespace>();
  if (prefix) {
    ns->namespace_prefix = prefix;
  }

  if (uri) {
    ns->namespace_uri = uri;
  }

  AddToStack(stack, parser, std::move(ns));
}

static void XMLCALL EndNamespaceHandler(void* user_data, const char* prefix) {
  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
  FinishPendingText(stack);

  CHECK(!stack->node_stack.empty());
  stack->node_stack.pop();
}

static bool less_attribute(const Attribute& lhs, const Attribute& rhs) {
  return std::tie(lhs.namespace_uri, lhs.name, lhs.value) <
         std::tie(rhs.namespace_uri, rhs.name, rhs.value);
}

static void XMLCALL StartElementHandler(void* user_data, const char* name,
                                        const char** attrs) {
  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
  FinishPendingText(stack);

  std::unique_ptr<Element> el = util::make_unique<Element>();
  SplitName(name, &el->namespace_uri, &el->name);

  while (*attrs) {
    Attribute attribute;
    SplitName(*attrs++, &attribute.namespace_uri, &attribute.name);
    util::StringBuilder builder;
    builder.Append(*attrs++);
    attribute.value = builder.ToString();

    // Insert in sorted order.
    auto iter = std::lower_bound(el->attributes.begin(), el->attributes.end(),
                                 attribute, less_attribute);
    el->attributes.insert(iter, std::move(attribute));
  }

  el->comment = std::move(stack->pending_comment);
  AddToStack(stack, parser, std::move(el));
}

static void XMLCALL EndElementHandler(void* user_data, const char* name) {
  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
  FinishPendingText(stack);

  CHECK(!stack->node_stack.empty());
  // stack->nodeStack.top()->comment = std::move(stack->pendingComment);
  stack->node_stack.pop();
}

static void XMLCALL CharacterDataHandler(void* user_data, const char* s, int len) {
  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));

  const StringPiece str(s, len);
  if (str.empty()) {
    return;
  }

  // See if we can just append the text to a previous text node.
  if (stack->last_text_node != nullptr) {
    stack->pending_text.Append(str);
    return;
  }

  stack->last_text_node = util::make_unique<Text>();
  stack->last_text_node->line_number = XML_GetCurrentLineNumber(parser);
  stack->last_text_node->column_number = XML_GetCurrentColumnNumber(parser);
  stack->pending_text.Append(str);
}

static void XMLCALL CommentDataHandler(void* user_data, const char* comment) {
  XML_Parser parser = reinterpret_cast<XML_Parser>(user_data);
  Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
  FinishPendingText(stack);

  if (!stack->pending_comment.empty()) {
    stack->pending_comment += '\n';
  }
  stack->pending_comment += comment;
}

std::unique_ptr<XmlResource> Inflate(std::istream* in, IDiagnostics* diag,
                                     const Source& source) {
  Stack stack;

  XML_Parser parser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
  XML_SetUserData(parser, &stack);
  XML_UseParserAsHandlerArg(parser);
  XML_SetElementHandler(parser, StartElementHandler, EndElementHandler);
  XML_SetNamespaceDeclHandler(parser, StartNamespaceHandler,
                              EndNamespaceHandler);
  XML_SetCharacterDataHandler(parser, CharacterDataHandler);
  XML_SetCommentHandler(parser, CommentDataHandler);

  char buffer[1024];
  while (!in->eof()) {
    in->read(buffer, sizeof(buffer) / sizeof(buffer[0]));
    if (in->bad() && !in->eof()) {
      stack.root = {};
      diag->Error(DiagMessage(source) << strerror(errno));
      break;
    }

    if (XML_Parse(parser, buffer, in->gcount(), in->eof()) ==
        XML_STATUS_ERROR) {
      stack.root = {};
      diag->Error(DiagMessage(source.WithLine(XML_GetCurrentLineNumber(parser)))
                  << XML_ErrorString(XML_GetErrorCode(parser)));
      break;
    }
  }

  XML_ParserFree(parser);
  if (stack.root) {
    return util::make_unique<XmlResource>(ResourceFile{{}, {}, source},
                                          std::move(stack.root));
  }
  return {};
}

static void CopyAttributes(Element* el, android::ResXMLParser* parser) {
  const size_t attr_count = parser->getAttributeCount();
  if (attr_count > 0) {
    el->attributes.reserve(attr_count);
    for (size_t i = 0; i < attr_count; i++) {
      Attribute attr;
      size_t len;
      const char16_t* str16 = parser->getAttributeNamespace(i, &len);
      if (str16) {
        attr.namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
      }

      str16 = parser->getAttributeName(i, &len);
      if (str16) {
        attr.name = util::Utf16ToUtf8(StringPiece16(str16, len));
      }

      str16 = parser->getAttributeStringValue(i, &len);
      if (str16) {
        attr.value = util::Utf16ToUtf8(StringPiece16(str16, len));
      }
      el->attributes.push_back(std::move(attr));
    }
  }
}

std::unique_ptr<XmlResource> Inflate(const void* data, size_t data_len,
                                     IDiagnostics* diag, const Source& source) {
  // We import the android namespace because on Windows NO_ERROR is a macro, not
  // an enum, which
  // causes errors when qualifying it with android::
  using namespace android;

  std::unique_ptr<Node> root;
  std::stack<Node*> node_stack;

  ResXMLTree tree;
  if (tree.setTo(data, data_len) != NO_ERROR) {
    return {};
  }

  ResXMLParser::event_code_t code;
  while ((code = tree.next()) != ResXMLParser::BAD_DOCUMENT &&
         code != ResXMLParser::END_DOCUMENT) {
    std::unique_ptr<Node> new_node;
    switch (code) {
      case ResXMLParser::START_NAMESPACE: {
        std::unique_ptr<Namespace> node = util::make_unique<Namespace>();
        size_t len;
        const char16_t* str16 = tree.getNamespacePrefix(&len);
        if (str16) {
          node->namespace_prefix = util::Utf16ToUtf8(StringPiece16(str16, len));
        }

        str16 = tree.getNamespaceUri(&len);
        if (str16) {
          node->namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
        }
        new_node = std::move(node);
        break;
      }

      case ResXMLParser::START_TAG: {
        std::unique_ptr<Element> node = util::make_unique<Element>();
        size_t len;
        const char16_t* str16 = tree.getElementNamespace(&len);
        if (str16) {
          node->namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
        }

        str16 = tree.getElementName(&len);
        if (str16) {
          node->name = util::Utf16ToUtf8(StringPiece16(str16, len));
        }

        CopyAttributes(node.get(), &tree);

        new_node = std::move(node);
        break;
      }

      case ResXMLParser::TEXT: {
        std::unique_ptr<Text> node = util::make_unique<Text>();
        size_t len;
        const char16_t* str16 = tree.getText(&len);
        if (str16) {
          node->text = util::Utf16ToUtf8(StringPiece16(str16, len));
        }
        new_node = std::move(node);
        break;
      }

      case ResXMLParser::END_NAMESPACE:
      case ResXMLParser::END_TAG:
        CHECK(!node_stack.empty());
        node_stack.pop();
        break;

      default:
        LOG(FATAL) << "unhandled XML chunk type";
        break;
    }

    if (new_node) {
      new_node->line_number = tree.getLineNumber();

      Node* this_node = new_node.get();
      if (!root) {
        CHECK(node_stack.empty()) << "node stack should be empty";
        root = std::move(new_node);
      } else {
        CHECK(!node_stack.empty()) << "node stack should not be empty";
        node_stack.top()->AppendChild(std::move(new_node));
      }

      if (!NodeCast<Text>(this_node)) {
        node_stack.push(this_node);
      }
    }
  }
  return util::make_unique<XmlResource>(ResourceFile{}, std::move(root));
}

std::unique_ptr<Node> Namespace::Clone() {
  auto ns = util::make_unique<Namespace>();
  ns->comment = comment;
  ns->line_number = line_number;
  ns->column_number = column_number;
  ns->namespace_prefix = namespace_prefix;
  ns->namespace_uri = namespace_uri;

  ns->children.reserve(children.size());
  for (const std::unique_ptr<xml::Node>& child : children) {
    ns->AppendChild(child->Clone());
  }
  return std::move(ns);
}

Element* FindRootElement(XmlResource* doc) {
  return FindRootElement(doc->root.get());
}

Element* FindRootElement(Node* node) {
  if (!node) {
    return nullptr;
  }

  Element* el = nullptr;
  while ((el = NodeCast<Element>(node)) == nullptr) {
    if (node->children.empty()) {
      return nullptr;
    }
    // We are looking for the first element, and namespaces can only have one
    // child.
    node = node->children.front().get();
  }
  return el;
}

void Node::AppendChild(std::unique_ptr<Node> child) {
  child->parent = this;
  children.push_back(std::move(child));
}

void Node::InsertChild(size_t index, std::unique_ptr<Node> child) {
  child->parent = this;
  children.insert(children.begin() + index, std::move(child));
}

Attribute* Element::FindAttribute(const StringPiece& ns,
                                  const StringPiece& name) {
  for (auto& attr : attributes) {
    if (ns == attr.namespace_uri && name == attr.name) {
      return &attr;
    }
  }
  return nullptr;
}

Element* Element::FindChild(const StringPiece& ns, const StringPiece& name) {
  return FindChildWithAttribute(ns, name, {}, {}, {});
}

Element* Element::FindChildWithAttribute(const StringPiece& ns,
                                         const StringPiece& name,
                                         const StringPiece& attr_ns,
                                         const StringPiece& attr_name,
                                         const StringPiece& attr_value) {
  for (auto& child_node : children) {
    Node* child = child_node.get();
    while (NodeCast<Namespace>(child)) {
      if (child->children.empty()) {
        break;
      }
      child = child->children[0].get();
    }

    if (Element* el = NodeCast<Element>(child)) {
      if (ns == el->namespace_uri && name == el->name) {
        if (attr_ns.empty() && attr_name.empty()) {
          return el;
        }

        Attribute* attr = el->FindAttribute(attr_ns, attr_name);
        if (attr && attr_value == attr->value) {
          return el;
        }
      }
    }
  }
  return nullptr;
}

std::vector<Element*> Element::GetChildElements() {
  std::vector<Element*> elements;
  for (auto& child_node : children) {
    Node* child = child_node.get();
    while (NodeCast<Namespace>(child)) {
      if (child->children.empty()) {
        break;
      }
      child = child->children[0].get();
    }

    if (Element* el = NodeCast<Element>(child)) {
      elements.push_back(el);
    }
  }
  return elements;
}

std::unique_ptr<Node> Element::Clone() {
  auto el = util::make_unique<Element>();
  el->comment = comment;
  el->line_number = line_number;
  el->column_number = column_number;
  el->name = name;
  el->namespace_uri = namespace_uri;

  el->attributes.reserve(attributes.size());
  for (xml::Attribute& attr : attributes) {
    // Don't copy compiled values or attributes.
    el->attributes.push_back(
        xml::Attribute{attr.namespace_uri, attr.name, attr.value});
  }

  el->children.reserve(children.size());
  for (const std::unique_ptr<xml::Node>& child : children) {
    el->AppendChild(child->Clone());
  }
  return std::move(el);
}

std::unique_ptr<Node> Text::Clone() {
  auto t = util::make_unique<Text>();
  t->comment = comment;
  t->line_number = line_number;
  t->column_number = column_number;
  t->text = text;
  return std::move(t);
}

void PackageAwareVisitor::Visit(Namespace* ns) {
  bool added = false;
  if (Maybe<ExtractedPackage> maybe_package =
          ExtractPackageFromNamespace(ns->namespace_uri)) {
    ExtractedPackage& package = maybe_package.value();
    package_decls_.push_back(
        PackageDecl{ns->namespace_prefix, std::move(package)});
    added = true;
  }

  Visitor::Visit(ns);

  if (added) {
    package_decls_.pop_back();
  }
}

Maybe<ExtractedPackage> PackageAwareVisitor::TransformPackageAlias(
    const StringPiece& alias, const StringPiece& local_package) const {
  if (alias.empty()) {
    return ExtractedPackage{local_package.to_string(), false /* private */};
  }

  const auto rend = package_decls_.rend();
  for (auto iter = package_decls_.rbegin(); iter != rend; ++iter) {
    if (alias == iter->prefix) {
      if (iter->package.package.empty()) {
        return ExtractedPackage{local_package.to_string(), iter->package.private_namespace};
      }
      return iter->package;
    }
  }
  return {};
}

}  // namespace xml
}  // namespace aapt