AAPT2: Rename to match new style
Use Google3 naming style to match new
projects' and open source google projects' style.
Preferred to do this in a massive CL so as to avoid
style inconsistencies that plague legacy code bases.
This is a relatively NEW code base, may as well keep
it up to date.
Test: name/style refactor - existing tests pass
Change-Id: Ie80ecb78d46ec53efdfca2336bb57d96cbb7fb87
diff --git a/tools/aapt2/xml/XmlActionExecutor.cpp b/tools/aapt2/xml/XmlActionExecutor.cpp
index 745079c..7580b46 100644
--- a/tools/aapt2/xml/XmlActionExecutor.cpp
+++ b/tools/aapt2/xml/XmlActionExecutor.cpp
@@ -19,93 +19,94 @@
namespace aapt {
namespace xml {
-static bool wrapperOne(XmlNodeAction::ActionFunc& f, Element* el, SourcePathDiagnostics*) {
- return f(el);
+static bool wrapper_one(XmlNodeAction::ActionFunc& f, Element* el,
+ SourcePathDiagnostics*) {
+ return f(el);
}
-static bool wrapperTwo(XmlNodeAction::ActionFuncWithDiag& f, Element* el,
- SourcePathDiagnostics* diag) {
- return f(el, diag);
+static bool wrapper_two(XmlNodeAction::ActionFuncWithDiag& f, Element* el,
+ SourcePathDiagnostics* diag) {
+ return f(el, diag);
}
-void XmlNodeAction::action(XmlNodeAction::ActionFunc f) {
- mActions.emplace_back(std::bind(wrapperOne, std::move(f),
- std::placeholders::_1,
- std::placeholders::_2));
+void XmlNodeAction::Action(XmlNodeAction::ActionFunc f) {
+ actions_.emplace_back(std::bind(
+ wrapper_one, std::move(f), std::placeholders::_1, std::placeholders::_2));
}
-void XmlNodeAction::action(XmlNodeAction::ActionFuncWithDiag f) {
- mActions.emplace_back(std::bind(wrapperTwo, std::move(f),
- std::placeholders::_1,
- std::placeholders::_2));
+void XmlNodeAction::Action(XmlNodeAction::ActionFuncWithDiag f) {
+ actions_.emplace_back(std::bind(
+ wrapper_two, std::move(f), std::placeholders::_1, std::placeholders::_2));
}
-static void printElementToDiagMessage(const Element* el, DiagMessage* msg) {
- *msg << "<";
- if (!el->namespaceUri.empty()) {
- *msg << el->namespaceUri << ":";
- }
- *msg << el->name << ">";
+static void PrintElementToDiagMessage(const Element* el, DiagMessage* msg) {
+ *msg << "<";
+ if (!el->namespace_uri.empty()) {
+ *msg << el->namespace_uri << ":";
+ }
+ *msg << el->name << ">";
}
-bool XmlNodeAction::execute(XmlActionExecutorPolicy policy, SourcePathDiagnostics* diag,
- Element* el) const {
- bool error = false;
- for (const ActionFuncWithDiag& action : mActions) {
- error |= !action(el, diag);
+bool XmlNodeAction::Execute(XmlActionExecutorPolicy policy,
+ SourcePathDiagnostics* diag, Element* el) const {
+ bool error = false;
+ for (const ActionFuncWithDiag& action : actions_) {
+ error |= !action(el, diag);
+ }
+
+ for (Element* child_el : el->GetChildElements()) {
+ if (child_el->namespace_uri.empty()) {
+ std::map<std::string, XmlNodeAction>::const_iterator iter =
+ map_.find(child_el->name);
+ if (iter != map_.end()) {
+ error |= !iter->second.Execute(policy, diag, child_el);
+ continue;
+ }
}
- for (Element* childEl : el->getChildElements()) {
- if (childEl->namespaceUri.empty()) {
- std::map<std::string, XmlNodeAction>::const_iterator iter = mMap.find(childEl->name);
- if (iter != mMap.end()) {
- error |= !iter->second.execute(policy, diag, childEl);
- continue;
- }
- }
-
- if (policy == XmlActionExecutorPolicy::Whitelist) {
- DiagMessage errorMsg(childEl->lineNumber);
- errorMsg << "unknown element ";
- printElementToDiagMessage(childEl, &errorMsg);
- errorMsg << " found";
- diag->error(errorMsg);
- error = true;
- }
+ if (policy == XmlActionExecutorPolicy::kWhitelist) {
+ DiagMessage error_msg(child_el->line_number);
+ error_msg << "unknown element ";
+ PrintElementToDiagMessage(child_el, &error_msg);
+ error_msg << " found";
+ diag->Error(error_msg);
+ error = true;
}
- return !error;
+ }
+ return !error;
}
-bool XmlActionExecutor::execute(XmlActionExecutorPolicy policy, IDiagnostics* diag,
- XmlResource* doc) const {
- SourcePathDiagnostics sourceDiag(doc->file.source, diag);
+bool XmlActionExecutor::Execute(XmlActionExecutorPolicy policy,
+ IDiagnostics* diag, XmlResource* doc) const {
+ SourcePathDiagnostics source_diag(doc->file.source, diag);
- Element* el = findRootElement(doc);
- if (!el) {
- if (policy == XmlActionExecutorPolicy::Whitelist) {
- sourceDiag.error(DiagMessage() << "no root XML tag found");
- return false;
- }
- return true;
- }
-
- if (el->namespaceUri.empty()) {
- std::map<std::string, XmlNodeAction>::const_iterator iter = mMap.find(el->name);
- if (iter != mMap.end()) {
- return iter->second.execute(policy, &sourceDiag, el);
- }
- }
-
- if (policy == XmlActionExecutorPolicy::Whitelist) {
- DiagMessage errorMsg(el->lineNumber);
- errorMsg << "unknown element ";
- printElementToDiagMessage(el, &errorMsg);
- errorMsg << " found";
- sourceDiag.error(errorMsg);
- return false;
+ Element* el = FindRootElement(doc);
+ if (!el) {
+ if (policy == XmlActionExecutorPolicy::kWhitelist) {
+ source_diag.Error(DiagMessage() << "no root XML tag found");
+ return false;
}
return true;
+ }
+
+ if (el->namespace_uri.empty()) {
+ std::map<std::string, XmlNodeAction>::const_iterator iter =
+ map_.find(el->name);
+ if (iter != map_.end()) {
+ return iter->second.Execute(policy, &source_diag, el);
+ }
+ }
+
+ if (policy == XmlActionExecutorPolicy::kWhitelist) {
+ DiagMessage error_msg(el->line_number);
+ error_msg << "unknown element ";
+ PrintElementToDiagMessage(el, &error_msg);
+ error_msg << " found";
+ source_diag.Error(error_msg);
+ return false;
+ }
+ return true;
}
-} // namespace xml
-} // namespace aapt
+} // namespace xml
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlActionExecutor.h b/tools/aapt2/xml/XmlActionExecutor.h
index ca21b08..68e3563 100644
--- a/tools/aapt2/xml/XmlActionExecutor.h
+++ b/tools/aapt2/xml/XmlActionExecutor.h
@@ -17,15 +17,16 @@
#ifndef AAPT_XML_XMLPATTERN_H
#define AAPT_XML_XMLPATTERN_H
-#include "Diagnostics.h"
-#include "xml/XmlDom.h"
-
-#include <android-base/macros.h>
#include <functional>
#include <map>
#include <string>
#include <vector>
+#include "android-base/macros.h"
+
+#include "Diagnostics.h"
+#include "xml/XmlDom.h"
+
namespace aapt {
namespace xml {
@@ -34,14 +35,14 @@
* Actions on run if elements are matched, errors occur only when actions
* return false.
*/
- None,
+ kNone,
/**
* The actions defined must match and run. If an element is found that does
* not match
* an action, an error occurs.
*/
- Whitelist,
+ kWhitelist,
};
/**
@@ -60,22 +61,22 @@
* element
* with the name `name`.
*/
- XmlNodeAction& operator[](const std::string& name) { return mMap[name]; }
+ XmlNodeAction& operator[](const std::string& name) { return map_[name]; }
/**
* Add an action to be performed at this XmlNodeAction.
*/
- void action(ActionFunc f);
- void action(ActionFuncWithDiag);
+ void Action(ActionFunc f);
+ void Action(ActionFuncWithDiag);
private:
friend class XmlActionExecutor;
- bool execute(XmlActionExecutorPolicy policy, SourcePathDiagnostics* diag,
+ bool Execute(XmlActionExecutorPolicy policy, SourcePathDiagnostics* diag,
Element* el) const;
- std::map<std::string, XmlNodeAction> mMap;
- std::vector<ActionFuncWithDiag> mActions;
+ std::map<std::string, XmlNodeAction> map_;
+ std::vector<ActionFuncWithDiag> actions_;
};
/**
@@ -89,20 +90,19 @@
/**
* Find or create a root XmlNodeAction that will be performed for the root XML
- * element
- * with the name `name`.
+ * element with the name `name`.
*/
- XmlNodeAction& operator[](const std::string& name) { return mMap[name]; }
+ XmlNodeAction& operator[](const std::string& name) { return map_[name]; }
/**
* Execute the defined actions for this XmlResource.
* Returns true if all actions return true, otherwise returns false.
*/
- bool execute(XmlActionExecutorPolicy policy, IDiagnostics* diag,
+ bool Execute(XmlActionExecutorPolicy policy, IDiagnostics* diag,
XmlResource* doc) const;
private:
- std::map<std::string, XmlNodeAction> mMap;
+ std::map<std::string, XmlNodeAction> map_;
DISALLOW_COPY_AND_ASSIGN(XmlActionExecutor);
};
diff --git a/tools/aapt2/xml/XmlActionExecutor_test.cpp b/tools/aapt2/xml/XmlActionExecutor_test.cpp
index 106e856..7110c90 100644
--- a/tools/aapt2/xml/XmlActionExecutor_test.cpp
+++ b/tools/aapt2/xml/XmlActionExecutor_test.cpp
@@ -14,49 +14,53 @@
* limitations under the License.
*/
-#include "test/Test.h"
#include "xml/XmlActionExecutor.h"
+#include "test/Test.h"
+
namespace aapt {
namespace xml {
TEST(XmlActionExecutorTest, BuildsAccessibleNestedPattern) {
- XmlActionExecutor executor;
- XmlNodeAction& manifestAction = executor["manifest"];
- XmlNodeAction& applicationAction = manifestAction["application"];
+ XmlActionExecutor executor;
+ XmlNodeAction& manifest_action = executor["manifest"];
+ XmlNodeAction& application_action = manifest_action["application"];
- Element* manifestEl = nullptr;
- manifestAction.action([&](Element* manifest) -> bool {
- manifestEl = manifest;
- return true;
- });
+ Element* manifest_el = nullptr;
+ manifest_action.Action([&](Element* manifest) -> bool {
+ manifest_el = manifest;
+ return true;
+ });
- Element* applicationEl = nullptr;
- applicationAction.action([&](Element* application) -> bool {
- applicationEl = application;
- return true;
- });
+ Element* application_el = nullptr;
+ application_action.Action([&](Element* application) -> bool {
+ application_el = application;
+ return true;
+ });
- std::unique_ptr<XmlResource> doc = test::buildXmlDom("<manifest><application /></manifest>");
+ std::unique_ptr<XmlResource> doc =
+ test::BuildXmlDom("<manifest><application /></manifest>");
- StdErrDiagnostics diag;
- ASSERT_TRUE(executor.execute(XmlActionExecutorPolicy::None, &diag, doc.get()));
- ASSERT_NE(nullptr, manifestEl);
- EXPECT_EQ(std::string("manifest"), manifestEl->name);
+ StdErrDiagnostics diag;
+ ASSERT_TRUE(
+ executor.Execute(XmlActionExecutorPolicy::kNone, &diag, doc.get()));
+ ASSERT_NE(nullptr, manifest_el);
+ EXPECT_EQ(std::string("manifest"), manifest_el->name);
- ASSERT_NE(nullptr, applicationEl);
- EXPECT_EQ(std::string("application"), applicationEl->name);
+ ASSERT_NE(nullptr, application_el);
+ EXPECT_EQ(std::string("application"), application_el->name);
}
TEST(XmlActionExecutorTest, FailsWhenUndefinedHierarchyExists) {
- XmlActionExecutor executor;
- executor["manifest"]["application"];
+ XmlActionExecutor executor;
+ executor["manifest"]["application"];
- std::unique_ptr<XmlResource> doc = test::buildXmlDom(
- "<manifest><application /><activity /></manifest>");
- StdErrDiagnostics diag;
- ASSERT_FALSE(executor.execute(XmlActionExecutorPolicy::Whitelist, &diag, doc.get()));
+ std::unique_ptr<XmlResource> doc =
+ test::BuildXmlDom("<manifest><application /><activity /></manifest>");
+ StdErrDiagnostics diag;
+ ASSERT_FALSE(
+ executor.Execute(XmlActionExecutorPolicy::kWhitelist, &diag, doc.get()));
}
-} // namespace xml
-} // namespace aapt
+} // namespace xml
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlDom.cpp b/tools/aapt2/xml/XmlDom.cpp
index 28de78a..567418e 100644
--- a/tools/aapt2/xml/XmlDom.cpp
+++ b/tools/aapt2/xml/XmlDom.cpp
@@ -15,475 +15,496 @@
*/
#include "XmlDom.h"
-#include "XmlPullParser.h"
-#include "util/Util.h"
+
+#include <expat.h>
#include <cassert>
-#include <expat.h>
#include <memory>
#include <stack>
#include <string>
#include <tuple>
+#include "android-base/logging.h"
+
+#include "XmlPullParser.h"
+#include "util/Util.h"
+
namespace aapt {
namespace xml {
constexpr char kXmlNamespaceSep = 1;
struct Stack {
- std::unique_ptr<xml::Node> root;
- std::stack<xml::Node*> nodeStack;
- std::string pendingComment;
+ std::unique_ptr<xml::Node> root;
+ std::stack<xml::Node*> node_stack;
+ std::string pending_comment;
};
/**
* Extracts the namespace and name of an expanded element or attribute name.
*/
-static void splitName(const char* name, std::string* outNs, std::string* outName) {
- const char* p = name;
- while (*p != 0 && *p != kXmlNamespaceSep) {
- p++;
- }
+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) {
- outNs->clear();
- *outName = StringPiece(name).toString();
- } else {
- *outNs = StringPiece(name, (p - name)).toString();
- *outName = StringPiece(p + 1).toString();
- }
+ if (*p == 0) {
+ out_ns->clear();
+ *out_name = StringPiece(name).ToString();
+ } else {
+ *out_ns = StringPiece(name, (p - name)).ToString();
+ *out_name = StringPiece(p + 1).ToString();
+ }
}
-static void addToStack(Stack* stack, XML_Parser parser, std::unique_ptr<Node> node) {
- node->lineNumber = XML_GetCurrentLineNumber(parser);
- node->columnNumber = XML_GetCurrentColumnNumber(parser);
+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* thisNode = node.get();
- if (!stack->nodeStack.empty()) {
- stack->nodeStack.top()->addChild(std::move(node));
- } else {
- stack->root = std::move(node);
- }
+ Node* this_node = node.get();
+ if (!stack->node_stack.empty()) {
+ stack->node_stack.top()->AddChild(std::move(node));
+ } else {
+ stack->root = std::move(node);
+ }
- if (!nodeCast<Text>(thisNode)) {
- stack->nodeStack.push(thisNode);
- }
+ if (!NodeCast<Text>(this_node)) {
+ stack->node_stack.push(this_node);
+ }
}
-static void XMLCALL startNamespaceHandler(void* userData, const char* prefix, const char* uri) {
- XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
- Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+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));
- std::unique_ptr<Namespace> ns = util::make_unique<Namespace>();
- if (prefix) {
- ns->namespacePrefix = StringPiece(prefix).toString();
- }
+ std::unique_ptr<Namespace> ns = util::make_unique<Namespace>();
+ if (prefix) {
+ ns->namespace_prefix = StringPiece(prefix).ToString();
+ }
- if (uri) {
- ns->namespaceUri = StringPiece(uri).toString();
- }
+ if (uri) {
+ ns->namespace_uri = StringPiece(uri).ToString();
+ }
- addToStack(stack, parser, std::move(ns));
+ AddToStack(stack, parser, std::move(ns));
}
-static void XMLCALL endNamespaceHandler(void* userData, const char* prefix) {
- XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
- Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+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));
- assert(!stack->nodeStack.empty());
- stack->nodeStack.pop();
+ CHECK(!stack->node_stack.empty());
+ stack->node_stack.pop();
}
-static bool lessAttribute(const Attribute& lhs, const Attribute& rhs) {
- return std::tie(lhs.namespaceUri, lhs.name, lhs.value) <
- std::tie(rhs.namespaceUri, rhs.name, rhs.value);
+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* userData, const char* name, const char** attrs) {
- XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
- Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+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));
- std::unique_ptr<Element> el = util::make_unique<Element>();
- splitName(name, &el->namespaceUri, &el->name);
+ std::unique_ptr<Element> el = util::make_unique<Element>();
+ SplitName(name, &el->namespace_uri, &el->name);
- while (*attrs) {
- Attribute attribute;
- splitName(*attrs++, &attribute.namespaceUri, &attribute.name);
- attribute.value = StringPiece(*attrs++).toString();
+ while (*attrs) {
+ Attribute attribute;
+ SplitName(*attrs++, &attribute.namespace_uri, &attribute.name);
+ attribute.value = StringPiece(*attrs++).ToString();
- // Insert in sorted order.
- auto iter = std::lower_bound(el->attributes.begin(), el->attributes.end(), attribute,
- lessAttribute);
- el->attributes.insert(iter, std::move(attribute));
- }
+ // 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->pendingComment);
- addToStack(stack, parser, std::move(el));
+ el->comment = std::move(stack->pending_comment);
+ AddToStack(stack, parser, std::move(el));
}
-static void XMLCALL endElementHandler(void* userData, const char* name) {
- XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
- Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+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));
- assert(!stack->nodeStack.empty());
- //stack->nodeStack.top()->comment = std::move(stack->pendingComment);
- stack->nodeStack.pop();
+ CHECK(!stack->node_stack.empty());
+ // stack->nodeStack.top()->comment = std::move(stack->pendingComment);
+ stack->node_stack.pop();
}
-static void XMLCALL characterDataHandler(void* userData, const char* s, int len) {
- XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
- Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+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));
- if (!s || len <= 0) {
+ if (!s || len <= 0) {
+ return;
+ }
+
+ // See if we can just append the text to a previous text node.
+ if (!stack->node_stack.empty()) {
+ Node* currentParent = stack->node_stack.top();
+ if (!currentParent->children.empty()) {
+ Node* last_child = currentParent->children.back().get();
+ if (Text* text = NodeCast<Text>(last_child)) {
+ text->text += StringPiece(s, len).ToString();
return;
+ }
}
+ }
- // See if we can just append the text to a previous text node.
- if (!stack->nodeStack.empty()) {
- Node* currentParent = stack->nodeStack.top();
- if (!currentParent->children.empty()) {
- Node* lastChild = currentParent->children.back().get();
- if (Text* text = nodeCast<Text>(lastChild)) {
- text->text += StringPiece(s, len).toString();
- return;
- }
- }
- }
-
- std::unique_ptr<Text> text = util::make_unique<Text>();
- text->text = StringPiece(s, len).toString();
- addToStack(stack, parser, std::move(text));
+ std::unique_ptr<Text> text = util::make_unique<Text>();
+ text->text = StringPiece(s, len).ToString();
+ AddToStack(stack, parser, std::move(text));
}
-static void XMLCALL commentDataHandler(void* userData, const char* comment) {
- XML_Parser parser = reinterpret_cast<XML_Parser>(userData);
- Stack* stack = reinterpret_cast<Stack*>(XML_GetUserData(parser));
+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));
- if (!stack->pendingComment.empty()) {
- stack->pendingComment += '\n';
- }
- stack->pendingComment += comment;
+ 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 attrCount = parser->getAttributeCount();
- if (attrCount > 0) {
- el->attributes.reserve(attrCount);
- for (size_t i = 0; i < attrCount; i++) {
- Attribute attr;
- size_t len;
- const char16_t* str16 = parser->getAttributeNamespace(i, &len);
- if (str16) {
- attr.namespaceUri = 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 dataLen, IDiagnostics* diag,
+std::unique_ptr<XmlResource> Inflate(std::istream* in, 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;
+ Stack stack;
- std::unique_ptr<Node> root;
- std::stack<Node*> nodeStack;
+ 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);
- ResXMLTree tree;
- if (tree.setTo(data, dataLen) != NO_ERROR) {
- return {};
+ 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;
}
- ResXMLParser::event_code_t code;
- while ((code = tree.next()) != ResXMLParser::BAD_DOCUMENT &&
- code != ResXMLParser::END_DOCUMENT) {
- std::unique_ptr<Node> newNode;
- 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->namespacePrefix = util::utf16ToUtf8(StringPiece16(str16, len));
- }
+ 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;
+ }
+ }
- str16 = tree.getNamespaceUri(&len);
- if (str16) {
- node->namespaceUri = util::utf16ToUtf8(StringPiece16(str16, len));
- }
- newNode = std::move(node);
- break;
- }
+ XML_ParserFree(parser);
+ if (stack.root) {
+ return util::make_unique<XmlResource>(ResourceFile{{}, {}, source},
+ std::move(stack.root));
+ }
+ return {};
+}
- 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->namespaceUri = util::utf16ToUtf8(StringPiece16(str16, len));
- }
+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 = tree.getElementName(&len);
- if (str16) {
- node->name = util::utf16ToUtf8(StringPiece16(str16, len));
- }
+ str16 = parser->getAttributeName(i, &len);
+ if (str16) {
+ attr.name = util::Utf16ToUtf8(StringPiece16(str16, len));
+ }
- copyAttributes(node.get(), &tree);
+ str16 = parser->getAttributeStringValue(i, &len);
+ if (str16) {
+ attr.value = util::Utf16ToUtf8(StringPiece16(str16, len));
+ }
+ el->attributes.push_back(std::move(attr));
+ }
+ }
+}
- newNode = std::move(node);
- break;
- }
+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;
- 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));
- }
- newNode = std::move(node);
- break;
- }
+ std::unique_ptr<Node> root;
+ std::stack<Node*> node_stack;
- case ResXMLParser::END_NAMESPACE:
- case ResXMLParser::END_TAG:
- assert(!nodeStack.empty());
- nodeStack.pop();
- break;
+ ResXMLTree tree;
+ if (tree.setTo(data, data_len) != NO_ERROR) {
+ return {};
+ }
- default:
- assert(false);
- break;
+ 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));
}
- if (newNode) {
- newNode->lineNumber = tree.getLineNumber();
-
- Node* thisNode = newNode.get();
- if (!root) {
- assert(nodeStack.empty());
- root = std::move(newNode);
- } else {
- assert(!nodeStack.empty());
- nodeStack.top()->addChild(std::move(newNode));
- }
-
- if (!nodeCast<Text>(thisNode)) {
- nodeStack.push(thisNode);
- }
+ str16 = tree.getNamespaceUri(&len);
+ if (str16) {
+ node->namespace_uri = util::Utf16ToUtf8(StringPiece16(str16, len));
}
- }
- return util::make_unique<XmlResource>(ResourceFile{}, std::move(root));
-}
+ new_node = std::move(node);
+ break;
+ }
-std::unique_ptr<Node> Namespace::clone() {
- auto ns = util::make_unique<Namespace>();
- ns->comment = comment;
- ns->lineNumber = lineNumber;
- ns->columnNumber = columnNumber;
- ns->namespacePrefix = namespacePrefix;
- ns->namespaceUri = namespaceUri;
-
- ns->children.reserve(children.size());
- for (const std::unique_ptr<xml::Node>& child : children) {
- ns->addChild(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;
+ 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));
}
- // We are looking for the first element, and namespaces can only have one child.
- node = node->children.front().get();
- }
- return el;
-}
-void Node::addChild(std::unique_ptr<Node> child) {
- child->parent = this;
- children.push_back(std::move(child));
-}
-
-Attribute* Element::findAttribute(const StringPiece& ns, const StringPiece& name) {
- for (auto& attr : attributes) {
- if (ns == attr.namespaceUri && name == attr.name) {
- return &attr;
+ 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()->AddChild(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->AddChild(child->Clone());
+ }
+ return std::move(ns);
+}
+
+Element* FindRootElement(XmlResource* doc) {
+ return FindRootElement(doc->root.get());
+}
+
+Element* FindRootElement(Node* node) {
+ if (!node) {
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& attrNs, const StringPiece& attrName,
- const StringPiece& attrValue) {
- for (auto& childNode : children) {
- Node* child = childNode.get();
- while (nodeCast<Namespace>(child)) {
- if (child->children.empty()) {
- break;
- }
- child = child->children[0].get();
- }
-
- if (Element* el = nodeCast<Element>(child)) {
- if (ns == el->namespaceUri && name == el->name) {
- if (attrNs.empty() && attrName.empty()) {
- return el;
- }
-
- Attribute* attr = el->findAttribute(attrNs, attrName);
- if (attr && attrValue == attr->value) {
- return el;
- }
- }
- }
+ Element* el = nullptr;
+ while ((el = NodeCast<Element>(node)) == nullptr) {
+ if (node->children.empty()) {
+ return nullptr;
}
- return nullptr;
+ // We are looking for the first element, and namespaces can only have one
+ // child.
+ node = node->children.front().get();
+ }
+ return el;
}
-std::vector<Element*> Element::getChildElements() {
- std::vector<Element*> elements;
- for (auto& childNode : children) {
- Node* child = childNode.get();
- while (nodeCast<Namespace>(child)) {
- if (child->children.empty()) {
- break;
- }
- child = child->children[0].get();
- }
+void Node::AddChild(std::unique_ptr<Node> child) {
+ child->parent = this;
+ children.push_back(std::move(child));
+}
- if (Element* el = nodeCast<Element>(child)) {
- elements.push_back(el);
- }
+Attribute* Element::FindAttribute(const StringPiece& ns,
+ const StringPiece& name) {
+ for (auto& attr : attributes) {
+ if (ns == attr.namespace_uri && name == attr.name) {
+ return &attr;
}
- return elements;
+ }
+ return nullptr;
}
-std::unique_ptr<Node> Element::clone() {
- auto el = util::make_unique<Element>();
- el->comment = comment;
- el->lineNumber = lineNumber;
- el->columnNumber = columnNumber;
- el->name = name;
- el->namespaceUri = namespaceUri;
+Element* Element::FindChild(const StringPiece& ns, const StringPiece& name) {
+ return FindChildWithAttribute(ns, name, {}, {}, {});
+}
- el->attributes.reserve(attributes.size());
- for (xml::Attribute& attr : attributes) {
- // Don't copy compiled values or attributes.
- el->attributes.push_back(xml::Attribute{ attr.namespaceUri, attr.name, attr.value });
+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();
}
- el->children.reserve(children.size());
- for (const std::unique_ptr<xml::Node>& child : children) {
- el->addChild(child->clone());
+ 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 std::move(el);
+ }
+ return nullptr;
}
-std::unique_ptr<Node> Text::clone() {
- auto t = util::make_unique<Text>();
- t->comment = comment;
- t->lineNumber = lineNumber;
- t->columnNumber = columnNumber;
- t->text = text;
- return std::move(t);
+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;
}
-void PackageAwareVisitor::visit(Namespace* ns) {
- bool added = false;
- if (Maybe<ExtractedPackage> maybePackage = extractPackageFromNamespace(ns->namespaceUri)) {
- ExtractedPackage& package = maybePackage.value();
- mPackageDecls.push_back(PackageDecl{ ns->namespacePrefix, std::move(package) });
- added = true;
- }
+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;
- Visitor::visit(ns);
+ 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});
+ }
- if (added) {
- mPackageDecls.pop_back();
- }
+ el->children.reserve(children.size());
+ for (const std::unique_ptr<xml::Node>& child : children) {
+ el->AddChild(child->Clone());
+ }
+ return std::move(el);
}
-Maybe<ExtractedPackage> PackageAwareVisitor::transformPackageAlias(
- const StringPiece& alias, const StringPiece& localPackage) const {
- if (alias.empty()) {
- return ExtractedPackage{ localPackage.toString(), false /* private */ };
- }
-
- const auto rend = mPackageDecls.rend();
- for (auto iter = mPackageDecls.rbegin(); iter != rend; ++iter) {
- if (alias == iter->prefix) {
- if (iter->package.package.empty()) {
- return ExtractedPackage{ localPackage.toString(),
- iter->package.privateNamespace };
- }
- return iter->package;
- }
- }
- return {};
+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);
}
-} // namespace xml
-} // namespace aapt
+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.ToString(), 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.ToString(),
+ iter->package.private_namespace};
+ }
+ return iter->package;
+ }
+ }
+ return {};
+}
+
+} // namespace xml
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlDom.h b/tools/aapt2/xml/XmlDom.h
index 932303e..e771d87 100644
--- a/tools/aapt2/xml/XmlDom.h
+++ b/tools/aapt2/xml/XmlDom.h
@@ -17,6 +17,11 @@
#ifndef AAPT_XML_DOM_H
#define AAPT_XML_DOM_H
+#include <istream>
+#include <memory>
+#include <string>
+#include <vector>
+
#include "Diagnostics.h"
#include "Resource.h"
#include "ResourceValues.h"
@@ -24,11 +29,6 @@
#include "util/Util.h"
#include "xml/XmlUtil.h"
-#include <istream>
-#include <memory>
-#include <string>
-#include <vector>
-
namespace aapt {
namespace xml {
@@ -40,16 +40,16 @@
class Node {
public:
Node* parent = nullptr;
- size_t lineNumber = 0;
- size_t columnNumber = 0;
+ size_t line_number = 0;
+ size_t column_number = 0;
std::string comment;
std::vector<std::unique_ptr<Node>> children;
virtual ~Node() = default;
- void addChild(std::unique_ptr<Node> child);
- virtual void accept(RawVisitor* visitor) = 0;
- virtual std::unique_ptr<Node> clone() = 0;
+ void AddChild(std::unique_ptr<Node> child);
+ virtual void Accept(RawVisitor* visitor) = 0;
+ virtual std::unique_ptr<Node> Clone() = 0;
};
/**
@@ -59,7 +59,7 @@
template <typename Derived>
class BaseNode : public Node {
public:
- virtual void accept(RawVisitor* visitor) override;
+ virtual void Accept(RawVisitor* visitor) override;
};
/**
@@ -67,10 +67,10 @@
*/
class Namespace : public BaseNode<Namespace> {
public:
- std::string namespacePrefix;
- std::string namespaceUri;
+ std::string namespace_prefix;
+ std::string namespace_uri;
- std::unique_ptr<Node> clone() override;
+ std::unique_ptr<Node> Clone() override;
};
struct AaptAttribute {
@@ -82,12 +82,12 @@
* An XML attribute.
*/
struct Attribute {
- std::string namespaceUri;
+ std::string namespace_uri;
std::string name;
std::string value;
- Maybe<AaptAttribute> compiledAttribute;
- std::unique_ptr<Item> compiledValue;
+ Maybe<AaptAttribute> compiled_attribute;
+ std::unique_ptr<Item> compiled_value;
};
/**
@@ -95,19 +95,19 @@
*/
class Element : public BaseNode<Element> {
public:
- std::string namespaceUri;
+ std::string namespace_uri;
std::string name;
std::vector<Attribute> attributes;
- Attribute* findAttribute(const StringPiece& ns, const StringPiece& name);
- xml::Element* findChild(const StringPiece& ns, const StringPiece& name);
- xml::Element* findChildWithAttribute(const StringPiece& ns,
+ Attribute* FindAttribute(const StringPiece& ns, const StringPiece& name);
+ xml::Element* FindChild(const StringPiece& ns, const StringPiece& name);
+ xml::Element* FindChildWithAttribute(const StringPiece& ns,
const StringPiece& name,
- const StringPiece& attrNs,
- const StringPiece& attrName,
- const StringPiece& attrValue);
- std::vector<xml::Element*> getChildElements();
- std::unique_ptr<Node> clone() override;
+ const StringPiece& attr_ns,
+ const StringPiece& attr_name,
+ const StringPiece& attr_value);
+ std::vector<xml::Element*> GetChildElements();
+ std::unique_ptr<Node> Clone() override;
};
/**
@@ -117,7 +117,7 @@
public:
std::string text;
- std::unique_ptr<Node> clone() override;
+ std::unique_ptr<Node> Clone() override;
};
/**
@@ -133,18 +133,18 @@
* Inflates an XML DOM from a text stream, logging errors to the logger.
* Returns the root node on success, or nullptr on failure.
*/
-std::unique_ptr<XmlResource> inflate(std::istream* in, IDiagnostics* diag,
+std::unique_ptr<XmlResource> Inflate(std::istream* in, IDiagnostics* diag,
const Source& source);
/**
* Inflates an XML DOM from a binary ResXMLTree, logging errors to the logger.
* Returns the root node on success, or nullptr on failure.
*/
-std::unique_ptr<XmlResource> inflate(const void* data, size_t dataLen,
+std::unique_ptr<XmlResource> Inflate(const void* data, size_t data_len,
IDiagnostics* diag, const Source& source);
-Element* findRootElement(XmlResource* doc);
-Element* findRootElement(Node* node);
+Element* FindRootElement(XmlResource* doc);
+Element* FindRootElement(Node* node);
/**
* A visitor interface for the different XML Node subtypes. This will not
@@ -155,9 +155,9 @@
public:
virtual ~RawVisitor() = default;
- virtual void visit(Namespace* node) {}
- virtual void visit(Element* node) {}
- virtual void visit(Text* text) {}
+ virtual void Visit(Namespace* node) {}
+ virtual void Visit(Element* node) {}
+ virtual void Visit(Text* text) {}
};
/**
@@ -165,17 +165,17 @@
*/
class Visitor : public RawVisitor {
public:
- using RawVisitor::visit;
+ using RawVisitor::Visit;
- void visit(Namespace* node) override { visitChildren(node); }
+ void Visit(Namespace* node) override { VisitChildren(node); }
- void visit(Element* node) override { visitChildren(node); }
+ void Visit(Element* node) override { VisitChildren(node); }
- void visit(Text* text) override { visitChildren(text); }
+ void Visit(Text* text) override { VisitChildren(text); }
- void visitChildren(Node* node) {
+ void VisitChildren(Node* node) {
for (auto& child : node->children) {
- child->accept(this);
+ child->Accept(this);
}
}
};
@@ -185,11 +185,12 @@
*/
class PackageAwareVisitor : public Visitor, public IPackageDeclStack {
public:
- using Visitor::visit;
+ using Visitor::Visit;
- void visit(Namespace* ns) override;
- Maybe<ExtractedPackage> transformPackageAlias(
- const StringPiece& alias, const StringPiece& localPackage) const override;
+ void Visit(Namespace* ns) override;
+ Maybe<ExtractedPackage> TransformPackageAlias(
+ const StringPiece& alias,
+ const StringPiece& local_package) const override;
private:
struct PackageDecl {
@@ -197,30 +198,30 @@
ExtractedPackage package;
};
- std::vector<PackageDecl> mPackageDecls;
+ std::vector<PackageDecl> package_decls_;
};
// Implementations
template <typename Derived>
-void BaseNode<Derived>::accept(RawVisitor* visitor) {
- visitor->visit(static_cast<Derived*>(this));
+void BaseNode<Derived>::Accept(RawVisitor* visitor) {
+ visitor->Visit(static_cast<Derived*>(this));
}
template <typename T>
class NodeCastImpl : public RawVisitor {
public:
- using RawVisitor::visit;
+ using RawVisitor::Visit;
T* value = nullptr;
- void visit(T* v) override { value = v; }
+ void Visit(T* v) override { value = v; }
};
template <typename T>
-T* nodeCast(Node* node) {
+T* NodeCast(Node* node) {
NodeCastImpl<T> visitor;
- node->accept(&visitor);
+ node->Accept(&visitor);
return visitor.value;
}
diff --git a/tools/aapt2/xml/XmlDom_test.cpp b/tools/aapt2/xml/XmlDom_test.cpp
index 1909f75..a414afe 100644
--- a/tools/aapt2/xml/XmlDom_test.cpp
+++ b/tools/aapt2/xml/XmlDom_test.cpp
@@ -16,17 +16,19 @@
#include "xml/XmlDom.h"
-#include <gtest/gtest.h>
#include <sstream>
#include <string>
+#include "test/Test.h"
+
namespace aapt {
-constexpr const char* kXmlPreamble = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
+constexpr const char* kXmlPreamble =
+ "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
TEST(XmlDomTest, Inflate) {
- std::stringstream in(kXmlPreamble);
- in << R"EOF(
+ std::stringstream in(kXmlPreamble);
+ in << R"EOF(
<Layout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content">
@@ -36,15 +38,15 @@
</Layout>
)EOF";
- const Source source = { "test.xml" };
- StdErrDiagnostics diag;
- std::unique_ptr<xml::XmlResource> doc = xml::inflate(&in, &diag, source);
- ASSERT_NE(doc, nullptr);
+ const Source source = {"test.xml"};
+ StdErrDiagnostics diag;
+ std::unique_ptr<xml::XmlResource> doc = xml::Inflate(&in, &diag, source);
+ ASSERT_NE(doc, nullptr);
- xml::Namespace* ns = xml::nodeCast<xml::Namespace>(doc->root.get());
- ASSERT_NE(ns, nullptr);
- EXPECT_EQ(ns->namespaceUri, xml::kSchemaAndroid);
- EXPECT_EQ(ns->namespacePrefix, "android");
+ xml::Namespace* ns = xml::NodeCast<xml::Namespace>(doc->root.get());
+ ASSERT_NE(ns, nullptr);
+ EXPECT_EQ(ns->namespace_uri, xml::kSchemaAndroid);
+ EXPECT_EQ(ns->namespace_prefix, "android");
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlPullParser.cpp b/tools/aapt2/xml/XmlPullParser.cpp
index 4a944f1..e59fa86 100644
--- a/tools/aapt2/xml/XmlPullParser.cpp
+++ b/tools/aapt2/xml/XmlPullParser.cpp
@@ -14,295 +14,295 @@
* limitations under the License.
*/
+#include <iostream>
+#include <string>
+
#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(std::istream& in) : in_(in), empty_(), depth_(0) {
+ parser_ = XML_ParserCreateNS(nullptr, kXmlNamespaceSep);
+ XML_SetUserData(parser_, this);
+ XML_SetElementHandler(parser_, StartElementHandler, EndElementHandler);
+ XML_SetNamespaceDeclHandler(parser_, StartNamespaceHandler,
+ EndNamespaceHandler);
+ XML_SetCharacterDataHandler(parser_, CharacterDataHandler);
+ XML_SetCommentHandler(parser_, CommentDataHandler);
+ event_queue_.push(EventData{Event::kStartDocument, 0, depth_++});
}
-XmlPullParser::~XmlPullParser() {
- XML_ParserFree(mParser);
-}
+XmlPullParser::~XmlPullParser() { XML_ParserFree(parser_); }
-XmlPullParser::Event XmlPullParser::next() {
- const Event currentEvent = getEvent();
- if (currentEvent == Event::kBadDocument || currentEvent == Event::kEndDocument) {
- return currentEvent;
+XmlPullParser::Event XmlPullParser::Next() {
+ const Event currentEvent = event();
+ if (currentEvent == Event::kBadDocument ||
+ currentEvent == Event::kEndDocument) {
+ return currentEvent;
+ }
+
+ event_queue_.pop();
+ while (event_queue_.empty()) {
+ in_.read(buffer_, sizeof(buffer_) / sizeof(*buffer_));
+
+ const bool done = in_.eof();
+ if (in_.bad() && !done) {
+ error_ = strerror(errno);
+ event_queue_.push(EventData{Event::kBadDocument});
+ continue;
}
- 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 });
- }
+ if (XML_Parse(parser_, buffer_, in_.gcount(), done) == XML_STATUS_ERROR) {
+ error_ = XML_ErrorString(XML_GetErrorCode(parser_));
+ event_queue_.push(EventData{Event::kBadDocument});
+ continue;
}
- 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();
- }
- }
+ if (done) {
+ event_queue_.push(EventData{Event::kEndDocument, 0, 0});
}
+ }
- return event;
-}
+ Event next_event = event();
-XmlPullParser::Event XmlPullParser::getEvent() const {
- return mEventQueue.front().event;
-}
-
-const std::string& XmlPullParser::getLastError() const {
- return mLastError;
-}
-
-const std::string& 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::string& XmlPullParser::getText() const {
- if (getEvent() != Event::kText) {
- return mEmpty;
+ // Record namespace prefixes and package names so that we can do our own
+ // handling of references that use namespace aliases.
+ if (next_event == Event::kStartNamespace ||
+ next_event == Event::kEndNamespace) {
+ Maybe<ExtractedPackage> result =
+ ExtractPackageFromNamespace(namespace_uri());
+ if (next_event == Event::kStartNamespace) {
+ if (result) {
+ package_aliases_.emplace_back(
+ PackageDecl{namespace_prefix(), std::move(result.value())});
+ }
+ } else {
+ if (result) {
+ package_aliases_.pop_back();
+ }
}
- return mEventQueue.front().data1;
+ }
+
+ return next_event;
}
-const std::string& XmlPullParser::getNamespacePrefix() const {
- const Event currentEvent = getEvent();
- if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) {
- return mEmpty;
+XmlPullParser::Event XmlPullParser::event() const {
+ return event_queue_.front().event;
+}
+
+const std::string& XmlPullParser::error() const { return error_; }
+
+const std::string& XmlPullParser::comment() const {
+ return event_queue_.front().data1;
+}
+
+size_t XmlPullParser::line_number() const {
+ return event_queue_.front().line_number;
+}
+
+size_t XmlPullParser::depth() const { return event_queue_.front().depth; }
+
+const std::string& XmlPullParser::text() const {
+ if (event() != Event::kText) {
+ return empty_;
+ }
+ return event_queue_.front().data1;
+}
+
+const std::string& XmlPullParser::namespace_prefix() const {
+ const Event current_event = event();
+ if (current_event != Event::kStartNamespace &&
+ current_event != Event::kEndNamespace) {
+ return empty_;
+ }
+ return event_queue_.front().data1;
+}
+
+const std::string& XmlPullParser::namespace_uri() const {
+ const Event current_event = event();
+ if (current_event != Event::kStartNamespace &&
+ current_event != Event::kEndNamespace) {
+ return empty_;
+ }
+ return event_queue_.front().data2;
+}
+
+Maybe<ExtractedPackage> XmlPullParser::TransformPackageAlias(
+ const StringPiece& alias, const StringPiece& local_package) const {
+ if (alias.empty()) {
+ return ExtractedPackage{local_package.ToString(), false /* private */};
+ }
+
+ const auto end_iter = package_aliases_.rend();
+ for (auto iter = package_aliases_.rbegin(); iter != end_iter; ++iter) {
+ if (alias == iter->prefix) {
+ if (iter->package.package.empty()) {
+ return ExtractedPackage{local_package.ToString(),
+ iter->package.private_namespace};
+ }
+ return iter->package;
}
- return mEventQueue.front().data1;
+ }
+ return {};
}
-const std::string& XmlPullParser::getNamespaceUri() const {
- const Event currentEvent = getEvent();
- if (currentEvent != Event::kStartNamespace && currentEvent != Event::kEndNamespace) {
- return mEmpty;
- }
- return mEventQueue.front().data2;
+const std::string& XmlPullParser::element_namespace() const {
+ const Event current_event = event();
+ if (current_event != Event::kStartElement &&
+ current_event != Event::kEndElement) {
+ return empty_;
+ }
+ return event_queue_.front().data1;
}
-Maybe<ExtractedPackage> XmlPullParser::transformPackageAlias(
- const StringPiece& alias, const StringPiece& 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::string& XmlPullParser::element_name() const {
+ const Event current_event = event();
+ if (current_event != Event::kStartElement &&
+ current_event != Event::kEndElement) {
+ return empty_;
+ }
+ return event_queue_.front().data2;
}
-const std::string& XmlPullParser::getElementNamespace() const {
- const Event currentEvent = getEvent();
- if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) {
- return mEmpty;
- }
- return mEventQueue.front().data1;
+XmlPullParser::const_iterator XmlPullParser::begin_attributes() const {
+ return event_queue_.front().attributes.begin();
}
-const std::string& XmlPullParser::getElementName() const {
- const Event currentEvent = getEvent();
- if (currentEvent != Event::kStartElement && currentEvent != Event::kEndElement) {
- return mEmpty;
- }
- return mEventQueue.front().data2;
+XmlPullParser::const_iterator XmlPullParser::end_attributes() const {
+ return event_queue_.front().attributes.end();
}
-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();
+size_t XmlPullParser::attribute_count() const {
+ if (event() != Event::kStartElement) {
+ return 0;
+ }
+ return event_queue_.front().attributes.size();
}
/**
* Extracts the namespace and name of an expanded element or attribute name.
*/
-static void splitName(const char* name, std::string& outNs, std::string& outName) {
- const char* p = name;
- while (*p != 0 && *p != kXmlNamespaceSep) {
- p++;
+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 = std::string();
+ out_name = name;
+ } else {
+ out_ns = StringPiece(name, (p - name)).ToString();
+ out_name = p + 1;
+ }
+}
+
+void XMLCALL XmlPullParser::StartNamespaceHandler(void* user_data,
+ const char* prefix,
+ const char* uri) {
+ XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+ std::string namespace_uri = uri != nullptr ? uri : std::string();
+ parser->namespace_uris_.push(namespace_uri);
+ parser->event_queue_.push(
+ EventData{Event::kStartNamespace,
+ XML_GetCurrentLineNumber(parser->parser_), parser->depth_++,
+ prefix != nullptr ? prefix : std::string(), namespace_uri});
+}
+
+void XMLCALL XmlPullParser::StartElementHandler(void* user_data,
+ const char* name,
+ const char** attrs) {
+ XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+ EventData data = {Event::kStartElement,
+ XML_GetCurrentLineNumber(parser->parser_),
+ parser->depth_++};
+ SplitName(name, data.data1, data.data2);
+
+ while (*attrs) {
+ Attribute attribute;
+ SplitName(*attrs++, attribute.namespace_uri, attribute.name);
+ attribute.value = *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->event_queue_.push(std::move(data));
+}
+
+void XMLCALL XmlPullParser::CharacterDataHandler(void* user_data, const char* s,
+ int len) {
+ XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+ parser->event_queue_.push(
+ EventData{Event::kText, XML_GetCurrentLineNumber(parser->parser_),
+ parser->depth_, StringPiece(s, len).ToString()});
+}
+
+void XMLCALL XmlPullParser::EndElementHandler(void* user_data,
+ const char* name) {
+ XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+ EventData data = {Event::kEndElement,
+ XML_GetCurrentLineNumber(parser->parser_),
+ --(parser->depth_)};
+ SplitName(name, data.data1, data.data2);
+
+ // Move the data into the queue (no copy).
+ parser->event_queue_.push(std::move(data));
+}
+
+void XMLCALL XmlPullParser::EndNamespaceHandler(void* user_data,
+ const char* prefix) {
+ XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+ parser->event_queue_.push(
+ EventData{Event::kEndNamespace, XML_GetCurrentLineNumber(parser->parser_),
+ --(parser->depth_), prefix != nullptr ? prefix : std::string(),
+ parser->namespace_uris_.top()});
+ parser->namespace_uris_.pop();
+}
+
+void XMLCALL XmlPullParser::CommentDataHandler(void* user_data,
+ const char* comment) {
+ XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(user_data);
+
+ parser->event_queue_.push(EventData{Event::kComment,
+ XML_GetCurrentLineNumber(parser->parser_),
+ parser->depth_, comment});
+}
+
+Maybe<StringPiece> FindAttribute(const XmlPullParser* parser,
+ const StringPiece& name) {
+ auto iter = parser->FindAttribute("", name);
+ if (iter != parser->end_attributes()) {
+ return StringPiece(util::TrimWhitespace(iter->value));
+ }
+ return {};
+}
+
+Maybe<StringPiece> FindNonEmptyAttribute(const XmlPullParser* parser,
+ const StringPiece& name) {
+ auto iter = parser->FindAttribute("", name);
+ if (iter != parser->end_attributes()) {
+ StringPiece trimmed = util::TrimWhitespace(iter->value);
+ if (!trimmed.empty()) {
+ return trimmed;
}
-
- if (*p == 0) {
- outNs = std::string();
- outName = name;
- } else {
- outNs = StringPiece(name, (p - name)).toString();
- outName = p + 1;
- }
+ }
+ return {};
}
-void XMLCALL XmlPullParser::startNamespaceHandler(void* userData, const char* prefix,
- const char* uri) {
- XmlPullParser* parser = reinterpret_cast<XmlPullParser*>(userData);
- std::string namespaceUri = uri != nullptr ? uri : std::string();
- parser->mNamespaceUris.push(namespaceUri);
- parser->mEventQueue.push(EventData{
- Event::kStartNamespace,
- XML_GetCurrentLineNumber(parser->mParser),
- parser->mDepth++,
- prefix != nullptr ? prefix : std::string(),
- 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 = *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,
- StringPiece(s, len).toString()
- });
-}
-
-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 ? prefix : std::string(),
- 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,
- comment
- });
-}
-
-Maybe<StringPiece> findAttribute(const XmlPullParser* parser, const StringPiece& name) {
- auto iter = parser->findAttribute("", name);
- if (iter != parser->endAttributes()) {
- return StringPiece(util::trimWhitespace(iter->value));
- }
- return {};
-}
-
-Maybe<StringPiece> findNonEmptyAttribute(const XmlPullParser* parser, const StringPiece& name) {
- auto iter = parser->findAttribute("", name);
- if (iter != parser->endAttributes()) {
- StringPiece trimmed = util::trimWhitespace(iter->value);
- if (!trimmed.empty()) {
- return trimmed;
- }
- }
- return {};
-}
-
-} // namespace xml
-} // namespace aapt
+} // namespace xml
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlPullParser.h b/tools/aapt2/xml/XmlPullParser.h
index ce69df6..ff58d60 100644
--- a/tools/aapt2/xml/XmlPullParser.h
+++ b/tools/aapt2/xml/XmlPullParser.h
@@ -17,13 +17,8 @@
#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 <expat.h>
+
#include <algorithm>
#include <istream>
#include <ostream>
@@ -32,6 +27,14 @@
#include <string>
#include <vector>
+#include "android-base/macros.h"
+
+#include "Resource.h"
+#include "process/IResourceTableConsumer.h"
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+#include "xml/XmlUtil.h"
+
namespace aapt {
namespace xml {
@@ -51,15 +54,15 @@
};
/**
- * Skips to the next direct descendant node of the given startDepth,
+ * Skips to the next direct descendant node of the given start_depth,
* skipping namespace nodes.
*
- * When nextChildNode returns true, you can expect Comments, Text, and
+ * 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);
+ static bool NextChildNode(XmlPullParser* parser, size_t start_depth);
+ static bool SkipCurrentElement(XmlPullParser* parser);
+ static bool IsGoodEvent(Event event);
explicit XmlPullParser(std::istream& in);
~XmlPullParser();
@@ -67,42 +70,42 @@
/**
* Returns the current event that is being processed.
*/
- Event getEvent() const;
+ Event event() const;
- const std::string& getLastError() const;
+ const std::string& error() const;
/**
* Note, unlike XmlPullParser, the first call to next() will return
* StartElement of the first element.
*/
- Event next();
+ Event Next();
//
// These are available for all nodes.
//
- const std::string& getComment() const;
- size_t getLineNumber() const;
- size_t getDepth() const;
+ const std::string& comment() const;
+ size_t line_number() const;
+ size_t depth() const;
/**
* Returns the character data for a Text event.
*/
- const std::string& getText() const;
+ const std::string& text() const;
//
// Namespace prefix and URI are available for StartNamespace and EndNamespace.
//
- const std::string& getNamespacePrefix() const;
- const std::string& getNamespaceUri() const;
+ const std::string& namespace_prefix() const;
+ const std::string& namespace_uri() const;
//
// These are available for StartElement and EndElement.
//
- const std::string& getElementNamespace() const;
- const std::string& getElementName() const;
+ const std::string& element_namespace() const;
+ const std::string& element_name() const;
/*
* Uses the current stack of namespaces to resolve the package. Eg:
@@ -115,8 +118,9 @@
* If xmlns:app="http://schemas.android.com/apk/res-auto", then
* 'package' will be set to 'defaultPackage'.
*/
- Maybe<ExtractedPackage> transformPackageAlias(
- const StringPiece& alias, const StringPiece& localPackage) const override;
+ Maybe<ExtractedPackage> TransformPackageAlias(
+ const StringPiece& alias,
+ const StringPiece& local_package) const override;
//
// Remaining methods are for retrieving information about attributes
@@ -127,7 +131,7 @@
//
struct Attribute {
- std::string namespaceUri;
+ std::string namespace_uri;
std::string name;
std::string value;
@@ -139,52 +143,54 @@
using const_iterator = std::vector<Attribute>::const_iterator;
- const_iterator beginAttributes() const;
- const_iterator endAttributes() const;
- size_t getAttributeCount() const;
- const_iterator findAttribute(StringPiece namespaceUri,
+ const_iterator begin_attributes() const;
+ const_iterator end_attributes() const;
+ size_t attribute_count() const;
+ const_iterator FindAttribute(StringPiece namespace_uri,
StringPiece name) const;
private:
- static void XMLCALL startNamespaceHandler(void* userData, const char* prefix,
+ DISALLOW_COPY_AND_ASSIGN(XmlPullParser);
+
+ static void XMLCALL StartNamespaceHandler(void* user_data, const char* prefix,
const char* uri);
- static void XMLCALL startElementHandler(void* userData, const char* name,
+ static void XMLCALL StartElementHandler(void* user_data, const char* name,
const char** attrs);
- static void XMLCALL characterDataHandler(void* userData, const char* s,
+ static void XMLCALL CharacterDataHandler(void* user_data, 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);
+ static void XMLCALL EndElementHandler(void* user_data, const char* name);
+ static void XMLCALL EndNamespaceHandler(void* user_data, const char* prefix);
+ static void XMLCALL CommentDataHandler(void* user_data, const char* comment);
struct EventData {
Event event;
- size_t lineNumber;
+ size_t line_number;
size_t depth;
std::string data1;
std::string data2;
std::vector<Attribute> attributes;
};
- std::istream& mIn;
- XML_Parser mParser;
- char mBuffer[16384];
- std::queue<EventData> mEventQueue;
- std::string mLastError;
- const std::string mEmpty;
- size_t mDepth;
- std::stack<std::string> mNamespaceUris;
+ std::istream& in_;
+ XML_Parser parser_;
+ char buffer_[16384];
+ std::queue<EventData> event_queue_;
+ std::string error_;
+ const std::string empty_;
+ size_t depth_;
+ std::stack<std::string> namespace_uris_;
struct PackageDecl {
std::string prefix;
ExtractedPackage package;
};
- std::vector<PackageDecl> mPackageAliases;
+ std::vector<PackageDecl> package_aliases_;
};
/**
* Finds the attribute in the current element within the global namespace.
*/
-Maybe<StringPiece> findAttribute(const XmlPullParser* parser,
+Maybe<StringPiece> FindAttribute(const XmlPullParser* parser,
const StringPiece& name);
/**
@@ -192,7 +198,7 @@
* attribute's value
* must not be the empty string.
*/
-Maybe<StringPiece> findNonEmptyAttribute(const XmlPullParser* parser,
+Maybe<StringPiece> FindNonEmptyAttribute(const XmlPullParser* parser,
const StringPiece& name);
//
@@ -224,18 +230,18 @@
return out;
}
-inline bool XmlPullParser::nextChildNode(XmlPullParser* parser,
- size_t startDepth) {
+inline bool XmlPullParser::NextChildNode(XmlPullParser* parser,
+ size_t start_depth) {
Event event;
// First get back to the start depth.
- while (isGoodEvent(event = parser->next()) &&
- parser->getDepth() > startDepth + 1) {
+ while (IsGoodEvent(event = parser->Next()) &&
+ parser->depth() > start_depth + 1) {
}
// Now look for the first good node.
- while ((event != Event::kEndElement || parser->getDepth() > startDepth) &&
- isGoodEvent(event)) {
+ while ((event != Event::kEndElement || parser->depth() > start_depth) &&
+ IsGoodEvent(event)) {
switch (event) {
case Event::kText:
case Event::kComment:
@@ -244,15 +250,15 @@
default:
break;
}
- event = parser->next();
+ event = parser->Next();
}
return false;
}
-inline bool XmlPullParser::skipCurrentElement(XmlPullParser* parser) {
+inline bool XmlPullParser::SkipCurrentElement(XmlPullParser* parser) {
int depth = 1;
while (depth > 0) {
- switch (parser->next()) {
+ switch (parser->Next()) {
case Event::kEndDocument:
return true;
case Event::kBadDocument:
@@ -270,12 +276,12 @@
return true;
}
-inline bool XmlPullParser::isGoodEvent(XmlPullParser::Event event) {
+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);
+ int cmp = namespace_uri.compare(rhs.namespace_uri);
if (cmp != 0) return cmp;
return name.compare(rhs.name);
}
@@ -292,16 +298,16 @@
return compare(rhs) != 0;
}
-inline XmlPullParser::const_iterator XmlPullParser::findAttribute(
- StringPiece namespaceUri, StringPiece name) const {
- const auto endIter = endAttributes();
+inline XmlPullParser::const_iterator XmlPullParser::FindAttribute(
+ StringPiece namespace_uri, StringPiece name) const {
+ const auto end_iter = end_attributes();
const auto iter = std::lower_bound(
- beginAttributes(), endIter,
- std::pair<StringPiece, StringPiece>(namespaceUri, name),
+ begin_attributes(), end_iter,
+ std::pair<StringPiece, StringPiece>(namespace_uri, name),
[](const Attribute& attr,
const std::pair<StringPiece, StringPiece>& rhs) -> bool {
- int cmp = attr.namespaceUri.compare(0, attr.namespaceUri.size(),
- rhs.first.data(), rhs.first.size());
+ int cmp = attr.namespace_uri.compare(
+ 0, attr.namespace_uri.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(),
@@ -310,11 +316,11 @@
return false;
});
- if (iter != endIter && namespaceUri == iter->namespaceUri &&
+ if (iter != end_iter && namespace_uri == iter->namespace_uri &&
name == iter->name) {
return iter;
}
- return endIter;
+ return end_iter;
}
} // namespace xml
diff --git a/tools/aapt2/xml/XmlPullParser_test.cpp b/tools/aapt2/xml/XmlPullParser_test.cpp
index 2c1fdc7..4f18cd2 100644
--- a/tools/aapt2/xml/XmlPullParser_test.cpp
+++ b/tools/aapt2/xml/XmlPullParser_test.cpp
@@ -14,42 +14,43 @@
* limitations under the License.
*/
-#include "test/Test.h"
-#include "util/StringPiece.h"
#include "xml/XmlPullParser.h"
#include <sstream>
+#include "test/Test.h"
+#include "util/StringPiece.h"
+
namespace aapt {
TEST(XmlPullParserTest, NextChildNodeTraversesCorrectly) {
- std::stringstream str;
- str << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
- "<a><b><c xmlns:a=\"http://schema.org\"><d/></c><e/></b></a>";
- xml::XmlPullParser parser(str);
+ std::stringstream str;
+ str << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+ "<a><b><c xmlns:a=\"http://schema.org\"><d/></c><e/></b></a>";
+ xml::XmlPullParser parser(str);
- const size_t depthOuter = parser.getDepth();
- ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthOuter));
+ const size_t depth_outer = parser.depth();
+ ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_outer));
- EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
- EXPECT_EQ(StringPiece("a"), StringPiece(parser.getElementName()));
+ EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+ EXPECT_EQ(StringPiece("a"), StringPiece(parser.element_name()));
- const size_t depthA = parser.getDepth();
- ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthA));
- EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
- EXPECT_EQ(StringPiece("b"), StringPiece(parser.getElementName()));
+ const size_t depth_a = parser.depth();
+ ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_a));
+ EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+ EXPECT_EQ(StringPiece("b"), StringPiece(parser.element_name()));
- const size_t depthB = parser.getDepth();
- ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthB));
- EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
- EXPECT_EQ(StringPiece("c"), StringPiece(parser.getElementName()));
+ const size_t depth_b = parser.depth();
+ ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_b));
+ EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+ EXPECT_EQ(StringPiece("c"), StringPiece(parser.element_name()));
- ASSERT_TRUE(xml::XmlPullParser::nextChildNode(&parser, depthB));
- EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.getEvent());
- EXPECT_EQ(StringPiece("e"), StringPiece(parser.getElementName()));
+ ASSERT_TRUE(xml::XmlPullParser::NextChildNode(&parser, depth_b));
+ EXPECT_EQ(xml::XmlPullParser::Event::kStartElement, parser.event());
+ EXPECT_EQ(StringPiece("e"), StringPiece(parser.element_name()));
- ASSERT_FALSE(xml::XmlPullParser::nextChildNode(&parser, depthOuter));
- EXPECT_EQ(xml::XmlPullParser::Event::kEndDocument, parser.getEvent());
+ ASSERT_FALSE(xml::XmlPullParser::NextChildNode(&parser, depth_outer));
+ EXPECT_EQ(xml::XmlPullParser::Event::kEndDocument, parser.event());
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlUtil.cpp b/tools/aapt2/xml/XmlUtil.cpp
index b570fd7..d00f7f2 100644
--- a/tools/aapt2/xml/XmlUtil.cpp
+++ b/tools/aapt2/xml/XmlUtil.cpp
@@ -14,60 +14,69 @@
* limitations under the License.
*/
-#include "util/Maybe.h"
-#include "util/Util.h"
#include "xml/XmlUtil.h"
#include <string>
+#include "util/Maybe.h"
+#include "util/Util.h"
+
namespace aapt {
namespace xml {
-std::string buildPackageNamespace(const StringPiece& package, bool privateReference) {
- std::string result = privateReference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
- result.append(package.data(), package.size());
- return result;
+std::string BuildPackageNamespace(const StringPiece& package,
+ bool private_reference) {
+ std::string result =
+ private_reference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
+ result.append(package.data(), package.size());
+ return result;
}
-Maybe<ExtractedPackage> extractPackageFromNamespace(const std::string& namespaceUri) {
- if (util::stringStartsWith(namespaceUri, kSchemaPublicPrefix)) {
- StringPiece schemaPrefix = kSchemaPublicPrefix;
- StringPiece package = namespaceUri;
- package = package.substr(schemaPrefix.size(), package.size() - schemaPrefix.size());
- if (package.empty()) {
- return {};
- }
- return ExtractedPackage{ package.toString(), false /* isPrivate */ };
-
- } else if (util::stringStartsWith(namespaceUri, kSchemaPrivatePrefix)) {
- StringPiece schemaPrefix = kSchemaPrivatePrefix;
- StringPiece package = namespaceUri;
- package = package.substr(schemaPrefix.size(), package.size() - schemaPrefix.size());
- if (package.empty()) {
- return {};
- }
- return ExtractedPackage{ package.toString(), true /* isPrivate */ };
-
- } else if (namespaceUri == kSchemaAuto) {
- return ExtractedPackage{ std::string(), true /* isPrivate */ };
+Maybe<ExtractedPackage> ExtractPackageFromNamespace(
+ const std::string& namespace_uri) {
+ if (util::StartsWith(namespace_uri, kSchemaPublicPrefix)) {
+ StringPiece schema_prefix = kSchemaPublicPrefix;
+ StringPiece package = namespace_uri;
+ package = package.substr(schema_prefix.size(),
+ package.size() - schema_prefix.size());
+ if (package.empty()) {
+ return {};
}
- return {};
-}
+ return ExtractedPackage{package.ToString(), false /* is_private */};
-void transformReferenceFromNamespace(IPackageDeclStack* declStack,
- const StringPiece& localPackage, Reference* inRef) {
- if (inRef->name) {
- if (Maybe<ExtractedPackage> transformedPackage =
- declStack->transformPackageAlias(inRef->name.value().package, localPackage)) {
- ExtractedPackage& extractedPackage = transformedPackage.value();
- inRef->name.value().package = std::move(extractedPackage.package);
-
- // If the reference was already private (with a * prefix) and the namespace is public,
- // we keep the reference private.
- inRef->privateReference |= extractedPackage.privateNamespace;
- }
+ } else if (util::StartsWith(namespace_uri, kSchemaPrivatePrefix)) {
+ StringPiece schema_prefix = kSchemaPrivatePrefix;
+ StringPiece package = namespace_uri;
+ package = package.substr(schema_prefix.size(),
+ package.size() - schema_prefix.size());
+ if (package.empty()) {
+ return {};
}
+ return ExtractedPackage{package.ToString(), true /* is_private */};
+
+ } else if (namespace_uri == kSchemaAuto) {
+ return ExtractedPackage{std::string(), true /* is_private */};
+ }
+ return {};
}
-} // namespace xml
-} // namespace aapt
+void TransformReferenceFromNamespace(IPackageDeclStack* decl_stack,
+ const StringPiece& local_package,
+ Reference* in_ref) {
+ if (in_ref->name) {
+ if (Maybe<ExtractedPackage> transformed_package =
+ decl_stack->TransformPackageAlias(in_ref->name.value().package,
+ local_package)) {
+ ExtractedPackage& extracted_package = transformed_package.value();
+ in_ref->name.value().package = std::move(extracted_package.package);
+
+ // If the reference was already private (with a * prefix) and the
+ // namespace is public,
+ // we keep the reference private.
+ in_ref->private_reference |= extracted_package.private_namespace;
+ }
+ }
+}
+
+} // namespace xml
+} // namespace aapt
diff --git a/tools/aapt2/xml/XmlUtil.h b/tools/aapt2/xml/XmlUtil.h
index 96de654..5365401 100644
--- a/tools/aapt2/xml/XmlUtil.h
+++ b/tools/aapt2/xml/XmlUtil.h
@@ -17,11 +17,11 @@
#ifndef AAPT_XML_XMLUTIL_H
#define AAPT_XML_XMLUTIL_H
+#include <string>
+
#include "ResourceValues.h"
#include "util/Maybe.h"
-#include <string>
-
namespace aapt {
namespace xml {
@@ -51,7 +51,7 @@
* private resources
* are made visible.
*/
- bool privateNamespace;
+ bool private_namespace;
};
/**
@@ -62,8 +62,8 @@
* Special case: if namespaceUri is http://schemas.android.com/apk/res-auto,
* returns an empty package name.
*/
-Maybe<ExtractedPackage> extractPackageFromNamespace(
- const std::string& namespaceUri);
+Maybe<ExtractedPackage> ExtractPackageFromNamespace(
+ const std::string& namespace_uri);
/**
* Returns an XML Android namespace for the given package of the form:
@@ -74,8 +74,8 @@
*
* http://schemas.android.com/apk/prv/res/<package>
*/
-std::string buildPackageNamespace(const StringPiece& package,
- bool privateReference = false);
+std::string BuildPackageNamespace(const StringPiece& package,
+ bool private_reference = false);
/**
* Interface representing a stack of XML namespace declarations. When looking up
@@ -89,20 +89,19 @@
* Returns an ExtractedPackage struct if the alias given corresponds with a
* package declaration.
*/
- virtual Maybe<ExtractedPackage> transformPackageAlias(
- const StringPiece& alias, const StringPiece& localPackage) const = 0;
+ virtual Maybe<ExtractedPackage> TransformPackageAlias(
+ const StringPiece& alias, const StringPiece& local_package) const = 0;
};
/**
* Helper function for transforming the original Reference inRef to a fully
* qualified reference
* via the IPackageDeclStack. This will also mark the Reference as private if
- * the namespace of
- * the package declaration was private.
+ * the namespace of the package declaration was private.
*/
-void transformReferenceFromNamespace(IPackageDeclStack* declStack,
- const StringPiece& localPackage,
- Reference* inRef);
+void TransformReferenceFromNamespace(IPackageDeclStack* decl_stack,
+ const StringPiece& local_package,
+ Reference* in_ref);
} // namespace xml
} // namespace aapt
diff --git a/tools/aapt2/xml/XmlUtil_test.cpp b/tools/aapt2/xml/XmlUtil_test.cpp
index cbeb8bc..5eecc8f 100644
--- a/tools/aapt2/xml/XmlUtil_test.cpp
+++ b/tools/aapt2/xml/XmlUtil_test.cpp
@@ -14,38 +14,46 @@
* limitations under the License.
*/
-#include "test/Test.h"
#include "xml/XmlUtil.h"
+#include "test/Test.h"
+
namespace aapt {
TEST(XmlUtilTest, ExtractPackageFromNamespace) {
- AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("com.android"));
- AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk"));
- AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk/res"));
- AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk/res/"));
- AAPT_ASSERT_FALSE(xml::extractPackageFromNamespace("http://schemas.android.com/apk/prv/res/"));
+ AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace("com.android"));
+ AAPT_ASSERT_FALSE(
+ xml::ExtractPackageFromNamespace("http://schemas.android.com/apk"));
+ AAPT_ASSERT_FALSE(
+ xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res"));
+ AAPT_ASSERT_FALSE(
+ xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/"));
+ AAPT_ASSERT_FALSE(xml::ExtractPackageFromNamespace(
+ "http://schemas.android.com/apk/prv/res/"));
- Maybe<xml::ExtractedPackage> p =
- xml::extractPackageFromNamespace("http://schemas.android.com/apk/res/a");
- AAPT_ASSERT_TRUE(p);
- EXPECT_EQ(std::string("a"), p.value().package);
- EXPECT_FALSE(p.value().privateNamespace);
+ Maybe<xml::ExtractedPackage> p =
+ xml::ExtractPackageFromNamespace("http://schemas.android.com/apk/res/a");
+ AAPT_ASSERT_TRUE(p);
+ EXPECT_EQ(std::string("a"), p.value().package);
+ EXPECT_FALSE(p.value().private_namespace);
- p = xml::extractPackageFromNamespace("http://schemas.android.com/apk/prv/res/android");
- AAPT_ASSERT_TRUE(p);
- EXPECT_EQ(std::string("android"), p.value().package);
- EXPECT_TRUE(p.value().privateNamespace);
+ p = xml::ExtractPackageFromNamespace(
+ "http://schemas.android.com/apk/prv/res/android");
+ AAPT_ASSERT_TRUE(p);
+ EXPECT_EQ(std::string("android"), p.value().package);
+ EXPECT_TRUE(p.value().private_namespace);
- p = xml::extractPackageFromNamespace("http://schemas.android.com/apk/prv/res/com.test");
- AAPT_ASSERT_TRUE(p);
- EXPECT_EQ(std::string("com.test"), p.value().package);
- EXPECT_TRUE(p.value().privateNamespace);
+ p = xml::ExtractPackageFromNamespace(
+ "http://schemas.android.com/apk/prv/res/com.test");
+ AAPT_ASSERT_TRUE(p);
+ EXPECT_EQ(std::string("com.test"), p.value().package);
+ EXPECT_TRUE(p.value().private_namespace);
- p = xml::extractPackageFromNamespace("http://schemas.android.com/apk/res-auto");
- AAPT_ASSERT_TRUE(p);
- EXPECT_EQ(std::string(), p.value().package);
- EXPECT_TRUE(p.value().privateNamespace);
+ p = xml::ExtractPackageFromNamespace(
+ "http://schemas.android.com/apk/res-auto");
+ AAPT_ASSERT_TRUE(p);
+ EXPECT_EQ(std::string(), p.value().package);
+ EXPECT_TRUE(p.value().private_namespace);
}
-} // namespace aapt
+} // namespace aapt