tools/aapt2/xml/XmlPullParser.cpp - platform/frameworks/base - Gitiles

 /*
  * 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
	/*
	* 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