/*
* 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.
*/
#ifndef AAPT_XML_PULL_PARSER_H
#define AAPT_XML_PULL_PARSER_H
#include "Resource.h"
#include "process/IResourceTableConsumer.h"
#include "util/Maybe.h"
#include "util/StringPiece.h"
#include "xml/XmlUtil.h"
#include <algorithm>
#include <expat.h>
#include <istream>
#include <ostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
namespace aapt {
namespace xml {
class XmlPullParser : public IPackageDeclStack {
public:
enum class Event {
kBadDocument,
kStartDocument,
kEndDocument,
kStartNamespace,
kEndNamespace,
kStartElement,
kEndElement,
kText,
kComment,
};
/**
* Skips to the next direct descendant node of the given startDepth,
* skipping namespace nodes.
*
* When nextChildNode returns true, you can expect Comments, Text, and StartElement events.
*/
static bool nextChildNode(XmlPullParser* parser, size_t startDepth);
static bool skipCurrentElement(XmlPullParser* parser);
static bool isGoodEvent(Event event);
XmlPullParser(std::istream& in);
~XmlPullParser();
/**
* Returns the current event that is being processed.
*/
Event getEvent() const;
const std::string& getLastError() const;
/**
* Note, unlike XmlPullParser, the first call to next() will return
* StartElement of the first element.
*/
Event next();
//
// These are available for all nodes.
//
const std::u16string& getComment() const;
size_t getLineNumber() const;
size_t getDepth() const;
/**
* Returns the character data for a Text event.
*/
const std::u16string& getText() const;
//
// Namespace prefix and URI are available for StartNamespace and EndNamespace.
//
const std::u16string& getNamespacePrefix() const;
const std::u16string& getNamespaceUri() const;
//
// These are available for StartElement and EndElement.
//
const std::u16string& getElementNamespace() const;
const std::u16string& getElementName() const;
/*
* Uses the current stack of namespaces to resolve the package. Eg:
* xmlns:app = "http://schemas.android.com/apk/res/com.android.app"
* ...
* android:text="@app:string/message"
*
* In this case, 'app' will be converted to 'com.android.app'.
*
* If xmlns:app="http://schemas.android.com/apk/res-auto", then
* 'package' will be set to 'defaultPackage'.
*/
Maybe<ExtractedPackage> transformPackageAlias(
const StringPiece16& alias, const StringPiece16& localPackage) const override;
//
// Remaining methods are for retrieving information about attributes
// associated with a StartElement.
//
// Attributes must be in sorted order (according to the less than operator
// of struct Attribute).
//
struct Attribute {
std::u16string namespaceUri;
std::u16string name;
std::u16string value;
int compare(const Attribute& rhs) const;
bool operator<(const Attribute& rhs) const;
bool operator==(const Attribute& rhs) const;
bool operator!=(const Attribute& rhs) const;
};
using const_iterator = std::vector<Attribute>::const_iterator;
const_iterator beginAttributes() const;
const_iterator endAttributes() const;
size_t getAttributeCount() const;
const_iterator findAttribute(StringPiece16 namespaceUri, StringPiece16 name) const;
private:
static void XMLCALL startNamespaceHandler(void* userData, const char* prefix, const char* uri);
static void XMLCALL startElementHandler(void* userData, const char* name, const char** attrs);
static void XMLCALL characterDataHandler(void* userData, const char* s, int len);
static void XMLCALL endElementHandler(void* userData, const char* name);
static void XMLCALL endNamespaceHandler(void* userData, const char* prefix);
static void XMLCALL commentDataHandler(void* userData, const char* comment);
struct EventData {
Event event;
size_t lineNumber;
size_t depth;
std::u16string data1;
std::u16string data2;
std::vector<Attribute> attributes;
};
std::istream& mIn;
XML_Parser mParser;
char mBuffer[16384];
std::queue<EventData> mEventQueue;
std::string mLastError;
const std::u16string mEmpty;
size_t mDepth;
std::stack<std::u16string> mNamespaceUris;
struct PackageDecl {
std::u16string prefix;
ExtractedPackage package;
};
std::vector<PackageDecl> mPackageAliases;
};
/**
* Finds the attribute in the current element within the global namespace.
*/
Maybe<StringPiece16> findAttribute(const XmlPullParser* parser, const StringPiece16& name);
/**
* Finds the attribute in the current element within the global namespace. The attribute's value
* must not be the empty string.
*/
Maybe<StringPiece16> findNonEmptyAttribute(const XmlPullParser* parser, const StringPiece16& name);
//
// Implementation
//
inline ::std::ostream& operator<<(::std::ostream& out, XmlPullParser::Event event) {
switch (event) {
case XmlPullParser::Event::kBadDocument: return out << "BadDocument";
case XmlPullParser::Event::kStartDocument: return out << "StartDocument";
case XmlPullParser::Event::kEndDocument: return out << "EndDocument";
case XmlPullParser::Event::kStartNamespace: return out << "StartNamespace";
case XmlPullParser::Event::kEndNamespace: return out << "EndNamespace";
case XmlPullParser::Event::kStartElement: return out << "StartElement";
case XmlPullParser::Event::kEndElement: return out << "EndElement";
case XmlPullParser::Event::kText: return out << "Text";
case XmlPullParser::Event::kComment: return out << "Comment";
}
return out;
}
inline bool XmlPullParser::nextChildNode(XmlPullParser* parser, size_t startDepth) {
Event event;
// First get back to the start depth.
while (isGoodEvent(event = parser->next()) && parser->getDepth() > startDepth + 1) {}
// Now look for the first good node.
while ((event != Event::kEndElement || parser->getDepth() > startDepth) && isGoodEvent(event)) {
switch (event) {
case Event::kText:
case Event::kComment:
case Event::kStartElement:
return true;
default:
break;
}
event = parser->next();
}
return false;
}
inline bool XmlPullParser::skipCurrentElement(XmlPullParser* parser) {
int depth = 1;
while (depth > 0) {
switch (parser->next()) {
case Event::kEndDocument:
return true;
case Event::kBadDocument:
return false;
case Event::kStartElement:
depth++;
break;
case Event::kEndElement:
depth--;
break;
default:
break;
}
}
return true;
}
inline bool XmlPullParser::isGoodEvent(XmlPullParser::Event event) {
return event != Event::kBadDocument && event != Event::kEndDocument;
}
inline int XmlPullParser::Attribute::compare(const Attribute& rhs) const {
int cmp = namespaceUri.compare(rhs.namespaceUri);
if (cmp != 0) return cmp;
return name.compare(rhs.name);
}
inline bool XmlPullParser::Attribute::operator<(const Attribute& rhs) const {
return compare(rhs) < 0;
}
inline bool XmlPullParser::Attribute::operator==(const Attribute& rhs) const {
return compare(rhs) == 0;
}
inline bool XmlPullParser::Attribute::operator!=(const Attribute& rhs) const {
return compare(rhs) != 0;
}
inline XmlPullParser::const_iterator XmlPullParser::findAttribute(StringPiece16 namespaceUri,
StringPiece16 name) const {
const auto endIter = endAttributes();
const auto iter = std::lower_bound(beginAttributes(), endIter,
std::pair<StringPiece16, StringPiece16>(namespaceUri, name),
[](const Attribute& attr, const std::pair<StringPiece16, StringPiece16>& rhs) -> bool {
int cmp = attr.namespaceUri.compare(0, attr.namespaceUri.size(),
rhs.first.data(), rhs.first.size());
if (cmp < 0) return true;
if (cmp > 0) return false;
cmp = attr.name.compare(0, attr.name.size(), rhs.second.data(), rhs.second.size());
if (cmp < 0) return true;
return false;
}
);
if (iter != endIter && namespaceUri == iter->namespaceUri && name == iter->name) {
return iter;
}
return endIter;
}
} // namespace xml
} // namespace aapt
#endif // AAPT_XML_PULL_PARSER_H