blob: 323ec05b5f2cad55ad8c8ace9e6586ab93af45f4 [file] [log] [blame]
/*
* 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 "util/Maybe.h"
#include "util/Util.h"
#include "xml/XmlPullParser.h"
#include "xml/XmlUtil.h"
#include <iostream>
#include <string>
namespace aapt {
namespace xml {
constexpr char kXmlNamespaceSep = 1;
XmlPullParser::XmlPullParser(std::istream& in) : mIn(in), mEmpty(), mDepth(0) {
mParser = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
XML_SetUserData(mParser, this);
XML_SetElementHandler(mParser, startElementHandler, endElementHandler);
XML_SetNamespaceDeclHandler(mParser, startNamespaceHandler, endNamespaceHandler);
XML_SetCharacterDataHandler(mParser, characterDataHandler);
XML_SetCommentHandler(mParser, commentDataHandler);
mEventQueue.push(EventData{ Event::kStartDocument, 0, mDepth++ });
}
XmlPullParser::~XmlPullParser() {
XML_ParserFree(mParser);
}
XmlPullParser::Event XmlPullParser::next() {
const Event currentEvent = getEvent();
if (currentEvent == Event::kBadDocument || currentEvent == Event::kEndDocument) {
return currentEvent;
}
mEventQueue.pop();
while (mEventQueue.empty()) {
mIn.read(mBuffer, sizeof(mBuffer) / sizeof(*mBuffer));
const bool done = mIn.eof();
if (mIn.bad() && !done) {
mLastError = strerror(errno);
mEventQueue.push(EventData{ Event::kBadDocument });
continue;
}
if (XML_Parse(mParser, mBuffer, mIn.gcount(), done) == XML_STATUS_ERROR) {
mLastError = XML_ErrorString(XML_GetErrorCode(mParser));
mEventQueue.push(EventData{ Event::kBadDocument });
continue;
}
if (done) {
mEventQueue.push(EventData{ Event::kEndDocument, 0, 0 });
}
}
Event event = getEvent();
// Record namespace prefixes and package names so that we can do our own
// handling of references that use namespace aliases.
if (event == Event::kStartNamespace || event == Event::kEndNamespace) {
Maybe<ExtractedPackage> result = extractPackageFromNamespace(getNamespaceUri());
if (event == Event::kStartNamespace) {
if (result) {
mPackageAliases.emplace_back(
PackageDecl{ getNamespacePrefix(), std::move(result.value()) });
}
} else {
if (result) {
mPackageAliases.pop_back();
}
}
}
return event;
}
XmlPullParser::Event XmlPullParser::getEvent() const {
return mEventQueue.front().event;
}
const std::string& XmlPullParser::getLastError() const {
return mLastError;
}
const std::u16string& XmlPullParser::getComment() const {
return mEventQueue.front().data1;
}
size_t XmlPullParser::getLineNumber() const {
return mEventQueue.front().lineNumber;
}
size_t XmlPullParser::getDepth() const {
return mEventQueue.front().depth;
}
const std::u16string& XmlPullParser::getText() const {
if (getEvent() != Event::kText) {
return mEmpty;
}
return mEventQueue.front().data1;
}
const std::u16string& XmlPullParser::getNamespacePrefix() const {
const Event currentEvent = getEvent();
if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) {
return mEmpty;
}
return mEventQueue.front().data1;
}
const std::u16string& XmlPullParser::getNamespaceUri() const {
const Event currentEvent = getEvent();
if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) {
return mEmpty;
}
return mEventQueue.front().data2;
}
Maybe<ExtractedPackage> XmlPullParser::transformPackageAlias(
const StringPiece16& alias, const StringPiece16& localPackage) const {
if (alias.empty()) {
return ExtractedPackage{ localPackage.toString(), false /* private */ };
}
const auto endIter = mPackageAliases.rend();
for (auto iter = mPackageAliases.rbegin(); iter != endIter; ++iter) {
if (alias == iter->prefix) {
if (iter->package.package.empty()) {
return ExtractedPackage{ localPackage.toString(),
iter->package.privateNamespace };
}
return iter->package;
}
}
return {};
}
const std::u16string& XmlPullParser::getElementNamespace() const {
const Event currentEvent = getEvent();
if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) {
return mEmpty;
}
return mEventQueue.front().data1;
}
const std::u16string& XmlPullParser::getElementName() const {
const Event currentEvent = getEvent();
if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) {
return mEmpty;
}
return mEventQueue.front().data2;
}
XmlPullParser::const_iterator XmlPullParser::beginAttributes() const {
return mEventQueue.front().attributes.begin();
}
XmlPullParser::const_iterator XmlPullParser::endAttributes() const {
return mEventQueue.front().attributes.end();
}
size_t XmlPullParser::getAttributeCount() const {
if (getEvent() != Event::kStartElement) {
return 0;
}
return mEventQueue.front().attributes.size();
}
/**
* Extracts the namespace and name of an expanded element or attribute name.
*/
static void splitName(const char* name, std::u16string& outNs, std::u16string& outName) {
const char* p = name;
while (*p != 0 && *p != kXmlNamespaceSep) {
p++;
}
if (*p == 0) {
outNs = std::u16string();
outName = util::utf8ToUtf16(name);
} else {
outNs = util::utf8ToUtf16(StringPiece(name, (p - name)));
outName = util::utf8ToUtf16(p + 1);
}
}
void XMLCALL XmlPullParser::startNamespaceHandler(void* userData, const char* prefix,
const char* uri) {
XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
std::u16string namespaceUri = uri != nullptr ? util::utf8ToUtf16(uri) : std::u16string();
parser->mNamespaceUris.push(namespaceUri);
parser->mEventQueue.push(EventData{
Event::kStartNamespace,
XML_GetCurrentLineNumber(parser->mParser),
parser->mDepth++,
prefix != nullptr ? util::utf8ToUtf16(prefix) : std::u16string(),
namespaceUri
});
}
void XMLCALL XmlPullParser::startElementHandler(void* userData, const char* name,
const char** attrs) {
XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
EventData data = {
Event::kStartElement, XML_GetCurrentLineNumber(parser->mParser), parser->mDepth++
};
splitName(name, data.data1, data.data2);
while (*attrs) {
Attribute attribute;
splitName(*attrs++, attribute.namespaceUri, attribute.name);
attribute.value = util::utf8ToUtf16(*attrs++);
// Insert in sorted order.
auto iter = std::lower_bound(data.attributes.begin(), data.attributes.end(), attribute);
data.attributes.insert(iter, std::move(attribute));
}
// Move the structure into the queue (no copy).
parser->mEventQueue.push(std::move(data));
}
void XMLCALL XmlPullParser::characterDataHandler(void* userData, const char* s, int len) {
XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
parser->mEventQueue.push(EventData{
Event::kText,
XML_GetCurrentLineNumber(parser->mParser),
parser->mDepth,
util::utf8ToUtf16(StringPiece(s, len))
});
}
void XMLCALL XmlPullParser::endElementHandler(void* userData, const char* name) {
XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
EventData data = {
Event::kEndElement, XML_GetCurrentLineNumber(parser->mParser), --(parser->mDepth)
};
splitName(name, data.data1, data.data2);
// Move the data into the queue (no copy).
parser->mEventQueue.push(std::move(data));
}
void XMLCALL XmlPullParser::endNamespaceHandler(void* userData, const char* prefix) {
XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
parser->mEventQueue.push(EventData{
Event::kEndNamespace,
XML_GetCurrentLineNumber(parser->mParser),
--(parser->mDepth),
prefix != nullptr ? util::utf8ToUtf16(prefix) : std::u16string(),
parser->mNamespaceUris.top()
});
parser->mNamespaceUris.pop();
}
void XMLCALL XmlPullParser::commentDataHandler(void* userData, const char* comment) {
XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
parser->mEventQueue.push(EventData{
Event::kComment,
XML_GetCurrentLineNumber(parser->mParser),
parser->mDepth,
util::utf8ToUtf16(comment)
});
}
Maybe<StringPiece16> findAttribute(const XmlPullParser* parser, const StringPiece16& name) {
auto iter = parser->findAttribute(u"", name);
if (iter != parser->endAttributes()) {
return StringPiece16(util::trimWhitespace(iter->value));
}
return {};
}
Maybe<StringPiece16> findNonEmptyAttribute(const XmlPullParser* parser, const StringPiece16& name) {
auto iter = parser->findAttribute(u"", name);
if (iter != parser->endAttributes()) {
StringPiece16 trimmed = util::trimWhitespace(iter->value);
if (!trimmed.empty()) {
return trimmed;
}
}
return {};
}
} // namespace xml
} // namespace aapt