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/.clang-format b/tools/aapt2/.clang-format
index 71c5ef2..545366a 100644
--- a/tools/aapt2/.clang-format
+++ b/tools/aapt2/.clang-format
@@ -1,3 +1,2 @@
BasedOnStyle: Google
-ColumnLimit: 100
diff --git a/tools/aapt2/Android.mk b/tools/aapt2/Android.mk
index 284c787..197884dc 100644
--- a/tools/aapt2/Android.mk
+++ b/tools/aapt2/Android.mk
@@ -158,7 +158,7 @@
hostLdLibs_linux := -lz
hostLdLibs_darwin := -lz
-cFlags := -Wall -Werror -Wno-unused-parameter -UNDEBUG
+cFlags := -Wall -Werror -Wno-unused-parameter
cFlags_darwin := -D_DARWIN_UNLIMITED_STREAMS
cFlags_windows := -Wno-maybe-uninitialized # Incorrectly marking use of Maybe.value() as error.
cppFlags := -Wno-missing-field-initializers -fno-exceptions -fno-rtti
diff --git a/tools/aapt2/AppInfo.h b/tools/aapt2/AppInfo.h
index 2cbe117..1e488f7 100644
--- a/tools/aapt2/AppInfo.h
+++ b/tools/aapt2/AppInfo.h
@@ -17,10 +17,10 @@
#ifndef AAPT_APP_INFO_H
#define AAPT_APP_INFO_H
-#include "util/Maybe.h"
-
#include <string>
+#include "util/Maybe.h"
+
namespace aapt {
/**
@@ -36,17 +36,17 @@
/**
* The App's minimum SDK version.
*/
- Maybe<std::string> minSdkVersion;
+ Maybe<std::string> min_sdk_version;
/**
* The Version code of the app.
*/
- Maybe<uint32_t> versionCode;
+ Maybe<uint32_t> version_code;
/**
* The revision code of the app.
*/
- Maybe<uint32_t> revisionCode;
+ Maybe<uint32_t> revision_code;
};
} // namespace aapt
diff --git a/tools/aapt2/ConfigDescription.cpp b/tools/aapt2/ConfigDescription.cpp
index 6598d63..289919a3 100644
--- a/tools/aapt2/ConfigDescription.cpp
+++ b/tools/aapt2/ConfigDescription.cpp
@@ -15,22 +15,24 @@
*/
#include "ConfigDescription.h"
+
+#include <string>
+#include <vector>
+
+#include "androidfw/ResourceTypes.h"
+
#include "Locale.h"
#include "SdkConstants.h"
#include "util/StringPiece.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-#include <string>
-#include <vector>
-
namespace aapt {
using android::ResTable_config;
static const char* kWildcardName = "any";
-const ConfigDescription& ConfigDescription::defaultConfig() {
+const ConfigDescription& ConfigDescription::DefaultConfig() {
static ConfigDescription config = {};
return config;
}
@@ -589,169 +591,169 @@
return true;
}
-bool ConfigDescription::parse(const StringPiece& str, ConfigDescription* out) {
- std::vector<std::string> parts = util::splitAndLowercase(str, '-');
+bool ConfigDescription::Parse(const StringPiece& str, ConfigDescription* out) {
+ std::vector<std::string> parts = util::SplitAndLowercase(str, '-');
ConfigDescription config;
- ssize_t partsConsumed = 0;
+ ssize_t parts_consumed = 0;
LocaleValue locale;
- const auto partsEnd = parts.end();
- auto partIter = parts.begin();
+ const auto parts_end = parts.end();
+ auto part_iter = parts.begin();
if (str.size() == 0) {
goto success;
}
- if (parseMcc(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseMcc(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseMnc(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseMnc(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
// Locale spans a few '-' separators, so we let it
// control the index.
- partsConsumed = locale.initFromParts(partIter, partsEnd);
- if (partsConsumed < 0) {
+ parts_consumed = locale.InitFromParts(part_iter, parts_end);
+ if (parts_consumed < 0) {
return false;
} else {
- locale.writeTo(&config);
- partIter += partsConsumed;
- if (partIter == partsEnd) {
+ locale.WriteTo(&config);
+ part_iter += parts_consumed;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseLayoutDirection(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseLayoutDirection(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseSmallestScreenWidthDp(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseSmallestScreenWidthDp(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseScreenWidthDp(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseScreenWidthDp(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseScreenHeightDp(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseScreenHeightDp(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseScreenLayoutSize(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseScreenLayoutSize(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseScreenLayoutLong(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseScreenLayoutLong(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseScreenRound(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseScreenRound(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseOrientation(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseOrientation(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseUiModeType(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseUiModeType(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseUiModeNight(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseUiModeNight(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseDensity(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseDensity(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseTouchscreen(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseTouchscreen(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseKeysHidden(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseKeysHidden(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseKeyboard(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseKeyboard(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseNavHidden(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseNavHidden(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseNavigation(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseNavigation(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseScreenSize(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseScreenSize(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
- if (parseVersion(partIter->c_str(), &config)) {
- ++partIter;
- if (partIter == partsEnd) {
+ if (parseVersion(part_iter->c_str(), &config)) {
+ ++part_iter;
+ if (part_iter == parts_end) {
goto success;
}
}
@@ -761,57 +763,57 @@
success:
if (out != NULL) {
- applyVersionForCompatibility(&config);
+ ApplyVersionForCompatibility(&config);
*out = config;
}
return true;
}
-void ConfigDescription::applyVersionForCompatibility(
+void ConfigDescription::ApplyVersionForCompatibility(
ConfigDescription* config) {
- uint16_t minSdk = 0;
+ uint16_t min_sdk = 0;
if (config->screenLayout2 & ResTable_config::MASK_SCREENROUND) {
- minSdk = SDK_MARSHMALLOW;
+ min_sdk = SDK_MARSHMALLOW;
} else if (config->density == ResTable_config::DENSITY_ANY) {
- minSdk = SDK_LOLLIPOP;
+ min_sdk = SDK_LOLLIPOP;
} else if (config->smallestScreenWidthDp !=
ResTable_config::SCREENWIDTH_ANY ||
config->screenWidthDp != ResTable_config::SCREENWIDTH_ANY ||
config->screenHeightDp != ResTable_config::SCREENHEIGHT_ANY) {
- minSdk = SDK_HONEYCOMB_MR2;
+ min_sdk = SDK_HONEYCOMB_MR2;
} else if ((config->uiMode & ResTable_config::MASK_UI_MODE_TYPE) !=
ResTable_config::UI_MODE_TYPE_ANY ||
(config->uiMode & ResTable_config::MASK_UI_MODE_NIGHT) !=
ResTable_config::UI_MODE_NIGHT_ANY) {
- minSdk = SDK_FROYO;
+ min_sdk = SDK_FROYO;
} else if ((config->screenLayout & ResTable_config::MASK_SCREENSIZE) !=
ResTable_config::SCREENSIZE_ANY ||
(config->screenLayout & ResTable_config::MASK_SCREENLONG) !=
ResTable_config::SCREENLONG_ANY ||
config->density != ResTable_config::DENSITY_DEFAULT) {
- minSdk = SDK_DONUT;
+ min_sdk = SDK_DONUT;
}
- if (minSdk > config->sdkVersion) {
- config->sdkVersion = minSdk;
+ if (min_sdk > config->sdkVersion) {
+ config->sdkVersion = min_sdk;
}
}
-ConfigDescription ConfigDescription::copyWithoutSdkVersion() const {
+ConfigDescription ConfigDescription::CopyWithoutSdkVersion() const {
ConfigDescription copy = *this;
copy.sdkVersion = 0;
return copy;
}
-bool ConfigDescription::dominates(const ConfigDescription& o) const {
- if (*this == defaultConfig() || *this == o) {
+bool ConfigDescription::Dominates(const ConfigDescription& o) const {
+ if (*this == DefaultConfig() || *this == o) {
return true;
}
- return matchWithDensity(o) && !o.matchWithDensity(*this) &&
- !isMoreSpecificThan(o) && !o.hasHigherPrecedenceThan(*this);
+ return MatchWithDensity(o) && !o.MatchWithDensity(*this) &&
+ !isMoreSpecificThan(o) && !o.HasHigherPrecedenceThan(*this);
}
-bool ConfigDescription::hasHigherPrecedenceThan(
+bool ConfigDescription::HasHigherPrecedenceThan(
const ConfigDescription& o) const {
// The order of the following tests defines the importance of one
// configuration parameter over another. Those tests first are more
@@ -866,7 +868,7 @@
return *this != o;
}
-bool ConfigDescription::conflictsWith(const ConfigDescription& o) const {
+bool ConfigDescription::ConflictsWith(const ConfigDescription& o) const {
// This method should be updated as new configuration parameters are
// introduced (e.g. screenConfig2).
auto pred = [](const uint32_t a, const uint32_t b) -> bool {
@@ -892,8 +894,8 @@
!pred(keyboard, o.keyboard) || !pred(navigation, o.navigation);
}
-bool ConfigDescription::isCompatibleWith(const ConfigDescription& o) const {
- return !conflictsWith(o) && !dominates(o) && !o.dominates(*this);
+bool ConfigDescription::IsCompatibleWith(const ConfigDescription& o) const {
+ return !ConflictsWith(o) && !Dominates(o) && !o.Dominates(*this);
}
} // namespace aapt
diff --git a/tools/aapt2/ConfigDescription.h b/tools/aapt2/ConfigDescription.h
index bb54886..97d0f38 100644
--- a/tools/aapt2/ConfigDescription.h
+++ b/tools/aapt2/ConfigDescription.h
@@ -17,11 +17,12 @@
#ifndef AAPT_CONFIG_DESCRIPTION_H
#define AAPT_CONFIG_DESCRIPTION_H
-#include "util/StringPiece.h"
-
-#include <androidfw/ResourceTypes.h>
#include <ostream>
+#include "androidfw/ResourceTypes.h"
+
+#include "util/StringPiece.h"
+
namespace aapt {
/*
@@ -32,7 +33,7 @@
/**
* Returns an immutable default config.
*/
- static const ConfigDescription& defaultConfig();
+ static const ConfigDescription& DefaultConfig();
/*
* Parse a string of the form 'fr-sw600dp-land' and fill in the
@@ -41,14 +42,14 @@
* The resulting configuration has the appropriate sdkVersion defined
* for backwards compatibility.
*/
- static bool parse(const StringPiece& str, ConfigDescription* out = nullptr);
+ static bool Parse(const StringPiece& str, ConfigDescription* out = nullptr);
/**
* If the configuration uses an axis that was added after
* the original Android release, make sure the SDK version
* is set accordingly.
*/
- static void applyVersionForCompatibility(ConfigDescription* config);
+ static void ApplyVersionForCompatibility(ConfigDescription* config);
ConfigDescription();
ConfigDescription(const android::ResTable_config& o); // NOLINT(implicit)
@@ -59,7 +60,7 @@
ConfigDescription& operator=(const ConfigDescription& o);
ConfigDescription& operator=(ConfigDescription&& o);
- ConfigDescription copyWithoutSdkVersion() const;
+ ConfigDescription CopyWithoutSdkVersion() const;
/**
* A configuration X dominates another configuration Y, if X has at least the
@@ -70,14 +71,14 @@
* For example, the configuration 'en-w800dp' dominates 'en-rGB-w1024dp'. It
* does not dominate 'fr', 'en-w720dp', or 'mcc001-en-w800dp'.
*/
- bool dominates(const ConfigDescription& o) const;
+ bool Dominates(const ConfigDescription& o) const;
/**
* Returns true if this configuration defines a more important configuration
* parameter than o. For example, "en" has higher precedence than "v23",
* whereas "en" has the same precedence as "en-v23".
*/
- bool hasHigherPrecedenceThan(const ConfigDescription& o) const;
+ bool HasHigherPrecedenceThan(const ConfigDescription& o) const;
/**
* A configuration conflicts with another configuration if both
@@ -85,7 +86,7 @@
* incompatible configuration parameter is a non-range, non-density parameter
* that is defined in both configurations as a different, non-default value.
*/
- bool conflictsWith(const ConfigDescription& o) const;
+ bool ConflictsWith(const ConfigDescription& o) const;
/**
* A configuration is compatible with another configuration if both
@@ -93,9 +94,9 @@
* unrelated by domination. For example, land-v11 conflicts with port-v21
* but is compatible with v21 (both land-v11 and v21 would match en-land-v23).
*/
- bool isCompatibleWith(const ConfigDescription& o) const;
+ bool IsCompatibleWith(const ConfigDescription& o) const;
- bool matchWithDensity(const ConfigDescription& o) const;
+ bool MatchWithDensity(const ConfigDescription& o) const;
bool operator<(const ConfigDescription& o) const;
bool operator<=(const ConfigDescription& o) const;
@@ -141,7 +142,7 @@
return *this;
}
-inline bool ConfigDescription::matchWithDensity(
+inline bool ConfigDescription::MatchWithDensity(
const ConfigDescription& o) const {
return match(o) && (density == 0 || density == o.density);
}
diff --git a/tools/aapt2/ConfigDescription_test.cpp b/tools/aapt2/ConfigDescription_test.cpp
index 66b7d47..c331dc0 100644
--- a/tools/aapt2/ConfigDescription_test.cpp
+++ b/tools/aapt2/ConfigDescription_test.cpp
@@ -15,17 +15,18 @@
*/
#include "ConfigDescription.h"
+
+#include <string>
+
#include "SdkConstants.h"
#include "test/Test.h"
#include "util/StringPiece.h"
-#include <string>
-
namespace aapt {
static ::testing::AssertionResult TestParse(
const StringPiece& input, ConfigDescription* config = nullptr) {
- if (ConfigDescription::parse(input, config)) {
+ if (ConfigDescription::Parse(input, config)) {
return ::testing::AssertionSuccess() << input << " was successfully parsed";
}
return ::testing::AssertionFailure() << input << " could not be parsed";
diff --git a/tools/aapt2/Debug.cpp b/tools/aapt2/Debug.cpp
index 965db9e..60b01e3 100644
--- a/tools/aapt2/Debug.cpp
+++ b/tools/aapt2/Debug.cpp
@@ -15,10 +15,6 @@
*/
#include "Debug.h"
-#include "ResourceTable.h"
-#include "ResourceValues.h"
-#include "ValueVisitor.h"
-#include "util/Util.h"
#include <algorithm>
#include <iostream>
@@ -28,18 +24,25 @@
#include <set>
#include <vector>
+#include "android-base/logging.h"
+
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "ValueVisitor.h"
+#include "util/Util.h"
+
namespace aapt {
class PrintVisitor : public ValueVisitor {
public:
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
- void visit(Attribute* attr) override {
+ void Visit(Attribute* attr) override {
std::cout << "(attr) type=";
- attr->printMask(&std::cout);
+ attr->PrintMask(&std::cout);
static constexpr uint32_t kMask =
android::ResTable_map::TYPE_ENUM | android::ResTable_map::TYPE_FLAGS;
- if (attr->typeMask & kMask) {
+ if (attr->type_mask & kMask) {
for (const auto& symbol : attr->symbols) {
std::cout << "\n " << symbol.symbol.name.value().entry;
if (symbol.symbol.id) {
@@ -50,20 +53,20 @@
}
}
- void visit(Style* style) override {
+ void Visit(Style* style) override {
std::cout << "(style)";
if (style->parent) {
- const Reference& parentRef = style->parent.value();
+ const Reference& parent_ref = style->parent.value();
std::cout << " parent=";
- if (parentRef.name) {
- if (parentRef.privateReference) {
+ if (parent_ref.name) {
+ if (parent_ref.private_reference) {
std::cout << "*";
}
- std::cout << parentRef.name.value() << " ";
+ std::cout << parent_ref.name.value() << " ";
}
- if (parentRef.id) {
- std::cout << parentRef.id.value();
+ if (parent_ref.id) {
+ std::cout << parent_ref.id.value();
}
}
@@ -85,11 +88,11 @@
}
}
- void visit(Array* array) override { array->print(&std::cout); }
+ void Visit(Array* array) override { array->Print(&std::cout); }
- void visit(Plural* plural) override { plural->print(&std::cout); }
+ void Visit(Plural* plural) override { plural->Print(&std::cout); }
- void visit(Styleable* styleable) override {
+ void Visit(Styleable* styleable) override {
std::cout << "(styleable)";
for (const auto& attr : styleable->entries) {
std::cout << "\n ";
@@ -107,10 +110,10 @@
}
}
- void visitItem(Item* item) override { item->print(&std::cout); }
+ void VisitItem(Item* item) override { item->Print(&std::cout); }
};
-void Debug::printTable(ResourceTable* table,
+void Debug::PrintTable(ResourceTable* table,
const DebugPrintTableOptions& options) {
PrintVisitor visitor;
@@ -128,10 +131,10 @@
}
std::cout << " entryCount=" << type->entries.size() << std::endl;
- std::vector<const ResourceEntry*> sortedEntries;
+ std::vector<const ResourceEntry*> sorted_entries;
for (const auto& entry : type->entries) {
auto iter = std::lower_bound(
- sortedEntries.begin(), sortedEntries.end(), entry.get(),
+ sorted_entries.begin(), sorted_entries.end(), entry.get(),
[](const ResourceEntry* a, const ResourceEntry* b) -> bool {
if (a->id && b->id) {
return a->id.value() < b->id.value();
@@ -141,17 +144,17 @@
return false;
}
});
- sortedEntries.insert(iter, entry.get());
+ sorted_entries.insert(iter, entry.get());
}
- for (const ResourceEntry* entry : sortedEntries) {
+ for (const ResourceEntry* entry : sorted_entries) {
ResourceId id(package->id ? package->id.value() : uint8_t(0),
type->id ? type->id.value() : uint8_t(0),
entry->id ? entry->id.value() : uint16_t(0));
ResourceName name(package->name, type->type, entry->name);
std::cout << " spec resource " << id << " " << name;
- switch (entry->symbolStatus.state) {
+ switch (entry->symbol_status.state) {
case SymbolState::kPublic:
std::cout << " PUBLIC";
break;
@@ -166,9 +169,9 @@
for (const auto& value : entry->values) {
std::cout << " (" << value->config << ") ";
- value->value->accept(&visitor);
- if (options.showSources && !value->value->getSource().path.empty()) {
- std::cout << " src=" << value->value->getSource();
+ value->value->Accept(&visitor);
+ if (options.show_sources && !value->value->GetSource().path.empty()) {
+ std::cout << " src=" << value->value->GetSource();
}
std::cout << std::endl;
}
@@ -177,35 +180,36 @@
}
}
-static size_t getNodeIndex(const std::vector<ResourceName>& names,
+static size_t GetNodeIndex(const std::vector<ResourceName>& names,
const ResourceName& name) {
auto iter = std::lower_bound(names.begin(), names.end(), name);
- assert(iter != names.end() && *iter == name);
+ CHECK(iter != names.end());
+ CHECK(*iter == name);
return std::distance(names.begin(), iter);
}
-void Debug::printStyleGraph(ResourceTable* table,
- const ResourceName& targetStyle) {
+void Debug::PrintStyleGraph(ResourceTable* table,
+ const ResourceName& target_style) {
std::map<ResourceName, std::set<ResourceName>> graph;
- std::queue<ResourceName> stylesToVisit;
- stylesToVisit.push(targetStyle);
- for (; !stylesToVisit.empty(); stylesToVisit.pop()) {
- const ResourceName& styleName = stylesToVisit.front();
- std::set<ResourceName>& parents = graph[styleName];
+ std::queue<ResourceName> styles_to_visit;
+ styles_to_visit.push(target_style);
+ for (; !styles_to_visit.empty(); styles_to_visit.pop()) {
+ const ResourceName& style_name = styles_to_visit.front();
+ std::set<ResourceName>& parents = graph[style_name];
if (!parents.empty()) {
// We've already visited this style.
continue;
}
- Maybe<ResourceTable::SearchResult> result = table->findResource(styleName);
+ Maybe<ResourceTable::SearchResult> result = table->FindResource(style_name);
if (result) {
ResourceEntry* entry = result.value().entry;
for (const auto& value : entry->values) {
- if (Style* style = valueCast<Style>(value->value.get())) {
+ if (Style* style = ValueCast<Style>(value->value.get())) {
if (style->parent && style->parent.value().name) {
parents.insert(style->parent.value().name.value());
- stylesToVisit.push(style->parent.value().name.value());
+ styles_to_visit.push(style->parent.value().name.value());
}
}
}
@@ -219,24 +223,24 @@
std::cout << "digraph styles {\n";
for (const auto& name : names) {
- std::cout << " node_" << getNodeIndex(names, name) << " [label=\"" << name
+ std::cout << " node_" << GetNodeIndex(names, name) << " [label=\"" << name
<< "\"];\n";
}
for (const auto& entry : graph) {
- const ResourceName& styleName = entry.first;
- size_t styleNodeIndex = getNodeIndex(names, styleName);
+ const ResourceName& style_name = entry.first;
+ size_t style_node_index = GetNodeIndex(names, style_name);
- for (const auto& parentName : entry.second) {
- std::cout << " node_" << styleNodeIndex << " -> "
- << "node_" << getNodeIndex(names, parentName) << ";\n";
+ for (const auto& parent_name : entry.second) {
+ std::cout << " node_" << style_node_index << " -> "
+ << "node_" << GetNodeIndex(names, parent_name) << ";\n";
}
}
std::cout << "}" << std::endl;
}
-void Debug::dumpHex(const void* data, size_t len) {
+void Debug::DumpHex(const void* data, size_t len) {
const uint8_t* d = (const uint8_t*)data;
for (size_t i = 0; i < len; i++) {
std::cerr << std::hex << std::setfill('0') << std::setw(2) << (uint32_t)d[i]
@@ -255,55 +259,55 @@
class XmlPrinter : public xml::Visitor {
public:
- using xml::Visitor::visit;
+ using xml::Visitor::Visit;
- void visit(xml::Element* el) override {
- std::cerr << mPrefix;
+ void Visit(xml::Element* el) override {
+ std::cerr << prefix_;
std::cerr << "E: ";
- if (!el->namespaceUri.empty()) {
- std::cerr << el->namespaceUri << ":";
+ if (!el->namespace_uri.empty()) {
+ std::cerr << el->namespace_uri << ":";
}
- std::cerr << el->name << " (line=" << el->lineNumber << ")\n";
+ std::cerr << el->name << " (line=" << el->line_number << ")\n";
for (const xml::Attribute& attr : el->attributes) {
- std::cerr << mPrefix << " A: ";
- if (!attr.namespaceUri.empty()) {
- std::cerr << attr.namespaceUri << ":";
+ std::cerr << prefix_ << " A: ";
+ if (!attr.namespace_uri.empty()) {
+ std::cerr << attr.namespace_uri << ":";
}
std::cerr << attr.name << "=" << attr.value << "\n";
}
- const size_t previousSize = mPrefix.size();
- mPrefix += " ";
- xml::Visitor::visit(el);
- mPrefix.resize(previousSize);
+ const size_t previous_size = prefix_.size();
+ prefix_ += " ";
+ xml::Visitor::Visit(el);
+ prefix_.resize(previous_size);
}
- void visit(xml::Namespace* ns) override {
- std::cerr << mPrefix;
- std::cerr << "N: " << ns->namespacePrefix << "=" << ns->namespaceUri
- << " (line=" << ns->lineNumber << ")\n";
+ void Visit(xml::Namespace* ns) override {
+ std::cerr << prefix_;
+ std::cerr << "N: " << ns->namespace_prefix << "=" << ns->namespace_uri
+ << " (line=" << ns->line_number << ")\n";
- const size_t previousSize = mPrefix.size();
- mPrefix += " ";
- xml::Visitor::visit(ns);
- mPrefix.resize(previousSize);
+ const size_t previous_size = prefix_.size();
+ prefix_ += " ";
+ xml::Visitor::Visit(ns);
+ prefix_.resize(previous_size);
}
- void visit(xml::Text* text) override {
- std::cerr << mPrefix;
+ void Visit(xml::Text* text) override {
+ std::cerr << prefix_;
std::cerr << "T: '" << text->text << "'\n";
}
private:
- std::string mPrefix;
+ std::string prefix_;
};
} // namespace
-void Debug::dumpXml(xml::XmlResource* doc) {
+void Debug::DumpXml(xml::XmlResource* doc) {
XmlPrinter printer;
- doc->root->accept(&printer);
+ doc->root->Accept(&printer);
}
} // namespace aapt
diff --git a/tools/aapt2/Debug.h b/tools/aapt2/Debug.h
index bd92ec1..56e2e95 100644
--- a/tools/aapt2/Debug.h
+++ b/tools/aapt2/Debug.h
@@ -17,26 +17,26 @@
#ifndef AAPT_DEBUG_H
#define AAPT_DEBUG_H
+// Include for printf-like debugging.
+#include <iostream>
+
#include "Resource.h"
#include "ResourceTable.h"
#include "xml/XmlDom.h"
-// Include for printf-like debugging.
-#include <iostream>
-
namespace aapt {
struct DebugPrintTableOptions {
- bool showSources = false;
+ bool show_sources = false;
};
struct Debug {
- static void printTable(ResourceTable* table,
+ static void PrintTable(ResourceTable* table,
const DebugPrintTableOptions& options = {});
- static void printStyleGraph(ResourceTable* table,
- const ResourceName& targetStyle);
- static void dumpHex(const void* data, size_t len);
- static void dumpXml(xml::XmlResource* doc);
+ static void PrintStyleGraph(ResourceTable* table,
+ const ResourceName& target_style);
+ static void DumpHex(const void* data, size_t len);
+ static void DumpXml(xml::XmlResource* doc);
};
} // namespace aapt
diff --git a/tools/aapt2/Diagnostics.h b/tools/aapt2/Diagnostics.h
index d39cf4c..5bc86a9 100644
--- a/tools/aapt2/Diagnostics.h
+++ b/tools/aapt2/Diagnostics.h
@@ -17,15 +17,16 @@
#ifndef AAPT_DIAGNOSTICS_H
#define AAPT_DIAGNOSTICS_H
-#include "Source.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
-
-#include <android-base/macros.h>
#include <iostream>
#include <sstream>
#include <string>
+#include "android-base/macros.h"
+
+#include "Source.h"
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
namespace aapt {
struct DiagMessageActual {
@@ -34,28 +35,28 @@
};
struct DiagMessage {
- private:
- Source mSource;
- std::stringstream mMessage;
-
public:
DiagMessage() = default;
- explicit DiagMessage(const StringPiece& src) : mSource(src) {}
+ explicit DiagMessage(const StringPiece& src) : source_(src) {}
- explicit DiagMessage(const Source& src) : mSource(src) {}
+ explicit DiagMessage(const Source& src) : source_(src) {}
- explicit DiagMessage(size_t line) : mSource(Source().withLine(line)) {}
+ explicit DiagMessage(size_t line) : source_(Source().WithLine(line)) {}
template <typename T>
DiagMessage& operator<<(const T& value) {
- mMessage << value;
+ message_ << value;
return *this;
}
- DiagMessageActual build() const {
- return DiagMessageActual{mSource, mMessage.str()};
+ DiagMessageActual Build() const {
+ return DiagMessageActual{source_, message_.str()};
}
+
+ private:
+ Source source_;
+ std::stringstream message_;
};
struct IDiagnostics {
@@ -63,21 +64,21 @@
enum class Level { Note, Warn, Error };
- virtual void log(Level level, DiagMessageActual& actualMsg) = 0;
+ virtual void Log(Level level, DiagMessageActual& actualMsg) = 0;
- virtual void error(const DiagMessage& message) {
- DiagMessageActual actual = message.build();
- log(Level::Error, actual);
+ virtual void Error(const DiagMessage& message) {
+ DiagMessageActual actual = message.Build();
+ Log(Level::Error, actual);
}
- virtual void warn(const DiagMessage& message) {
- DiagMessageActual actual = message.build();
- log(Level::Warn, actual);
+ virtual void Warn(const DiagMessage& message) {
+ DiagMessageActual actual = message.Build();
+ Log(Level::Warn, actual);
}
- virtual void note(const DiagMessage& message) {
- DiagMessageActual actual = message.build();
- log(Level::Note, actual);
+ virtual void Note(const DiagMessage& message) {
+ DiagMessageActual actual = message.Build();
+ Log(Level::Note, actual);
}
};
@@ -85,13 +86,13 @@
public:
StdErrDiagnostics() = default;
- void log(Level level, DiagMessageActual& actualMsg) override {
+ void Log(Level level, DiagMessageActual& actual_msg) override {
const char* tag;
switch (level) {
case Level::Error:
- mNumErrors++;
- if (mNumErrors > 20) {
+ num_errors_++;
+ if (num_errors_ > 20) {
return;
}
tag = "error";
@@ -106,14 +107,14 @@
break;
}
- if (!actualMsg.source.path.empty()) {
- std::cerr << actualMsg.source << ": ";
+ if (!actual_msg.source.path.empty()) {
+ std::cerr << actual_msg.source << ": ";
}
- std::cerr << tag << ": " << actualMsg.message << "." << std::endl;
+ std::cerr << tag << ": " << actual_msg.message << "." << std::endl;
}
private:
- size_t mNumErrors = 0;
+ size_t num_errors_ = 0;
DISALLOW_COPY_AND_ASSIGN(StdErrDiagnostics);
};
@@ -121,16 +122,16 @@
class SourcePathDiagnostics : public IDiagnostics {
public:
SourcePathDiagnostics(const Source& src, IDiagnostics* diag)
- : mSource(src), mDiag(diag) {}
+ : source_(src), diag_(diag) {}
- void log(Level level, DiagMessageActual& actualMsg) override {
- actualMsg.source.path = mSource.path;
- mDiag->log(level, actualMsg);
+ void Log(Level level, DiagMessageActual& actual_msg) override {
+ actual_msg.source.path = source_.path;
+ diag_->Log(level, actual_msg);
}
private:
- Source mSource;
- IDiagnostics* mDiag;
+ Source source_;
+ IDiagnostics* diag_;
DISALLOW_COPY_AND_ASSIGN(SourcePathDiagnostics);
};
diff --git a/tools/aapt2/DominatorTree.cpp b/tools/aapt2/DominatorTree.cpp
index 8f6f783..118a385 100644
--- a/tools/aapt2/DominatorTree.cpp
+++ b/tools/aapt2/DominatorTree.cpp
@@ -15,77 +15,80 @@
*/
#include "DominatorTree.h"
-#include "ConfigDescription.h"
#include <algorithm>
+#include "android-base/logging.h"
+
+#include "ConfigDescription.h"
+
namespace aapt {
DominatorTree::DominatorTree(
const std::vector<std::unique_ptr<ResourceConfigValue>>& configs) {
for (const auto& config : configs) {
- mProductRoots[config->product].tryAddChild(
+ product_roots_[config->product].TryAddChild(
util::make_unique<Node>(config.get(), nullptr));
}
}
-void DominatorTree::accept(Visitor* visitor) {
- for (auto& entry : mProductRoots) {
- visitor->visitTree(entry.first, &entry.second);
+void DominatorTree::Accept(Visitor* visitor) {
+ for (auto& entry : product_roots_) {
+ visitor->VisitTree(entry.first, &entry.second);
}
}
-bool DominatorTree::Node::tryAddChild(std::unique_ptr<Node> newChild) {
- assert(newChild->mValue && "cannot add a root or empty node as a child");
- if (mValue && !dominates(newChild.get())) {
+bool DominatorTree::Node::TryAddChild(std::unique_ptr<Node> new_child) {
+ CHECK(new_child->value_) << "cannot add a root or empty node as a child";
+ if (value_ && !Dominates(new_child.get())) {
// This is not the root and the child dominates us.
return false;
}
- return addChild(std::move(newChild));
+ return AddChild(std::move(new_child));
}
-bool DominatorTree::Node::addChild(std::unique_ptr<Node> newChild) {
- bool hasDominatedChildren = false;
+bool DominatorTree::Node::AddChild(std::unique_ptr<Node> new_child) {
+ bool has_dominated_children = false;
// Demote children dominated by the new config.
- for (auto& child : mChildren) {
- if (newChild->dominates(child.get())) {
- child->mParent = newChild.get();
- newChild->mChildren.push_back(std::move(child));
+ for (auto& child : children_) {
+ if (new_child->Dominates(child.get())) {
+ child->parent_ = new_child.get();
+ new_child->children_.push_back(std::move(child));
child = {};
- hasDominatedChildren = true;
+ has_dominated_children = true;
}
}
// Remove dominated children.
- if (hasDominatedChildren) {
- mChildren.erase(
- std::remove_if(mChildren.begin(), mChildren.end(),
+ if (has_dominated_children) {
+ children_.erase(
+ std::remove_if(children_.begin(), children_.end(),
[](const std::unique_ptr<Node>& child) -> bool {
return child == nullptr;
}),
- mChildren.end());
+ children_.end());
}
// Add the new config to a child if a child dominates the new config.
- for (auto& child : mChildren) {
- if (child->dominates(newChild.get())) {
- child->addChild(std::move(newChild));
+ for (auto& child : children_) {
+ if (child->Dominates(new_child.get())) {
+ child->AddChild(std::move(new_child));
return true;
}
}
// The new config is not dominated by a child, so add it here.
- newChild->mParent = this;
- mChildren.push_back(std::move(newChild));
+ new_child->parent_ = this;
+ children_.push_back(std::move(new_child));
return true;
}
-bool DominatorTree::Node::dominates(const Node* other) const {
+bool DominatorTree::Node::Dominates(const Node* other) const {
// Check root node dominations.
- if (other->isRootNode()) {
- return isRootNode();
- } else if (isRootNode()) {
+ if (other->is_root_node()) {
+ return is_root_node();
+ } else if (is_root_node()) {
return true;
}
// Neither node is a root node; compare the configurations.
- return mValue->config.dominates(other->mValue->config);
+ return value_->config.Dominates(other->value_->config);
}
} // namespace aapt
diff --git a/tools/aapt2/DominatorTree.h b/tools/aapt2/DominatorTree.h
index 6d45b5d..7d50935 100644
--- a/tools/aapt2/DominatorTree.h
+++ b/tools/aapt2/DominatorTree.h
@@ -17,13 +17,13 @@
#ifndef AAPT_DOMINATOR_TREE_H
#define AAPT_DOMINATOR_TREE_H
-#include "ResourceTable.h"
-
#include <map>
#include <memory>
#include <string>
#include <vector>
+#include "ResourceTable.h"
+
namespace aapt {
/**
@@ -53,67 +53,67 @@
class Node {
public:
explicit Node(ResourceConfigValue* value = nullptr, Node* parent = nullptr)
- : mValue(value), mParent(parent) {}
+ : value_(value), parent_(parent) {}
- inline ResourceConfigValue* value() const { return mValue; }
+ inline ResourceConfigValue* value() const { return value_; }
- inline Node* parent() const { return mParent; }
+ inline Node* parent() const { return parent_; }
- inline bool isRootNode() const { return !mValue; }
+ inline bool is_root_node() const { return !value_; }
inline const std::vector<std::unique_ptr<Node>>& children() const {
- return mChildren;
+ return children_;
}
- bool tryAddChild(std::unique_ptr<Node> newChild);
+ bool TryAddChild(std::unique_ptr<Node> new_child);
private:
- bool addChild(std::unique_ptr<Node> newChild);
- bool dominates(const Node* other) const;
+ bool AddChild(std::unique_ptr<Node> new_child);
+ bool Dominates(const Node* other) const;
- ResourceConfigValue* mValue;
- Node* mParent;
- std::vector<std::unique_ptr<Node>> mChildren;
+ ResourceConfigValue* value_;
+ Node* parent_;
+ std::vector<std::unique_ptr<Node>> children_;
DISALLOW_COPY_AND_ASSIGN(Node);
};
struct Visitor {
virtual ~Visitor() = default;
- virtual void visitTree(const std::string& product, Node* root) = 0;
+ virtual void VisitTree(const std::string& product, Node* root) = 0;
};
class BottomUpVisitor : public Visitor {
public:
virtual ~BottomUpVisitor() = default;
- void visitTree(const std::string& product, Node* root) override {
+ void VisitTree(const std::string& product, Node* root) override {
for (auto& child : root->children()) {
- visitNode(child.get());
+ VisitNode(child.get());
}
}
- virtual void visitConfig(Node* node) = 0;
+ virtual void VisitConfig(Node* node) = 0;
private:
- void visitNode(Node* node) {
+ void VisitNode(Node* node) {
for (auto& child : node->children()) {
- visitNode(child.get());
+ VisitNode(child.get());
}
- visitConfig(node);
+ VisitConfig(node);
}
};
- void accept(Visitor* visitor);
+ void Accept(Visitor* visitor);
- inline const std::map<std::string, Node>& getProductRoots() const {
- return mProductRoots;
+ inline const std::map<std::string, Node>& product_roots() const {
+ return product_roots_;
}
private:
DISALLOW_COPY_AND_ASSIGN(DominatorTree);
- std::map<std::string, Node> mProductRoots;
+ std::map<std::string, Node> product_roots_;
};
} // namespace aapt
diff --git a/tools/aapt2/DominatorTree_test.cpp b/tools/aapt2/DominatorTree_test.cpp
index a42d2f7..e89c6be 100644
--- a/tools/aapt2/DominatorTree_test.cpp
+++ b/tools/aapt2/DominatorTree_test.cpp
@@ -15,67 +15,68 @@
*/
#include "DominatorTree.h"
-#include "test/Test.h"
-#include "util/Util.h"
#include <sstream>
#include <string>
#include <vector>
+#include "test/Test.h"
+#include "util/Util.h"
+
namespace aapt {
namespace {
class PrettyPrinter : public DominatorTree::Visitor {
public:
- explicit PrettyPrinter(const int indent = 2) : mIndent(indent) {}
+ explicit PrettyPrinter(const int indent = 2) : indent_(indent) {}
- void visitTree(const std::string& product,
+ void VisitTree(const std::string& product,
DominatorTree::Node* root) override {
for (auto& child : root->children()) {
- visitNode(child.get(), 0);
+ VisitNode(child.get(), 0);
}
}
- std::string toString(DominatorTree* tree) {
- mBuffer.str("");
- mBuffer.clear();
- tree->accept(this);
- return mBuffer.str();
+ std::string ToString(DominatorTree* tree) {
+ buffer_.str("");
+ buffer_.clear();
+ tree->Accept(this);
+ return buffer_.str();
}
private:
- void visitConfig(const DominatorTree::Node* node, const int indent) {
- auto configString = node->value()->config.toString();
- mBuffer << std::string(indent, ' ')
- << (configString.isEmpty() ? "<default>" : configString)
+ void VisitConfig(const DominatorTree::Node* node, const int indent) {
+ auto config_string = node->value()->config.toString();
+ buffer_ << std::string(indent, ' ')
+ << (config_string.isEmpty() ? "<default>" : config_string)
<< std::endl;
}
- void visitNode(const DominatorTree::Node* node, const int indent) {
- visitConfig(node, indent);
+ void VisitNode(const DominatorTree::Node* node, const int indent) {
+ VisitConfig(node, indent);
for (const auto& child : node->children()) {
- visitNode(child.get(), indent + mIndent);
+ VisitNode(child.get(), indent + indent_);
}
}
- std::stringstream mBuffer;
- const int mIndent = 2;
+ std::stringstream buffer_;
+ const int indent_ = 2;
};
} // namespace
TEST(DominatorTreeTest, DefaultDominatesEverything) {
- const ConfigDescription defaultConfig = {};
- const ConfigDescription landConfig = test::parseConfigOrDie("land");
- const ConfigDescription sw600dpLandConfig =
- test::parseConfigOrDie("sw600dp-land-v13");
+ const ConfigDescription default_config = {};
+ const ConfigDescription land_config = test::ParseConfigOrDie("land");
+ const ConfigDescription sw600dp_land_config =
+ test::ParseConfigOrDie("sw600dp-land-v13");
std::vector<std::unique_ptr<ResourceConfigValue>> configs;
- configs.push_back(util::make_unique<ResourceConfigValue>(defaultConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(landConfig, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(default_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(land_config, ""));
configs.push_back(
- util::make_unique<ResourceConfigValue>(sw600dpLandConfig, ""));
+ util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
DominatorTree tree(configs);
PrettyPrinter printer;
@@ -84,22 +85,22 @@
"<default>\n"
" land\n"
" sw600dp-land-v13\n";
- EXPECT_EQ(expected, printer.toString(&tree));
+ EXPECT_EQ(expected, printer.ToString(&tree));
}
TEST(DominatorTreeTest, ProductsAreDominatedSeparately) {
- const ConfigDescription defaultConfig = {};
- const ConfigDescription landConfig = test::parseConfigOrDie("land");
- const ConfigDescription sw600dpLandConfig =
- test::parseConfigOrDie("sw600dp-land-v13");
+ const ConfigDescription default_config = {};
+ const ConfigDescription land_config = test::ParseConfigOrDie("land");
+ const ConfigDescription sw600dp_land_config =
+ test::ParseConfigOrDie("sw600dp-land-v13");
std::vector<std::unique_ptr<ResourceConfigValue>> configs;
- configs.push_back(util::make_unique<ResourceConfigValue>(defaultConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(landConfig, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(default_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(land_config, ""));
configs.push_back(
- util::make_unique<ResourceConfigValue>(defaultConfig, "phablet"));
+ util::make_unique<ResourceConfigValue>(default_config, "phablet"));
configs.push_back(
- util::make_unique<ResourceConfigValue>(sw600dpLandConfig, "phablet"));
+ util::make_unique<ResourceConfigValue>(sw600dp_land_config, "phablet"));
DominatorTree tree(configs);
PrettyPrinter printer;
@@ -109,34 +110,38 @@
" land\n"
"<default>\n"
" sw600dp-land-v13\n";
- EXPECT_EQ(expected, printer.toString(&tree));
+ EXPECT_EQ(expected, printer.ToString(&tree));
}
TEST(DominatorTreeTest, MoreSpecificConfigurationsAreDominated) {
- const ConfigDescription defaultConfig = {};
- const ConfigDescription enConfig = test::parseConfigOrDie("en");
- const ConfigDescription enV21Config = test::parseConfigOrDie("en-v21");
- const ConfigDescription ldrtlConfig = test::parseConfigOrDie("ldrtl-v4");
- const ConfigDescription ldrtlXhdpiConfig =
- test::parseConfigOrDie("ldrtl-xhdpi-v4");
- const ConfigDescription sw300dpConfig = test::parseConfigOrDie("sw300dp-v13");
- const ConfigDescription sw540dpConfig = test::parseConfigOrDie("sw540dp-v14");
- const ConfigDescription sw600dpConfig = test::parseConfigOrDie("sw600dp-v14");
- const ConfigDescription sw720dpConfig = test::parseConfigOrDie("sw720dp-v13");
- const ConfigDescription v20Config = test::parseConfigOrDie("v20");
+ const ConfigDescription default_config = {};
+ const ConfigDescription en_config = test::ParseConfigOrDie("en");
+ const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21");
+ const ConfigDescription ldrtl_config = test::ParseConfigOrDie("ldrtl-v4");
+ const ConfigDescription ldrtl_xhdpi_config =
+ test::ParseConfigOrDie("ldrtl-xhdpi-v4");
+ const ConfigDescription sw300dp_config =
+ test::ParseConfigOrDie("sw300dp-v13");
+ const ConfigDescription sw540dp_config =
+ test::ParseConfigOrDie("sw540dp-v14");
+ const ConfigDescription sw600dp_config =
+ test::ParseConfigOrDie("sw600dp-v14");
+ const ConfigDescription sw720dp_config =
+ test::ParseConfigOrDie("sw720dp-v13");
+ const ConfigDescription v20_config = test::ParseConfigOrDie("v20");
std::vector<std::unique_ptr<ResourceConfigValue>> configs;
- configs.push_back(util::make_unique<ResourceConfigValue>(defaultConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(enConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(enV21Config, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(ldrtlConfig, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(default_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(en_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(en_v21_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(ldrtl_config, ""));
configs.push_back(
- util::make_unique<ResourceConfigValue>(ldrtlXhdpiConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(sw300dpConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(sw540dpConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(sw600dpConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(sw720dpConfig, ""));
- configs.push_back(util::make_unique<ResourceConfigValue>(v20Config, ""));
+ util::make_unique<ResourceConfigValue>(ldrtl_xhdpi_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(sw300dp_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(sw540dp_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(sw600dp_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(sw720dp_config, ""));
+ configs.push_back(util::make_unique<ResourceConfigValue>(v20_config, ""));
DominatorTree tree(configs);
PrettyPrinter printer;
@@ -152,7 +157,7 @@
" sw600dp-v14\n"
" sw720dp-v13\n"
" v20\n";
- EXPECT_EQ(expected, printer.toString(&tree));
+ EXPECT_EQ(expected, printer.ToString(&tree));
}
} // namespace aapt
diff --git a/tools/aapt2/Flags.cpp b/tools/aapt2/Flags.cpp
index cb16196..c98cd37 100644
--- a/tools/aapt2/Flags.cpp
+++ b/tools/aapt2/Flags.cpp
@@ -15,97 +15,98 @@
*/
#include "Flags.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
namespace aapt {
-Flags& Flags::requiredFlag(const StringPiece& name,
+Flags& Flags::RequiredFlag(const StringPiece& name,
const StringPiece& description, std::string* value) {
auto func = [value](const StringPiece& arg) -> bool {
- *value = arg.toString();
+ *value = arg.ToString();
return true;
};
- mFlags.push_back(
- Flag{name.toString(), description.toString(), func, true, 1, false});
+ flags_.push_back(
+ Flag{name.ToString(), description.ToString(), func, true, 1, false});
return *this;
}
-Flags& Flags::requiredFlagList(const StringPiece& name,
+Flags& Flags::RequiredFlagList(const StringPiece& name,
const StringPiece& description,
std::vector<std::string>* value) {
auto func = [value](const StringPiece& arg) -> bool {
- value->push_back(arg.toString());
+ value->push_back(arg.ToString());
return true;
};
- mFlags.push_back(
- Flag{name.toString(), description.toString(), func, true, 1, false});
+ flags_.push_back(
+ Flag{name.ToString(), description.ToString(), func, true, 1, false});
return *this;
}
-Flags& Flags::optionalFlag(const StringPiece& name,
+Flags& Flags::OptionalFlag(const StringPiece& name,
const StringPiece& description,
Maybe<std::string>* value) {
auto func = [value](const StringPiece& arg) -> bool {
- *value = arg.toString();
+ *value = arg.ToString();
return true;
};
- mFlags.push_back(
- Flag{name.toString(), description.toString(), func, false, 1, false});
+ flags_.push_back(
+ Flag{name.ToString(), description.ToString(), func, false, 1, false});
return *this;
}
-Flags& Flags::optionalFlagList(const StringPiece& name,
+Flags& Flags::OptionalFlagList(const StringPiece& name,
const StringPiece& description,
std::vector<std::string>* value) {
auto func = [value](const StringPiece& arg) -> bool {
- value->push_back(arg.toString());
+ value->push_back(arg.ToString());
return true;
};
- mFlags.push_back(
- Flag{name.toString(), description.toString(), func, false, 1, false});
+ flags_.push_back(
+ Flag{name.ToString(), description.ToString(), func, false, 1, false});
return *this;
}
-Flags& Flags::optionalFlagList(const StringPiece& name,
+Flags& Flags::OptionalFlagList(const StringPiece& name,
const StringPiece& description,
std::unordered_set<std::string>* value) {
auto func = [value](const StringPiece& arg) -> bool {
- value->insert(arg.toString());
+ value->insert(arg.ToString());
return true;
};
- mFlags.push_back(
- Flag{name.toString(), description.toString(), func, false, 1, false});
+ flags_.push_back(
+ Flag{name.ToString(), description.ToString(), func, false, 1, false});
return *this;
}
-Flags& Flags::optionalSwitch(const StringPiece& name,
+Flags& Flags::OptionalSwitch(const StringPiece& name,
const StringPiece& description, bool* value) {
auto func = [value](const StringPiece& arg) -> bool {
*value = true;
return true;
};
- mFlags.push_back(
- Flag{name.toString(), description.toString(), func, false, 0, false});
+ flags_.push_back(
+ Flag{name.ToString(), description.ToString(), func, false, 0, false});
return *this;
}
-void Flags::usage(const StringPiece& command, std::ostream* out) {
+void Flags::Usage(const StringPiece& command, std::ostream* out) {
constexpr size_t kWidth = 50;
*out << command << " [options]";
- for (const Flag& flag : mFlags) {
+ for (const Flag& flag : flags_) {
if (flag.required) {
*out << " " << flag.name << " arg";
}
@@ -113,10 +114,10 @@
*out << " files...\n\nOptions:\n";
- for (const Flag& flag : mFlags) {
- std::string argLine = flag.name;
- if (flag.numArgs > 0) {
- argLine += " arg";
+ for (const Flag& flag : flags_) {
+ std::string argline = flag.name;
+ if (flag.num_args > 0) {
+ argline += " arg";
}
// Split the description by newlines and write out the argument (which is
@@ -124,9 +125,9 @@
// the first line) followed by the description line. This will make sure
// that multiline
// descriptions are still right justified and aligned.
- for (StringPiece line : util::tokenize(flag.description, '\n')) {
- *out << " " << std::setw(kWidth) << std::left << argLine << line << "\n";
- argLine = " ";
+ for (StringPiece line : util::Tokenize(flag.description, '\n')) {
+ *out << " " << std::setw(kWidth) << std::left << argline << line << "\n";
+ argline = " ";
}
}
*out << " " << std::setw(kWidth) << std::left << "-h"
@@ -134,29 +135,29 @@
out->flush();
}
-bool Flags::parse(const StringPiece& command,
+bool Flags::Parse(const StringPiece& command,
const std::vector<StringPiece>& args,
- std::ostream* outError) {
+ std::ostream* out_error) {
for (size_t i = 0; i < args.size(); i++) {
StringPiece arg = args[i];
if (*(arg.data()) != '-') {
- mArgs.push_back(arg.toString());
+ args_.push_back(arg.ToString());
continue;
}
if (arg == "-h" || arg == "--help") {
- usage(command, outError);
+ Usage(command, out_error);
return false;
}
bool match = false;
- for (Flag& flag : mFlags) {
+ for (Flag& flag : flags_) {
if (arg == flag.name) {
- if (flag.numArgs > 0) {
+ if (flag.num_args > 0) {
i++;
if (i >= args.size()) {
- *outError << flag.name << " missing argument.\n\n";
- usage(command, outError);
+ *out_error << flag.name << " missing argument.\n\n";
+ Usage(command, out_error);
return false;
}
flag.action(args[i]);
@@ -170,22 +171,22 @@
}
if (!match) {
- *outError << "unknown option '" << arg << "'.\n\n";
- usage(command, outError);
+ *out_error << "unknown option '" << arg << "'.\n\n";
+ Usage(command, out_error);
return false;
}
}
- for (const Flag& flag : mFlags) {
+ for (const Flag& flag : flags_) {
if (flag.required && !flag.parsed) {
- *outError << "missing required flag " << flag.name << "\n\n";
- usage(command, outError);
+ *out_error << "missing required flag " << flag.name << "\n\n";
+ Usage(command, out_error);
return false;
}
}
return true;
}
-const std::vector<std::string>& Flags::getArgs() { return mArgs; }
+const std::vector<std::string>& Flags::GetArgs() { return args_; }
} // namespace aapt
diff --git a/tools/aapt2/Flags.h b/tools/aapt2/Flags.h
index 4a0efdb..9feff6b 100644
--- a/tools/aapt2/Flags.h
+++ b/tools/aapt2/Flags.h
@@ -17,41 +17,41 @@
#ifndef AAPT_FLAGS_H
#define AAPT_FLAGS_H
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-
#include <functional>
#include <ostream>
#include <string>
#include <unordered_set>
#include <vector>
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+
namespace aapt {
class Flags {
public:
- Flags& requiredFlag(const StringPiece& name, const StringPiece& description,
+ Flags& RequiredFlag(const StringPiece& name, const StringPiece& description,
std::string* value);
- Flags& requiredFlagList(const StringPiece& name,
+ Flags& RequiredFlagList(const StringPiece& name,
const StringPiece& description,
std::vector<std::string>* value);
- Flags& optionalFlag(const StringPiece& name, const StringPiece& description,
+ Flags& OptionalFlag(const StringPiece& name, const StringPiece& description,
Maybe<std::string>* value);
- Flags& optionalFlagList(const StringPiece& name,
+ Flags& OptionalFlagList(const StringPiece& name,
const StringPiece& description,
std::vector<std::string>* value);
- Flags& optionalFlagList(const StringPiece& name,
+ Flags& OptionalFlagList(const StringPiece& name,
const StringPiece& description,
std::unordered_set<std::string>* value);
- Flags& optionalSwitch(const StringPiece& name, const StringPiece& description,
+ Flags& OptionalSwitch(const StringPiece& name, const StringPiece& description,
bool* value);
- void usage(const StringPiece& command, std::ostream* out);
+ void Usage(const StringPiece& command, std::ostream* out);
- bool parse(const StringPiece& command, const std::vector<StringPiece>& args,
+ bool Parse(const StringPiece& command, const std::vector<StringPiece>& args,
std::ostream* outError);
- const std::vector<std::string>& getArgs();
+ const std::vector<std::string>& GetArgs();
private:
struct Flag {
@@ -59,13 +59,13 @@
std::string description;
std::function<bool(const StringPiece& value)> action;
bool required;
- size_t numArgs;
+ size_t num_args;
bool parsed;
};
- std::vector<Flag> mFlags;
- std::vector<std::string> mArgs;
+ std::vector<Flag> flags_;
+ std::vector<std::string> args_;
};
} // namespace aapt
diff --git a/tools/aapt2/Locale.cpp b/tools/aapt2/Locale.cpp
index a0f7641..78f56c7a 100644
--- a/tools/aapt2/Locale.cpp
+++ b/tools/aapt2/Locale.cpp
@@ -15,174 +15,176 @@
*/
#include "Locale.h"
-#include "util/Util.h"
#include <ctype.h>
+
#include <algorithm>
#include <string>
#include <vector>
+#include "util/Util.h"
+
namespace aapt {
using android::ResTable_config;
-void LocaleValue::setLanguage(const char* languageChars) {
+void LocaleValue::set_language(const char* language_chars) {
size_t i = 0;
- while ((*languageChars) != '\0') {
- language[i++] = ::tolower(*languageChars);
- languageChars++;
+ while ((*language_chars) != '\0') {
+ language[i++] = ::tolower(*language_chars);
+ language_chars++;
}
}
-void LocaleValue::setRegion(const char* regionChars) {
+void LocaleValue::set_region(const char* region_chars) {
size_t i = 0;
- while ((*regionChars) != '\0') {
- region[i++] = ::toupper(*regionChars);
- regionChars++;
+ while ((*region_chars) != '\0') {
+ region[i++] = ::toupper(*region_chars);
+ region_chars++;
}
}
-void LocaleValue::setScript(const char* scriptChars) {
+void LocaleValue::set_script(const char* script_chars) {
size_t i = 0;
- while ((*scriptChars) != '\0') {
+ while ((*script_chars) != '\0') {
if (i == 0) {
- script[i++] = ::toupper(*scriptChars);
+ script[i++] = ::toupper(*script_chars);
} else {
- script[i++] = ::tolower(*scriptChars);
+ script[i++] = ::tolower(*script_chars);
}
- scriptChars++;
+ script_chars++;
}
}
-void LocaleValue::setVariant(const char* variantChars) {
+void LocaleValue::set_variant(const char* variant_chars) {
size_t i = 0;
- while ((*variantChars) != '\0') {
- variant[i++] = *variantChars;
- variantChars++;
+ while ((*variant_chars) != '\0') {
+ variant[i++] = *variant_chars;
+ variant_chars++;
}
}
-static inline bool isAlpha(const std::string& str) {
+static inline bool is_alpha(const std::string& str) {
return std::all_of(std::begin(str), std::end(str), ::isalpha);
}
-static inline bool isNumber(const std::string& str) {
+static inline bool is_number(const std::string& str) {
return std::all_of(std::begin(str), std::end(str), ::isdigit);
}
-bool LocaleValue::initFromFilterString(const StringPiece& str) {
+bool LocaleValue::InitFromFilterString(const StringPiece& str) {
// A locale (as specified in the filter) is an underscore separated name such
// as "en_US", "en_Latn_US", or "en_US_POSIX".
- std::vector<std::string> parts = util::splitAndLowercase(str, '_');
+ std::vector<std::string> parts = util::SplitAndLowercase(str, '_');
- const int numTags = parts.size();
+ const int num_tags = parts.size();
bool valid = false;
- if (numTags >= 1) {
+ if (num_tags >= 1) {
const std::string& lang = parts[0];
- if (isAlpha(lang) && (lang.length() == 2 || lang.length() == 3)) {
- setLanguage(lang.c_str());
+ if (is_alpha(lang) && (lang.length() == 2 || lang.length() == 3)) {
+ set_language(lang.c_str());
valid = true;
}
}
- if (!valid || numTags == 1) {
+ if (!valid || num_tags == 1) {
return valid;
}
// At this point, valid == true && numTags > 1.
const std::string& part2 = parts[1];
- if ((part2.length() == 2 && isAlpha(part2)) ||
- (part2.length() == 3 && isNumber(part2))) {
- setRegion(part2.c_str());
- } else if (part2.length() == 4 && isAlpha(part2)) {
- setScript(part2.c_str());
+ if ((part2.length() == 2 && is_alpha(part2)) ||
+ (part2.length() == 3 && is_number(part2))) {
+ set_region(part2.c_str());
+ } else if (part2.length() == 4 && is_alpha(part2)) {
+ set_script(part2.c_str());
} else if (part2.length() >= 4 && part2.length() <= 8) {
- setVariant(part2.c_str());
+ set_variant(part2.c_str());
} else {
valid = false;
}
- if (!valid || numTags == 2) {
+ if (!valid || num_tags == 2) {
return valid;
}
// At this point, valid == true && numTags > 1.
const std::string& part3 = parts[2];
- if (((part3.length() == 2 && isAlpha(part3)) ||
- (part3.length() == 3 && isNumber(part3))) &&
+ if (((part3.length() == 2 && is_alpha(part3)) ||
+ (part3.length() == 3 && is_number(part3))) &&
script[0]) {
- setRegion(part3.c_str());
+ set_region(part3.c_str());
} else if (part3.length() >= 4 && part3.length() <= 8) {
- setVariant(part3.c_str());
+ set_variant(part3.c_str());
} else {
valid = false;
}
- if (!valid || numTags == 3) {
+ if (!valid || num_tags == 3) {
return valid;
}
const std::string& part4 = parts[3];
if (part4.length() >= 4 && part4.length() <= 8) {
- setVariant(part4.c_str());
+ set_variant(part4.c_str());
} else {
valid = false;
}
- if (!valid || numTags > 4) {
+ if (!valid || num_tags > 4) {
return false;
}
return true;
}
-ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
+ssize_t LocaleValue::InitFromParts(std::vector<std::string>::iterator iter,
std::vector<std::string>::iterator end) {
- const std::vector<std::string>::iterator startIter = iter;
+ const std::vector<std::string>::iterator start_iter = iter;
std::string& part = *iter;
if (part[0] == 'b' && part[1] == '+') {
// This is a "modified" BCP 47 language tag. Same semantics as BCP 47 tags,
// except that the separator is "+" and not "-".
- std::vector<std::string> subtags = util::splitAndLowercase(part, '+');
+ std::vector<std::string> subtags = util::SplitAndLowercase(part, '+');
subtags.erase(subtags.begin());
if (subtags.size() == 1) {
- setLanguage(subtags[0].c_str());
+ set_language(subtags[0].c_str());
} else if (subtags.size() == 2) {
- setLanguage(subtags[0].c_str());
+ set_language(subtags[0].c_str());
// The second tag can either be a region, a variant or a script.
switch (subtags[1].size()) {
case 2:
case 3:
- setRegion(subtags[1].c_str());
+ set_region(subtags[1].c_str());
break;
case 4:
if ('0' <= subtags[1][0] && subtags[1][0] <= '9') {
// This is a variant: fall through
} else {
- setScript(subtags[1].c_str());
+ set_script(subtags[1].c_str());
break;
}
case 5:
case 6:
case 7:
case 8:
- setVariant(subtags[1].c_str());
+ set_variant(subtags[1].c_str());
break;
default:
return -1;
}
} else if (subtags.size() == 3) {
// The language is always the first subtag.
- setLanguage(subtags[0].c_str());
+ set_language(subtags[0].c_str());
// The second subtag can either be a script or a region code.
// If its size is 4, it's a script code, else it's a region code.
if (subtags[1].size() == 4) {
- setScript(subtags[1].c_str());
+ set_script(subtags[1].c_str());
} else if (subtags[1].size() == 2 || subtags[1].size() == 3) {
- setRegion(subtags[1].c_str());
+ set_region(subtags[1].c_str());
} else {
return -1;
}
@@ -190,15 +192,15 @@
// The third tag can either be a region code (if the second tag was
// a script), else a variant code.
if (subtags[2].size() >= 4) {
- setVariant(subtags[2].c_str());
+ set_variant(subtags[2].c_str());
} else {
- setRegion(subtags[2].c_str());
+ set_region(subtags[2].c_str());
}
} else if (subtags.size() == 4) {
- setLanguage(subtags[0].c_str());
- setScript(subtags[1].c_str());
- setRegion(subtags[2].c_str());
- setVariant(subtags[3].c_str());
+ set_language(subtags[0].c_str());
+ set_script(subtags[1].c_str());
+ set_region(subtags[2].c_str());
+ set_variant(subtags[3].c_str());
} else {
return -1;
}
@@ -206,25 +208,25 @@
++iter;
} else {
- if ((part.length() == 2 || part.length() == 3) && isAlpha(part) &&
+ if ((part.length() == 2 || part.length() == 3) && is_alpha(part) &&
part != "car") {
- setLanguage(part.c_str());
+ set_language(part.c_str());
++iter;
if (iter != end) {
- const std::string& regionPart = *iter;
- if (regionPart.c_str()[0] == 'r' && regionPart.length() == 3) {
- setRegion(regionPart.c_str() + 1);
+ const std::string& region_part = *iter;
+ if (region_part.c_str()[0] == 'r' && region_part.length() == 3) {
+ set_region(region_part.c_str() + 1);
++iter;
}
}
}
}
- return static_cast<ssize_t>(iter - startIter);
+ return static_cast<ssize_t>(iter - start_iter);
}
-void LocaleValue::initFromResTable(const ResTable_config& config) {
+void LocaleValue::InitFromResTable(const ResTable_config& config) {
config.unpackLanguage(language);
config.unpackRegion(region);
if (config.localeScript[0] && !config.localeScriptWasComputed) {
@@ -236,7 +238,7 @@
}
}
-void LocaleValue::writeTo(ResTable_config* out) const {
+void LocaleValue::WriteTo(ResTable_config* out) const {
out->packLanguage(language);
out->packRegion(region);
diff --git a/tools/aapt2/Locale.h b/tools/aapt2/Locale.h
index 0f75850..fc6c448 100644
--- a/tools/aapt2/Locale.h
+++ b/tools/aapt2/Locale.h
@@ -17,12 +17,13 @@
#ifndef AAPT_LOCALE_VALUE_H
#define AAPT_LOCALE_VALUE_H
-#include "util/StringPiece.h"
-
-#include <androidfw/ResourceTypes.h>
#include <string>
#include <vector>
+#include "androidfw/ResourceTypes.h"
+
+#include "util/StringPiece.h"
+
namespace aapt {
/**
@@ -39,23 +40,23 @@
/**
* Initialize this LocaleValue from a config string.
*/
- bool initFromFilterString(const StringPiece& config);
+ bool InitFromFilterString(const StringPiece& config);
/**
* Initialize this LocaleValue from parts of a vector.
*/
- ssize_t initFromParts(std::vector<std::string>::iterator iter,
+ ssize_t InitFromParts(std::vector<std::string>::iterator iter,
std::vector<std::string>::iterator end);
/**
* Initialize this LocaleValue from a ResTable_config.
*/
- void initFromResTable(const android::ResTable_config& config);
+ void InitFromResTable(const android::ResTable_config& config);
/**
* Set the locale in a ResTable_config from this LocaleValue.
*/
- void writeTo(android::ResTable_config* out) const;
+ void WriteTo(android::ResTable_config* out) const;
inline int compare(const LocaleValue& other) const;
@@ -67,10 +68,10 @@
inline bool operator>(const LocaleValue& o) const;
private:
- void setLanguage(const char* language);
- void setRegion(const char* language);
- void setScript(const char* script);
- void setVariant(const char* variant);
+ void set_language(const char* language);
+ void set_region(const char* language);
+ void set_script(const char* script);
+ void set_variant(const char* variant);
};
//
diff --git a/tools/aapt2/Locale_test.cpp b/tools/aapt2/Locale_test.cpp
index b82d2b9..68b4cae 100644
--- a/tools/aapt2/Locale_test.cpp
+++ b/tools/aapt2/Locale_test.cpp
@@ -15,18 +15,20 @@
*/
#include "Locale.h"
-#include "util/Util.h"
-#include <gtest/gtest.h>
#include <string>
+#include "gtest/gtest.h"
+
+#include "util/Util.h"
+
namespace aapt {
static ::testing::AssertionResult TestLanguage(const char* input,
const char* lang) {
- std::vector<std::string> parts = util::splitAndLowercase(input, '-');
+ std::vector<std::string> parts = util::SplitAndLowercase(input, '-');
LocaleValue lv;
- ssize_t count = lv.initFromParts(std::begin(parts), std::end(parts));
+ ssize_t count = lv.InitFromParts(std::begin(parts), std::end(parts));
if (count < 0) {
return ::testing::AssertionFailure() << " failed to parse '" << input
<< "'.";
@@ -51,9 +53,9 @@
static ::testing::AssertionResult TestLanguageRegion(const char* input,
const char* lang,
const char* region) {
- std::vector<std::string> parts = util::splitAndLowercase(input, '-');
+ std::vector<std::string> parts = util::SplitAndLowercase(input, '-');
LocaleValue lv;
- ssize_t count = lv.initFromParts(std::begin(parts), std::end(parts));
+ ssize_t count = lv.InitFromParts(std::begin(parts), std::end(parts));
if (count < 0) {
return ::testing::AssertionFailure() << " failed to parse '" << input
<< "'.";
diff --git a/tools/aapt2/Main.cpp b/tools/aapt2/Main.cpp
index 8aedd44..8dd176d 100644
--- a/tools/aapt2/Main.cpp
+++ b/tools/aapt2/Main.cpp
@@ -14,11 +14,11 @@
* limitations under the License.
*/
-#include "util/StringPiece.h"
-
#include <iostream>
#include <vector>
+#include "util/StringPiece.h"
+
namespace aapt {
// DO NOT UPDATE, this is more of a marketing version.
@@ -27,16 +27,16 @@
// Update minor version whenever a feature or flag is added.
static const char* sMinorVersion = "2";
-int printVersion() {
+int PrintVersion() {
std::cerr << "Android Asset Packaging Tool (aapt) " << sMajorVersion << "."
<< sMinorVersion << std::endl;
return 0;
}
-extern int compile(const std::vector<StringPiece>& args);
-extern int link(const std::vector<StringPiece>& args);
-extern int dump(const std::vector<StringPiece>& args);
-extern int diff(const std::vector<StringPiece>& args);
+extern int Compile(const std::vector<StringPiece>& args);
+extern int Link(const std::vector<StringPiece>& args);
+extern int Dump(const std::vector<StringPiece>& args);
+extern int Diff(const std::vector<StringPiece>& args);
} // namespace aapt
@@ -52,15 +52,15 @@
aapt::StringPiece command(argv[0]);
if (command == "compile" || command == "c") {
- return aapt::compile(args);
+ return aapt::Compile(args);
} else if (command == "link" || command == "l") {
- return aapt::link(args);
+ return aapt::Link(args);
} else if (command == "dump" || command == "d") {
- return aapt::dump(args);
+ return aapt::Dump(args);
} else if (command == "diff") {
- return aapt::diff(args);
+ return aapt::Diff(args);
} else if (command == "version") {
- return aapt::printVersion();
+ return aapt::PrintVersion();
}
std::cerr << "unknown command '" << command << "'\n";
} else {
diff --git a/tools/aapt2/NameMangler.h b/tools/aapt2/NameMangler.h
index 6d244aa..dba2d09 100644
--- a/tools/aapt2/NameMangler.h
+++ b/tools/aapt2/NameMangler.h
@@ -17,12 +17,12 @@
#ifndef AAPT_NAME_MANGLER_H
#define AAPT_NAME_MANGLER_H
-#include "Resource.h"
-#include "util/Maybe.h"
-
#include <set>
#include <string>
+#include "Resource.h"
+#include "util/Maybe.h"
+
namespace aapt {
struct NameManglerPolicy {
@@ -31,37 +31,35 @@
* to this package are not mangled, and mangled references inherit this
* package name.
*/
- std::string targetPackageName;
+ std::string target_package_name;
/**
* We must know which references to mangle, and which to keep (android vs.
* com.android.support).
*/
- std::set<std::string> packagesToMangle;
+ std::set<std::string> packages_to_mangle;
};
class NameMangler {
- private:
- NameManglerPolicy mPolicy;
-
public:
- explicit NameMangler(NameManglerPolicy policy) : mPolicy(policy) {}
+ explicit NameMangler(NameManglerPolicy policy) : policy_(policy) {}
- Maybe<ResourceName> mangleName(const ResourceName& name) {
- if (mPolicy.targetPackageName == name.package ||
- mPolicy.packagesToMangle.count(name.package) == 0) {
+ Maybe<ResourceName> MangleName(const ResourceName& name) {
+ if (policy_.target_package_name == name.package ||
+ policy_.packages_to_mangle.count(name.package) == 0) {
return {};
}
- std::string mangledEntryName = mangleEntry(name.package, name.entry);
- return ResourceName(mPolicy.targetPackageName, name.type, mangledEntryName);
+ std::string mangled_entry_name = MangleEntry(name.package, name.entry);
+ return ResourceName(policy_.target_package_name, name.type,
+ mangled_entry_name);
}
- bool shouldMangle(const std::string& package) const {
- if (package.empty() || mPolicy.targetPackageName == package) {
+ bool ShouldMangle(const std::string& package) const {
+ if (package.empty() || policy_.target_package_name == package) {
return false;
}
- return mPolicy.packagesToMangle.count(package) != 0;
+ return policy_.packages_to_mangle.count(package) != 0;
}
/**
@@ -69,7 +67,7 @@
* The mangled name should contain symbols that are illegal to define in XML,
* so that there will never be name mangling collisions.
*/
- static std::string mangleEntry(const std::string& package,
+ static std::string MangleEntry(const std::string& package,
const std::string& name) {
return package + "$" + name;
}
@@ -79,16 +77,20 @@
* and the package in `outPackage`. Returns true if the name was unmangled or
* false if the name was never mangled to begin with.
*/
- static bool unmangle(std::string* outName, std::string* outPackage) {
- size_t pivot = outName->find('$');
+ static bool Unmangle(std::string* out_name, std::string* out_package) {
+ size_t pivot = out_name->find('$');
if (pivot == std::string::npos) {
return false;
}
- outPackage->assign(outName->data(), pivot);
- outName->assign(outName->data() + pivot + 1, outName->size() - (pivot + 1));
+ out_package->assign(out_name->data(), pivot);
+ out_name->assign(out_name->data() + pivot + 1,
+ out_name->size() - (pivot + 1));
return true;
}
+
+ private:
+ NameManglerPolicy policy_;
};
} // namespace aapt
diff --git a/tools/aapt2/NameMangler_test.cpp b/tools/aapt2/NameMangler_test.cpp
index b02986d..bc89b5c 100644
--- a/tools/aapt2/NameMangler_test.cpp
+++ b/tools/aapt2/NameMangler_test.cpp
@@ -15,31 +15,32 @@
*/
#include "NameMangler.h"
-#include "test/Test.h"
#include <string>
+#include "test/Test.h"
+
namespace aapt {
TEST(NameManglerTest, MangleName) {
std::string package = "android.appcompat";
std::string name = "Platform.AppCompat";
- std::string mangledName = NameMangler::mangleEntry(package, name);
- EXPECT_EQ(mangledName, "android.appcompat$Platform.AppCompat");
+ std::string mangled_name = NameMangler::MangleEntry(package, name);
+ EXPECT_EQ(mangled_name, "android.appcompat$Platform.AppCompat");
- std::string unmangledPackage;
- std::string unmangledName = mangledName;
- ASSERT_TRUE(NameMangler::unmangle(&unmangledName, &unmangledPackage));
- EXPECT_EQ(unmangledName, "Platform.AppCompat");
- EXPECT_EQ(unmangledPackage, "android.appcompat");
+ std::string unmangled_package;
+ std::string unmangled_name = mangled_name;
+ ASSERT_TRUE(NameMangler::Unmangle(&unmangled_name, &unmangled_package));
+ EXPECT_EQ(unmangled_name, "Platform.AppCompat");
+ EXPECT_EQ(unmangled_package, "android.appcompat");
}
TEST(NameManglerTest, IgnoreUnmangledName) {
std::string package;
std::string name = "foo_bar";
- EXPECT_FALSE(NameMangler::unmangle(&name, &package));
+ EXPECT_FALSE(NameMangler::Unmangle(&name, &package));
EXPECT_EQ(name, "foo_bar");
}
diff --git a/tools/aapt2/Resource.cpp b/tools/aapt2/Resource.cpp
index 6805631..1d414743 100644
--- a/tools/aapt2/Resource.cpp
+++ b/tools/aapt2/Resource.cpp
@@ -15,14 +15,13 @@
*/
#include "Resource.h"
-#include "util/StringPiece.h"
#include <map>
#include <string>
namespace aapt {
-StringPiece toString(ResourceType type) {
+StringPiece ToString(ResourceType type) {
switch (type) {
case ResourceType::kAnim:
return "anim";
@@ -100,7 +99,7 @@
{"xml", ResourceType::kXml},
};
-const ResourceType* parseResourceType(const StringPiece& str) {
+const ResourceType* ParseResourceType(const StringPiece& str) {
auto iter = sResourceTypeMap.find(str);
if (iter == std::end(sResourceTypeMap)) {
return nullptr;
diff --git a/tools/aapt2/Resource.h b/tools/aapt2/Resource.h
index 30739db..78acb70 100644
--- a/tools/aapt2/Resource.h
+++ b/tools/aapt2/Resource.h
@@ -17,12 +17,6 @@
#ifndef AAPT_RESOURCE_H
#define AAPT_RESOURCE_H
-#include "ConfigDescription.h"
-#include "Source.h"
-#include "util/StringPiece.h"
-
-#include <utils/JenkinsHash.h>
-
#include <iomanip>
#include <limits>
#include <sstream>
@@ -30,6 +24,12 @@
#include <tuple>
#include <vector>
+#include "utils/JenkinsHash.h"
+
+#include "ConfigDescription.h"
+#include "Source.h"
+#include "util/StringPiece.h"
+
namespace aapt {
/**
@@ -62,13 +62,13 @@
kXml,
};
-StringPiece toString(ResourceType type);
+StringPiece ToString(ResourceType type);
/**
* Returns a pointer to a valid ResourceType, or nullptr if
* the string was invalid.
*/
-const ResourceType* parseResourceType(const StringPiece& str);
+const ResourceType* ParseResourceType(const StringPiece& str);
/**
* A resource's name. This can uniquely identify
@@ -76,16 +76,16 @@
*/
struct ResourceName {
std::string package;
- ResourceType type;
+ ResourceType type = ResourceType::kRaw;
std::string entry;
- ResourceName() : type(ResourceType::kRaw) {}
+ ResourceName() = default;
ResourceName(const StringPiece& p, ResourceType t, const StringPiece& e);
int compare(const ResourceName& other) const;
- bool isValid() const;
- std::string toString() const;
+ bool is_valid() const;
+ std::string ToString() const;
};
/**
@@ -96,7 +96,7 @@
*/
struct ResourceNameRef {
StringPiece package;
- ResourceType type;
+ ResourceType type = ResourceType::kRaw;
StringPiece entry;
ResourceNameRef() = default;
@@ -108,8 +108,8 @@
ResourceNameRef& operator=(ResourceNameRef&& rhs) = default;
ResourceNameRef& operator=(const ResourceName& rhs);
- ResourceName toResourceName() const;
- bool isValid() const;
+ ResourceName ToResourceName() const;
+ bool is_valid() const;
};
/**
@@ -128,13 +128,13 @@
ResourceId();
ResourceId(const ResourceId& rhs);
- ResourceId(uint32_t resId); // NOLINT(implicit)
+ ResourceId(uint32_t res_id); // NOLINT(implicit)
ResourceId(uint8_t p, uint8_t t, uint16_t e);
- bool isValid() const;
- uint8_t packageId() const;
- uint8_t typeId() const;
- uint16_t entryId() const;
+ bool is_valid() const;
+ uint8_t package_id() const;
+ uint8_t type_id() const;
+ uint16_t entry_id() const;
};
struct SourcedResourceName {
@@ -153,7 +153,7 @@
Source source;
// Exported symbols
- std::vector<SourcedResourceName> exportedSymbols;
+ std::vector<SourcedResourceName> exported_symbols;
};
/**
@@ -196,24 +196,24 @@
inline ResourceId::ResourceId(const ResourceId& rhs) : id(rhs.id) {}
-inline ResourceId::ResourceId(uint32_t resId) : id(resId) {}
+inline ResourceId::ResourceId(uint32_t res_id) : id(res_id) {}
inline ResourceId::ResourceId(uint8_t p, uint8_t t, uint16_t e)
: id((p << 24) | (t << 16) | e) {}
-inline bool ResourceId::isValid() const {
+inline bool ResourceId::is_valid() const {
return (id & 0xff000000u) != 0 && (id & 0x00ff0000u) != 0;
}
-inline uint8_t ResourceId::packageId() const {
+inline uint8_t ResourceId::package_id() const {
return static_cast<uint8_t>(id >> 24);
}
-inline uint8_t ResourceId::typeId() const {
+inline uint8_t ResourceId::type_id() const {
return static_cast<uint8_t>(id >> 16);
}
-inline uint16_t ResourceId::entryId() const {
+inline uint16_t ResourceId::entry_id() const {
return static_cast<uint16_t>(id);
}
@@ -234,13 +234,13 @@
}
inline ::std::ostream& operator<<(::std::ostream& out,
- const ResourceId& resId) {
- std::ios_base::fmtflags oldFlags = out.flags();
- char oldFill = out.fill();
+ const ResourceId& res_id) {
+ std::ios_base::fmtflags old_flags = out.flags();
+ char old_fill = out.fill();
out << "0x" << std::internal << std::setfill('0') << std::setw(8) << std::hex
- << resId.id;
- out.flags(oldFlags);
- out.fill(oldFill);
+ << res_id.id;
+ out.flags(old_flags);
+ out.fill(old_fill);
return out;
}
@@ -250,7 +250,7 @@
inline ::std::ostream& operator<<(::std::ostream& out,
const ResourceType& val) {
- return out << toString(val);
+ return out << ToString(val);
}
//
@@ -259,7 +259,7 @@
inline ResourceName::ResourceName(const StringPiece& p, ResourceType t,
const StringPiece& e)
- : package(p.toString()), type(t), entry(e.toString()) {}
+ : package(p.ToString()), type(t), entry(e.ToString()) {}
inline int ResourceName::compare(const ResourceName& other) const {
int cmp = package.compare(other.package);
@@ -270,7 +270,7 @@
return cmp;
}
-inline bool ResourceName::isValid() const {
+inline bool ResourceName::is_valid() const {
return !package.empty() && !entry.empty();
}
@@ -297,7 +297,7 @@
return out << name.type << "/" << name.entry;
}
-inline std::string ResourceName::toString() const {
+inline std::string ResourceName::ToString() const {
std::stringstream stream;
stream << *this;
return stream.str();
@@ -321,11 +321,11 @@
return *this;
}
-inline ResourceName ResourceNameRef::toResourceName() const {
+inline ResourceName ResourceNameRef::ToResourceName() const {
return ResourceName(package, type, entry);
}
-inline bool ResourceNameRef::isValid() const {
+inline bool ResourceNameRef::is_valid() const {
return !package.empty() && !entry.empty();
}
diff --git a/tools/aapt2/ResourceParser.cpp b/tools/aapt2/ResourceParser.cpp
index 7d50e1d..b16def4 100644
--- a/tools/aapt2/ResourceParser.cpp
+++ b/tools/aapt2/ResourceParser.cpp
@@ -15,6 +15,12 @@
*/
#include "ResourceParser.h"
+
+#include <functional>
+#include <sstream>
+
+#include "android-base/logging.h"
+
#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
@@ -23,9 +29,6 @@
#include "util/Util.h"
#include "xml/XmlPullParser.h"
-#include <functional>
-#include <sstream>
-
namespace aapt {
constexpr const char* sXliffNamespaceUri =
@@ -35,12 +38,12 @@
* Returns true if the element is <skip> or <eat-comment> and can be safely
* ignored.
*/
-static bool shouldIgnoreElement(const StringPiece& ns,
+static bool ShouldIgnoreElement(const StringPiece& ns,
const StringPiece& name) {
return ns.empty() && (name == "skip" || name == "eat-comment");
}
-static uint32_t parseFormatType(const StringPiece& piece) {
+static uint32_t ParseFormatType(const StringPiece& piece) {
if (piece == "reference")
return android::ResTable_map::TYPE_REFERENCE;
else if (piece == "string")
@@ -64,11 +67,11 @@
return 0;
}
-static uint32_t parseFormatAttribute(const StringPiece& str) {
+static uint32_t ParseFormatAttribute(const StringPiece& str) {
uint32_t mask = 0;
- for (StringPiece part : util::tokenize(str, '|')) {
- StringPiece trimmedPart = util::trimWhitespace(part);
- uint32_t type = parseFormatType(trimmedPart);
+ for (StringPiece part : util::Tokenize(str, '|')) {
+ StringPiece trimmed_part = util::TrimWhitespace(part);
+ uint32_t type = ParseFormatType(trimmed_part);
if (type == 0) {
return 0;
}
@@ -86,45 +89,45 @@
std::string product;
Source source;
ResourceId id;
- Maybe<SymbolState> symbolState;
+ Maybe<SymbolState> symbol_state;
std::string comment;
std::unique_ptr<Value> value;
- std::list<ParsedResource> childResources;
+ std::list<ParsedResource> child_resources;
};
// Recursively adds resources to the ResourceTable.
-static bool addResourcesToTable(ResourceTable* table, IDiagnostics* diag,
+static bool AddResourcesToTable(ResourceTable* table, IDiagnostics* diag,
ParsedResource* res) {
- StringPiece trimmedComment = util::trimWhitespace(res->comment);
- if (trimmedComment.size() != res->comment.size()) {
+ StringPiece trimmed_comment = util::TrimWhitespace(res->comment);
+ if (trimmed_comment.size() != res->comment.size()) {
// Only if there was a change do we re-assign.
- res->comment = trimmedComment.toString();
+ res->comment = trimmed_comment.ToString();
}
- if (res->symbolState) {
+ if (res->symbol_state) {
Symbol symbol;
- symbol.state = res->symbolState.value();
+ symbol.state = res->symbol_state.value();
symbol.source = res->source;
symbol.comment = res->comment;
- if (!table->setSymbolState(res->name, res->id, symbol, diag)) {
+ if (!table->SetSymbolState(res->name, res->id, symbol, diag)) {
return false;
}
}
if (res->value) {
// Attach the comment, source and config to the value.
- res->value->setComment(std::move(res->comment));
- res->value->setSource(std::move(res->source));
+ res->value->SetComment(std::move(res->comment));
+ res->value->SetSource(std::move(res->source));
- if (!table->addResource(res->name, res->id, res->config, res->product,
+ if (!table->AddResource(res->name, res->id, res->config, res->product,
std::move(res->value), diag)) {
return false;
}
}
bool error = false;
- for (ParsedResource& child : res->childResources) {
- error |= !addResourcesToTable(table, diag, &child);
+ for (ParsedResource& child : res->child_resources) {
+ error |= !AddResourcesToTable(table, diag, &child);
}
return !error;
}
@@ -136,29 +139,29 @@
const Source& source,
const ConfigDescription& config,
const ResourceParserOptions& options)
- : mDiag(diag),
- mTable(table),
- mSource(source),
- mConfig(config),
- mOptions(options) {}
+ : diag_(diag),
+ table_(table),
+ source_(source),
+ config_(config),
+ options_(options) {}
/**
* Build a string from XML that converts nested elements into Span objects.
*/
-bool ResourceParser::flattenXmlSubtree(xml::XmlPullParser* parser,
- std::string* outRawString,
- StyleString* outStyleString) {
- std::vector<Span> spanStack;
+bool ResourceParser::FlattenXmlSubtree(xml::XmlPullParser* parser,
+ std::string* out_raw_string,
+ StyleString* out_style_string) {
+ std::vector<Span> span_stack;
bool error = false;
- outRawString->clear();
- outStyleString->spans.clear();
+ out_raw_string->clear();
+ out_style_string->spans.clear();
util::StringBuilder builder;
size_t depth = 1;
- while (xml::XmlPullParser::isGoodEvent(parser->next())) {
- const xml::XmlPullParser::Event event = parser->getEvent();
+ while (xml::XmlPullParser::IsGoodEvent(parser->Next())) {
+ const xml::XmlPullParser::Event event = parser->event();
if (event == xml::XmlPullParser::Event::kEndElement) {
- if (!parser->getElementNamespace().empty()) {
+ if (!parser->element_namespace().empty()) {
// We already warned and skipped the start element, so just skip here
// too
continue;
@@ -169,150 +172,151 @@
break;
}
- spanStack.back().lastChar = builder.utf16Len() - 1;
- outStyleString->spans.push_back(spanStack.back());
- spanStack.pop_back();
+ span_stack.back().last_char = builder.Utf16Len() - 1;
+ out_style_string->spans.push_back(span_stack.back());
+ span_stack.pop_back();
} else if (event == xml::XmlPullParser::Event::kText) {
- outRawString->append(parser->getText());
- builder.append(parser->getText());
+ out_raw_string->append(parser->text());
+ builder.Append(parser->text());
} else if (event == xml::XmlPullParser::Event::kStartElement) {
- if (!parser->getElementNamespace().empty()) {
- if (parser->getElementNamespace() != sXliffNamespaceUri) {
+ if (!parser->element_namespace().empty()) {
+ if (parser->element_namespace() != sXliffNamespaceUri) {
// Only warn if this isn't an xliff namespace.
- mDiag->warn(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "skipping element '" << parser->getElementName()
+ diag_->Warn(DiagMessage(source_.WithLine(parser->line_number()))
+ << "skipping element '" << parser->element_name()
<< "' with unknown namespace '"
- << parser->getElementNamespace() << "'");
+ << parser->element_namespace() << "'");
}
continue;
}
depth++;
// Build a span object out of the nested element.
- std::string spanName = parser->getElementName();
- const auto endAttrIter = parser->endAttributes();
- for (auto attrIter = parser->beginAttributes(); attrIter != endAttrIter;
- ++attrIter) {
- spanName += ";";
- spanName += attrIter->name;
- spanName += "=";
- spanName += attrIter->value;
+ std::string span_name = parser->element_name();
+ const auto end_attr_iter = parser->end_attributes();
+ for (auto attr_iter = parser->begin_attributes();
+ attr_iter != end_attr_iter; ++attr_iter) {
+ span_name += ";";
+ span_name += attr_iter->name;
+ span_name += "=";
+ span_name += attr_iter->value;
}
- if (builder.utf16Len() > std::numeric_limits<uint32_t>::max()) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "style string '" << builder.str() << "' is too long");
+ if (builder.Utf16Len() > std::numeric_limits<uint32_t>::max()) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << "style string '" << builder.ToString()
+ << "' is too long");
error = true;
} else {
- spanStack.push_back(
- Span{spanName, static_cast<uint32_t>(builder.utf16Len())});
+ span_stack.push_back(
+ Span{span_name, static_cast<uint32_t>(builder.Utf16Len())});
}
} else if (event == xml::XmlPullParser::Event::kComment) {
// Skip
} else {
- assert(false);
+ LOG(FATAL) << "unhandled XML event";
}
}
- assert(spanStack.empty() && "spans haven't been fully processed");
+ CHECK(span_stack.empty()) << "spans haven't been fully processed";
- outStyleString->str = builder.str();
+ out_style_string->str = builder.ToString();
return !error;
}
-bool ResourceParser::parse(xml::XmlPullParser* parser) {
+bool ResourceParser::Parse(xml::XmlPullParser* parser) {
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Skip comments and text.
continue;
}
- if (!parser->getElementNamespace().empty() ||
- parser->getElementName() != "resources") {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+ if (!parser->element_namespace().empty() ||
+ parser->element_name() != "resources") {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
<< "root element must be <resources>");
return false;
}
- error |= !parseResources(parser);
+ error |= !ParseResources(parser);
break;
};
- if (parser->getEvent() == xml::XmlPullParser::Event::kBadDocument) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "xml parser error: " << parser->getLastError());
+ if (parser->event() == xml::XmlPullParser::Event::kBadDocument) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << "xml parser error: " << parser->error());
return false;
}
return !error;
}
-bool ResourceParser::parseResources(xml::XmlPullParser* parser) {
- std::set<ResourceName> strippedResources;
+bool ResourceParser::ParseResources(xml::XmlPullParser* parser) {
+ std::set<ResourceName> stripped_resources;
bool error = false;
std::string comment;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- const xml::XmlPullParser::Event event = parser->getEvent();
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ const xml::XmlPullParser::Event event = parser->event();
if (event == xml::XmlPullParser::Event::kComment) {
- comment = parser->getComment();
+ comment = parser->comment();
continue;
}
if (event == xml::XmlPullParser::Event::kText) {
- if (!util::trimWhitespace(parser->getText()).empty()) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+ if (!util::TrimWhitespace(parser->text()).empty()) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
<< "plain text not allowed here");
error = true;
}
continue;
}
- assert(event == xml::XmlPullParser::Event::kStartElement);
+ CHECK(event == xml::XmlPullParser::Event::kStartElement);
- if (!parser->getElementNamespace().empty()) {
+ if (!parser->element_namespace().empty()) {
// Skip unknown namespace.
continue;
}
- std::string elementName = parser->getElementName();
- if (elementName == "skip" || elementName == "eat-comment") {
+ std::string element_name = parser->element_name();
+ if (element_name == "skip" || element_name == "eat-comment") {
comment = "";
continue;
}
- ParsedResource parsedResource;
- parsedResource.config = mConfig;
- parsedResource.source = mSource.withLine(parser->getLineNumber());
- parsedResource.comment = std::move(comment);
+ ParsedResource parsed_resource;
+ parsed_resource.config = config_;
+ parsed_resource.source = source_.WithLine(parser->line_number());
+ parsed_resource.comment = std::move(comment);
// Extract the product name if it exists.
- if (Maybe<StringPiece> maybeProduct =
- xml::findNonEmptyAttribute(parser, "product")) {
- parsedResource.product = maybeProduct.value().toString();
+ if (Maybe<StringPiece> maybe_product =
+ xml::FindNonEmptyAttribute(parser, "product")) {
+ parsed_resource.product = maybe_product.value().ToString();
}
// Parse the resource regardless of product.
- if (!parseResource(parser, &parsedResource)) {
+ if (!ParseResource(parser, &parsed_resource)) {
error = true;
continue;
}
- if (!addResourcesToTable(mTable, mDiag, &parsedResource)) {
+ if (!AddResourcesToTable(table_, diag_, &parsed_resource)) {
error = true;
}
}
// Check that we included at least one variant of each stripped resource.
- for (const ResourceName& strippedResource : strippedResources) {
- if (!mTable->findResource(strippedResource)) {
+ for (const ResourceName& stripped_resource : stripped_resources) {
+ if (!table_->FindResource(stripped_resource)) {
// Failed to find the resource.
- mDiag->error(DiagMessage(mSource)
- << "resource '" << strippedResource
+ diag_->Error(DiagMessage(source_)
+ << "resource '" << stripped_resource
<< "' "
"was filtered out but no product variant remains");
error = true;
@@ -322,8 +326,8 @@
return !error;
}
-bool ResourceParser::parseResource(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
+bool ResourceParser::ParseResource(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
struct ItemTypeFormat {
ResourceType type;
uint32_t format;
@@ -333,7 +337,7 @@
ParsedResource*)>;
static const auto elToItemMap =
- ImmutableMap<std::string, ItemTypeFormat>::createPreSorted({
+ ImmutableMap<std::string, ItemTypeFormat>::CreatePreSorted({
{"bool", {ResourceType::kBool, android::ResTable_map::TYPE_BOOLEAN}},
{"color", {ResourceType::kColor, android::ResTable_map::TYPE_COLOR}},
{"dimen",
@@ -354,48 +358,49 @@
});
static const auto elToBagMap =
- ImmutableMap<std::string, BagParseFunc>::createPreSorted({
- {"add-resource", std::mem_fn(&ResourceParser::parseAddResource)},
- {"array", std::mem_fn(&ResourceParser::parseArray)},
- {"attr", std::mem_fn(&ResourceParser::parseAttr)},
+ ImmutableMap<std::string, BagParseFunc>::CreatePreSorted({
+ {"add-resource", std::mem_fn(&ResourceParser::ParseAddResource)},
+ {"array", std::mem_fn(&ResourceParser::ParseArray)},
+ {"attr", std::mem_fn(&ResourceParser::ParseAttr)},
{"declare-styleable",
- std::mem_fn(&ResourceParser::parseDeclareStyleable)},
- {"integer-array", std::mem_fn(&ResourceParser::parseIntegerArray)},
- {"java-symbol", std::mem_fn(&ResourceParser::parseSymbol)},
- {"plurals", std::mem_fn(&ResourceParser::parsePlural)},
- {"public", std::mem_fn(&ResourceParser::parsePublic)},
- {"public-group", std::mem_fn(&ResourceParser::parsePublicGroup)},
- {"string-array", std::mem_fn(&ResourceParser::parseStringArray)},
- {"style", std::mem_fn(&ResourceParser::parseStyle)},
- {"symbol", std::mem_fn(&ResourceParser::parseSymbol)},
+ std::mem_fn(&ResourceParser::ParseDeclareStyleable)},
+ {"integer-array", std::mem_fn(&ResourceParser::ParseIntegerArray)},
+ {"java-symbol", std::mem_fn(&ResourceParser::ParseSymbol)},
+ {"plurals", std::mem_fn(&ResourceParser::ParsePlural)},
+ {"public", std::mem_fn(&ResourceParser::ParsePublic)},
+ {"public-group", std::mem_fn(&ResourceParser::ParsePublicGroup)},
+ {"string-array", std::mem_fn(&ResourceParser::ParseStringArray)},
+ {"style", std::mem_fn(&ResourceParser::ParseStyle)},
+ {"symbol", std::mem_fn(&ResourceParser::ParseSymbol)},
});
- std::string resourceType = parser->getElementName();
+ std::string resource_type = parser->element_name();
// The value format accepted for this resource.
- uint32_t resourceFormat = 0u;
+ uint32_t resource_format = 0u;
- if (resourceType == "item") {
+ if (resource_type == "item") {
// Items have their type encoded in the type attribute.
- if (Maybe<StringPiece> maybeType =
- xml::findNonEmptyAttribute(parser, "type")) {
- resourceType = maybeType.value().toString();
+ if (Maybe<StringPiece> maybe_type =
+ xml::FindNonEmptyAttribute(parser, "type")) {
+ resource_type = maybe_type.value().ToString();
} else {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
<< "<item> must have a 'type' attribute");
return false;
}
- if (Maybe<StringPiece> maybeFormat =
- xml::findNonEmptyAttribute(parser, "format")) {
+ if (Maybe<StringPiece> maybe_format =
+ xml::FindNonEmptyAttribute(parser, "format")) {
// An explicit format for this resource was specified. The resource will
// retain
// its type in its name, but the accepted value for this type is
// overridden.
- resourceFormat = parseFormatType(maybeFormat.value());
- if (!resourceFormat) {
- mDiag->error(DiagMessage(outResource->source)
- << "'" << maybeFormat.value() << "' is an invalid format");
+ resource_format = ParseFormatType(maybe_format.value());
+ if (!resource_format) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "'" << maybe_format.value()
+ << "' is an invalid format");
return false;
}
}
@@ -403,65 +408,65 @@
// Get the name of the resource. This will be checked later, because not all
// XML elements require a name.
- Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
+ Maybe<StringPiece> maybe_name = xml::FindNonEmptyAttribute(parser, "name");
- if (resourceType == "id") {
- if (!maybeName) {
- mDiag->error(DiagMessage(outResource->source)
- << "<" << parser->getElementName()
+ if (resource_type == "id") {
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "<" << parser->element_name()
<< "> missing 'name' attribute");
return false;
}
- outResource->name.type = ResourceType::kId;
- outResource->name.entry = maybeName.value().toString();
- outResource->value = util::make_unique<Id>();
+ out_resource->name.type = ResourceType::kId;
+ out_resource->name.entry = maybe_name.value().ToString();
+ out_resource->value = util::make_unique<Id>();
return true;
}
- const auto itemIter = elToItemMap.find(resourceType);
- if (itemIter != elToItemMap.end()) {
+ const auto item_iter = elToItemMap.find(resource_type);
+ if (item_iter != elToItemMap.end()) {
// This is an item, record its type and format and start parsing.
- if (!maybeName) {
- mDiag->error(DiagMessage(outResource->source)
- << "<" << parser->getElementName()
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "<" << parser->element_name()
<< "> missing 'name' attribute");
return false;
}
- outResource->name.type = itemIter->second.type;
- outResource->name.entry = maybeName.value().toString();
+ out_resource->name.type = item_iter->second.type;
+ out_resource->name.entry = maybe_name.value().ToString();
// Only use the implicit format for this type if it wasn't overridden.
- if (!resourceFormat) {
- resourceFormat = itemIter->second.format;
+ if (!resource_format) {
+ resource_format = item_iter->second.format;
}
- if (!parseItem(parser, outResource, resourceFormat)) {
+ if (!ParseItem(parser, out_resource, resource_format)) {
return false;
}
return true;
}
// This might be a bag or something.
- const auto bagIter = elToBagMap.find(resourceType);
- if (bagIter != elToBagMap.end()) {
+ const auto bag_iter = elToBagMap.find(resource_type);
+ if (bag_iter != elToBagMap.end()) {
// Ensure we have a name (unless this is a <public-group>).
- if (resourceType != "public-group") {
- if (!maybeName) {
- mDiag->error(DiagMessage(outResource->source)
- << "<" << parser->getElementName()
+ if (resource_type != "public-group") {
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "<" << parser->element_name()
<< "> missing 'name' attribute");
return false;
}
- outResource->name.entry = maybeName.value().toString();
+ out_resource->name.entry = maybe_name.value().ToString();
}
// Call the associated parse method. The type will be filled in by the
// parse func.
- if (!bagIter->second(this, parser, outResource)) {
+ if (!bag_iter->second(this, parser, out_resource)) {
return false;
}
return true;
@@ -469,44 +474,44 @@
// Try parsing the elementName (or type) as a resource. These shall only be
// resources like 'layout' or 'xml' and they can only be references.
- const ResourceType* parsedType = parseResourceType(resourceType);
- if (parsedType) {
- if (!maybeName) {
- mDiag->error(DiagMessage(outResource->source)
- << "<" << parser->getElementName()
+ const ResourceType* parsed_type = ParseResourceType(resource_type);
+ if (parsed_type) {
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "<" << parser->element_name()
<< "> missing 'name' attribute");
return false;
}
- outResource->name.type = *parsedType;
- outResource->name.entry = maybeName.value().toString();
- outResource->value =
- parseXml(parser, android::ResTable_map::TYPE_REFERENCE, kNoRawString);
- if (!outResource->value) {
- mDiag->error(DiagMessage(outResource->source)
- << "invalid value for type '" << *parsedType
+ out_resource->name.type = *parsed_type;
+ out_resource->name.entry = maybe_name.value().ToString();
+ out_resource->value =
+ ParseXml(parser, android::ResTable_map::TYPE_REFERENCE, kNoRawString);
+ if (!out_resource->value) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "invalid value for type '" << *parsed_type
<< "'. Expected a reference");
return false;
}
return true;
}
- mDiag->warn(DiagMessage(outResource->source)
- << "unknown resource type '" << parser->getElementName() << "'");
+ diag_->Warn(DiagMessage(out_resource->source)
+ << "unknown resource type '" << parser->element_name() << "'");
return false;
}
-bool ResourceParser::parseItem(xml::XmlPullParser* parser,
- ParsedResource* outResource,
+bool ResourceParser::ParseItem(xml::XmlPullParser* parser,
+ ParsedResource* out_resource,
const uint32_t format) {
if (format == android::ResTable_map::TYPE_STRING) {
- return parseString(parser, outResource);
+ return ParseString(parser, out_resource);
}
- outResource->value = parseXml(parser, format, kNoRawString);
- if (!outResource->value) {
- mDiag->error(DiagMessage(outResource->source) << "invalid "
- << outResource->name.type);
+ out_resource->value = ParseXml(parser, format, kNoRawString);
+ if (!out_resource->value) {
+ diag_->Error(DiagMessage(out_resource->source) << "invalid "
+ << out_resource->name.type);
return false;
}
return true;
@@ -519,362 +524,364 @@
* an Item. If allowRawValue is false, nullptr is returned in this
* case.
*/
-std::unique_ptr<Item> ResourceParser::parseXml(xml::XmlPullParser* parser,
- const uint32_t typeMask,
- const bool allowRawValue) {
- const size_t beginXmlLine = parser->getLineNumber();
+std::unique_ptr<Item> ResourceParser::ParseXml(xml::XmlPullParser* parser,
+ const uint32_t type_mask,
+ const bool allow_raw_value) {
+ const size_t begin_xml_line = parser->line_number();
- std::string rawValue;
- StyleString styleString;
- if (!flattenXmlSubtree(parser, &rawValue, &styleString)) {
+ std::string raw_value;
+ StyleString style_string;
+ if (!FlattenXmlSubtree(parser, &raw_value, &style_string)) {
return {};
}
- if (!styleString.spans.empty()) {
+ if (!style_string.spans.empty()) {
// This can only be a StyledString.
- return util::make_unique<StyledString>(mTable->stringPool.makeRef(
- styleString,
- StringPool::Context(StringPool::Context::kStylePriority, mConfig)));
+ return util::make_unique<StyledString>(table_->string_pool.MakeRef(
+ style_string,
+ StringPool::Context(StringPool::Context::kStylePriority, config_)));
}
- auto onCreateReference = [&](const ResourceName& name) {
+ auto on_create_reference = [&](const ResourceName& name) {
// name.package can be empty here, as it will assume the package name of the
// table.
std::unique_ptr<Id> id = util::make_unique<Id>();
- id->setSource(mSource.withLine(beginXmlLine));
- mTable->addResource(name, {}, {}, std::move(id), mDiag);
+ id->SetSource(source_.WithLine(begin_xml_line));
+ table_->AddResource(name, {}, {}, std::move(id), diag_);
};
// Process the raw value.
- std::unique_ptr<Item> processedItem = ResourceUtils::tryParseItemForAttribute(
- rawValue, typeMask, onCreateReference);
- if (processedItem) {
+ std::unique_ptr<Item> processed_item =
+ ResourceUtils::TryParseItemForAttribute(raw_value, type_mask,
+ on_create_reference);
+ if (processed_item) {
// Fix up the reference.
- if (Reference* ref = valueCast<Reference>(processedItem.get())) {
- transformReferenceFromNamespace(parser, "", ref);
+ if (Reference* ref = ValueCast<Reference>(processed_item.get())) {
+ TransformReferenceFromNamespace(parser, "", ref);
}
- return processedItem;
+ return processed_item;
}
// Try making a regular string.
- if (typeMask & android::ResTable_map::TYPE_STRING) {
+ if (type_mask & android::ResTable_map::TYPE_STRING) {
// Use the trimmed, escaped string.
- return util::make_unique<String>(mTable->stringPool.makeRef(
- styleString.str, StringPool::Context(mConfig)));
+ return util::make_unique<String>(table_->string_pool.MakeRef(
+ style_string.str, StringPool::Context(config_)));
}
- if (allowRawValue) {
+ if (allow_raw_value) {
// We can't parse this so return a RawString if we are allowed.
return util::make_unique<RawString>(
- mTable->stringPool.makeRef(rawValue, StringPool::Context(mConfig)));
+ table_->string_pool.MakeRef(raw_value, StringPool::Context(config_)));
}
return {};
}
-bool ResourceParser::parseString(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
+bool ResourceParser::ParseString(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
bool formatted = true;
- if (Maybe<StringPiece> formattedAttr =
- xml::findAttribute(parser, "formatted")) {
- Maybe<bool> maybeFormatted =
- ResourceUtils::parseBool(formattedAttr.value());
- if (!maybeFormatted) {
- mDiag->error(DiagMessage(outResource->source)
+ if (Maybe<StringPiece> formatted_attr =
+ xml::FindAttribute(parser, "formatted")) {
+ Maybe<bool> maybe_formatted =
+ ResourceUtils::ParseBool(formatted_attr.value());
+ if (!maybe_formatted) {
+ diag_->Error(DiagMessage(out_resource->source)
<< "invalid value for 'formatted'. Must be a boolean");
return false;
}
- formatted = maybeFormatted.value();
+ formatted = maybe_formatted.value();
}
- bool translateable = mOptions.translatable;
- if (Maybe<StringPiece> translateableAttr =
- xml::findAttribute(parser, "translatable")) {
- Maybe<bool> maybeTranslateable =
- ResourceUtils::parseBool(translateableAttr.value());
- if (!maybeTranslateable) {
- mDiag->error(DiagMessage(outResource->source)
+ bool translateable = options_.translatable;
+ if (Maybe<StringPiece> translateable_attr =
+ xml::FindAttribute(parser, "translatable")) {
+ Maybe<bool> maybe_translateable =
+ ResourceUtils::ParseBool(translateable_attr.value());
+ if (!maybe_translateable) {
+ diag_->Error(DiagMessage(out_resource->source)
<< "invalid value for 'translatable'. Must be a boolean");
return false;
}
- translateable = maybeTranslateable.value();
+ translateable = maybe_translateable.value();
}
- outResource->value =
- parseXml(parser, android::ResTable_map::TYPE_STRING, kNoRawString);
- if (!outResource->value) {
- mDiag->error(DiagMessage(outResource->source) << "not a valid string");
+ out_resource->value =
+ ParseXml(parser, android::ResTable_map::TYPE_STRING, kNoRawString);
+ if (!out_resource->value) {
+ diag_->Error(DiagMessage(out_resource->source) << "not a valid string");
return false;
}
- if (String* stringValue = valueCast<String>(outResource->value.get())) {
- stringValue->setTranslateable(translateable);
+ if (String* string_value = ValueCast<String>(out_resource->value.get())) {
+ string_value->SetTranslateable(translateable);
if (formatted && translateable) {
- if (!util::verifyJavaStringFormat(*stringValue->value)) {
- DiagMessage msg(outResource->source);
+ if (!util::VerifyJavaStringFormat(*string_value->value)) {
+ DiagMessage msg(out_resource->source);
msg << "multiple substitutions specified in non-positional format; "
"did you mean to add the formatted=\"false\" attribute?";
- if (mOptions.errorOnPositionalArguments) {
- mDiag->error(msg);
+ if (options_.error_on_positional_arguments) {
+ diag_->Error(msg);
return false;
}
- mDiag->warn(msg);
+ diag_->Warn(msg);
}
}
- } else if (StyledString* stringValue =
- valueCast<StyledString>(outResource->value.get())) {
- stringValue->setTranslateable(translateable);
+ } else if (StyledString* string_value =
+ ValueCast<StyledString>(out_resource->value.get())) {
+ string_value->SetTranslateable(translateable);
}
return true;
}
-bool ResourceParser::parsePublic(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- Maybe<StringPiece> maybeType = xml::findNonEmptyAttribute(parser, "type");
- if (!maybeType) {
- mDiag->error(DiagMessage(outResource->source)
+bool ResourceParser::ParsePublic(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ Maybe<StringPiece> maybe_type = xml::FindNonEmptyAttribute(parser, "type");
+ if (!maybe_type) {
+ diag_->Error(DiagMessage(out_resource->source)
<< "<public> must have a 'type' attribute");
return false;
}
- const ResourceType* parsedType = parseResourceType(maybeType.value());
- if (!parsedType) {
- mDiag->error(DiagMessage(outResource->source) << "invalid resource type '"
- << maybeType.value()
- << "' in <public>");
+ const ResourceType* parsed_type = ParseResourceType(maybe_type.value());
+ if (!parsed_type) {
+ diag_->Error(DiagMessage(out_resource->source) << "invalid resource type '"
+ << maybe_type.value()
+ << "' in <public>");
return false;
}
- outResource->name.type = *parsedType;
+ out_resource->name.type = *parsed_type;
- if (Maybe<StringPiece> maybeIdStr =
- xml::findNonEmptyAttribute(parser, "id")) {
- Maybe<ResourceId> maybeId =
- ResourceUtils::parseResourceId(maybeIdStr.value());
- if (!maybeId) {
- mDiag->error(DiagMessage(outResource->source) << "invalid resource ID '"
- << maybeId.value()
- << "' in <public>");
+ if (Maybe<StringPiece> maybe_id_str =
+ xml::FindNonEmptyAttribute(parser, "id")) {
+ Maybe<ResourceId> maybe_id =
+ ResourceUtils::ParseResourceId(maybe_id_str.value());
+ if (!maybe_id) {
+ diag_->Error(DiagMessage(out_resource->source) << "invalid resource ID '"
+ << maybe_id.value()
+ << "' in <public>");
return false;
}
- outResource->id = maybeId.value();
+ out_resource->id = maybe_id.value();
}
- if (*parsedType == ResourceType::kId) {
+ if (*parsed_type == ResourceType::kId) {
// An ID marked as public is also the definition of an ID.
- outResource->value = util::make_unique<Id>();
+ out_resource->value = util::make_unique<Id>();
}
- outResource->symbolState = SymbolState::kPublic;
+ out_resource->symbol_state = SymbolState::kPublic;
return true;
}
-bool ResourceParser::parsePublicGroup(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- Maybe<StringPiece> maybeType = xml::findNonEmptyAttribute(parser, "type");
- if (!maybeType) {
- mDiag->error(DiagMessage(outResource->source)
+bool ResourceParser::ParsePublicGroup(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ Maybe<StringPiece> maybe_type = xml::FindNonEmptyAttribute(parser, "type");
+ if (!maybe_type) {
+ diag_->Error(DiagMessage(out_resource->source)
<< "<public-group> must have a 'type' attribute");
return false;
}
- const ResourceType* parsedType = parseResourceType(maybeType.value());
- if (!parsedType) {
- mDiag->error(DiagMessage(outResource->source) << "invalid resource type '"
- << maybeType.value()
- << "' in <public-group>");
+ const ResourceType* parsed_type = ParseResourceType(maybe_type.value());
+ if (!parsed_type) {
+ diag_->Error(DiagMessage(out_resource->source) << "invalid resource type '"
+ << maybe_type.value()
+ << "' in <public-group>");
return false;
}
- Maybe<StringPiece> maybeIdStr =
- xml::findNonEmptyAttribute(parser, "first-id");
- if (!maybeIdStr) {
- mDiag->error(DiagMessage(outResource->source)
+ Maybe<StringPiece> maybe_id_str =
+ xml::FindNonEmptyAttribute(parser, "first-id");
+ if (!maybe_id_str) {
+ diag_->Error(DiagMessage(out_resource->source)
<< "<public-group> must have a 'first-id' attribute");
return false;
}
- Maybe<ResourceId> maybeId =
- ResourceUtils::parseResourceId(maybeIdStr.value());
- if (!maybeId) {
- mDiag->error(DiagMessage(outResource->source) << "invalid resource ID '"
- << maybeIdStr.value()
- << "' in <public-group>");
+ Maybe<ResourceId> maybe_id =
+ ResourceUtils::ParseResourceId(maybe_id_str.value());
+ if (!maybe_id) {
+ diag_->Error(DiagMessage(out_resource->source) << "invalid resource ID '"
+ << maybe_id_str.value()
+ << "' in <public-group>");
return false;
}
- ResourceId nextId = maybeId.value();
+ ResourceId next_id = maybe_id.value();
std::string comment;
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() == xml::XmlPullParser::Event::kComment) {
- comment = util::trimWhitespace(parser->getComment()).toString();
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() == xml::XmlPullParser::Event::kComment) {
+ comment = util::TrimWhitespace(parser->comment()).ToString();
continue;
- } else if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ } else if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Skip text.
continue;
}
- const Source itemSource = mSource.withLine(parser->getLineNumber());
- const std::string& elementNamespace = parser->getElementNamespace();
- const std::string& elementName = parser->getElementName();
- if (elementNamespace.empty() && elementName == "public") {
- Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
- if (!maybeName) {
- mDiag->error(DiagMessage(itemSource)
+ const Source item_source = source_.WithLine(parser->line_number());
+ const std::string& element_namespace = parser->element_namespace();
+ const std::string& element_name = parser->element_name();
+ if (element_namespace.empty() && element_name == "public") {
+ Maybe<StringPiece> maybe_name =
+ xml::FindNonEmptyAttribute(parser, "name");
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(item_source)
<< "<public> must have a 'name' attribute");
error = true;
continue;
}
- if (xml::findNonEmptyAttribute(parser, "id")) {
- mDiag->error(DiagMessage(itemSource)
+ if (xml::FindNonEmptyAttribute(parser, "id")) {
+ diag_->Error(DiagMessage(item_source)
<< "'id' is ignored within <public-group>");
error = true;
continue;
}
- if (xml::findNonEmptyAttribute(parser, "type")) {
- mDiag->error(DiagMessage(itemSource)
+ if (xml::FindNonEmptyAttribute(parser, "type")) {
+ diag_->Error(DiagMessage(item_source)
<< "'type' is ignored within <public-group>");
error = true;
continue;
}
- ParsedResource childResource;
- childResource.name.type = *parsedType;
- childResource.name.entry = maybeName.value().toString();
- childResource.id = nextId;
- childResource.comment = std::move(comment);
- childResource.source = itemSource;
- childResource.symbolState = SymbolState::kPublic;
- outResource->childResources.push_back(std::move(childResource));
+ ParsedResource child_resource;
+ child_resource.name.type = *parsed_type;
+ child_resource.name.entry = maybe_name.value().ToString();
+ child_resource.id = next_id;
+ child_resource.comment = std::move(comment);
+ child_resource.source = item_source;
+ child_resource.symbol_state = SymbolState::kPublic;
+ out_resource->child_resources.push_back(std::move(child_resource));
- nextId.id += 1;
+ next_id.id += 1;
- } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
- mDiag->error(DiagMessage(itemSource) << ":" << elementName << ">");
+ } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+ diag_->Error(DiagMessage(item_source) << ":" << element_name << ">");
error = true;
}
}
return !error;
}
-bool ResourceParser::parseSymbolImpl(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- Maybe<StringPiece> maybeType = xml::findNonEmptyAttribute(parser, "type");
- if (!maybeType) {
- mDiag->error(DiagMessage(outResource->source)
- << "<" << parser->getElementName()
+bool ResourceParser::ParseSymbolImpl(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ Maybe<StringPiece> maybe_type = xml::FindNonEmptyAttribute(parser, "type");
+ if (!maybe_type) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "<" << parser->element_name()
<< "> must have a 'type' attribute");
return false;
}
- const ResourceType* parsedType = parseResourceType(maybeType.value());
- if (!parsedType) {
- mDiag->error(DiagMessage(outResource->source)
- << "invalid resource type '" << maybeType.value() << "' in <"
- << parser->getElementName() << ">");
+ const ResourceType* parsed_type = ParseResourceType(maybe_type.value());
+ if (!parsed_type) {
+ diag_->Error(DiagMessage(out_resource->source)
+ << "invalid resource type '" << maybe_type.value() << "' in <"
+ << parser->element_name() << ">");
return false;
}
- outResource->name.type = *parsedType;
+ out_resource->name.type = *parsed_type;
return true;
}
-bool ResourceParser::parseSymbol(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- if (parseSymbolImpl(parser, outResource)) {
- outResource->symbolState = SymbolState::kPrivate;
+bool ResourceParser::ParseSymbol(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ if (ParseSymbolImpl(parser, out_resource)) {
+ out_resource->symbol_state = SymbolState::kPrivate;
return true;
}
return false;
}
-bool ResourceParser::parseAddResource(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- if (parseSymbolImpl(parser, outResource)) {
- outResource->symbolState = SymbolState::kUndefined;
+bool ResourceParser::ParseAddResource(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ if (ParseSymbolImpl(parser, out_resource)) {
+ out_resource->symbol_state = SymbolState::kUndefined;
return true;
}
return false;
}
-bool ResourceParser::parseAttr(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- return parseAttrImpl(parser, outResource, false);
+bool ResourceParser::ParseAttr(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ return ParseAttrImpl(parser, out_resource, false);
}
-bool ResourceParser::parseAttrImpl(xml::XmlPullParser* parser,
- ParsedResource* outResource, bool weak) {
- outResource->name.type = ResourceType::kAttr;
+bool ResourceParser::ParseAttrImpl(xml::XmlPullParser* parser,
+ ParsedResource* out_resource, bool weak) {
+ out_resource->name.type = ResourceType::kAttr;
// Attributes only end up in default configuration.
- if (outResource->config != ConfigDescription::defaultConfig()) {
- mDiag->warn(DiagMessage(outResource->source)
- << "ignoring configuration '" << outResource->config
- << "' for attribute " << outResource->name);
- outResource->config = ConfigDescription::defaultConfig();
+ if (out_resource->config != ConfigDescription::DefaultConfig()) {
+ diag_->Warn(DiagMessage(out_resource->source)
+ << "ignoring configuration '" << out_resource->config
+ << "' for attribute " << out_resource->name);
+ out_resource->config = ConfigDescription::DefaultConfig();
}
- uint32_t typeMask = 0;
+ uint32_t type_mask = 0;
- Maybe<StringPiece> maybeFormat = xml::findAttribute(parser, "format");
- if (maybeFormat) {
- typeMask = parseFormatAttribute(maybeFormat.value());
- if (typeMask == 0) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "invalid attribute format '" << maybeFormat.value()
+ Maybe<StringPiece> maybe_format = xml::FindAttribute(parser, "format");
+ if (maybe_format) {
+ type_mask = ParseFormatAttribute(maybe_format.value());
+ if (type_mask == 0) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << "invalid attribute format '" << maybe_format.value()
<< "'");
return false;
}
}
- Maybe<int32_t> maybeMin, maybeMax;
+ Maybe<int32_t> maybe_min, maybe_max;
- if (Maybe<StringPiece> maybeMinStr = xml::findAttribute(parser, "min")) {
- StringPiece minStr = util::trimWhitespace(maybeMinStr.value());
- if (!minStr.empty()) {
- std::u16string minStr16 = util::utf8ToUtf16(minStr);
+ if (Maybe<StringPiece> maybe_min_str = xml::FindAttribute(parser, "min")) {
+ StringPiece min_str = util::TrimWhitespace(maybe_min_str.value());
+ if (!min_str.empty()) {
+ std::u16string min_str16 = util::Utf8ToUtf16(min_str);
android::Res_value value;
- if (android::ResTable::stringToInt(minStr16.data(), minStr16.size(),
+ if (android::ResTable::stringToInt(min_str16.data(), min_str16.size(),
&value)) {
- maybeMin = static_cast<int32_t>(value.data);
+ maybe_min = static_cast<int32_t>(value.data);
}
}
- if (!maybeMin) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "invalid 'min' value '" << minStr << "'");
+ if (!maybe_min) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << "invalid 'min' value '" << min_str << "'");
return false;
}
}
- if (Maybe<StringPiece> maybeMaxStr = xml::findAttribute(parser, "max")) {
- StringPiece maxStr = util::trimWhitespace(maybeMaxStr.value());
- if (!maxStr.empty()) {
- std::u16string maxStr16 = util::utf8ToUtf16(maxStr);
+ if (Maybe<StringPiece> maybe_max_str = xml::FindAttribute(parser, "max")) {
+ StringPiece max_str = util::TrimWhitespace(maybe_max_str.value());
+ if (!max_str.empty()) {
+ std::u16string max_str16 = util::Utf8ToUtf16(max_str);
android::Res_value value;
- if (android::ResTable::stringToInt(maxStr16.data(), maxStr16.size(),
+ if (android::ResTable::stringToInt(max_str16.data(), max_str16.size(),
&value)) {
- maybeMax = static_cast<int32_t>(value.data);
+ maybe_max = static_cast<int32_t>(value.data);
}
}
- if (!maybeMax) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "invalid 'max' value '" << maxStr << "'");
+ if (!maybe_max) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << "invalid 'max' value '" << max_str << "'");
return false;
}
}
- if ((maybeMin || maybeMax) &&
- (typeMask & android::ResTable_map::TYPE_INTEGER) == 0) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
+ if ((maybe_min || maybe_max) &&
+ (type_mask & android::ResTable_map::TYPE_INTEGER) == 0) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
<< "'min' and 'max' can only be used when format='integer'");
return false;
}
@@ -889,68 +896,68 @@
std::string comment;
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() == xml::XmlPullParser::Event::kComment) {
- comment = util::trimWhitespace(parser->getComment()).toString();
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() == xml::XmlPullParser::Event::kComment) {
+ comment = util::TrimWhitespace(parser->comment()).ToString();
continue;
- } else if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ } else if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Skip text.
continue;
}
- const Source itemSource = mSource.withLine(parser->getLineNumber());
- const std::string& elementNamespace = parser->getElementNamespace();
- const std::string& elementName = parser->getElementName();
- if (elementNamespace.empty() &&
- (elementName == "flag" || elementName == "enum")) {
- if (elementName == "enum") {
- if (typeMask & android::ResTable_map::TYPE_FLAGS) {
- mDiag->error(DiagMessage(itemSource)
+ const Source item_source = source_.WithLine(parser->line_number());
+ const std::string& element_namespace = parser->element_namespace();
+ const std::string& element_name = parser->element_name();
+ if (element_namespace.empty() &&
+ (element_name == "flag" || element_name == "enum")) {
+ if (element_name == "enum") {
+ if (type_mask & android::ResTable_map::TYPE_FLAGS) {
+ diag_->Error(DiagMessage(item_source)
<< "can not define an <enum>; already defined a <flag>");
error = true;
continue;
}
- typeMask |= android::ResTable_map::TYPE_ENUM;
+ type_mask |= android::ResTable_map::TYPE_ENUM;
- } else if (elementName == "flag") {
- if (typeMask & android::ResTable_map::TYPE_ENUM) {
- mDiag->error(DiagMessage(itemSource)
+ } else if (element_name == "flag") {
+ if (type_mask & android::ResTable_map::TYPE_ENUM) {
+ diag_->Error(DiagMessage(item_source)
<< "can not define a <flag>; already defined an <enum>");
error = true;
continue;
}
- typeMask |= android::ResTable_map::TYPE_FLAGS;
+ type_mask |= android::ResTable_map::TYPE_FLAGS;
}
if (Maybe<Attribute::Symbol> s =
- parseEnumOrFlagItem(parser, elementName)) {
+ ParseEnumOrFlagItem(parser, element_name)) {
Attribute::Symbol& symbol = s.value();
- ParsedResource childResource;
- childResource.name = symbol.symbol.name.value();
- childResource.source = itemSource;
- childResource.value = util::make_unique<Id>();
- outResource->childResources.push_back(std::move(childResource));
+ ParsedResource child_resource;
+ child_resource.name = symbol.symbol.name.value();
+ child_resource.source = item_source;
+ child_resource.value = util::make_unique<Id>();
+ out_resource->child_resources.push_back(std::move(child_resource));
- symbol.symbol.setComment(std::move(comment));
- symbol.symbol.setSource(itemSource);
+ symbol.symbol.SetComment(std::move(comment));
+ symbol.symbol.SetSource(item_source);
- auto insertResult = items.insert(std::move(symbol));
- if (!insertResult.second) {
- const Attribute::Symbol& existingSymbol = *insertResult.first;
- mDiag->error(DiagMessage(itemSource)
+ auto insert_result = items.insert(std::move(symbol));
+ if (!insert_result.second) {
+ const Attribute::Symbol& existing_symbol = *insert_result.first;
+ diag_->Error(DiagMessage(item_source)
<< "duplicate symbol '"
- << existingSymbol.symbol.name.value().entry << "'");
+ << existing_symbol.symbol.name.value().entry << "'");
- mDiag->note(DiagMessage(existingSymbol.symbol.getSource())
+ diag_->Note(DiagMessage(existing_symbol.symbol.GetSource())
<< "first defined here");
error = true;
}
} else {
error = true;
}
- } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
- mDiag->error(DiagMessage(itemSource) << ":" << elementName << ">");
+ } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+ diag_->Error(DiagMessage(item_source) << ":" << element_name << ">");
error = true;
}
@@ -963,134 +970,134 @@
std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(weak);
attr->symbols = std::vector<Attribute::Symbol>(items.begin(), items.end());
- attr->typeMask =
- typeMask ? typeMask : uint32_t(android::ResTable_map::TYPE_ANY);
- if (maybeMin) {
- attr->minInt = maybeMin.value();
+ attr->type_mask =
+ type_mask ? type_mask : uint32_t(android::ResTable_map::TYPE_ANY);
+ if (maybe_min) {
+ attr->min_int = maybe_min.value();
}
- if (maybeMax) {
- attr->maxInt = maybeMax.value();
+ if (maybe_max) {
+ attr->max_int = maybe_max.value();
}
- outResource->value = std::move(attr);
+ out_resource->value = std::move(attr);
return true;
}
-Maybe<Attribute::Symbol> ResourceParser::parseEnumOrFlagItem(
+Maybe<Attribute::Symbol> ResourceParser::ParseEnumOrFlagItem(
xml::XmlPullParser* parser, const StringPiece& tag) {
- const Source source = mSource.withLine(parser->getLineNumber());
+ const Source source = source_.WithLine(parser->line_number());
- Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
- if (!maybeName) {
- mDiag->error(DiagMessage(source) << "no attribute 'name' found for tag <"
+ Maybe<StringPiece> maybe_name = xml::FindNonEmptyAttribute(parser, "name");
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(source) << "no attribute 'name' found for tag <"
<< tag << ">");
return {};
}
- Maybe<StringPiece> maybeValue = xml::findNonEmptyAttribute(parser, "value");
- if (!maybeValue) {
- mDiag->error(DiagMessage(source) << "no attribute 'value' found for tag <"
+ Maybe<StringPiece> maybe_value = xml::FindNonEmptyAttribute(parser, "value");
+ if (!maybe_value) {
+ diag_->Error(DiagMessage(source) << "no attribute 'value' found for tag <"
<< tag << ">");
return {};
}
- std::u16string value16 = util::utf8ToUtf16(maybeValue.value());
+ std::u16string value16 = util::Utf8ToUtf16(maybe_value.value());
android::Res_value val;
if (!android::ResTable::stringToInt(value16.data(), value16.size(), &val)) {
- mDiag->error(DiagMessage(source) << "invalid value '" << maybeValue.value()
+ diag_->Error(DiagMessage(source) << "invalid value '" << maybe_value.value()
<< "' for <" << tag
<< ">; must be an integer");
return {};
}
return Attribute::Symbol{
- Reference(ResourceNameRef({}, ResourceType::kId, maybeName.value())),
+ Reference(ResourceNameRef({}, ResourceType::kId, maybe_name.value())),
val.data};
}
-bool ResourceParser::parseStyleItem(xml::XmlPullParser* parser, Style* style) {
- const Source source = mSource.withLine(parser->getLineNumber());
+bool ResourceParser::ParseStyleItem(xml::XmlPullParser* parser, Style* style) {
+ const Source source = source_.WithLine(parser->line_number());
- Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
- if (!maybeName) {
- mDiag->error(DiagMessage(source) << "<item> must have a 'name' attribute");
+ Maybe<StringPiece> maybe_name = xml::FindNonEmptyAttribute(parser, "name");
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(source) << "<item> must have a 'name' attribute");
return false;
}
- Maybe<Reference> maybeKey =
- ResourceUtils::parseXmlAttributeName(maybeName.value());
- if (!maybeKey) {
- mDiag->error(DiagMessage(source) << "invalid attribute name '"
- << maybeName.value() << "'");
+ Maybe<Reference> maybe_key =
+ ResourceUtils::ParseXmlAttributeName(maybe_name.value());
+ if (!maybe_key) {
+ diag_->Error(DiagMessage(source) << "invalid attribute name '"
+ << maybe_name.value() << "'");
return false;
}
- transformReferenceFromNamespace(parser, "", &maybeKey.value());
- maybeKey.value().setSource(source);
+ TransformReferenceFromNamespace(parser, "", &maybe_key.value());
+ maybe_key.value().SetSource(source);
- std::unique_ptr<Item> value = parseXml(parser, 0, kAllowRawString);
+ std::unique_ptr<Item> value = ParseXml(parser, 0, kAllowRawString);
if (!value) {
- mDiag->error(DiagMessage(source) << "could not parse style item");
+ diag_->Error(DiagMessage(source) << "could not parse style item");
return false;
}
style->entries.push_back(
- Style::Entry{std::move(maybeKey.value()), std::move(value)});
+ Style::Entry{std::move(maybe_key.value()), std::move(value)});
return true;
}
-bool ResourceParser::parseStyle(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- outResource->name.type = ResourceType::kStyle;
+bool ResourceParser::ParseStyle(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ out_resource->name.type = ResourceType::kStyle;
std::unique_ptr<Style> style = util::make_unique<Style>();
- Maybe<StringPiece> maybeParent = xml::findAttribute(parser, "parent");
- if (maybeParent) {
+ Maybe<StringPiece> maybe_parent = xml::FindAttribute(parser, "parent");
+ if (maybe_parent) {
// If the parent is empty, we don't have a parent, but we also don't infer
// either.
- if (!maybeParent.value().empty()) {
- std::string errStr;
- style->parent = ResourceUtils::parseStyleParentReference(
- maybeParent.value(), &errStr);
+ if (!maybe_parent.value().empty()) {
+ std::string err_str;
+ style->parent = ResourceUtils::ParseStyleParentReference(
+ maybe_parent.value(), &err_str);
if (!style->parent) {
- mDiag->error(DiagMessage(outResource->source) << errStr);
+ diag_->Error(DiagMessage(out_resource->source) << err_str);
return false;
}
// Transform the namespace prefix to the actual package name, and mark the
// reference as
// private if appropriate.
- transformReferenceFromNamespace(parser, "", &style->parent.value());
+ TransformReferenceFromNamespace(parser, "", &style->parent.value());
}
} else {
// No parent was specified, so try inferring it from the style name.
- std::string styleName = outResource->name.entry;
- size_t pos = styleName.find_last_of(u'.');
+ std::string style_name = out_resource->name.entry;
+ size_t pos = style_name.find_last_of(u'.');
if (pos != std::string::npos) {
- style->parentInferred = true;
+ style->parent_inferred = true;
style->parent = Reference(
- ResourceName({}, ResourceType::kStyle, styleName.substr(0, pos)));
+ ResourceName({}, ResourceType::kStyle, style_name.substr(0, pos)));
}
}
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Skip text and comments.
continue;
}
- const std::string& elementNamespace = parser->getElementNamespace();
- const std::string& elementName = parser->getElementName();
- if (elementNamespace == "" && elementName == "item") {
- error |= !parseStyleItem(parser, style.get());
+ const std::string& element_namespace = parser->element_namespace();
+ const std::string& element_name = parser->element_name();
+ if (element_namespace == "" && element_name == "item") {
+ error |= !ParseStyleItem(parser, style.get());
- } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << ":" << elementName << ">");
+ } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << ":" << element_name << ">");
error = true;
}
}
@@ -1099,73 +1106,73 @@
return false;
}
- outResource->value = std::move(style);
+ out_resource->value = std::move(style);
return true;
}
-bool ResourceParser::parseArray(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- return parseArrayImpl(parser, outResource, android::ResTable_map::TYPE_ANY);
+bool ResourceParser::ParseArray(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ return ParseArrayImpl(parser, out_resource, android::ResTable_map::TYPE_ANY);
}
-bool ResourceParser::parseIntegerArray(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- return parseArrayImpl(parser, outResource,
+bool ResourceParser::ParseIntegerArray(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ return ParseArrayImpl(parser, out_resource,
android::ResTable_map::TYPE_INTEGER);
}
-bool ResourceParser::parseStringArray(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- return parseArrayImpl(parser, outResource,
+bool ResourceParser::ParseStringArray(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ return ParseArrayImpl(parser, out_resource,
android::ResTable_map::TYPE_STRING);
}
-bool ResourceParser::parseArrayImpl(xml::XmlPullParser* parser,
- ParsedResource* outResource,
+bool ResourceParser::ParseArrayImpl(xml::XmlPullParser* parser,
+ ParsedResource* out_resource,
const uint32_t typeMask) {
- outResource->name.type = ResourceType::kArray;
+ out_resource->name.type = ResourceType::kArray;
std::unique_ptr<Array> array = util::make_unique<Array>();
- bool translateable = mOptions.translatable;
- if (Maybe<StringPiece> translateableAttr =
- xml::findAttribute(parser, "translatable")) {
- Maybe<bool> maybeTranslateable =
- ResourceUtils::parseBool(translateableAttr.value());
- if (!maybeTranslateable) {
- mDiag->error(DiagMessage(outResource->source)
+ bool translateable = options_.translatable;
+ if (Maybe<StringPiece> translateable_attr =
+ xml::FindAttribute(parser, "translatable")) {
+ Maybe<bool> maybe_translateable =
+ ResourceUtils::ParseBool(translateable_attr.value());
+ if (!maybe_translateable) {
+ diag_->Error(DiagMessage(out_resource->source)
<< "invalid value for 'translatable'. Must be a boolean");
return false;
}
- translateable = maybeTranslateable.value();
+ translateable = maybe_translateable.value();
}
- array->setTranslateable(translateable);
+ array->SetTranslateable(translateable);
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Skip text and comments.
continue;
}
- const Source itemSource = mSource.withLine(parser->getLineNumber());
- const std::string& elementNamespace = parser->getElementNamespace();
- const std::string& elementName = parser->getElementName();
- if (elementNamespace.empty() && elementName == "item") {
- std::unique_ptr<Item> item = parseXml(parser, typeMask, kNoRawString);
+ const Source item_source = source_.WithLine(parser->line_number());
+ const std::string& element_namespace = parser->element_namespace();
+ const std::string& element_name = parser->element_name();
+ if (element_namespace.empty() && element_name == "item") {
+ std::unique_ptr<Item> item = ParseXml(parser, typeMask, kNoRawString);
if (!item) {
- mDiag->error(DiagMessage(itemSource) << "could not parse array item");
+ diag_->Error(DiagMessage(item_source) << "could not parse array item");
error = true;
continue;
}
- item->setSource(itemSource);
+ item->SetSource(item_source);
array->items.emplace_back(std::move(item));
- } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
- mDiag->error(DiagMessage(mSource.withLine(parser->getLineNumber()))
- << "unknown tag <" << elementNamespace << ":" << elementName
- << ">");
+ } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+ diag_->Error(DiagMessage(source_.WithLine(parser->line_number()))
+ << "unknown tag <" << element_namespace << ":"
+ << element_name << ">");
error = true;
}
}
@@ -1174,77 +1181,78 @@
return false;
}
- outResource->value = std::move(array);
+ out_resource->value = std::move(array);
return true;
}
-bool ResourceParser::parsePlural(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- outResource->name.type = ResourceType::kPlurals;
+bool ResourceParser::ParsePlural(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ out_resource->name.type = ResourceType::kPlurals;
std::unique_ptr<Plural> plural = util::make_unique<Plural>();
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Skip text and comments.
continue;
}
- const Source itemSource = mSource.withLine(parser->getLineNumber());
- const std::string& elementNamespace = parser->getElementNamespace();
- const std::string& elementName = parser->getElementName();
- if (elementNamespace.empty() && elementName == "item") {
- Maybe<StringPiece> maybeQuantity =
- xml::findNonEmptyAttribute(parser, "quantity");
- if (!maybeQuantity) {
- mDiag->error(DiagMessage(itemSource)
+ const Source item_source = source_.WithLine(parser->line_number());
+ const std::string& element_namespace = parser->element_namespace();
+ const std::string& element_name = parser->element_name();
+ if (element_namespace.empty() && element_name == "item") {
+ Maybe<StringPiece> maybe_quantity =
+ xml::FindNonEmptyAttribute(parser, "quantity");
+ if (!maybe_quantity) {
+ diag_->Error(DiagMessage(item_source)
<< "<item> in <plurals> requires attribute "
<< "'quantity'");
error = true;
continue;
}
- StringPiece trimmedQuantity = util::trimWhitespace(maybeQuantity.value());
+ StringPiece trimmed_quantity =
+ util::TrimWhitespace(maybe_quantity.value());
size_t index = 0;
- if (trimmedQuantity == "zero") {
+ if (trimmed_quantity == "zero") {
index = Plural::Zero;
- } else if (trimmedQuantity == "one") {
+ } else if (trimmed_quantity == "one") {
index = Plural::One;
- } else if (trimmedQuantity == "two") {
+ } else if (trimmed_quantity == "two") {
index = Plural::Two;
- } else if (trimmedQuantity == "few") {
+ } else if (trimmed_quantity == "few") {
index = Plural::Few;
- } else if (trimmedQuantity == "many") {
+ } else if (trimmed_quantity == "many") {
index = Plural::Many;
- } else if (trimmedQuantity == "other") {
+ } else if (trimmed_quantity == "other") {
index = Plural::Other;
} else {
- mDiag->error(DiagMessage(itemSource)
+ diag_->Error(DiagMessage(item_source)
<< "<item> in <plural> has invalid value '"
- << trimmedQuantity << "' for attribute 'quantity'");
+ << trimmed_quantity << "' for attribute 'quantity'");
error = true;
continue;
}
if (plural->values[index]) {
- mDiag->error(DiagMessage(itemSource) << "duplicate quantity '"
- << trimmedQuantity << "'");
+ diag_->Error(DiagMessage(item_source) << "duplicate quantity '"
+ << trimmed_quantity << "'");
error = true;
continue;
}
- if (!(plural->values[index] = parseXml(
+ if (!(plural->values[index] = ParseXml(
parser, android::ResTable_map::TYPE_STRING, kNoRawString))) {
error = true;
}
- plural->values[index]->setSource(itemSource);
+ plural->values[index]->SetSource(item_source);
- } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
- mDiag->error(DiagMessage(itemSource)
- << "unknown tag <" << elementNamespace << ":" << elementName
- << ">");
+ } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+ diag_->Error(DiagMessage(item_source) << "unknown tag <"
+ << element_namespace << ":"
+ << element_name << ">");
error = true;
}
}
@@ -1253,47 +1261,48 @@
return false;
}
- outResource->value = std::move(plural);
+ out_resource->value = std::move(plural);
return true;
}
-bool ResourceParser::parseDeclareStyleable(xml::XmlPullParser* parser,
- ParsedResource* outResource) {
- outResource->name.type = ResourceType::kStyleable;
+bool ResourceParser::ParseDeclareStyleable(xml::XmlPullParser* parser,
+ ParsedResource* out_resource) {
+ out_resource->name.type = ResourceType::kStyleable;
// Declare-styleable is kPrivate by default, because it technically only
// exists in R.java.
- outResource->symbolState = SymbolState::kPublic;
+ out_resource->symbol_state = SymbolState::kPublic;
// Declare-styleable only ends up in default config;
- if (outResource->config != ConfigDescription::defaultConfig()) {
- mDiag->warn(DiagMessage(outResource->source)
- << "ignoring configuration '" << outResource->config
- << "' for styleable " << outResource->name.entry);
- outResource->config = ConfigDescription::defaultConfig();
+ if (out_resource->config != ConfigDescription::DefaultConfig()) {
+ diag_->Warn(DiagMessage(out_resource->source)
+ << "ignoring configuration '" << out_resource->config
+ << "' for styleable " << out_resource->name.entry);
+ out_resource->config = ConfigDescription::DefaultConfig();
}
std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>();
std::string comment;
bool error = false;
- const size_t depth = parser->getDepth();
- while (xml::XmlPullParser::nextChildNode(parser, depth)) {
- if (parser->getEvent() == xml::XmlPullParser::Event::kComment) {
- comment = util::trimWhitespace(parser->getComment()).toString();
+ const size_t depth = parser->depth();
+ while (xml::XmlPullParser::NextChildNode(parser, depth)) {
+ if (parser->event() == xml::XmlPullParser::Event::kComment) {
+ comment = util::TrimWhitespace(parser->comment()).ToString();
continue;
- } else if (parser->getEvent() != xml::XmlPullParser::Event::kStartElement) {
+ } else if (parser->event() != xml::XmlPullParser::Event::kStartElement) {
// Ignore text.
continue;
}
- const Source itemSource = mSource.withLine(parser->getLineNumber());
- const std::string& elementNamespace = parser->getElementNamespace();
- const std::string& elementName = parser->getElementName();
- if (elementNamespace.empty() && elementName == "attr") {
- Maybe<StringPiece> maybeName = xml::findNonEmptyAttribute(parser, "name");
- if (!maybeName) {
- mDiag->error(DiagMessage(itemSource)
+ const Source item_source = source_.WithLine(parser->line_number());
+ const std::string& element_namespace = parser->element_namespace();
+ const std::string& element_name = parser->element_name();
+ if (element_namespace.empty() && element_name == "attr") {
+ Maybe<StringPiece> maybe_name =
+ xml::FindNonEmptyAttribute(parser, "name");
+ if (!maybe_name) {
+ diag_->Error(DiagMessage(item_source)
<< "<attr> tag must have a 'name' attribute");
error = true;
continue;
@@ -1302,40 +1311,40 @@
// If this is a declaration, the package name may be in the name. Separate
// these out.
// Eg. <attr name="android:text" />
- Maybe<Reference> maybeRef =
- ResourceUtils::parseXmlAttributeName(maybeName.value());
- if (!maybeRef) {
- mDiag->error(DiagMessage(itemSource) << "<attr> tag has invalid name '"
- << maybeName.value() << "'");
+ Maybe<Reference> maybe_ref =
+ ResourceUtils::ParseXmlAttributeName(maybe_name.value());
+ if (!maybe_ref) {
+ diag_->Error(DiagMessage(item_source) << "<attr> tag has invalid name '"
+ << maybe_name.value() << "'");
error = true;
continue;
}
- Reference& childRef = maybeRef.value();
- xml::transformReferenceFromNamespace(parser, "", &childRef);
+ Reference& child_ref = maybe_ref.value();
+ xml::TransformReferenceFromNamespace(parser, "", &child_ref);
// Create the ParsedResource that will add the attribute to the table.
- ParsedResource childResource;
- childResource.name = childRef.name.value();
- childResource.source = itemSource;
- childResource.comment = std::move(comment);
+ ParsedResource child_resource;
+ child_resource.name = child_ref.name.value();
+ child_resource.source = item_source;
+ child_resource.comment = std::move(comment);
- if (!parseAttrImpl(parser, &childResource, true)) {
+ if (!ParseAttrImpl(parser, &child_resource, true)) {
error = true;
continue;
}
// Create the reference to this attribute.
- childRef.setComment(childResource.comment);
- childRef.setSource(itemSource);
- styleable->entries.push_back(std::move(childRef));
+ child_ref.SetComment(child_resource.comment);
+ child_ref.SetSource(item_source);
+ styleable->entries.push_back(std::move(child_ref));
- outResource->childResources.push_back(std::move(childResource));
+ out_resource->child_resources.push_back(std::move(child_resource));
- } else if (!shouldIgnoreElement(elementNamespace, elementName)) {
- mDiag->error(DiagMessage(itemSource)
- << "unknown tag <" << elementNamespace << ":" << elementName
- << ">");
+ } else if (!ShouldIgnoreElement(element_namespace, element_name)) {
+ diag_->Error(DiagMessage(item_source) << "unknown tag <"
+ << element_namespace << ":"
+ << element_name << ">");
error = true;
}
@@ -1346,7 +1355,7 @@
return false;
}
- outResource->value = std::move(styleable);
+ out_resource->value = std::move(styleable);
return true;
}
diff --git a/tools/aapt2/ResourceParser.h b/tools/aapt2/ResourceParser.h
index 644ed49..11b1e5b 100644
--- a/tools/aapt2/ResourceParser.h
+++ b/tools/aapt2/ResourceParser.h
@@ -17,6 +17,10 @@
#ifndef AAPT_RESOURCE_PARSER_H
#define AAPT_RESOURCE_PARSER_H
+#include <memory>
+
+#include "android-base/macros.h"
+
#include "ConfigDescription.h"
#include "Diagnostics.h"
#include "ResourceTable.h"
@@ -26,8 +30,6 @@
#include "util/StringPiece.h"
#include "xml/XmlPullParser.h"
-#include <memory>
-
namespace aapt {
struct ParsedResource;
@@ -42,7 +44,7 @@
* Whether positional arguments in formatted strings are treated as errors or
* warnings.
*/
- bool errorOnPositionalArguments = true;
+ bool error_on_positional_arguments = true;
};
/*
@@ -53,70 +55,71 @@
ResourceParser(IDiagnostics* diag, ResourceTable* table, const Source& source,
const ConfigDescription& config,
const ResourceParserOptions& options = {});
-
- ResourceParser(const ResourceParser&) = delete; // No copy.
-
- bool parse(xml::XmlPullParser* parser);
+ bool Parse(xml::XmlPullParser* parser);
private:
+ DISALLOW_COPY_AND_ASSIGN(ResourceParser);
+
/*
* Parses the XML subtree as a StyleString (flattened XML representation for
* strings
- * with formatting). If successful, `outStyleString`
- * contains the escaped and whitespace trimmed text, while `outRawString`
+ * with formatting). If successful, `out_style_string`
+ * contains the escaped and whitespace trimmed text, while `out_raw_string`
* contains the unescaped text. Returns true on success.
*/
- bool flattenXmlSubtree(xml::XmlPullParser* parser, std::string* outRawString,
- StyleString* outStyleString);
+ bool FlattenXmlSubtree(xml::XmlPullParser* parser,
+ std::string* out_raw_string,
+ StyleString* out_style_string);
/*
* Parses the XML subtree and returns an Item.
- * The type of Item that can be parsed is denoted by the `typeMask`.
- * If `allowRawValue` is true and the subtree can not be parsed as a regular
+ * The type of Item that can be parsed is denoted by the `type_mask`.
+ * If `allow_raw_value` is true and the subtree can not be parsed as a regular
* Item, then a
* RawString is returned. Otherwise this returns false;
*/
- std::unique_ptr<Item> parseXml(xml::XmlPullParser* parser,
- const uint32_t typeMask,
- const bool allowRawValue);
+ std::unique_ptr<Item> ParseXml(xml::XmlPullParser* parser,
+ const uint32_t type_mask,
+ const bool allow_raw_value);
- bool parseResources(xml::XmlPullParser* parser);
- bool parseResource(xml::XmlPullParser* parser, ParsedResource* outResource);
+ bool ParseResources(xml::XmlPullParser* parser);
+ bool ParseResource(xml::XmlPullParser* parser, ParsedResource* out_resource);
- bool parseItem(xml::XmlPullParser* parser, ParsedResource* outResource,
+ bool ParseItem(xml::XmlPullParser* parser, ParsedResource* out_resource,
uint32_t format);
- bool parseString(xml::XmlPullParser* parser, ParsedResource* outResource);
+ bool ParseString(xml::XmlPullParser* parser, ParsedResource* out_resource);
- bool parsePublic(xml::XmlPullParser* parser, ParsedResource* outResource);
- bool parsePublicGroup(xml::XmlPullParser* parser,
- ParsedResource* outResource);
- bool parseSymbolImpl(xml::XmlPullParser* parser, ParsedResource* outResource);
- bool parseSymbol(xml::XmlPullParser* parser, ParsedResource* outResource);
- bool parseAddResource(xml::XmlPullParser* parser,
- ParsedResource* outResource);
- bool parseAttr(xml::XmlPullParser* parser, ParsedResource* outResource);
- bool parseAttrImpl(xml::XmlPullParser* parser, ParsedResource* outResource,
+ bool ParsePublic(xml::XmlPullParser* parser, ParsedResource* out_resource);
+ bool ParsePublicGroup(xml::XmlPullParser* parser,
+ ParsedResource* out_resource);
+ bool ParseSymbolImpl(xml::XmlPullParser* parser,
+ ParsedResource* out_resource);
+ bool ParseSymbol(xml::XmlPullParser* parser, ParsedResource* out_resource);
+ bool ParseAddResource(xml::XmlPullParser* parser,
+ ParsedResource* out_resource);
+ bool ParseAttr(xml::XmlPullParser* parser, ParsedResource* out_resource);
+ bool ParseAttrImpl(xml::XmlPullParser* parser, ParsedResource* out_resource,
bool weak);
- Maybe<Attribute::Symbol> parseEnumOrFlagItem(xml::XmlPullParser* parser,
+ Maybe<Attribute::Symbol> ParseEnumOrFlagItem(xml::XmlPullParser* parser,
const StringPiece& tag);
- bool parseStyle(xml::XmlPullParser* parser, ParsedResource* outResource);
- bool parseStyleItem(xml::XmlPullParser* parser, Style* style);
- bool parseDeclareStyleable(xml::XmlPullParser* parser,
- ParsedResource* outResource);
- bool parseArray(xml::XmlPullParser* parser, ParsedResource* outResource);
- bool parseIntegerArray(xml::XmlPullParser* parser,
- ParsedResource* outResource);
- bool parseStringArray(xml::XmlPullParser* parser,
- ParsedResource* outResource);
- bool parseArrayImpl(xml::XmlPullParser* parser, ParsedResource* outResource,
+ bool ParseStyle(xml::XmlPullParser* parser, ParsedResource* out_resource);
+ bool ParseStyleItem(xml::XmlPullParser* parser, Style* style);
+ bool ParseDeclareStyleable(xml::XmlPullParser* parser,
+ ParsedResource* out_resource);
+ bool ParseArray(xml::XmlPullParser* parser, ParsedResource* out_resource);
+ bool ParseIntegerArray(xml::XmlPullParser* parser,
+ ParsedResource* out_resource);
+ bool ParseStringArray(xml::XmlPullParser* parser,
+ ParsedResource* out_resource);
+ bool ParseArrayImpl(xml::XmlPullParser* parser, ParsedResource* out_resource,
uint32_t typeMask);
- bool parsePlural(xml::XmlPullParser* parser, ParsedResource* outResource);
+ bool ParsePlural(xml::XmlPullParser* parser, ParsedResource* out_resource);
- IDiagnostics* mDiag;
- ResourceTable* mTable;
- Source mSource;
- ConfigDescription mConfig;
- ResourceParserOptions mOptions;
+ IDiagnostics* diag_;
+ ResourceTable* table_;
+ Source source_;
+ ConfigDescription config_;
+ ResourceParserOptions options_;
};
} // namespace aapt
diff --git a/tools/aapt2/ResourceParser_test.cpp b/tools/aapt2/ResourceParser_test.cpp
index b6d57c0..2463911 100644
--- a/tools/aapt2/ResourceParser_test.cpp
+++ b/tools/aapt2/ResourceParser_test.cpp
@@ -15,79 +15,82 @@
*/
#include "ResourceParser.h"
+
+#include <sstream>
+#include <string>
+
#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
#include "test/Test.h"
#include "xml/XmlPullParser.h"
-#include <sstream>
-#include <string>
-
namespace aapt {
constexpr const char* kXmlPreamble =
"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
TEST(ResourceParserSingleTest, FailToParseWithNoRootResourcesElement) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
std::stringstream input(kXmlPreamble);
input << "<attr name=\"foo\"/>" << std::endl;
ResourceTable table;
- ResourceParser parser(context->getDiagnostics(), &table, Source{"test"}, {});
- xml::XmlPullParser xmlParser(input);
- ASSERT_FALSE(parser.parse(&xmlParser));
+ ResourceParser parser(context->GetDiagnostics(), &table, Source{"test"}, {});
+ xml::XmlPullParser xml_parser(input);
+ ASSERT_FALSE(parser.Parse(&xml_parser));
}
-struct ResourceParserTest : public ::testing::Test {
- ResourceTable mTable;
- std::unique_ptr<IAaptContext> mContext;
+class ResourceParserTest : public ::testing::Test {
+ public:
+ void SetUp() override { context_ = test::ContextBuilder().Build(); }
- void SetUp() override { mContext = test::ContextBuilder().build(); }
-
- ::testing::AssertionResult testParse(const StringPiece& str) {
- return testParse(str, ConfigDescription{});
+ ::testing::AssertionResult TestParse(const StringPiece& str) {
+ return TestParse(str, ConfigDescription{});
}
- ::testing::AssertionResult testParse(const StringPiece& str,
+ ::testing::AssertionResult TestParse(const StringPiece& str,
const ConfigDescription& config) {
std::stringstream input(kXmlPreamble);
input << "<resources>\n" << str << "\n</resources>" << std::endl;
ResourceParserOptions parserOptions;
- ResourceParser parser(mContext->getDiagnostics(), &mTable, Source{"test"},
+ ResourceParser parser(context_->GetDiagnostics(), &table_, Source{"test"},
config, parserOptions);
xml::XmlPullParser xmlParser(input);
- if (parser.parse(&xmlParser)) {
+ if (parser.Parse(&xmlParser)) {
return ::testing::AssertionSuccess();
}
return ::testing::AssertionFailure();
}
+
+ protected:
+ ResourceTable table_;
+ std::unique_ptr<IAaptContext> context_;
};
TEST_F(ResourceParserTest, ParseQuotedString) {
std::string input = "<string name=\"foo\"> \" hey there \" </string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* str = test::getValue<String>(&mTable, "string/foo");
+ String* str = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::string(" hey there "), *str->value);
}
TEST_F(ResourceParserTest, ParseEscapedString) {
std::string input = "<string name=\"foo\">\\?123</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* str = test::getValue<String>(&mTable, "string/foo");
+ String* str = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::string("?123"), *str->value);
}
TEST_F(ResourceParserTest, ParseFormattedString) {
std::string input = "<string name=\"foo\">%d %s</string>";
- ASSERT_FALSE(testParse(input));
+ ASSERT_FALSE(TestParse(input));
input = "<string name=\"foo\">%1$d %2$s</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
}
TEST_F(ResourceParserTest, ParseStyledString) {
@@ -96,32 +99,32 @@
// use UTF-16 length and not UTF-18 length.
std::string input =
"<string name=\"foo\">This is my aunt\u2019s <b>string</b></string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- StyledString* str = test::getValue<StyledString>(&mTable, "string/foo");
+ StyledString* str = test::GetValue<StyledString>(&table_, "string/foo");
ASSERT_NE(nullptr, str);
- const std::string expectedStr = "This is my aunt\u2019s string";
- EXPECT_EQ(expectedStr, *str->value->str);
+ const std::string expected_str = "This is my aunt\u2019s string";
+ EXPECT_EQ(expected_str, *str->value->str);
EXPECT_EQ(1u, str->value->spans.size());
EXPECT_EQ(std::string("b"), *str->value->spans[0].name);
- EXPECT_EQ(17u, str->value->spans[0].firstChar);
- EXPECT_EQ(23u, str->value->spans[0].lastChar);
+ EXPECT_EQ(17u, str->value->spans[0].first_char);
+ EXPECT_EQ(23u, str->value->spans[0].last_char);
}
TEST_F(ResourceParserTest, ParseStringWithWhitespace) {
std::string input = "<string name=\"foo\"> This is what I think </string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* str = test::getValue<String>(&mTable, "string/foo");
+ String* str = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::string("This is what I think"), *str->value);
input = "<string name=\"foo2\">\" This is what I think \"</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- str = test::getValue<String>(&mTable, "string/foo2");
+ str = test::GetValue<String>(&table_, "string/foo2");
ASSERT_NE(nullptr, str);
EXPECT_EQ(std::string(" This is what I think "), *str->value);
}
@@ -131,16 +134,16 @@
"<string name=\"foo\" \n"
" xmlns:xliff=\"urn:oasis:names:tc:xliff:document:1.2\">\n"
" There are <xliff:g id=\"count\">%1$d</xliff:g> apples</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* str = test::getValue<String>(&mTable, "string/foo");
+ String* str = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, str);
EXPECT_EQ(StringPiece("There are %1$d apples"), StringPiece(*str->value));
}
TEST_F(ResourceParserTest, ParseNull) {
std::string input = "<integer name=\"foo\">@null</integer>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
// The Android runtime treats a value of android::Res_value::TYPE_NULL as
// a non-existing value, and this causes problems in styles when trying to
@@ -149,7 +152,7 @@
// android::Res_value::TYPE_REFERENCE
// with a data value of 0.
BinaryPrimitive* integer =
- test::getValue<BinaryPrimitive>(&mTable, "integer/foo");
+ test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
ASSERT_NE(nullptr, integer);
EXPECT_EQ(uint16_t(android::Res_value::TYPE_REFERENCE),
integer->value.dataType);
@@ -158,10 +161,10 @@
TEST_F(ResourceParserTest, ParseEmpty) {
std::string input = "<integer name=\"foo\">@empty</integer>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
BinaryPrimitive* integer =
- test::getValue<BinaryPrimitive>(&mTable, "integer/foo");
+ test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
ASSERT_NE(nullptr, integer);
EXPECT_EQ(uint16_t(android::Res_value::TYPE_NULL), integer->value.dataType);
EXPECT_EQ(uint32_t(android::Res_value::DATA_NULL_EMPTY), integer->value.data);
@@ -171,15 +174,15 @@
std::string input =
"<attr name=\"foo\" format=\"string\"/>\n"
"<attr name=\"bar\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+ Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
ASSERT_NE(nullptr, attr);
- EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask);
+ EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask);
- attr = test::getValue<Attribute>(&mTable, "attr/bar");
+ attr = test::GetValue<Attribute>(&table_, "attr/bar");
ASSERT_NE(nullptr, attr);
- EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->typeMask);
+ EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_ANY), attr->type_mask);
}
// Old AAPT allowed attributes to be defined under different configurations, but
@@ -188,42 +191,42 @@
// behavior.
TEST_F(ResourceParserTest,
ParseAttrAndDeclareStyleableUnderConfigButRecordAsNoConfig) {
- const ConfigDescription watchConfig = test::parseConfigOrDie("watch");
+ const ConfigDescription watch_config = test::ParseConfigOrDie("watch");
std::string input = R"EOF(
<attr name="foo" />
<declare-styleable name="bar">
<attr name="baz" />
</declare-styleable>)EOF";
- ASSERT_TRUE(testParse(input, watchConfig));
+ ASSERT_TRUE(TestParse(input, watch_config));
- EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, "attr/foo",
- watchConfig));
- EXPECT_EQ(nullptr, test::getValueForConfig<Attribute>(&mTable, "attr/baz",
- watchConfig));
- EXPECT_EQ(nullptr, test::getValueForConfig<Styleable>(
- &mTable, "styleable/bar", watchConfig));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/foo",
+ watch_config));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<Attribute>(&table_, "attr/baz",
+ watch_config));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<Styleable>(
+ &table_, "styleable/bar", watch_config));
- EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, "attr/foo"));
- EXPECT_NE(nullptr, test::getValue<Attribute>(&mTable, "attr/baz"));
- EXPECT_NE(nullptr, test::getValue<Styleable>(&mTable, "styleable/bar"));
+ EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/foo"));
+ EXPECT_NE(nullptr, test::GetValue<Attribute>(&table_, "attr/baz"));
+ EXPECT_NE(nullptr, test::GetValue<Styleable>(&table_, "styleable/bar"));
}
TEST_F(ResourceParserTest, ParseAttrWithMinMax) {
std::string input =
"<attr name=\"foo\" min=\"10\" max=\"23\" format=\"integer\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+ Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
ASSERT_NE(nullptr, attr);
- EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->typeMask);
- EXPECT_EQ(10, attr->minInt);
- EXPECT_EQ(23, attr->maxInt);
+ EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_INTEGER), attr->type_mask);
+ EXPECT_EQ(10, attr->min_int);
+ EXPECT_EQ(23, attr->max_int);
}
TEST_F(ResourceParserTest, FailParseAttrWithMinMaxButNotInteger) {
std::string input =
"<attr name=\"foo\" min=\"10\" max=\"23\" format=\"string\"/>";
- ASSERT_FALSE(testParse(input));
+ ASSERT_FALSE(TestParse(input));
}
TEST_F(ResourceParserTest, ParseUseAndDeclOfAttr) {
@@ -232,11 +235,11 @@
" <attr name=\"foo\" />\n"
"</declare-styleable>\n"
"<attr name=\"foo\" format=\"string\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+ Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
ASSERT_NE(nullptr, attr);
- EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->typeMask);
+ EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_STRING), attr->type_mask);
}
TEST_F(ResourceParserTest, ParseDoubleUseOfAttr) {
@@ -247,11 +250,11 @@
"<declare-styleable name=\"Window\">\n"
" <attr name=\"foo\" format=\"boolean\"/>\n"
"</declare-styleable>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+ Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
ASSERT_NE(nullptr, attr);
- EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->typeMask);
+ EXPECT_EQ(uint32_t(android::ResTable_map::TYPE_BOOLEAN), attr->type_mask);
}
TEST_F(ResourceParserTest, ParseEnumAttr) {
@@ -261,24 +264,24 @@
" <enum name=\"bat\" value=\"1\"/>\n"
" <enum name=\"baz\" value=\"2\"/>\n"
"</attr>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Attribute* enumAttr = test::getValue<Attribute>(&mTable, "attr/foo");
- ASSERT_NE(enumAttr, nullptr);
- EXPECT_EQ(enumAttr->typeMask, android::ResTable_map::TYPE_ENUM);
- ASSERT_EQ(enumAttr->symbols.size(), 3u);
+ Attribute* enum_attr = test::GetValue<Attribute>(&table_, "attr/foo");
+ ASSERT_NE(enum_attr, nullptr);
+ EXPECT_EQ(enum_attr->type_mask, android::ResTable_map::TYPE_ENUM);
+ ASSERT_EQ(enum_attr->symbols.size(), 3u);
- AAPT_ASSERT_TRUE(enumAttr->symbols[0].symbol.name);
- EXPECT_EQ(enumAttr->symbols[0].symbol.name.value().entry, "bar");
- EXPECT_EQ(enumAttr->symbols[0].value, 0u);
+ AAPT_ASSERT_TRUE(enum_attr->symbols[0].symbol.name);
+ EXPECT_EQ(enum_attr->symbols[0].symbol.name.value().entry, "bar");
+ EXPECT_EQ(enum_attr->symbols[0].value, 0u);
- AAPT_ASSERT_TRUE(enumAttr->symbols[1].symbol.name);
- EXPECT_EQ(enumAttr->symbols[1].symbol.name.value().entry, "bat");
- EXPECT_EQ(enumAttr->symbols[1].value, 1u);
+ AAPT_ASSERT_TRUE(enum_attr->symbols[1].symbol.name);
+ EXPECT_EQ(enum_attr->symbols[1].symbol.name.value().entry, "bat");
+ EXPECT_EQ(enum_attr->symbols[1].value, 1u);
- AAPT_ASSERT_TRUE(enumAttr->symbols[2].symbol.name);
- EXPECT_EQ(enumAttr->symbols[2].symbol.name.value().entry, "baz");
- EXPECT_EQ(enumAttr->symbols[2].value, 2u);
+ AAPT_ASSERT_TRUE(enum_attr->symbols[2].symbol.name);
+ EXPECT_EQ(enum_attr->symbols[2].symbol.name.value().entry, "baz");
+ EXPECT_EQ(enum_attr->symbols[2].value, 2u);
}
TEST_F(ResourceParserTest, ParseFlagAttr) {
@@ -288,29 +291,29 @@
" <flag name=\"bat\" value=\"1\"/>\n"
" <flag name=\"baz\" value=\"2\"/>\n"
"</attr>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Attribute* flagAttr = test::getValue<Attribute>(&mTable, "attr/foo");
- ASSERT_NE(nullptr, flagAttr);
- EXPECT_EQ(flagAttr->typeMask, android::ResTable_map::TYPE_FLAGS);
- ASSERT_EQ(flagAttr->symbols.size(), 3u);
+ Attribute* flag_attr = test::GetValue<Attribute>(&table_, "attr/foo");
+ ASSERT_NE(nullptr, flag_attr);
+ EXPECT_EQ(flag_attr->type_mask, android::ResTable_map::TYPE_FLAGS);
+ ASSERT_EQ(flag_attr->symbols.size(), 3u);
- AAPT_ASSERT_TRUE(flagAttr->symbols[0].symbol.name);
- EXPECT_EQ(flagAttr->symbols[0].symbol.name.value().entry, "bar");
- EXPECT_EQ(flagAttr->symbols[0].value, 0u);
+ AAPT_ASSERT_TRUE(flag_attr->symbols[0].symbol.name);
+ EXPECT_EQ(flag_attr->symbols[0].symbol.name.value().entry, "bar");
+ EXPECT_EQ(flag_attr->symbols[0].value, 0u);
- AAPT_ASSERT_TRUE(flagAttr->symbols[1].symbol.name);
- EXPECT_EQ(flagAttr->symbols[1].symbol.name.value().entry, "bat");
- EXPECT_EQ(flagAttr->symbols[1].value, 1u);
+ AAPT_ASSERT_TRUE(flag_attr->symbols[1].symbol.name);
+ EXPECT_EQ(flag_attr->symbols[1].symbol.name.value().entry, "bat");
+ EXPECT_EQ(flag_attr->symbols[1].value, 1u);
- AAPT_ASSERT_TRUE(flagAttr->symbols[2].symbol.name);
- EXPECT_EQ(flagAttr->symbols[2].symbol.name.value().entry, "baz");
- EXPECT_EQ(flagAttr->symbols[2].value, 2u);
+ AAPT_ASSERT_TRUE(flag_attr->symbols[2].symbol.name);
+ EXPECT_EQ(flag_attr->symbols[2].symbol.name.value().entry, "baz");
+ EXPECT_EQ(flag_attr->symbols[2].value, 2u);
- std::unique_ptr<BinaryPrimitive> flagValue =
- ResourceUtils::tryParseFlagSymbol(flagAttr, "baz|bat");
- ASSERT_NE(nullptr, flagValue);
- EXPECT_EQ(flagValue->value.data, 1u | 2u);
+ std::unique_ptr<BinaryPrimitive> flag_value =
+ ResourceUtils::TryParseFlagSymbol(flag_attr, "baz|bat");
+ ASSERT_NE(nullptr, flag_value);
+ EXPECT_EQ(flag_value->value.data, 1u | 2u);
}
TEST_F(ResourceParserTest, FailToParseEnumAttrWithNonUniqueKeys) {
@@ -320,7 +323,7 @@
" <enum name=\"bat\" value=\"1\"/>\n"
" <enum name=\"bat\" value=\"2\"/>\n"
"</attr>";
- ASSERT_FALSE(testParse(input));
+ ASSERT_FALSE(TestParse(input));
}
TEST_F(ResourceParserTest, ParseStyle) {
@@ -330,38 +333,38 @@
" <item name=\"bat\">@string/hey</item>\n"
" <item name=\"baz\"><b>hey</b></item>\n"
"</style>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo");
+ Style* style = test::GetValue<Style>(&table_, "style/foo");
ASSERT_NE(nullptr, style);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
- EXPECT_EQ(test::parseNameOrDie("style/fu"),
+ EXPECT_EQ(test::ParseNameOrDie("style/fu"),
style->parent.value().name.value());
ASSERT_EQ(3u, style->entries.size());
AAPT_ASSERT_TRUE(style->entries[0].key.name);
- EXPECT_EQ(test::parseNameOrDie("attr/bar"),
+ EXPECT_EQ(test::ParseNameOrDie("attr/bar"),
style->entries[0].key.name.value());
AAPT_ASSERT_TRUE(style->entries[1].key.name);
- EXPECT_EQ(test::parseNameOrDie("attr/bat"),
+ EXPECT_EQ(test::ParseNameOrDie("attr/bat"),
style->entries[1].key.name.value());
AAPT_ASSERT_TRUE(style->entries[2].key.name);
- EXPECT_EQ(test::parseNameOrDie("attr/baz"),
+ EXPECT_EQ(test::ParseNameOrDie("attr/baz"),
style->entries[2].key.name.value());
}
TEST_F(ResourceParserTest, ParseStyleWithShorthandParent) {
std::string input = "<style name=\"foo\" parent=\"com.app:Theme\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo");
+ Style* style = test::GetValue<Style>(&table_, "style/foo");
ASSERT_NE(nullptr, style);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
- EXPECT_EQ(test::parseNameOrDie("com.app:style/Theme"),
+ EXPECT_EQ(test::ParseNameOrDie("com.app:style/Theme"),
style->parent.value().name.value());
}
@@ -369,13 +372,13 @@
std::string input =
"<style xmlns:app=\"http://schemas.android.com/apk/res/android\"\n"
" name=\"foo\" parent=\"app:Theme\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo");
+ Style* style = test::GetValue<Style>(&table_, "style/foo");
ASSERT_NE(nullptr, style);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
- EXPECT_EQ(test::parseNameOrDie("android:style/Theme"),
+ EXPECT_EQ(test::ParseNameOrDie("android:style/Theme"),
style->parent.value().name.value());
}
@@ -385,55 +388,55 @@
"name=\"foo\">\n"
" <item name=\"app:bar\">0</item>\n"
"</style>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo");
+ Style* style = test::GetValue<Style>(&table_, "style/foo");
ASSERT_NE(nullptr, style);
ASSERT_EQ(1u, style->entries.size());
- EXPECT_EQ(test::parseNameOrDie("android:attr/bar"),
+ EXPECT_EQ(test::ParseNameOrDie("android:attr/bar"),
style->entries[0].key.name.value());
}
TEST_F(ResourceParserTest, ParseStyleWithInferredParent) {
std::string input = "<style name=\"foo.bar\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo.bar");
+ Style* style = test::GetValue<Style>(&table_, "style/foo.bar");
ASSERT_NE(nullptr, style);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().name);
EXPECT_EQ(style->parent.value().name.value(),
- test::parseNameOrDie("style/foo"));
- EXPECT_TRUE(style->parentInferred);
+ test::ParseNameOrDie("style/foo"));
+ EXPECT_TRUE(style->parent_inferred);
}
TEST_F(ResourceParserTest,
ParseStyleWithInferredParentOverridenByEmptyParentAttribute) {
std::string input = "<style name=\"foo.bar\" parent=\"\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo.bar");
+ Style* style = test::GetValue<Style>(&table_, "style/foo.bar");
ASSERT_NE(nullptr, style);
AAPT_EXPECT_FALSE(style->parent);
- EXPECT_FALSE(style->parentInferred);
+ EXPECT_FALSE(style->parent_inferred);
}
TEST_F(ResourceParserTest, ParseStyleWithPrivateParentReference) {
std::string input =
R"EOF(<style name="foo" parent="*android:style/bar" />)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Style* style = test::getValue<Style>(&mTable, "style/foo");
+ Style* style = test::GetValue<Style>(&table_, "style/foo");
ASSERT_NE(nullptr, style);
AAPT_ASSERT_TRUE(style->parent);
- EXPECT_TRUE(style->parent.value().privateReference);
+ EXPECT_TRUE(style->parent.value().private_reference);
}
TEST_F(ResourceParserTest, ParseAutoGeneratedIdReference) {
std::string input = "<string name=\"foo\">@+id/bar</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Id* id = test::getValue<Id>(&mTable, "id/bar");
+ Id* id = test::GetValue<Id>(&table_, "id/bar");
ASSERT_NE(id, nullptr);
}
@@ -446,35 +449,35 @@
" <enum name=\"foo\" value=\"1\"/>\n"
" </attr>\n"
"</declare-styleable>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
Maybe<ResourceTable::SearchResult> result =
- mTable.findResource(test::parseNameOrDie("styleable/foo"));
+ table_.FindResource(test::ParseNameOrDie("styleable/foo"));
AAPT_ASSERT_TRUE(result);
- EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbolStatus.state);
+ EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state);
- Attribute* attr = test::getValue<Attribute>(&mTable, "attr/bar");
+ Attribute* attr = test::GetValue<Attribute>(&table_, "attr/bar");
ASSERT_NE(attr, nullptr);
- EXPECT_TRUE(attr->isWeak());
+ EXPECT_TRUE(attr->IsWeak());
- attr = test::getValue<Attribute>(&mTable, "attr/bat");
+ attr = test::GetValue<Attribute>(&table_, "attr/bat");
ASSERT_NE(attr, nullptr);
- EXPECT_TRUE(attr->isWeak());
+ EXPECT_TRUE(attr->IsWeak());
- attr = test::getValue<Attribute>(&mTable, "attr/baz");
+ attr = test::GetValue<Attribute>(&table_, "attr/baz");
ASSERT_NE(attr, nullptr);
- EXPECT_TRUE(attr->isWeak());
+ EXPECT_TRUE(attr->IsWeak());
EXPECT_EQ(1u, attr->symbols.size());
- EXPECT_NE(nullptr, test::getValue<Id>(&mTable, "id/foo"));
+ EXPECT_NE(nullptr, test::GetValue<Id>(&table_, "id/foo"));
- Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo");
+ Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
ASSERT_NE(styleable, nullptr);
ASSERT_EQ(3u, styleable->entries.size());
- EXPECT_EQ(test::parseNameOrDie("attr/bar"),
+ EXPECT_EQ(test::ParseNameOrDie("attr/bar"),
styleable->entries[0].name.value());
- EXPECT_EQ(test::parseNameOrDie("attr/bat"),
+ EXPECT_EQ(test::ParseNameOrDie("attr/bat"),
styleable->entries[1].name.value());
}
@@ -485,16 +488,16 @@
" <attr name=\"*android:bar\" />\n"
" <attr name=\"privAndroid:bat\" />\n"
"</declare-styleable>";
- ASSERT_TRUE(testParse(input));
- Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo");
+ ASSERT_TRUE(TestParse(input));
+ Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
ASSERT_NE(nullptr, styleable);
ASSERT_EQ(2u, styleable->entries.size());
- EXPECT_TRUE(styleable->entries[0].privateReference);
+ EXPECT_TRUE(styleable->entries[0].private_reference);
AAPT_ASSERT_TRUE(styleable->entries[0].name);
EXPECT_EQ(std::string("android"), styleable->entries[0].name.value().package);
- EXPECT_TRUE(styleable->entries[1].privateReference);
+ EXPECT_TRUE(styleable->entries[1].private_reference);
AAPT_ASSERT_TRUE(styleable->entries[1].name);
EXPECT_EQ(std::string("android"), styleable->entries[1].name.value().package);
}
@@ -506,15 +509,15 @@
" <item>hey</item>\n"
" <item>23</item>\n"
"</array>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Array* array = test::getValue<Array>(&mTable, "array/foo");
+ Array* array = test::GetValue<Array>(&table_, "array/foo");
ASSERT_NE(array, nullptr);
ASSERT_EQ(3u, array->items.size());
- EXPECT_NE(nullptr, valueCast<Reference>(array->items[0].get()));
- EXPECT_NE(nullptr, valueCast<String>(array->items[1].get()));
- EXPECT_NE(nullptr, valueCast<BinaryPrimitive>(array->items[2].get()));
+ EXPECT_NE(nullptr, ValueCast<Reference>(array->items[0].get()));
+ EXPECT_NE(nullptr, ValueCast<String>(array->items[1].get()));
+ EXPECT_NE(nullptr, ValueCast<BinaryPrimitive>(array->items[2].get()));
}
TEST_F(ResourceParserTest, ParseStringArray) {
@@ -522,8 +525,8 @@
"<string-array name=\"foo\">\n"
" <item>\"Werk\"</item>\n"
"</string-array>\n";
- ASSERT_TRUE(testParse(input));
- EXPECT_NE(nullptr, test::getValue<Array>(&mTable, "array/foo"));
+ ASSERT_TRUE(TestParse(input));
+ EXPECT_NE(nullptr, test::GetValue<Array>(&table_, "array/foo"));
}
TEST_F(ResourceParserTest, ParsePlural) {
@@ -532,18 +535,18 @@
" <item quantity=\"other\">apples</item>\n"
" <item quantity=\"one\">apple</item>\n"
"</plurals>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
}
TEST_F(ResourceParserTest, ParseCommentsWithResource) {
std::string input =
"<!--This is a comment-->\n"
"<string name=\"foo\">Hi</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* value = test::getValue<String>(&mTable, "string/foo");
+ String* value = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, value);
- EXPECT_EQ(value->getComment(), "This is a comment");
+ EXPECT_EQ(value->GetComment(), "This is a comment");
}
TEST_F(ResourceParserTest, DoNotCombineMultipleComments) {
@@ -552,11 +555,11 @@
"<!--Two-->\n"
"<string name=\"foo\">Hi</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* value = test::getValue<String>(&mTable, "string/foo");
+ String* value = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, value);
- EXPECT_EQ(value->getComment(), "Two");
+ EXPECT_EQ(value->GetComment(), "Two");
}
TEST_F(ResourceParserTest, IgnoreCommentBeforeEndTag) {
@@ -567,11 +570,11 @@
"<!--Two-->\n"
"</string>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- String* value = test::getValue<String>(&mTable, "string/foo");
+ String* value = test::GetValue<String>(&table_, "string/foo");
ASSERT_NE(nullptr, value);
- EXPECT_EQ(value->getComment(), "One");
+ EXPECT_EQ(value->GetComment(), "One");
}
TEST_F(ResourceParserTest, ParseNestedComments) {
@@ -588,21 +591,21 @@
<!-- The very first -->
<enum name="one" value="1" />
</attr>)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Styleable* styleable = test::getValue<Styleable>(&mTable, "styleable/foo");
+ Styleable* styleable = test::GetValue<Styleable>(&table_, "styleable/foo");
ASSERT_NE(nullptr, styleable);
ASSERT_EQ(1u, styleable->entries.size());
EXPECT_EQ(StringPiece("The name of the bar"),
- styleable->entries.front().getComment());
+ styleable->entries.front().GetComment());
- Attribute* attr = test::getValue<Attribute>(&mTable, "attr/foo");
+ Attribute* attr = test::GetValue<Attribute>(&table_, "attr/foo");
ASSERT_NE(nullptr, attr);
ASSERT_EQ(1u, attr->symbols.size());
EXPECT_EQ(StringPiece("The very first"),
- attr->symbols.front().symbol.getComment());
+ attr->symbols.front().symbol.GetComment());
}
/*
@@ -611,9 +614,9 @@
*/
TEST_F(ResourceParserTest, ParsePublicIdAsDefinition) {
std::string input = "<public type=\"id\" name=\"foo\"/>";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- Id* id = test::getValue<Id>(&mTable, "id/foo");
+ Id* id = test::GetValue<Id>(&table_, "id/foo");
ASSERT_NE(nullptr, id);
}
@@ -626,26 +629,26 @@
<string name="bit" product="phablet">hoot</string>
<string name="bot" product="default">yes</string>
)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
- &mTable, "string/foo",
- ConfigDescription::defaultConfig(), "phone"));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
- &mTable, "string/foo",
- ConfigDescription::defaultConfig(), "no-sdcard"));
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+ &table_, "string/foo",
+ ConfigDescription::DefaultConfig(), "phone"));
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+ &table_, "string/foo",
+ ConfigDescription::DefaultConfig(), "no-sdcard"));
EXPECT_NE(nullptr,
- test::getValueForConfigAndProduct<String>(
- &mTable, "string/bar", ConfigDescription::defaultConfig(), ""));
+ test::GetValueForConfigAndProduct<String>(
+ &table_, "string/bar", ConfigDescription::DefaultConfig(), ""));
EXPECT_NE(nullptr,
- test::getValueForConfigAndProduct<String>(
- &mTable, "string/baz", ConfigDescription::defaultConfig(), ""));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
- &mTable, "string/bit",
- ConfigDescription::defaultConfig(), "phablet"));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<String>(
- &mTable, "string/bot",
- ConfigDescription::defaultConfig(), "default"));
+ test::GetValueForConfigAndProduct<String>(
+ &table_, "string/baz", ConfigDescription::DefaultConfig(), ""));
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+ &table_, "string/bit",
+ ConfigDescription::DefaultConfig(), "phablet"));
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<String>(
+ &table_, "string/bot",
+ ConfigDescription::DefaultConfig(), "default"));
}
TEST_F(ResourceParserTest, AutoIncrementIdsInPublicGroup) {
@@ -654,61 +657,61 @@
<public name="foo" />
<public name="bar" />
</public-group>)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
Maybe<ResourceTable::SearchResult> result =
- mTable.findResource(test::parseNameOrDie("attr/foo"));
+ table_.FindResource(test::ParseNameOrDie("attr/foo"));
AAPT_ASSERT_TRUE(result);
AAPT_ASSERT_TRUE(result.value().package->id);
AAPT_ASSERT_TRUE(result.value().type->id);
AAPT_ASSERT_TRUE(result.value().entry->id);
- ResourceId actualId(result.value().package->id.value(),
- result.value().type->id.value(),
- result.value().entry->id.value());
- EXPECT_EQ(ResourceId(0x01010040), actualId);
+ ResourceId actual_id(result.value().package->id.value(),
+ result.value().type->id.value(),
+ result.value().entry->id.value());
+ EXPECT_EQ(ResourceId(0x01010040), actual_id);
- result = mTable.findResource(test::parseNameOrDie("attr/bar"));
+ result = table_.FindResource(test::ParseNameOrDie("attr/bar"));
AAPT_ASSERT_TRUE(result);
AAPT_ASSERT_TRUE(result.value().package->id);
AAPT_ASSERT_TRUE(result.value().type->id);
AAPT_ASSERT_TRUE(result.value().entry->id);
- actualId = ResourceId(result.value().package->id.value(),
- result.value().type->id.value(),
- result.value().entry->id.value());
- EXPECT_EQ(ResourceId(0x01010041), actualId);
+ actual_id = ResourceId(result.value().package->id.value(),
+ result.value().type->id.value(),
+ result.value().entry->id.value());
+ EXPECT_EQ(ResourceId(0x01010041), actual_id);
}
TEST_F(ResourceParserTest, ExternalTypesShouldOnlyBeReferences) {
std::string input =
R"EOF(<item type="layout" name="foo">@layout/bar</item>)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
input = R"EOF(<item type="layout" name="bar">"this is a string"</item>)EOF";
- ASSERT_FALSE(testParse(input));
+ ASSERT_FALSE(TestParse(input));
}
TEST_F(ResourceParserTest,
AddResourcesElementShouldAddEntryWithUndefinedSymbol) {
std::string input = R"EOF(<add-resource name="bar" type="string" />)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
Maybe<ResourceTable::SearchResult> result =
- mTable.findResource(test::parseNameOrDie("string/bar"));
+ table_.FindResource(test::ParseNameOrDie("string/bar"));
AAPT_ASSERT_TRUE(result);
const ResourceEntry* entry = result.value().entry;
ASSERT_NE(nullptr, entry);
- EXPECT_EQ(SymbolState::kUndefined, entry->symbolStatus.state);
+ EXPECT_EQ(SymbolState::kUndefined, entry->symbol_status.state);
}
TEST_F(ResourceParserTest, ParseItemElementWithFormat) {
std::string input =
R"EOF(<item name="foo" type="integer" format="float">0.3</item>)EOF";
- ASSERT_TRUE(testParse(input));
+ ASSERT_TRUE(TestParse(input));
BinaryPrimitive* val =
- test::getValue<BinaryPrimitive>(&mTable, "integer/foo");
+ test::GetValue<BinaryPrimitive>(&table_, "integer/foo");
ASSERT_NE(nullptr, val);
EXPECT_EQ(uint32_t(android::Res_value::TYPE_FLOAT), val->value.dataType);
diff --git a/tools/aapt2/ResourceTable.cpp b/tools/aapt2/ResourceTable.cpp
index c52c91c..4e6a50a 100644
--- a/tools/aapt2/ResourceTable.cpp
+++ b/tools/aapt2/ResourceTable.cpp
@@ -21,6 +21,7 @@
#include "ValueVisitor.h"
#include "util/Util.h"
+#include <android-base/logging.h>
#include <androidfw/ResourceTypes.h>
#include <algorithm>
#include <memory>
@@ -29,28 +30,29 @@
namespace aapt {
-static bool lessThanType(const std::unique_ptr<ResourceTableType>& lhs,
- ResourceType rhs) {
+static bool less_than_type(const std::unique_ptr<ResourceTableType>& lhs,
+ ResourceType rhs) {
return lhs->type < rhs;
}
template <typename T>
-static bool lessThanStructWithName(const std::unique_ptr<T>& lhs,
- const StringPiece& rhs) {
+static bool less_than_struct_with_name(const std::unique_ptr<T>& lhs,
+ const StringPiece& rhs) {
return lhs->name.compare(0, lhs->name.size(), rhs.data(), rhs.size()) < 0;
}
-ResourceTablePackage* ResourceTable::findPackage(const StringPiece& name) {
+ResourceTablePackage* ResourceTable::FindPackage(const StringPiece& name) {
const auto last = packages.end();
- auto iter = std::lower_bound(packages.begin(), last, name,
- lessThanStructWithName<ResourceTablePackage>);
+ auto iter =
+ std::lower_bound(packages.begin(), last, name,
+ less_than_struct_with_name<ResourceTablePackage>);
if (iter != last && name == (*iter)->name) {
return iter->get();
}
return nullptr;
}
-ResourceTablePackage* ResourceTable::findPackageById(uint8_t id) {
+ResourceTablePackage* ResourceTable::FindPackageById(uint8_t id) {
for (auto& package : packages) {
if (package->id && package->id.value() == id) {
return package.get();
@@ -59,9 +61,9 @@
return nullptr;
}
-ResourceTablePackage* ResourceTable::createPackage(const StringPiece& name,
+ResourceTablePackage* ResourceTable::CreatePackage(const StringPiece& name,
Maybe<uint8_t> id) {
- ResourceTablePackage* package = findOrCreatePackage(name);
+ ResourceTablePackage* package = FindOrCreatePackage(name);
if (id && !package->id) {
package->id = id;
return package;
@@ -73,61 +75,62 @@
return package;
}
-ResourceTablePackage* ResourceTable::findOrCreatePackage(
+ResourceTablePackage* ResourceTable::FindOrCreatePackage(
const StringPiece& name) {
const auto last = packages.end();
- auto iter = std::lower_bound(packages.begin(), last, name,
- lessThanStructWithName<ResourceTablePackage>);
+ auto iter =
+ std::lower_bound(packages.begin(), last, name,
+ less_than_struct_with_name<ResourceTablePackage>);
if (iter != last && name == (*iter)->name) {
return iter->get();
}
- std::unique_ptr<ResourceTablePackage> newPackage =
+ std::unique_ptr<ResourceTablePackage> new_package =
util::make_unique<ResourceTablePackage>();
- newPackage->name = name.toString();
- return packages.emplace(iter, std::move(newPackage))->get();
+ new_package->name = name.ToString();
+ return packages.emplace(iter, std::move(new_package))->get();
}
-ResourceTableType* ResourceTablePackage::findType(ResourceType type) {
+ResourceTableType* ResourceTablePackage::FindType(ResourceType type) {
const auto last = types.end();
- auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
+ auto iter = std::lower_bound(types.begin(), last, type, less_than_type);
if (iter != last && (*iter)->type == type) {
return iter->get();
}
return nullptr;
}
-ResourceTableType* ResourceTablePackage::findOrCreateType(ResourceType type) {
+ResourceTableType* ResourceTablePackage::FindOrCreateType(ResourceType type) {
const auto last = types.end();
- auto iter = std::lower_bound(types.begin(), last, type, lessThanType);
+ auto iter = std::lower_bound(types.begin(), last, type, less_than_type);
if (iter != last && (*iter)->type == type) {
return iter->get();
}
return types.emplace(iter, new ResourceTableType(type))->get();
}
-ResourceEntry* ResourceTableType::findEntry(const StringPiece& name) {
+ResourceEntry* ResourceTableType::FindEntry(const StringPiece& name) {
const auto last = entries.end();
auto iter = std::lower_bound(entries.begin(), last, name,
- lessThanStructWithName<ResourceEntry>);
+ less_than_struct_with_name<ResourceEntry>);
if (iter != last && name == (*iter)->name) {
return iter->get();
}
return nullptr;
}
-ResourceEntry* ResourceTableType::findOrCreateEntry(const StringPiece& name) {
+ResourceEntry* ResourceTableType::FindOrCreateEntry(const StringPiece& name) {
auto last = entries.end();
auto iter = std::lower_bound(entries.begin(), last, name,
- lessThanStructWithName<ResourceEntry>);
+ less_than_struct_with_name<ResourceEntry>);
if (iter != last && name == (*iter)->name) {
return iter->get();
}
return entries.emplace(iter, new ResourceEntry(name))->get();
}
-ResourceConfigValue* ResourceEntry::findValue(const ConfigDescription& config) {
- return findValue(config, StringPiece());
+ResourceConfigValue* ResourceEntry::FindValue(const ConfigDescription& config) {
+ return FindValue(config, StringPiece());
}
struct ConfigKey {
@@ -144,7 +147,7 @@
return cmp < 0;
}
-ResourceConfigValue* ResourceEntry::findValue(const ConfigDescription& config,
+ResourceConfigValue* ResourceEntry::FindValue(const ConfigDescription& config,
const StringPiece& product) {
auto iter = std::lower_bound(values.begin(), values.end(),
ConfigKey{&config, product}, ltConfigKeyRef);
@@ -157,7 +160,7 @@
return nullptr;
}
-ResourceConfigValue* ResourceEntry::findOrCreateValue(
+ResourceConfigValue* ResourceEntry::FindOrCreateValue(
const ConfigDescription& config, const StringPiece& product) {
auto iter = std::lower_bound(values.begin(), values.end(),
ConfigKey{&config, product}, ltConfigKeyRef);
@@ -197,7 +200,7 @@
return results;
}
-std::vector<ResourceConfigValue*> ResourceEntry::findValuesIf(
+std::vector<ResourceConfigValue*> ResourceEntry::FindValuesIf(
const std::function<bool(ResourceConfigValue*)>& f) {
std::vector<ResourceConfigValue*> results;
for (auto& configValue : values) {
@@ -232,16 +235,16 @@
* format for there to be
* no error.
*/
-ResourceTable::CollisionResult ResourceTable::resolveValueCollision(
+ResourceTable::CollisionResult ResourceTable::ResolveValueCollision(
Value* existing, Value* incoming) {
- Attribute* existingAttr = valueCast<Attribute>(existing);
- Attribute* incomingAttr = valueCast<Attribute>(incoming);
- if (!incomingAttr) {
- if (incoming->isWeak()) {
+ Attribute* existing_attr = ValueCast<Attribute>(existing);
+ Attribute* incoming_attr = ValueCast<Attribute>(incoming);
+ if (!incoming_attr) {
+ if (incoming->IsWeak()) {
// We're trying to add a weak resource but a resource
// already exists. Keep the existing.
return CollisionResult::kKeepOriginal;
- } else if (existing->isWeak()) {
+ } else if (existing->IsWeak()) {
// Override the weak resource with the new strong resource.
return CollisionResult::kTakeNew;
}
@@ -250,8 +253,8 @@
return CollisionResult::kConflict;
}
- if (!existingAttr) {
- if (existing->isWeak()) {
+ if (!existing_attr) {
+ if (existing->IsWeak()) {
// The existing value is not an attribute and it is weak,
// so take the incoming attribute value.
return CollisionResult::kTakeNew;
@@ -261,7 +264,7 @@
return CollisionResult::kConflict;
}
- assert(incomingAttr && existingAttr);
+ CHECK(incoming_attr != nullptr && existing_attr != nullptr);
//
// Attribute specific handling. At this point we know both
@@ -269,22 +272,22 @@
// attributes all-over, we do special handling to see
// which definition sticks.
//
- if (existingAttr->typeMask == incomingAttr->typeMask) {
+ if (existing_attr->type_mask == incoming_attr->type_mask) {
// The two attributes are both DECLs, but they are plain attributes
// with the same formats.
// Keep the strongest one.
- return existingAttr->isWeak() ? CollisionResult::kTakeNew
- : CollisionResult::kKeepOriginal;
+ return existing_attr->IsWeak() ? CollisionResult::kTakeNew
+ : CollisionResult::kKeepOriginal;
}
- if (existingAttr->isWeak() &&
- existingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
+ if (existing_attr->IsWeak() &&
+ existing_attr->type_mask == android::ResTable_map::TYPE_ANY) {
// Any incoming attribute is better than this.
return CollisionResult::kTakeNew;
}
- if (incomingAttr->isWeak() &&
- incomingAttr->typeMask == android::ResTable_map::TYPE_ANY) {
+ if (incoming_attr->IsWeak() &&
+ incoming_attr->type_mask == android::ResTable_map::TYPE_ANY) {
// The incoming attribute may be a USE instead of a DECL.
// Keep the existing attribute.
return CollisionResult::kKeepOriginal;
@@ -295,138 +298,139 @@
static constexpr const char* kValidNameChars = "._-";
static constexpr const char* kValidNameMangledChars = "._-$";
-bool ResourceTable::addResource(const ResourceNameRef& name,
+bool ResourceTable::AddResource(const ResourceNameRef& name,
const ConfigDescription& config,
const StringPiece& product,
std::unique_ptr<Value> value,
IDiagnostics* diag) {
- return addResourceImpl(name, {}, config, product, std::move(value),
- kValidNameChars, resolveValueCollision, diag);
+ return AddResourceImpl(name, {}, config, product, std::move(value),
+ kValidNameChars, ResolveValueCollision, diag);
}
-bool ResourceTable::addResource(const ResourceNameRef& name,
- const ResourceId& resId,
+bool ResourceTable::AddResource(const ResourceNameRef& name,
+ const ResourceId& res_id,
const ConfigDescription& config,
const StringPiece& product,
std::unique_ptr<Value> value,
IDiagnostics* diag) {
- return addResourceImpl(name, resId, config, product, std::move(value),
- kValidNameChars, resolveValueCollision, diag);
+ return AddResourceImpl(name, res_id, config, product, std::move(value),
+ kValidNameChars, ResolveValueCollision, diag);
}
-bool ResourceTable::addFileReference(const ResourceNameRef& name,
+bool ResourceTable::AddFileReference(const ResourceNameRef& name,
const ConfigDescription& config,
const Source& source,
const StringPiece& path,
IDiagnostics* diag) {
- return addFileReferenceImpl(name, config, source, path, nullptr,
+ return AddFileReferenceImpl(name, config, source, path, nullptr,
kValidNameChars, diag);
}
-bool ResourceTable::addFileReferenceAllowMangled(
+bool ResourceTable::AddFileReferenceAllowMangled(
const ResourceNameRef& name, const ConfigDescription& config,
const Source& source, const StringPiece& path, io::IFile* file,
IDiagnostics* diag) {
- return addFileReferenceImpl(name, config, source, path, file,
+ return AddFileReferenceImpl(name, config, source, path, file,
kValidNameMangledChars, diag);
}
-bool ResourceTable::addFileReferenceImpl(
+bool ResourceTable::AddFileReferenceImpl(
const ResourceNameRef& name, const ConfigDescription& config,
const Source& source, const StringPiece& path, io::IFile* file,
- const char* validChars, IDiagnostics* diag) {
+ const char* valid_chars, IDiagnostics* diag) {
std::unique_ptr<FileReference> fileRef =
- util::make_unique<FileReference>(stringPool.makeRef(path));
- fileRef->setSource(source);
+ util::make_unique<FileReference>(string_pool.MakeRef(path));
+ fileRef->SetSource(source);
fileRef->file = file;
- return addResourceImpl(name, ResourceId{}, config, StringPiece{},
- std::move(fileRef), validChars, resolveValueCollision,
+ return AddResourceImpl(name, ResourceId{}, config, StringPiece{},
+ std::move(fileRef), valid_chars, ResolveValueCollision,
diag);
}
-bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
+bool ResourceTable::AddResourceAllowMangled(const ResourceNameRef& name,
const ConfigDescription& config,
const StringPiece& product,
std::unique_ptr<Value> value,
IDiagnostics* diag) {
- return addResourceImpl(name, ResourceId{}, config, product, std::move(value),
- kValidNameMangledChars, resolveValueCollision, diag);
+ return AddResourceImpl(name, ResourceId{}, config, product, std::move(value),
+ kValidNameMangledChars, ResolveValueCollision, diag);
}
-bool ResourceTable::addResourceAllowMangled(const ResourceNameRef& name,
+bool ResourceTable::AddResourceAllowMangled(const ResourceNameRef& name,
const ResourceId& id,
const ConfigDescription& config,
const StringPiece& product,
std::unique_ptr<Value> value,
IDiagnostics* diag) {
- return addResourceImpl(name, id, config, product, std::move(value),
- kValidNameMangledChars, resolveValueCollision, diag);
+ return AddResourceImpl(name, id, config, product, std::move(value),
+ kValidNameMangledChars, ResolveValueCollision, diag);
}
-bool ResourceTable::addResourceImpl(
- const ResourceNameRef& name, const ResourceId& resId,
+bool ResourceTable::AddResourceImpl(
+ const ResourceNameRef& name, const ResourceId& res_id,
const ConfigDescription& config, const StringPiece& product,
- std::unique_ptr<Value> value, const char* validChars,
+ std::unique_ptr<Value> value, const char* valid_chars,
const CollisionResolverFunc& conflictResolver, IDiagnostics* diag) {
- assert(value && "value can't be nullptr");
- assert(diag && "diagnostics can't be nullptr");
+ CHECK(value != nullptr);
+ CHECK(diag != nullptr);
- auto badCharIter =
- util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
- if (badCharIter != name.entry.end()) {
- diag->error(DiagMessage(value->getSource())
+ auto bad_char_iter =
+ util::FindNonAlphaNumericAndNotInSet(name.entry, valid_chars);
+ if (bad_char_iter != name.entry.end()) {
+ diag->Error(DiagMessage(value->GetSource())
<< "resource '" << name << "' has invalid entry name '"
<< name.entry << "'. Invalid character '"
- << StringPiece(badCharIter, 1) << "'");
+ << StringPiece(bad_char_iter, 1) << "'");
return false;
}
- ResourceTablePackage* package = findOrCreatePackage(name.package);
- if (resId.isValid() && package->id &&
- package->id.value() != resId.packageId()) {
- diag->error(DiagMessage(value->getSource())
- << "trying to add resource '" << name << "' with ID " << resId
+ ResourceTablePackage* package = FindOrCreatePackage(name.package);
+ if (res_id.is_valid() && package->id &&
+ package->id.value() != res_id.package_id()) {
+ diag->Error(DiagMessage(value->GetSource())
+ << "trying to add resource '" << name << "' with ID " << res_id
<< " but package '" << package->name << "' already has ID "
<< std::hex << (int)package->id.value() << std::dec);
return false;
}
- ResourceTableType* type = package->findOrCreateType(name.type);
- if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
- diag->error(DiagMessage(value->getSource())
- << "trying to add resource '" << name << "' with ID " << resId
+ ResourceTableType* type = package->FindOrCreateType(name.type);
+ if (res_id.is_valid() && type->id && type->id.value() != res_id.type_id()) {
+ diag->Error(DiagMessage(value->GetSource())
+ << "trying to add resource '" << name << "' with ID " << res_id
<< " but type '" << type->type << "' already has ID "
<< std::hex << (int)type->id.value() << std::dec);
return false;
}
- ResourceEntry* entry = type->findOrCreateEntry(name.entry);
- if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
- diag->error(DiagMessage(value->getSource())
- << "trying to add resource '" << name << "' with ID " << resId
+ ResourceEntry* entry = type->FindOrCreateEntry(name.entry);
+ if (res_id.is_valid() && entry->id &&
+ entry->id.value() != res_id.entry_id()) {
+ diag->Error(DiagMessage(value->GetSource())
+ << "trying to add resource '" << name << "' with ID " << res_id
<< " but resource already has ID "
<< ResourceId(package->id.value(), type->id.value(),
entry->id.value()));
return false;
}
- ResourceConfigValue* configValue = entry->findOrCreateValue(config, product);
- if (!configValue->value) {
+ ResourceConfigValue* config_value = entry->FindOrCreateValue(config, product);
+ if (!config_value->value) {
// Resource does not exist, add it now.
- configValue->value = std::move(value);
+ config_value->value = std::move(value);
} else {
- switch (conflictResolver(configValue->value.get(), value.get())) {
+ switch (conflictResolver(config_value->value.get(), value.get())) {
case CollisionResult::kTakeNew:
// Take the incoming value.
- configValue->value = std::move(value);
+ config_value->value = std::move(value);
break;
case CollisionResult::kConflict:
- diag->error(DiagMessage(value->getSource())
+ diag->Error(DiagMessage(value->GetSource())
<< "duplicate value for resource '" << name << "' "
<< "with config '" << config << "'");
- diag->error(DiagMessage(configValue->value->getSource())
+ diag->Error(DiagMessage(config_value->value->GetSource())
<< "resource previously defined here");
return false;
@@ -435,113 +439,114 @@
}
}
- if (resId.isValid()) {
- package->id = resId.packageId();
- type->id = resId.typeId();
- entry->id = resId.entryId();
+ if (res_id.is_valid()) {
+ package->id = res_id.package_id();
+ type->id = res_id.type_id();
+ entry->id = res_id.entry_id();
}
return true;
}
-bool ResourceTable::setSymbolState(const ResourceNameRef& name,
- const ResourceId& resId,
+bool ResourceTable::SetSymbolState(const ResourceNameRef& name,
+ const ResourceId& res_id,
const Symbol& symbol, IDiagnostics* diag) {
- return setSymbolStateImpl(name, resId, symbol, kValidNameChars, diag);
+ return SetSymbolStateImpl(name, res_id, symbol, kValidNameChars, diag);
}
-bool ResourceTable::setSymbolStateAllowMangled(const ResourceNameRef& name,
- const ResourceId& resId,
+bool ResourceTable::SetSymbolStateAllowMangled(const ResourceNameRef& name,
+ const ResourceId& res_id,
const Symbol& symbol,
IDiagnostics* diag) {
- return setSymbolStateImpl(name, resId, symbol, kValidNameMangledChars, diag);
+ return SetSymbolStateImpl(name, res_id, symbol, kValidNameMangledChars, diag);
}
-bool ResourceTable::setSymbolStateImpl(const ResourceNameRef& name,
- const ResourceId& resId,
+bool ResourceTable::SetSymbolStateImpl(const ResourceNameRef& name,
+ const ResourceId& res_id,
const Symbol& symbol,
- const char* validChars,
+ const char* valid_chars,
IDiagnostics* diag) {
- assert(diag && "diagnostics can't be nullptr");
+ CHECK(diag != nullptr);
- auto badCharIter =
- util::findNonAlphaNumericAndNotInSet(name.entry, validChars);
- if (badCharIter != name.entry.end()) {
- diag->error(DiagMessage(symbol.source)
+ auto bad_char_iter =
+ util::FindNonAlphaNumericAndNotInSet(name.entry, valid_chars);
+ if (bad_char_iter != name.entry.end()) {
+ diag->Error(DiagMessage(symbol.source)
<< "resource '" << name << "' has invalid entry name '"
<< name.entry << "'. Invalid character '"
- << StringPiece(badCharIter, 1) << "'");
+ << StringPiece(bad_char_iter, 1) << "'");
return false;
}
- ResourceTablePackage* package = findOrCreatePackage(name.package);
- if (resId.isValid() && package->id &&
- package->id.value() != resId.packageId()) {
- diag->error(DiagMessage(symbol.source)
- << "trying to add resource '" << name << "' with ID " << resId
+ ResourceTablePackage* package = FindOrCreatePackage(name.package);
+ if (res_id.is_valid() && package->id &&
+ package->id.value() != res_id.package_id()) {
+ diag->Error(DiagMessage(symbol.source)
+ << "trying to add resource '" << name << "' with ID " << res_id
<< " but package '" << package->name << "' already has ID "
<< std::hex << (int)package->id.value() << std::dec);
return false;
}
- ResourceTableType* type = package->findOrCreateType(name.type);
- if (resId.isValid() && type->id && type->id.value() != resId.typeId()) {
- diag->error(DiagMessage(symbol.source)
- << "trying to add resource '" << name << "' with ID " << resId
+ ResourceTableType* type = package->FindOrCreateType(name.type);
+ if (res_id.is_valid() && type->id && type->id.value() != res_id.type_id()) {
+ diag->Error(DiagMessage(symbol.source)
+ << "trying to add resource '" << name << "' with ID " << res_id
<< " but type '" << type->type << "' already has ID "
<< std::hex << (int)type->id.value() << std::dec);
return false;
}
- ResourceEntry* entry = type->findOrCreateEntry(name.entry);
- if (resId.isValid() && entry->id && entry->id.value() != resId.entryId()) {
- diag->error(DiagMessage(symbol.source)
- << "trying to add resource '" << name << "' with ID " << resId
+ ResourceEntry* entry = type->FindOrCreateEntry(name.entry);
+ if (res_id.is_valid() && entry->id &&
+ entry->id.value() != res_id.entry_id()) {
+ diag->Error(DiagMessage(symbol.source)
+ << "trying to add resource '" << name << "' with ID " << res_id
<< " but resource already has ID "
<< ResourceId(package->id.value(), type->id.value(),
entry->id.value()));
return false;
}
- if (resId.isValid()) {
- package->id = resId.packageId();
- type->id = resId.typeId();
- entry->id = resId.entryId();
+ if (res_id.is_valid()) {
+ package->id = res_id.package_id();
+ type->id = res_id.type_id();
+ entry->id = res_id.entry_id();
}
// Only mark the type state as public, it doesn't care about being private.
if (symbol.state == SymbolState::kPublic) {
- type->symbolStatus.state = SymbolState::kPublic;
+ type->symbol_status.state = SymbolState::kPublic;
}
if (symbol.state == SymbolState::kUndefined &&
- entry->symbolStatus.state != SymbolState::kUndefined) {
+ entry->symbol_status.state != SymbolState::kUndefined) {
// We can't undefine a symbol (remove its visibility). Ignore.
return true;
}
if (symbol.state == SymbolState::kPrivate &&
- entry->symbolStatus.state == SymbolState::kPublic) {
+ entry->symbol_status.state == SymbolState::kPublic) {
// We can't downgrade public to private. Ignore.
return true;
}
- entry->symbolStatus = std::move(symbol);
+ entry->symbol_status = std::move(symbol);
return true;
}
-Maybe<ResourceTable::SearchResult> ResourceTable::findResource(
+Maybe<ResourceTable::SearchResult> ResourceTable::FindResource(
const ResourceNameRef& name) {
- ResourceTablePackage* package = findPackage(name.package);
+ ResourceTablePackage* package = FindPackage(name.package);
if (!package) {
return {};
}
- ResourceTableType* type = package->findType(name.type);
+ ResourceTableType* type = package->FindType(name.type);
if (!type) {
return {};
}
- ResourceEntry* entry = type->findEntry(name.entry);
+ ResourceEntry* entry = type->FindEntry(name.entry);
if (!entry) {
return {};
}
diff --git a/tools/aapt2/ResourceTable.h b/tools/aapt2/ResourceTable.h
index ebaad41..a0c3217 100644
--- a/tools/aapt2/ResourceTable.h
+++ b/tools/aapt2/ResourceTable.h
@@ -70,7 +70,7 @@
ResourceConfigValue(const ConfigDescription& config,
const StringPiece& product)
- : config(config), product(product.toString()) {}
+ : config(config), product(product.ToString()) {}
private:
DISALLOW_COPY_AND_ASSIGN(ResourceConfigValue);
@@ -98,23 +98,23 @@
* Whether this resource is public (and must maintain the same entry ID across
* builds).
*/
- Symbol symbolStatus;
+ Symbol symbol_status;
/**
* The resource's values for each configuration.
*/
std::vector<std::unique_ptr<ResourceConfigValue>> values;
- explicit ResourceEntry(const StringPiece& name) : name(name.toString()) {}
+ explicit ResourceEntry(const StringPiece& name) : name(name.ToString()) {}
- ResourceConfigValue* findValue(const ConfigDescription& config);
- ResourceConfigValue* findValue(const ConfigDescription& config,
+ ResourceConfigValue* FindValue(const ConfigDescription& config);
+ ResourceConfigValue* FindValue(const ConfigDescription& config,
const StringPiece& product);
- ResourceConfigValue* findOrCreateValue(const ConfigDescription& config,
+ ResourceConfigValue* FindOrCreateValue(const ConfigDescription& config,
const StringPiece& product);
std::vector<ResourceConfigValue*> findAllValues(
const ConfigDescription& config);
- std::vector<ResourceConfigValue*> findValuesIf(
+ std::vector<ResourceConfigValue*> FindValuesIf(
const std::function<bool(ResourceConfigValue*)>& f);
private:
@@ -141,7 +141,7 @@
* Whether this type is public (and must maintain the same
* type ID across builds).
*/
- Symbol symbolStatus;
+ Symbol symbol_status;
/**
* List of resources for this type.
@@ -150,8 +150,8 @@
explicit ResourceTableType(const ResourceType type) : type(type) {}
- ResourceEntry* findEntry(const StringPiece& name);
- ResourceEntry* findOrCreateEntry(const StringPiece& name);
+ ResourceEntry* FindEntry(const StringPiece& name);
+ ResourceEntry* FindOrCreateEntry(const StringPiece& name);
private:
DISALLOW_COPY_AND_ASSIGN(ResourceTableType);
@@ -168,8 +168,8 @@
std::vector<std::unique_ptr<ResourceTableType>> types;
ResourceTablePackage() = default;
- ResourceTableType* findType(ResourceType type);
- ResourceTableType* findOrCreateType(const ResourceType type);
+ ResourceTableType* FindType(ResourceType type);
+ ResourceTableType* FindOrCreateType(const ResourceType type);
private:
DISALLOW_COPY_AND_ASSIGN(ResourceTablePackage);
@@ -191,53 +191,53 @@
* When a collision of resources occurs, this method decides which value to
* keep.
*/
- static CollisionResult resolveValueCollision(Value* existing,
+ static CollisionResult ResolveValueCollision(Value* existing,
Value* incoming);
- bool addResource(const ResourceNameRef& name, const ConfigDescription& config,
+ bool AddResource(const ResourceNameRef& name, const ConfigDescription& config,
const StringPiece& product, std::unique_ptr<Value> value,
IDiagnostics* diag);
- bool addResource(const ResourceNameRef& name, const ResourceId& resId,
+ bool AddResource(const ResourceNameRef& name, const ResourceId& res_id,
const ConfigDescription& config, const StringPiece& product,
std::unique_ptr<Value> value, IDiagnostics* diag);
- bool addFileReference(const ResourceNameRef& name,
+ bool AddFileReference(const ResourceNameRef& name,
const ConfigDescription& config, const Source& source,
const StringPiece& path, IDiagnostics* diag);
- bool addFileReferenceAllowMangled(const ResourceNameRef& name,
+ bool AddFileReferenceAllowMangled(const ResourceNameRef& name,
const ConfigDescription& config,
const Source& source,
const StringPiece& path, io::IFile* file,
IDiagnostics* diag);
/**
- * Same as addResource, but doesn't verify the validity of the name. This is
+ * Same as AddResource, but doesn't verify the validity of the name. This is
* used
* when loading resources from an existing binary resource table that may have
* mangled
* names.
*/
- bool addResourceAllowMangled(const ResourceNameRef& name,
+ bool AddResourceAllowMangled(const ResourceNameRef& name,
const ConfigDescription& config,
const StringPiece& product,
std::unique_ptr<Value> value,
IDiagnostics* diag);
- bool addResourceAllowMangled(const ResourceNameRef& name,
+ bool AddResourceAllowMangled(const ResourceNameRef& name,
const ResourceId& id,
const ConfigDescription& config,
const StringPiece& product,
std::unique_ptr<Value> value,
IDiagnostics* diag);
- bool setSymbolState(const ResourceNameRef& name, const ResourceId& resId,
+ bool SetSymbolState(const ResourceNameRef& name, const ResourceId& res_id,
const Symbol& symbol, IDiagnostics* diag);
- bool setSymbolStateAllowMangled(const ResourceNameRef& name,
- const ResourceId& resId, const Symbol& symbol,
- IDiagnostics* diag);
+ bool SetSymbolStateAllowMangled(const ResourceNameRef& name,
+ const ResourceId& res_id,
+ const Symbol& symbol, IDiagnostics* diag);
struct SearchResult {
ResourceTablePackage* package;
@@ -245,21 +245,21 @@
ResourceEntry* entry;
};
- Maybe<SearchResult> findResource(const ResourceNameRef& name);
+ Maybe<SearchResult> FindResource(const ResourceNameRef& name);
/**
* The string pool used by this resource table. Values that reference strings
* must use
* this pool to create their strings.
*
- * NOTE: `stringPool` must come before `packages` so that it is destroyed
+ * NOTE: `string_pool` must come before `packages` so that it is destroyed
* after.
- * When `string pool` references are destroyed (as they will be when
+ * When `string_pool` references are destroyed (as they will be when
* `packages`
* is destroyed), they decrement a refCount, which would cause invalid
* memory access if the pool was already destroyed.
*/
- StringPool stringPool;
+ StringPool string_pool;
/**
* The list of packages in this table, sorted alphabetically by package name.
@@ -273,31 +273,31 @@
* represent the
* 'current' package before it is known to the ResourceTable.
*/
- ResourceTablePackage* findPackage(const StringPiece& name);
+ ResourceTablePackage* FindPackage(const StringPiece& name);
- ResourceTablePackage* findPackageById(uint8_t id);
+ ResourceTablePackage* FindPackageById(uint8_t id);
- ResourceTablePackage* createPackage(const StringPiece& name,
+ ResourceTablePackage* CreatePackage(const StringPiece& name,
Maybe<uint8_t> id = {});
private:
- ResourceTablePackage* findOrCreatePackage(const StringPiece& name);
+ ResourceTablePackage* FindOrCreatePackage(const StringPiece& name);
- bool addResourceImpl(const ResourceNameRef& name, const ResourceId& resId,
+ bool AddResourceImpl(const ResourceNameRef& name, const ResourceId& res_id,
const ConfigDescription& config,
const StringPiece& product, std::unique_ptr<Value> value,
- const char* validChars,
- const CollisionResolverFunc& conflictResolver,
+ const char* valid_chars,
+ const CollisionResolverFunc& conflict_resolver,
IDiagnostics* diag);
- bool addFileReferenceImpl(const ResourceNameRef& name,
+ bool AddFileReferenceImpl(const ResourceNameRef& name,
const ConfigDescription& config,
const Source& source, const StringPiece& path,
- io::IFile* file, const char* validChars,
+ io::IFile* file, const char* valid_chars,
IDiagnostics* diag);
- bool setSymbolStateImpl(const ResourceNameRef& name, const ResourceId& resId,
- const Symbol& symbol, const char* validChars,
+ bool SetSymbolStateImpl(const ResourceNameRef& name, const ResourceId& res_id,
+ const Symbol& symbol, const char* valid_chars,
IDiagnostics* diag);
DISALLOW_COPY_AND_ASSIGN(ResourceTable);
diff --git a/tools/aapt2/ResourceTable_test.cpp b/tools/aapt2/ResourceTable_test.cpp
index a64ad3e..cb3699a0 100644
--- a/tools/aapt2/ResourceTable_test.cpp
+++ b/tools/aapt2/ResourceTable_test.cpp
@@ -29,108 +29,108 @@
TEST(ResourceTableTest, FailToAddResourceWithBadName) {
ResourceTable table;
- EXPECT_FALSE(table.addResource(
- test::parseNameOrDie("android:id/hey,there"), ConfigDescription{}, "",
- test::ValueBuilder<Id>().setSource("test.xml", 21u).build(),
- test::getDiagnostics()));
+ EXPECT_FALSE(table.AddResource(
+ test::ParseNameOrDie("android:id/hey,there"), ConfigDescription{}, "",
+ test::ValueBuilder<Id>().SetSource("test.xml", 21u).Build(),
+ test::GetDiagnostics()));
- EXPECT_FALSE(table.addResource(
- test::parseNameOrDie("android:id/hey:there"), ConfigDescription{}, "",
- test::ValueBuilder<Id>().setSource("test.xml", 21u).build(),
- test::getDiagnostics()));
+ EXPECT_FALSE(table.AddResource(
+ test::ParseNameOrDie("android:id/hey:there"), ConfigDescription{}, "",
+ test::ValueBuilder<Id>().SetSource("test.xml", 21u).Build(),
+ test::GetDiagnostics()));
}
TEST(ResourceTableTest, AddOneResource) {
ResourceTable table;
- EXPECT_TRUE(table.addResource(
- test::parseNameOrDie("android:attr/id"), ConfigDescription{}, "",
- test::ValueBuilder<Id>().setSource("test/path/file.xml", 23u).build(),
- test::getDiagnostics()));
+ EXPECT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:attr/id"), ConfigDescription{}, "",
+ test::ValueBuilder<Id>().SetSource("test/path/file.xml", 23u).Build(),
+ test::GetDiagnostics()));
- ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:attr/id"));
+ ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
}
TEST(ResourceTableTest, AddMultipleResources) {
ResourceTable table;
ConfigDescription config;
- ConfigDescription languageConfig;
- memcpy(languageConfig.language, "pl", sizeof(languageConfig.language));
+ ConfigDescription language_config;
+ memcpy(language_config.language, "pl", sizeof(language_config.language));
- EXPECT_TRUE(table.addResource(
- test::parseNameOrDie("android:attr/layout_width"), config, "",
- test::ValueBuilder<Id>().setSource("test/path/file.xml", 10u).build(),
- test::getDiagnostics()));
+ EXPECT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:attr/layout_width"), config, "",
+ test::ValueBuilder<Id>().SetSource("test/path/file.xml", 10u).Build(),
+ test::GetDiagnostics()));
- EXPECT_TRUE(table.addResource(
- test::parseNameOrDie("android:attr/id"), config, "",
- test::ValueBuilder<Id>().setSource("test/path/file.xml", 12u).build(),
- test::getDiagnostics()));
+ EXPECT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:attr/id"), config, "",
+ test::ValueBuilder<Id>().SetSource("test/path/file.xml", 12u).Build(),
+ test::GetDiagnostics()));
- EXPECT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/ok"), config, "",
- test::ValueBuilder<Id>().setSource("test/path/file.xml", 14u).build(),
- test::getDiagnostics()));
+ EXPECT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/ok"), config, "",
+ test::ValueBuilder<Id>().SetSource("test/path/file.xml", 14u).Build(),
+ test::GetDiagnostics()));
- EXPECT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/ok"), languageConfig, "",
+ EXPECT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/ok"), language_config, "",
test::ValueBuilder<BinaryPrimitive>(android::Res_value{})
- .setSource("test/path/file.xml", 20u)
- .build(),
- test::getDiagnostics()));
+ .SetSource("test/path/file.xml", 20u)
+ .Build(),
+ test::GetDiagnostics()));
- ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:attr/layout_width"));
- ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:attr/id"));
- ASSERT_NE(nullptr, test::getValue<Id>(&table, "android:string/ok"));
- ASSERT_NE(nullptr, test::getValueForConfig<BinaryPrimitive>(
- &table, "android:string/ok", languageConfig));
+ ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/layout_width"));
+ ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:attr/id"));
+ ASSERT_NE(nullptr, test::GetValue<Id>(&table, "android:string/ok"));
+ ASSERT_NE(nullptr, test::GetValueForConfig<BinaryPrimitive>(
+ &table, "android:string/ok", language_config));
}
TEST(ResourceTableTest, OverrideWeakResourceValue) {
ResourceTable table;
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
- util::make_unique<Attribute>(true), test::getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
+ util::make_unique<Attribute>(true), test::GetDiagnostics()));
- Attribute* attr = test::getValue<Attribute>(&table, "android:attr/foo");
+ Attribute* attr = test::GetValue<Attribute>(&table, "android:attr/foo");
ASSERT_NE(nullptr, attr);
- EXPECT_TRUE(attr->isWeak());
+ EXPECT_TRUE(attr->IsWeak());
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
- util::make_unique<Attribute>(false), test::getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:attr/foo"), ConfigDescription{}, "",
+ util::make_unique<Attribute>(false), test::GetDiagnostics()));
- attr = test::getValue<Attribute>(&table, "android:attr/foo");
+ attr = test::GetValue<Attribute>(&table, "android:attr/foo");
ASSERT_NE(nullptr, attr);
- EXPECT_FALSE(attr->isWeak());
+ EXPECT_FALSE(attr->IsWeak());
}
TEST(ResourceTableTest, ProductVaryingValues) {
ResourceTable table;
- EXPECT_TRUE(table.addResource(test::parseNameOrDie("android:string/foo"),
- test::parseConfigOrDie("land"), "tablet",
+ EXPECT_TRUE(table.AddResource(test::ParseNameOrDie("android:string/foo"),
+ test::ParseConfigOrDie("land"), "tablet",
util::make_unique<Id>(),
- test::getDiagnostics()));
- EXPECT_TRUE(table.addResource(test::parseNameOrDie("android:string/foo"),
- test::parseConfigOrDie("land"), "phone",
+ test::GetDiagnostics()));
+ EXPECT_TRUE(table.AddResource(test::ParseNameOrDie("android:string/foo"),
+ test::ParseConfigOrDie("land"), "phone",
util::make_unique<Id>(),
- test::getDiagnostics()));
+ test::GetDiagnostics()));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/foo",
- test::parseConfigOrDie("land"), "tablet"));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+ test::ParseConfigOrDie("land"), "tablet"));
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/foo",
- test::parseConfigOrDie("land"), "phone"));
+ test::ParseConfigOrDie("land"), "phone"));
Maybe<ResourceTable::SearchResult> sr =
- table.findResource(test::parseNameOrDie("android:string/foo"));
+ table.FindResource(test::ParseNameOrDie("android:string/foo"));
AAPT_ASSERT_TRUE(sr);
std::vector<ResourceConfigValue*> values =
- sr.value().entry->findAllValues(test::parseConfigOrDie("land"));
+ sr.value().entry->findAllValues(test::ParseConfigOrDie("land"));
ASSERT_EQ(2u, values.size());
EXPECT_EQ(std::string("phone"), values[0]->product);
EXPECT_EQ(std::string("tablet"), values[1]->product);
diff --git a/tools/aapt2/ResourceUtils.cpp b/tools/aapt2/ResourceUtils.cpp
index b41be4b..fce9b33 100644
--- a/tools/aapt2/ResourceUtils.cpp
+++ b/tools/aapt2/ResourceUtils.cpp
@@ -15,34 +15,36 @@
*/
#include "ResourceUtils.h"
+
+#include <sstream>
+
+#include "androidfw/ResourceTypes.h"
+
#include "NameMangler.h"
#include "SdkConstants.h"
#include "flatten/ResourceTypeExtensions.h"
#include "util/Files.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-#include <sstream>
-
namespace aapt {
namespace ResourceUtils {
-Maybe<ResourceName> toResourceName(
- const android::ResTable::resource_name& nameIn) {
- ResourceName nameOut;
- if (!nameIn.package) {
+Maybe<ResourceName> ToResourceName(
+ const android::ResTable::resource_name& name_in) {
+ ResourceName name_out;
+ if (!name_in.package) {
return {};
}
- nameOut.package =
- util::utf16ToUtf8(StringPiece16(nameIn.package, nameIn.packageLen));
+ name_out.package =
+ util::Utf16ToUtf8(StringPiece16(name_in.package, name_in.packageLen));
const ResourceType* type;
- if (nameIn.type) {
- type = parseResourceType(
- util::utf16ToUtf8(StringPiece16(nameIn.type, nameIn.typeLen)));
- } else if (nameIn.type8) {
- type = parseResourceType(StringPiece(nameIn.type8, nameIn.typeLen));
+ if (name_in.type) {
+ type = ParseResourceType(
+ util::Utf16ToUtf8(StringPiece16(name_in.type, name_in.typeLen)));
+ } else if (name_in.type8) {
+ type = ParseResourceType(StringPiece(name_in.type8, name_in.typeLen));
} else {
return {};
}
@@ -51,46 +53,46 @@
return {};
}
- nameOut.type = *type;
+ name_out.type = *type;
- if (nameIn.name) {
- nameOut.entry =
- util::utf16ToUtf8(StringPiece16(nameIn.name, nameIn.nameLen));
- } else if (nameIn.name8) {
- nameOut.entry = StringPiece(nameIn.name8, nameIn.nameLen).toString();
+ if (name_in.name) {
+ name_out.entry =
+ util::Utf16ToUtf8(StringPiece16(name_in.name, name_in.nameLen));
+ } else if (name_in.name8) {
+ name_out.entry = StringPiece(name_in.name8, name_in.nameLen).ToString();
} else {
return {};
}
- return nameOut;
+ return name_out;
}
-bool extractResourceName(const StringPiece& str, StringPiece* outPackage,
- StringPiece* outType, StringPiece* outEntry) {
- bool hasPackageSeparator = false;
- bool hasTypeSeparator = false;
+bool ExtractResourceName(const StringPiece& str, StringPiece* out_package,
+ StringPiece* out_type, StringPiece* out_entry) {
+ bool has_package_separator = false;
+ bool has_type_separator = false;
const char* start = str.data();
const char* end = start + str.size();
const char* current = start;
while (current != end) {
- if (outType->size() == 0 && *current == '/') {
- hasTypeSeparator = true;
- outType->assign(start, current - start);
+ if (out_type->size() == 0 && *current == '/') {
+ has_type_separator = true;
+ out_type->assign(start, current - start);
start = current + 1;
- } else if (outPackage->size() == 0 && *current == ':') {
- hasPackageSeparator = true;
- outPackage->assign(start, current - start);
+ } else if (out_package->size() == 0 && *current == ':') {
+ has_package_separator = true;
+ out_package->assign(start, current - start);
start = current + 1;
}
current++;
}
- outEntry->assign(start, end - start);
+ out_entry->assign(start, end - start);
- return !(hasPackageSeparator && outPackage->empty()) &&
- !(hasTypeSeparator && outType->empty());
+ return !(has_package_separator && out_package->empty()) &&
+ !(has_type_separator && out_type->empty());
}
-bool parseResourceName(const StringPiece& str, ResourceNameRef* outRef,
- bool* outPrivate) {
+bool ParseResourceName(const StringPiece& str, ResourceNameRef* out_ref,
+ bool* out_private) {
if (str.empty()) {
return false;
}
@@ -105,13 +107,13 @@
StringPiece package;
StringPiece type;
StringPiece entry;
- if (!extractResourceName(str.substr(offset, str.size() - offset), &package,
+ if (!ExtractResourceName(str.substr(offset, str.size() - offset), &package,
&type, &entry)) {
return false;
}
- const ResourceType* parsedType = parseResourceType(type);
- if (!parsedType) {
+ const ResourceType* parsed_type = ParseResourceType(type);
+ if (!parsed_type) {
return false;
}
@@ -119,37 +121,37 @@
return false;
}
- if (outRef) {
- outRef->package = package;
- outRef->type = *parsedType;
- outRef->entry = entry;
+ if (out_ref) {
+ out_ref->package = package;
+ out_ref->type = *parsed_type;
+ out_ref->entry = entry;
}
- if (outPrivate) {
- *outPrivate = priv;
+ if (out_private) {
+ *out_private = priv;
}
return true;
}
-bool parseReference(const StringPiece& str, ResourceNameRef* outRef,
- bool* outCreate, bool* outPrivate) {
- StringPiece trimmedStr(util::trimWhitespace(str));
- if (trimmedStr.empty()) {
+bool ParseReference(const StringPiece& str, ResourceNameRef* out_ref,
+ bool* out_create, bool* out_private) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
+ if (trimmed_str.empty()) {
return false;
}
bool create = false;
bool priv = false;
- if (trimmedStr.data()[0] == '@') {
+ if (trimmed_str.data()[0] == '@') {
size_t offset = 1;
- if (trimmedStr.data()[1] == '+') {
+ if (trimmed_str.data()[1] == '+') {
create = true;
offset += 1;
}
ResourceNameRef name;
- if (!parseResourceName(
- trimmedStr.substr(offset, trimmedStr.size() - offset), &name,
+ if (!ParseResourceName(
+ trimmed_str.substr(offset, trimmed_str.size() - offset), &name,
&priv)) {
return false;
}
@@ -162,37 +164,37 @@
return false;
}
- if (outRef) {
- *outRef = name;
+ if (out_ref) {
+ *out_ref = name;
}
- if (outCreate) {
- *outCreate = create;
+ if (out_create) {
+ *out_create = create;
}
- if (outPrivate) {
- *outPrivate = priv;
+ if (out_private) {
+ *out_private = priv;
}
return true;
}
return false;
}
-bool isReference(const StringPiece& str) {
- return parseReference(str, nullptr, nullptr, nullptr);
+bool IsReference(const StringPiece& str) {
+ return ParseReference(str, nullptr, nullptr, nullptr);
}
-bool parseAttributeReference(const StringPiece& str, ResourceNameRef* outRef) {
- StringPiece trimmedStr(util::trimWhitespace(str));
- if (trimmedStr.empty()) {
+bool ParseAttributeReference(const StringPiece& str, ResourceNameRef* out_ref) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
+ if (trimmed_str.empty()) {
return false;
}
- if (*trimmedStr.data() == '?') {
+ if (*trimmed_str.data() == '?') {
StringPiece package;
StringPiece type;
StringPiece entry;
- if (!extractResourceName(trimmedStr.substr(1, trimmedStr.size() - 1),
+ if (!ExtractResourceName(trimmed_str.substr(1, trimmed_str.size() - 1),
&package, &type, &entry)) {
return false;
}
@@ -205,18 +207,18 @@
return false;
}
- if (outRef) {
- outRef->package = package;
- outRef->type = ResourceType::kAttr;
- outRef->entry = entry;
+ if (out_ref) {
+ out_ref->package = package;
+ out_ref->type = ResourceType::kAttr;
+ out_ref->entry = entry;
}
return true;
}
return false;
}
-bool isAttributeReference(const StringPiece& str) {
- return parseAttributeReference(str, nullptr);
+bool IsAttributeReference(const StringPiece& str) {
+ return ParseAttributeReference(str, nullptr);
}
/*
@@ -227,65 +229,65 @@
* <[*]package>:[style/]<entry>
* [[*]package:style/]<entry>
*/
-Maybe<Reference> parseStyleParentReference(const StringPiece& str,
- std::string* outError) {
+Maybe<Reference> ParseStyleParentReference(const StringPiece& str,
+ std::string* out_error) {
if (str.empty()) {
return {};
}
StringPiece name = str;
- bool hasLeadingIdentifiers = false;
- bool privateRef = false;
+ bool has_leading_identifiers = false;
+ bool private_ref = false;
// Skip over these identifiers. A style's parent is a normal reference.
if (name.data()[0] == '@' || name.data()[0] == '?') {
- hasLeadingIdentifiers = true;
+ has_leading_identifiers = true;
name = name.substr(1, name.size() - 1);
}
if (name.data()[0] == '*') {
- privateRef = true;
+ private_ref = true;
name = name.substr(1, name.size() - 1);
}
ResourceNameRef ref;
ref.type = ResourceType::kStyle;
- StringPiece typeStr;
- extractResourceName(name, &ref.package, &typeStr, &ref.entry);
- if (!typeStr.empty()) {
+ StringPiece type_str;
+ ExtractResourceName(name, &ref.package, &type_str, &ref.entry);
+ if (!type_str.empty()) {
// If we have a type, make sure it is a Style.
- const ResourceType* parsedType = parseResourceType(typeStr);
- if (!parsedType || *parsedType != ResourceType::kStyle) {
+ const ResourceType* parsed_type = ParseResourceType(type_str);
+ if (!parsed_type || *parsed_type != ResourceType::kStyle) {
std::stringstream err;
- err << "invalid resource type '" << typeStr << "' for parent of style";
- *outError = err.str();
+ err << "invalid resource type '" << type_str << "' for parent of style";
+ *out_error = err.str();
return {};
}
}
- if (!hasLeadingIdentifiers && ref.package.empty() && !typeStr.empty()) {
+ if (!has_leading_identifiers && ref.package.empty() && !type_str.empty()) {
std::stringstream err;
err << "invalid parent reference '" << str << "'";
- *outError = err.str();
+ *out_error = err.str();
return {};
}
Reference result(ref);
- result.privateReference = privateRef;
+ result.private_reference = private_ref;
return result;
}
-Maybe<Reference> parseXmlAttributeName(const StringPiece& str) {
- StringPiece trimmedStr = util::trimWhitespace(str);
- const char* start = trimmedStr.data();
- const char* const end = start + trimmedStr.size();
+Maybe<Reference> ParseXmlAttributeName(const StringPiece& str) {
+ StringPiece trimmed_str = util::TrimWhitespace(str);
+ const char* start = trimmed_str.data();
+ const char* const end = start + trimmed_str.size();
const char* p = start;
Reference ref;
if (p != end && *p == '*') {
- ref.privateReference = true;
+ ref.private_reference = true;
start++;
p++;
}
@@ -302,38 +304,38 @@
}
ref.name =
- ResourceName(package.toString(), ResourceType::kAttr,
- name.empty() ? trimmedStr.toString() : name.toString());
+ ResourceName(package.ToString(), ResourceType::kAttr,
+ name.empty() ? trimmed_str.ToString() : name.ToString());
return Maybe<Reference>(std::move(ref));
}
-std::unique_ptr<Reference> tryParseReference(const StringPiece& str,
- bool* outCreate) {
+std::unique_ptr<Reference> TryParseReference(const StringPiece& str,
+ bool* out_create) {
ResourceNameRef ref;
- bool privateRef = false;
- if (parseReference(str, &ref, outCreate, &privateRef)) {
+ bool private_ref = false;
+ if (ParseReference(str, &ref, out_create, &private_ref)) {
std::unique_ptr<Reference> value = util::make_unique<Reference>(ref);
- value->privateReference = privateRef;
+ value->private_reference = private_ref;
return value;
}
- if (parseAttributeReference(str, &ref)) {
- if (outCreate) {
- *outCreate = false;
+ if (ParseAttributeReference(str, &ref)) {
+ if (out_create) {
+ *out_create = false;
}
return util::make_unique<Reference>(ref, Reference::Type::kAttribute);
}
return {};
}
-std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece& str) {
- StringPiece trimmedStr(util::trimWhitespace(str));
+std::unique_ptr<BinaryPrimitive> TryParseNullOrEmpty(const StringPiece& str) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
android::Res_value value = {};
- if (trimmedStr == "@null") {
+ if (trimmed_str == "@null") {
// TYPE_NULL with data set to 0 is interpreted by the runtime as an error.
// Instead we set the data type to TYPE_REFERENCE with a value of 0.
value.dataType = android::Res_value::TYPE_REFERENCE;
- } else if (trimmedStr == "@empty") {
+ } else if (trimmed_str == "@empty") {
// TYPE_NULL with value of DATA_NULL_EMPTY is handled fine by the runtime.
value.dataType = android::Res_value::TYPE_NULL;
value.data = android::Res_value::DATA_NULL_EMPTY;
@@ -343,14 +345,14 @@
return util::make_unique<BinaryPrimitive>(value);
}
-std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute* enumAttr,
+std::unique_ptr<BinaryPrimitive> TryParseEnumSymbol(const Attribute* enum_attr,
const StringPiece& str) {
- StringPiece trimmedStr(util::trimWhitespace(str));
- for (const Attribute::Symbol& symbol : enumAttr->symbols) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
+ for (const Attribute::Symbol& symbol : enum_attr->symbols) {
// Enum symbols are stored as @package:id/symbol resources,
// so we need to match against the 'entry' part of the identifier.
- const ResourceName& enumSymbolResourceName = symbol.symbol.name.value();
- if (trimmedStr == enumSymbolResourceName.entry) {
+ const ResourceName& enum_symbol_resource_name = symbol.symbol.name.value();
+ if (trimmed_str == enum_symbol_resource_name.entry) {
android::Res_value value = {};
value.dataType = android::Res_value::TYPE_INT_DEC;
value.data = symbol.value;
@@ -360,40 +362,41 @@
return {};
}
-std::unique_ptr<BinaryPrimitive> tryParseFlagSymbol(const Attribute* flagAttr,
+std::unique_ptr<BinaryPrimitive> TryParseFlagSymbol(const Attribute* flag_attr,
const StringPiece& str) {
android::Res_value flags = {};
flags.dataType = android::Res_value::TYPE_INT_HEX;
flags.data = 0u;
- if (util::trimWhitespace(str).empty()) {
+ if (util::TrimWhitespace(str).empty()) {
// Empty string is a valid flag (0).
return util::make_unique<BinaryPrimitive>(flags);
}
- for (StringPiece part : util::tokenize(str, '|')) {
- StringPiece trimmedPart = util::trimWhitespace(part);
+ for (StringPiece part : util::Tokenize(str, '|')) {
+ StringPiece trimmed_part = util::TrimWhitespace(part);
- bool flagSet = false;
- for (const Attribute::Symbol& symbol : flagAttr->symbols) {
+ bool flag_set = false;
+ for (const Attribute::Symbol& symbol : flag_attr->symbols) {
// Flag symbols are stored as @package:id/symbol resources,
// so we need to match against the 'entry' part of the identifier.
- const ResourceName& flagSymbolResourceName = symbol.symbol.name.value();
- if (trimmedPart == flagSymbolResourceName.entry) {
+ const ResourceName& flag_symbol_resource_name =
+ symbol.symbol.name.value();
+ if (trimmed_part == flag_symbol_resource_name.entry) {
flags.data |= symbol.value;
- flagSet = true;
+ flag_set = true;
break;
}
}
- if (!flagSet) {
+ if (!flag_set) {
return {};
}
}
return util::make_unique<BinaryPrimitive>(flags);
}
-static uint32_t parseHex(char c, bool* outError) {
+static uint32_t ParseHex(char c, bool* out_error) {
if (c >= '0' && c <= '9') {
return c - '0';
} else if (c >= 'a' && c <= 'f') {
@@ -401,15 +404,15 @@
} else if (c >= 'A' && c <= 'F') {
return c - 'A' + 0xa;
} else {
- *outError = true;
+ *out_error = true;
return 0xffffffffu;
}
}
-std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece& str) {
- StringPiece colorStr(util::trimWhitespace(str));
- const char* start = colorStr.data();
- const size_t len = colorStr.size();
+std::unique_ptr<BinaryPrimitive> TryParseColor(const StringPiece& str) {
+ StringPiece color_str(util::TrimWhitespace(str));
+ const char* start = color_str.data();
+ const size_t len = color_str.size();
if (len == 0 || start[0] != '#') {
return {};
}
@@ -419,41 +422,41 @@
if (len == 4) {
value.dataType = android::Res_value::TYPE_INT_COLOR_RGB4;
value.data = 0xff000000u;
- value.data |= parseHex(start[1], &error) << 20;
- value.data |= parseHex(start[1], &error) << 16;
- value.data |= parseHex(start[2], &error) << 12;
- value.data |= parseHex(start[2], &error) << 8;
- value.data |= parseHex(start[3], &error) << 4;
- value.data |= parseHex(start[3], &error);
+ value.data |= ParseHex(start[1], &error) << 20;
+ value.data |= ParseHex(start[1], &error) << 16;
+ value.data |= ParseHex(start[2], &error) << 12;
+ value.data |= ParseHex(start[2], &error) << 8;
+ value.data |= ParseHex(start[3], &error) << 4;
+ value.data |= ParseHex(start[3], &error);
} else if (len == 5) {
value.dataType = android::Res_value::TYPE_INT_COLOR_ARGB4;
- value.data |= parseHex(start[1], &error) << 28;
- value.data |= parseHex(start[1], &error) << 24;
- value.data |= parseHex(start[2], &error) << 20;
- value.data |= parseHex(start[2], &error) << 16;
- value.data |= parseHex(start[3], &error) << 12;
- value.data |= parseHex(start[3], &error) << 8;
- value.data |= parseHex(start[4], &error) << 4;
- value.data |= parseHex(start[4], &error);
+ value.data |= ParseHex(start[1], &error) << 28;
+ value.data |= ParseHex(start[1], &error) << 24;
+ value.data |= ParseHex(start[2], &error) << 20;
+ value.data |= ParseHex(start[2], &error) << 16;
+ value.data |= ParseHex(start[3], &error) << 12;
+ value.data |= ParseHex(start[3], &error) << 8;
+ value.data |= ParseHex(start[4], &error) << 4;
+ value.data |= ParseHex(start[4], &error);
} else if (len == 7) {
value.dataType = android::Res_value::TYPE_INT_COLOR_RGB8;
value.data = 0xff000000u;
- value.data |= parseHex(start[1], &error) << 20;
- value.data |= parseHex(start[2], &error) << 16;
- value.data |= parseHex(start[3], &error) << 12;
- value.data |= parseHex(start[4], &error) << 8;
- value.data |= parseHex(start[5], &error) << 4;
- value.data |= parseHex(start[6], &error);
+ value.data |= ParseHex(start[1], &error) << 20;
+ value.data |= ParseHex(start[2], &error) << 16;
+ value.data |= ParseHex(start[3], &error) << 12;
+ value.data |= ParseHex(start[4], &error) << 8;
+ value.data |= ParseHex(start[5], &error) << 4;
+ value.data |= ParseHex(start[6], &error);
} else if (len == 9) {
value.dataType = android::Res_value::TYPE_INT_COLOR_ARGB8;
- value.data |= parseHex(start[1], &error) << 28;
- value.data |= parseHex(start[2], &error) << 24;
- value.data |= parseHex(start[3], &error) << 20;
- value.data |= parseHex(start[4], &error) << 16;
- value.data |= parseHex(start[5], &error) << 12;
- value.data |= parseHex(start[6], &error) << 8;
- value.data |= parseHex(start[7], &error) << 4;
- value.data |= parseHex(start[8], &error);
+ value.data |= ParseHex(start[1], &error) << 28;
+ value.data |= ParseHex(start[2], &error) << 24;
+ value.data |= ParseHex(start[3], &error) << 20;
+ value.data |= ParseHex(start[4], &error) << 16;
+ value.data |= ParseHex(start[5], &error) << 12;
+ value.data |= ParseHex(start[6], &error) << 8;
+ value.data |= ParseHex(start[7], &error) << 4;
+ value.data |= ParseHex(start[8], &error);
} else {
return {};
}
@@ -461,19 +464,19 @@
: util::make_unique<BinaryPrimitive>(value);
}
-Maybe<bool> parseBool(const StringPiece& str) {
- StringPiece trimmedStr(util::trimWhitespace(str));
- if (trimmedStr == "true" || trimmedStr == "TRUE" || trimmedStr == "True") {
+Maybe<bool> ParseBool(const StringPiece& str) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
+ if (trimmed_str == "true" || trimmed_str == "TRUE" || trimmed_str == "True") {
return Maybe<bool>(true);
- } else if (trimmedStr == "false" || trimmedStr == "FALSE" ||
- trimmedStr == "False") {
+ } else if (trimmed_str == "false" || trimmed_str == "FALSE" ||
+ trimmed_str == "False") {
return Maybe<bool>(false);
}
return {};
}
-Maybe<uint32_t> parseInt(const StringPiece& str) {
- std::u16string str16 = util::utf8ToUtf16(str);
+Maybe<uint32_t> ParseInt(const StringPiece& str) {
+ std::u16string str16 = util::Utf8ToUtf16(str);
android::Res_value value;
if (android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
return value.data;
@@ -481,15 +484,15 @@
return {};
}
-Maybe<ResourceId> parseResourceId(const StringPiece& str) {
- StringPiece trimmedStr(util::trimWhitespace(str));
+Maybe<ResourceId> ParseResourceId(const StringPiece& str) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
- std::u16string str16 = util::utf8ToUtf16(trimmedStr);
+ std::u16string str16 = util::Utf8ToUtf16(trimmed_str);
android::Res_value value;
if (android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
if (value.dataType == android::Res_value::TYPE_INT_HEX) {
ResourceId id(value.data);
- if (id.isValid()) {
+ if (id.is_valid()) {
return id;
}
}
@@ -497,29 +500,29 @@
return {};
}
-Maybe<int> parseSdkVersion(const StringPiece& str) {
- StringPiece trimmedStr(util::trimWhitespace(str));
+Maybe<int> ParseSdkVersion(const StringPiece& str) {
+ StringPiece trimmed_str(util::TrimWhitespace(str));
- std::u16string str16 = util::utf8ToUtf16(trimmedStr);
+ std::u16string str16 = util::Utf8ToUtf16(trimmed_str);
android::Res_value value;
if (android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
return static_cast<int>(value.data);
}
// Try parsing the code name.
- std::pair<StringPiece, int> entry = getDevelopmentSdkCodeNameAndVersion();
- if (entry.first == trimmedStr) {
+ std::pair<StringPiece, int> entry = GetDevelopmentSdkCodeNameAndVersion();
+ if (entry.first == trimmed_str) {
return entry.second;
}
return {};
}
-std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece& str) {
- if (Maybe<bool> maybeResult = parseBool(str)) {
+std::unique_ptr<BinaryPrimitive> TryParseBool(const StringPiece& str) {
+ if (Maybe<bool> maybe_result = ParseBool(str)) {
android::Res_value value = {};
value.dataType = android::Res_value::TYPE_INT_BOOLEAN;
- if (maybeResult.value()) {
+ if (maybe_result.value()) {
value.data = 0xffffffffu;
} else {
value.data = 0;
@@ -529,8 +532,8 @@
return {};
}
-std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece& str) {
- std::u16string str16 = util::utf8ToUtf16(str);
+std::unique_ptr<BinaryPrimitive> TryParseInt(const StringPiece& str) {
+ std::u16string str16 = util::Utf8ToUtf16(str);
android::Res_value value;
if (!android::ResTable::stringToInt(str16.data(), str16.size(), &value)) {
return {};
@@ -538,8 +541,8 @@
return util::make_unique<BinaryPrimitive>(value);
}
-std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece& str) {
- std::u16string str16 = util::utf8ToUtf16(str);
+std::unique_ptr<BinaryPrimitive> TryParseFloat(const StringPiece& str) {
+ std::u16string str16 = util::Utf8ToUtf16(str);
android::Res_value value;
if (!android::ResTable::stringToFloat(str16.data(), str16.size(), &value)) {
return {};
@@ -547,7 +550,7 @@
return util::make_unique<BinaryPrimitive>(value);
}
-uint32_t androidTypeToAttributeTypeMask(uint16_t type) {
+uint32_t AndroidTypeToAttributeTypeMask(uint16_t type) {
switch (type) {
case android::Res_value::TYPE_NULL:
case android::Res_value::TYPE_REFERENCE:
@@ -587,57 +590,57 @@
};
}
-std::unique_ptr<Item> tryParseItemForAttribute(
- const StringPiece& value, uint32_t typeMask,
- const std::function<void(const ResourceName&)>& onCreateReference) {
- std::unique_ptr<BinaryPrimitive> nullOrEmpty = tryParseNullOrEmpty(value);
- if (nullOrEmpty) {
- return std::move(nullOrEmpty);
+std::unique_ptr<Item> TryParseItemForAttribute(
+ const StringPiece& value, uint32_t type_mask,
+ const std::function<void(const ResourceName&)>& on_create_reference) {
+ std::unique_ptr<BinaryPrimitive> null_or_empty = TryParseNullOrEmpty(value);
+ if (null_or_empty) {
+ return std::move(null_or_empty);
}
bool create = false;
- std::unique_ptr<Reference> reference = tryParseReference(value, &create);
+ std::unique_ptr<Reference> reference = TryParseReference(value, &create);
if (reference) {
- if (create && onCreateReference) {
- onCreateReference(reference->name.value());
+ if (create && on_create_reference) {
+ on_create_reference(reference->name.value());
}
return std::move(reference);
}
- if (typeMask & android::ResTable_map::TYPE_COLOR) {
+ if (type_mask & android::ResTable_map::TYPE_COLOR) {
// Try parsing this as a color.
- std::unique_ptr<BinaryPrimitive> color = tryParseColor(value);
+ std::unique_ptr<BinaryPrimitive> color = TryParseColor(value);
if (color) {
return std::move(color);
}
}
- if (typeMask & android::ResTable_map::TYPE_BOOLEAN) {
+ if (type_mask & android::ResTable_map::TYPE_BOOLEAN) {
// Try parsing this as a boolean.
- std::unique_ptr<BinaryPrimitive> boolean = tryParseBool(value);
+ std::unique_ptr<BinaryPrimitive> boolean = TryParseBool(value);
if (boolean) {
return std::move(boolean);
}
}
- if (typeMask & android::ResTable_map::TYPE_INTEGER) {
+ if (type_mask & android::ResTable_map::TYPE_INTEGER) {
// Try parsing this as an integer.
- std::unique_ptr<BinaryPrimitive> integer = tryParseInt(value);
+ std::unique_ptr<BinaryPrimitive> integer = TryParseInt(value);
if (integer) {
return std::move(integer);
}
}
- const uint32_t floatMask = android::ResTable_map::TYPE_FLOAT |
- android::ResTable_map::TYPE_DIMENSION |
- android::ResTable_map::TYPE_FRACTION;
- if (typeMask & floatMask) {
+ const uint32_t float_mask = android::ResTable_map::TYPE_FLOAT |
+ android::ResTable_map::TYPE_DIMENSION |
+ android::ResTable_map::TYPE_FRACTION;
+ if (type_mask & float_mask) {
// Try parsing this as a float.
- std::unique_ptr<BinaryPrimitive> floatingPoint = tryParseFloat(value);
- if (floatingPoint) {
- if (typeMask &
- androidTypeToAttributeTypeMask(floatingPoint->value.dataType)) {
- return std::move(floatingPoint);
+ std::unique_ptr<BinaryPrimitive> floating_point = TryParseFloat(value);
+ if (floating_point) {
+ if (type_mask &
+ AndroidTypeToAttributeTypeMask(floating_point->value.dataType)) {
+ return std::move(floating_point);
}
}
}
@@ -648,49 +651,49 @@
* We successively try to parse the string as a resource type that the Attribute
* allows.
*/
-std::unique_ptr<Item> tryParseItemForAttribute(
+std::unique_ptr<Item> TryParseItemForAttribute(
const StringPiece& str, const Attribute* attr,
- const std::function<void(const ResourceName&)>& onCreateReference) {
- const uint32_t typeMask = attr->typeMask;
+ const std::function<void(const ResourceName&)>& on_create_reference) {
+ const uint32_t type_mask = attr->type_mask;
std::unique_ptr<Item> value =
- tryParseItemForAttribute(str, typeMask, onCreateReference);
+ TryParseItemForAttribute(str, type_mask, on_create_reference);
if (value) {
return value;
}
- if (typeMask & android::ResTable_map::TYPE_ENUM) {
+ if (type_mask & android::ResTable_map::TYPE_ENUM) {
// Try parsing this as an enum.
- std::unique_ptr<BinaryPrimitive> enumValue = tryParseEnumSymbol(attr, str);
- if (enumValue) {
- return std::move(enumValue);
+ std::unique_ptr<BinaryPrimitive> enum_value = TryParseEnumSymbol(attr, str);
+ if (enum_value) {
+ return std::move(enum_value);
}
}
- if (typeMask & android::ResTable_map::TYPE_FLAGS) {
+ if (type_mask & android::ResTable_map::TYPE_FLAGS) {
// Try parsing this as a flag.
- std::unique_ptr<BinaryPrimitive> flagValue = tryParseFlagSymbol(attr, str);
- if (flagValue) {
- return std::move(flagValue);
+ std::unique_ptr<BinaryPrimitive> flag_value = TryParseFlagSymbol(attr, str);
+ if (flag_value) {
+ return std::move(flag_value);
}
}
return {};
}
-std::string buildResourceFileName(const ResourceFile& resFile,
+std::string BuildResourceFileName(const ResourceFile& res_file,
const NameMangler* mangler) {
std::stringstream out;
- out << "res/" << resFile.name.type;
- if (resFile.config != ConfigDescription{}) {
- out << "-" << resFile.config;
+ out << "res/" << res_file.name.type;
+ if (res_file.config != ConfigDescription{}) {
+ out << "-" << res_file.config;
}
out << "/";
- if (mangler && mangler->shouldMangle(resFile.name.package)) {
- out << NameMangler::mangleEntry(resFile.name.package, resFile.name.entry);
+ if (mangler && mangler->ShouldMangle(res_file.name.package)) {
+ out << NameMangler::MangleEntry(res_file.name.package, res_file.name.entry);
} else {
- out << resFile.name.entry;
+ out << res_file.name.entry;
}
- out << file::getExtension(resFile.source.path);
+ out << file::GetExtension(res_file.source.path);
return out.str();
}
diff --git a/tools/aapt2/ResourceUtils.h b/tools/aapt2/ResourceUtils.h
index cebe47c..9766f6a 100644
--- a/tools/aapt2/ResourceUtils.h
+++ b/tools/aapt2/ResourceUtils.h
@@ -17,14 +17,14 @@
#ifndef AAPT_RESOURCEUTILS_H
#define AAPT_RESOURCEUTILS_H
+#include <functional>
+#include <memory>
+
#include "NameMangler.h"
#include "Resource.h"
#include "ResourceValues.h"
#include "util/StringPiece.h"
-#include <functional>
-#include <memory>
-
namespace aapt {
namespace ResourceUtils {
@@ -37,76 +37,75 @@
* individual extracted piece to verify that the pieces are valid.
* Returns false if there was no package but a ':' was present.
*/
-bool extractResourceName(const StringPiece& str, StringPiece* outPackage,
- StringPiece* outType, StringPiece* outEntry);
+bool ExtractResourceName(const StringPiece& str, StringPiece* out_package,
+ StringPiece* out_type, StringPiece* out_entry);
/**
* Returns true if the string was parsed as a resource name
* ([*][package:]type/name), with
- * `outResource` set to the parsed resource name and `outPrivate` set to true if
- * a '*' prefix
- * was present.
+ * `out_resource` set to the parsed resource name and `out_private` set to true
+ * if a '*' prefix was present.
*/
-bool parseResourceName(const StringPiece& str, ResourceNameRef* outResource,
- bool* outPrivate = nullptr);
+bool ParseResourceName(const StringPiece& str, ResourceNameRef* out_resource,
+ bool* out_private = nullptr);
/*
* Returns true if the string was parsed as a reference
* (@[+][package:]type/name), with
- * `outReference` set to the parsed reference.
+ * `out_reference` set to the parsed reference.
*
- * If '+' was present in the reference, `outCreate` is set to true.
- * If '*' was present in the reference, `outPrivate` is set to true.
+ * If '+' was present in the reference, `out_create` is set to true.
+ * If '*' was present in the reference, `out_private` is set to true.
*/
-bool parseReference(const StringPiece& str, ResourceNameRef* outReference,
- bool* outCreate = nullptr, bool* outPrivate = nullptr);
+bool ParseReference(const StringPiece& str, ResourceNameRef* out_reference,
+ bool* out_create = nullptr, bool* out_private = nullptr);
/*
* Returns true if the string is in the form of a resource reference
* (@[+][package:]type/name).
*/
-bool isReference(const StringPiece& str);
+bool IsReference(const StringPiece& str);
/*
* Returns true if the string was parsed as an attribute reference
* (?[package:][type/]name),
- * with `outReference` set to the parsed reference.
+ * with `out_reference` set to the parsed reference.
*/
-bool parseAttributeReference(const StringPiece& str,
- ResourceNameRef* outReference);
+bool ParseAttributeReference(const StringPiece& str,
+ ResourceNameRef* out_reference);
/**
* Returns true if the string is in the form of an attribute
* reference(?[package:][type/]name).
*/
-bool isAttributeReference(const StringPiece& str);
+bool IsAttributeReference(const StringPiece& str);
/**
* Convert an android::ResTable::resource_name to an aapt::ResourceName struct.
*/
-Maybe<ResourceName> toResourceName(
+Maybe<ResourceName> ToResourceName(
const android::ResTable::resource_name& name);
/**
* Returns a boolean value if the string is equal to TRUE, true, True, FALSE,
* false, or False.
*/
-Maybe<bool> parseBool(const StringPiece& str);
+Maybe<bool> ParseBool(const StringPiece& str);
/**
* Returns a uint32_t if the string is an integer.
*/
-Maybe<uint32_t> parseInt(const StringPiece& str);
+Maybe<uint32_t> ParseInt(const StringPiece& str);
/**
* Returns an ID if it the string represented a valid ID.
*/
-Maybe<ResourceId> parseResourceId(const StringPiece& str);
+Maybe<ResourceId> ParseResourceId(const StringPiece& str);
/**
* Parses an SDK version, which can be an integer, or a letter from A-Z.
*/
-Maybe<int> parseSdkVersion(const StringPiece& str);
+Maybe<int> ParseSdkVersion(const StringPiece& str);
/*
* Returns a Reference, or None Maybe instance if the string `str` was parsed as
@@ -119,8 +118,8 @@
* ?[package:]style/<entry> or
* <package>:[style/]<entry>
*/
-Maybe<Reference> parseStyleParentReference(const StringPiece& str,
- std::string* outError);
+Maybe<Reference> ParseStyleParentReference(const StringPiece& str,
+ std::string* out_error);
/*
* Returns a Reference if the string `str` was parsed as a valid XML attribute
@@ -129,7 +128,7 @@
*
* package:entry
*/
-Maybe<Reference> parseXmlAttributeName(const StringPiece& str);
+Maybe<Reference> ParseXmlAttributeName(const StringPiece& str);
/*
* Returns a Reference object if the string was parsed as a resource or
@@ -138,73 +137,68 @@
* if
* the '+' was present in the string.
*/
-std::unique_ptr<Reference> tryParseReference(const StringPiece& str,
- bool* outCreate = nullptr);
+std::unique_ptr<Reference> TryParseReference(const StringPiece& str,
+ bool* out_create = nullptr);
/*
* Returns a BinaryPrimitve object representing @null or @empty if the string
- * was parsed
- * as one.
+ * was parsed as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseNullOrEmpty(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseNullOrEmpty(const StringPiece& str);
/*
* Returns a BinaryPrimitve object representing a color if the string was parsed
* as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseColor(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseColor(const StringPiece& str);
/*
* Returns a BinaryPrimitve object representing a boolean if the string was
- * parsed
- * as one.
+ * parsed as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseBool(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseBool(const StringPiece& str);
/*
* Returns a BinaryPrimitve object representing an integer if the string was
- * parsed
- * as one.
+ * parsed as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseInt(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseInt(const StringPiece& str);
/*
* Returns a BinaryPrimitve object representing a floating point number
* (float, dimension, etc) if the string was parsed as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseFloat(const StringPiece& str);
+std::unique_ptr<BinaryPrimitive> TryParseFloat(const StringPiece& str);
/*
* Returns a BinaryPrimitve object representing an enum symbol if the string was
- * parsed
- * as one.
+ * parsed as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseEnumSymbol(const Attribute* enumAttr,
+std::unique_ptr<BinaryPrimitive> TryParseEnumSymbol(const Attribute* enum_attr,
const StringPiece& str);
/*
* Returns a BinaryPrimitve object representing a flag symbol if the string was
- * parsed
- * as one.
+ * parsed as one.
*/
-std::unique_ptr<BinaryPrimitive> tryParseFlagSymbol(const Attribute* enumAttr,
+std::unique_ptr<BinaryPrimitive> TryParseFlagSymbol(const Attribute* enum_attr,
const StringPiece& str);
/*
* Try to convert a string to an Item for the given attribute. The attribute
* will
* restrict what values the string can be converted to.
- * The callback function onCreateReference is called when the parsed item is a
+ * The callback function on_create_reference is called when the parsed item is a
* reference to an ID that must be created (@+id/foo).
*/
-std::unique_ptr<Item> tryParseItemForAttribute(
+std::unique_ptr<Item> TryParseItemForAttribute(
const StringPiece& value, const Attribute* attr,
- const std::function<void(const ResourceName&)>& onCreateReference = {});
+ const std::function<void(const ResourceName&)>& on_create_reference = {});
-std::unique_ptr<Item> tryParseItemForAttribute(
- const StringPiece& value, uint32_t typeMask,
- const std::function<void(const ResourceName&)>& onCreateReference = {});
+std::unique_ptr<Item> TryParseItemForAttribute(
+ const StringPiece& value, uint32_t type_mask,
+ const std::function<void(const ResourceName&)>& on_create_reference = {});
-uint32_t androidTypeToAttributeTypeMask(uint16_t type);
+uint32_t AndroidTypeToAttributeTypeMask(uint16_t type);
/**
* Returns a string path suitable for use within an APK. The path will look
@@ -216,8 +210,8 @@
* the package
* requires mangling.
*/
-std::string buildResourceFileName(const ResourceFile& resFile,
- const NameMangler* mangler);
+std::string BuildResourceFileName(const ResourceFile& res_file,
+ const NameMangler* mangler = nullptr);
} // namespace ResourceUtils
} // namespace aapt
diff --git a/tools/aapt2/ResourceUtils_test.cpp b/tools/aapt2/ResourceUtils_test.cpp
index eb62b1b..f9c500b 100644
--- a/tools/aapt2/ResourceUtils_test.cpp
+++ b/tools/aapt2/ResourceUtils_test.cpp
@@ -15,128 +15,129 @@
*/
#include "ResourceUtils.h"
+
#include "Resource.h"
#include "test/Test.h"
namespace aapt {
TEST(ResourceUtilsTest, ParseBool) {
- EXPECT_EQ(Maybe<bool>(true), ResourceUtils::parseBool("true"));
- EXPECT_EQ(Maybe<bool>(true), ResourceUtils::parseBool("TRUE"));
- EXPECT_EQ(Maybe<bool>(true), ResourceUtils::parseBool("True"));
- EXPECT_EQ(Maybe<bool>(false), ResourceUtils::parseBool("false"));
- EXPECT_EQ(Maybe<bool>(false), ResourceUtils::parseBool("FALSE"));
- EXPECT_EQ(Maybe<bool>(false), ResourceUtils::parseBool("False"));
+ EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("true"));
+ EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("TRUE"));
+ EXPECT_EQ(Maybe<bool>(true), ResourceUtils::ParseBool("True"));
+ EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("false"));
+ EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("FALSE"));
+ EXPECT_EQ(Maybe<bool>(false), ResourceUtils::ParseBool("False"));
}
TEST(ResourceUtilsTest, ParseResourceName) {
ResourceNameRef actual;
- bool actualPriv = false;
- EXPECT_TRUE(ResourceUtils::parseResourceName("android:color/foo", &actual,
- &actualPriv));
+ bool actual_priv = false;
+ EXPECT_TRUE(ResourceUtils::ParseResourceName("android:color/foo", &actual,
+ &actual_priv));
EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
- EXPECT_FALSE(actualPriv);
+ EXPECT_FALSE(actual_priv);
EXPECT_TRUE(
- ResourceUtils::parseResourceName("color/foo", &actual, &actualPriv));
+ ResourceUtils::ParseResourceName("color/foo", &actual, &actual_priv));
EXPECT_EQ(ResourceNameRef({}, ResourceType::kColor, "foo"), actual);
- EXPECT_FALSE(actualPriv);
+ EXPECT_FALSE(actual_priv);
- EXPECT_TRUE(ResourceUtils::parseResourceName("*android:color/foo", &actual,
- &actualPriv));
+ EXPECT_TRUE(ResourceUtils::ParseResourceName("*android:color/foo", &actual,
+ &actual_priv));
EXPECT_EQ(ResourceNameRef("android", ResourceType::kColor, "foo"), actual);
- EXPECT_TRUE(actualPriv);
+ EXPECT_TRUE(actual_priv);
EXPECT_FALSE(
- ResourceUtils::parseResourceName(StringPiece(), &actual, &actualPriv));
+ ResourceUtils::ParseResourceName(StringPiece(), &actual, &actual_priv));
}
TEST(ResourceUtilsTest, ParseReferenceWithNoPackage) {
ResourceNameRef expected({}, ResourceType::kColor, "foo");
ResourceNameRef actual;
bool create = false;
- bool privateRef = false;
- EXPECT_TRUE(ResourceUtils::parseReference("@color/foo", &actual, &create,
- &privateRef));
+ bool private_ref = false;
+ EXPECT_TRUE(ResourceUtils::ParseReference("@color/foo", &actual, &create,
+ &private_ref));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
- EXPECT_FALSE(privateRef);
+ EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParseReferenceWithPackage) {
ResourceNameRef expected("android", ResourceType::kColor, "foo");
ResourceNameRef actual;
bool create = false;
- bool privateRef = false;
- EXPECT_TRUE(ResourceUtils::parseReference("@android:color/foo", &actual,
- &create, &privateRef));
+ bool private_ref = false;
+ EXPECT_TRUE(ResourceUtils::ParseReference("@android:color/foo", &actual,
+ &create, &private_ref));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
- EXPECT_FALSE(privateRef);
+ EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParseReferenceWithSurroundingWhitespace) {
ResourceNameRef expected("android", ResourceType::kColor, "foo");
ResourceNameRef actual;
bool create = false;
- bool privateRef = false;
- EXPECT_TRUE(ResourceUtils::parseReference("\t @android:color/foo\n \n\t",
- &actual, &create, &privateRef));
+ bool private_ref = false;
+ EXPECT_TRUE(ResourceUtils::ParseReference("\t @android:color/foo\n \n\t",
+ &actual, &create, &private_ref));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
- EXPECT_FALSE(privateRef);
+ EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParseAutoCreateIdReference) {
ResourceNameRef expected("android", ResourceType::kId, "foo");
ResourceNameRef actual;
bool create = false;
- bool privateRef = false;
- EXPECT_TRUE(ResourceUtils::parseReference("@+android:id/foo", &actual,
- &create, &privateRef));
+ bool private_ref = false;
+ EXPECT_TRUE(ResourceUtils::ParseReference("@+android:id/foo", &actual,
+ &create, &private_ref));
EXPECT_EQ(expected, actual);
EXPECT_TRUE(create);
- EXPECT_FALSE(privateRef);
+ EXPECT_FALSE(private_ref);
}
TEST(ResourceUtilsTest, ParsePrivateReference) {
ResourceNameRef expected("android", ResourceType::kId, "foo");
ResourceNameRef actual;
bool create = false;
- bool privateRef = false;
- EXPECT_TRUE(ResourceUtils::parseReference("@*android:id/foo", &actual,
- &create, &privateRef));
+ bool private_ref = false;
+ EXPECT_TRUE(ResourceUtils::ParseReference("@*android:id/foo", &actual,
+ &create, &private_ref));
EXPECT_EQ(expected, actual);
EXPECT_FALSE(create);
- EXPECT_TRUE(privateRef);
+ EXPECT_TRUE(private_ref);
}
TEST(ResourceUtilsTest, FailToParseAutoCreateNonIdReference) {
bool create = false;
- bool privateRef = false;
+ bool private_ref = false;
ResourceNameRef actual;
- EXPECT_FALSE(ResourceUtils::parseReference("@+android:color/foo", &actual,
- &create, &privateRef));
+ EXPECT_FALSE(ResourceUtils::ParseReference("@+android:color/foo", &actual,
+ &create, &private_ref));
}
TEST(ResourceUtilsTest, ParseAttributeReferences) {
- EXPECT_TRUE(ResourceUtils::isAttributeReference("?android"));
- EXPECT_TRUE(ResourceUtils::isAttributeReference("?android:foo"));
- EXPECT_TRUE(ResourceUtils::isAttributeReference("?attr/foo"));
- EXPECT_TRUE(ResourceUtils::isAttributeReference("?android:attr/foo"));
+ EXPECT_TRUE(ResourceUtils::IsAttributeReference("?android"));
+ EXPECT_TRUE(ResourceUtils::IsAttributeReference("?android:foo"));
+ EXPECT_TRUE(ResourceUtils::IsAttributeReference("?attr/foo"));
+ EXPECT_TRUE(ResourceUtils::IsAttributeReference("?android:attr/foo"));
}
TEST(ResourceUtilsTest, FailParseIncompleteReference) {
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?style/foo"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?android:style/foo"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?android:"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?android:attr/"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?:attr/"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?:attr/foo"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?:/"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?:/foo"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?attr/"));
- EXPECT_FALSE(ResourceUtils::isAttributeReference("?/foo"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?style/foo"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?android:style/foo"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?android:"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?android:attr/"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:attr/"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:attr/foo"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:/"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?:/foo"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?attr/"));
+ EXPECT_FALSE(ResourceUtils::IsAttributeReference("?/foo"));
}
TEST(ResourceUtilsTest, ParseStyleParentReference) {
@@ -144,56 +145,58 @@
"foo");
const ResourceName kStyleFooName({}, ResourceType::kStyle, "foo");
- std::string errStr;
+ std::string err_str;
Maybe<Reference> ref =
- ResourceUtils::parseStyleParentReference("@android:style/foo", &errStr);
+ ResourceUtils::ParseStyleParentReference("@android:style/foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("@style/foo", &errStr);
+ ref = ResourceUtils::ParseStyleParentReference("@style/foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("?android:style/foo", &errStr);
+ ref =
+ ResourceUtils::ParseStyleParentReference("?android:style/foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("?style/foo", &errStr);
+ ref = ResourceUtils::ParseStyleParentReference("?style/foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("android:style/foo", &errStr);
+ ref = ResourceUtils::ParseStyleParentReference("android:style/foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("android:foo", &errStr);
+ ref = ResourceUtils::ParseStyleParentReference("android:foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("@android:foo", &errStr);
+ ref = ResourceUtils::ParseStyleParentReference("@android:foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("foo", &errStr);
+ ref = ResourceUtils::ParseStyleParentReference("foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kStyleFooName);
- ref = ResourceUtils::parseStyleParentReference("*android:style/foo", &errStr);
+ ref =
+ ResourceUtils::ParseStyleParentReference("*android:style/foo", &err_str);
AAPT_ASSERT_TRUE(ref);
EXPECT_EQ(ref.value().name.value(), kAndroidStyleFooName);
- EXPECT_TRUE(ref.value().privateReference);
+ EXPECT_TRUE(ref.value().private_reference);
}
TEST(ResourceUtilsTest, ParseEmptyFlag) {
std::unique_ptr<Attribute> attr =
test::AttributeBuilder(false)
- .setTypeMask(android::ResTable_map::TYPE_FLAGS)
- .addItem("one", 0x01)
- .addItem("two", 0x02)
- .build();
+ .SetTypeMask(android::ResTable_map::TYPE_FLAGS)
+ .AddItem("one", 0x01)
+ .AddItem("two", 0x02)
+ .Build();
std::unique_ptr<BinaryPrimitive> result =
- ResourceUtils::tryParseFlagSymbol(attr.get(), "");
+ ResourceUtils::TryParseFlagSymbol(attr.get(), "");
ASSERT_NE(nullptr, result);
EXPECT_EQ(0u, result->value.data);
}
diff --git a/tools/aapt2/ResourceValues.cpp b/tools/aapt2/ResourceValues.cpp
index 60590b6..7956ad8 100644
--- a/tools/aapt2/ResourceValues.cpp
+++ b/tools/aapt2/ResourceValues.cpp
@@ -15,94 +15,95 @@
*/
#include "ResourceValues.h"
+
+#include <algorithm>
+#include <limits>
+#include <set>
+
+#include "androidfw/ResourceTypes.h"
+
#include "Resource.h"
#include "ResourceUtils.h"
#include "ValueVisitor.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-#include <algorithm>
-#include <limits>
-#include <set>
-
namespace aapt {
template <typename Derived>
-void BaseValue<Derived>::accept(RawValueVisitor* visitor) {
- visitor->visit(static_cast<Derived*>(this));
+void BaseValue<Derived>::Accept(RawValueVisitor* visitor) {
+ visitor->Visit(static_cast<Derived*>(this));
}
template <typename Derived>
-void BaseItem<Derived>::accept(RawValueVisitor* visitor) {
- visitor->visit(static_cast<Derived*>(this));
+void BaseItem<Derived>::Accept(RawValueVisitor* visitor) {
+ visitor->Visit(static_cast<Derived*>(this));
}
RawString::RawString(const StringPool::Ref& ref) : value(ref) {}
-bool RawString::equals(const Value* value) const {
- const RawString* other = valueCast<RawString>(value);
+bool RawString::Equals(const Value* value) const {
+ const RawString* other = ValueCast<RawString>(value);
if (!other) {
return false;
}
return *this->value == *other->value;
}
-RawString* RawString::clone(StringPool* newPool) const {
- RawString* rs = new RawString(newPool->makeRef(*value));
- rs->mComment = mComment;
- rs->mSource = mSource;
+RawString* RawString::Clone(StringPool* new_pool) const {
+ RawString* rs = new RawString(new_pool->MakeRef(*value));
+ rs->comment_ = comment_;
+ rs->source_ = source_;
return rs;
}
-bool RawString::flatten(android::Res_value* outValue) const {
- outValue->dataType = android::Res_value::TYPE_STRING;
- outValue->data =
- util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
+bool RawString::Flatten(android::Res_value* out_value) const {
+ out_value->dataType = android::Res_value::TYPE_STRING;
+ out_value->data = util::HostToDevice32(static_cast<uint32_t>(value.index()));
return true;
}
-void RawString::print(std::ostream* out) const {
+void RawString::Print(std::ostream* out) const {
*out << "(raw string) " << *value;
}
-Reference::Reference() : referenceType(Type::kResource) {}
+Reference::Reference() : reference_type(Type::kResource) {}
Reference::Reference(const ResourceNameRef& n, Type t)
- : name(n.toResourceName()), referenceType(t) {}
+ : name(n.ToResourceName()), reference_type(t) {}
Reference::Reference(const ResourceId& i, Type type)
- : id(i), referenceType(type) {}
+ : id(i), reference_type(type) {}
Reference::Reference(const ResourceNameRef& n, const ResourceId& i)
- : name(n.toResourceName()), id(i), referenceType(Type::kResource) {}
+ : name(n.ToResourceName()), id(i), reference_type(Type::kResource) {}
-bool Reference::equals(const Value* value) const {
- const Reference* other = valueCast<Reference>(value);
+bool Reference::Equals(const Value* value) const {
+ const Reference* other = ValueCast<Reference>(value);
if (!other) {
return false;
}
- return referenceType == other->referenceType &&
- privateReference == other->privateReference && id == other->id &&
+ return reference_type == other->reference_type &&
+ private_reference == other->private_reference && id == other->id &&
name == other->name;
}
-bool Reference::flatten(android::Res_value* outValue) const {
- outValue->dataType = (referenceType == Reference::Type::kResource)
- ? android::Res_value::TYPE_REFERENCE
- : android::Res_value::TYPE_ATTRIBUTE;
- outValue->data = util::hostToDevice32(id ? id.value().id : 0);
+bool Reference::Flatten(android::Res_value* out_value) const {
+ out_value->dataType = (reference_type == Reference::Type::kResource)
+ ? android::Res_value::TYPE_REFERENCE
+ : android::Res_value::TYPE_ATTRIBUTE;
+ out_value->data = util::HostToDevice32(id ? id.value().id : 0);
return true;
}
-Reference* Reference::clone(StringPool* /*newPool*/) const {
+Reference* Reference::Clone(StringPool* /*new_pool*/) const {
return new Reference(*this);
}
-void Reference::print(std::ostream* out) const {
+void Reference::Print(std::ostream* out) const {
*out << "(reference) ";
- if (referenceType == Reference::Type::kResource) {
+ if (reference_type == Reference::Type::kResource) {
*out << "@";
- if (privateReference) {
+ if (private_reference) {
*out << "*";
}
} else {
@@ -118,128 +119,127 @@
}
}
-bool Id::equals(const Value* value) const {
- return valueCast<Id>(value) != nullptr;
+bool Id::Equals(const Value* value) const {
+ return ValueCast<Id>(value) != nullptr;
}
-bool Id::flatten(android::Res_value* out) const {
+bool Id::Flatten(android::Res_value* out) const {
out->dataType = android::Res_value::TYPE_INT_BOOLEAN;
- out->data = util::hostToDevice32(0);
+ out->data = util::HostToDevice32(0);
return true;
}
-Id* Id::clone(StringPool* /*newPool*/) const { return new Id(*this); }
+Id* Id::Clone(StringPool* /*new_pool*/) const { return new Id(*this); }
-void Id::print(std::ostream* out) const { *out << "(id)"; }
+void Id::Print(std::ostream* out) const { *out << "(id)"; }
String::String(const StringPool::Ref& ref) : value(ref) {}
-bool String::equals(const Value* value) const {
- const String* other = valueCast<String>(value);
+bool String::Equals(const Value* value) const {
+ const String* other = ValueCast<String>(value);
if (!other) {
return false;
}
return *this->value == *other->value;
}
-bool String::flatten(android::Res_value* outValue) const {
+bool String::Flatten(android::Res_value* out_value) const {
// Verify that our StringPool index is within encode-able limits.
- if (value.getIndex() > std::numeric_limits<uint32_t>::max()) {
+ if (value.index() > std::numeric_limits<uint32_t>::max()) {
return false;
}
- outValue->dataType = android::Res_value::TYPE_STRING;
- outValue->data =
- util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
+ out_value->dataType = android::Res_value::TYPE_STRING;
+ out_value->data = util::HostToDevice32(static_cast<uint32_t>(value.index()));
return true;
}
-String* String::clone(StringPool* newPool) const {
- String* str = new String(newPool->makeRef(*value));
- str->mComment = mComment;
- str->mSource = mSource;
+String* String::Clone(StringPool* new_pool) const {
+ String* str = new String(new_pool->MakeRef(*value));
+ str->comment_ = comment_;
+ str->source_ = source_;
return str;
}
-void String::print(std::ostream* out) const {
+void String::Print(std::ostream* out) const {
*out << "(string) \"" << *value << "\"";
}
StyledString::StyledString(const StringPool::StyleRef& ref) : value(ref) {}
-bool StyledString::equals(const Value* value) const {
- const StyledString* other = valueCast<StyledString>(value);
+bool StyledString::Equals(const Value* value) const {
+ const StyledString* other = ValueCast<StyledString>(value);
if (!other) {
return false;
}
if (*this->value->str == *other->value->str) {
- const std::vector<StringPool::Span>& spansA = this->value->spans;
- const std::vector<StringPool::Span>& spansB = other->value->spans;
+ const std::vector<StringPool::Span>& spans_a = this->value->spans;
+ const std::vector<StringPool::Span>& spans_b = other->value->spans;
return std::equal(
- spansA.begin(), spansA.end(), spansB.begin(),
+ spans_a.begin(), spans_a.end(), spans_b.begin(),
[](const StringPool::Span& a, const StringPool::Span& b) -> bool {
- return *a.name == *b.name && a.firstChar == b.firstChar &&
- a.lastChar == b.lastChar;
+ return *a.name == *b.name && a.first_char == b.first_char &&
+ a.last_char == b.last_char;
});
}
return false;
}
-bool StyledString::flatten(android::Res_value* outValue) const {
- if (value.getIndex() > std::numeric_limits<uint32_t>::max()) {
+bool StyledString::Flatten(android::Res_value* out_value) const {
+ if (value.index() > std::numeric_limits<uint32_t>::max()) {
return false;
}
- outValue->dataType = android::Res_value::TYPE_STRING;
- outValue->data =
- util::hostToDevice32(static_cast<uint32_t>(value.getIndex()));
+ out_value->dataType = android::Res_value::TYPE_STRING;
+ out_value->data = util::HostToDevice32(static_cast<uint32_t>(value.index()));
return true;
}
-StyledString* StyledString::clone(StringPool* newPool) const {
- StyledString* str = new StyledString(newPool->makeRef(value));
- str->mComment = mComment;
- str->mSource = mSource;
+StyledString* StyledString::Clone(StringPool* new_pool) const {
+ StyledString* str = new StyledString(new_pool->MakeRef(value));
+ str->comment_ = comment_;
+ str->source_ = source_;
return str;
}
-void StyledString::print(std::ostream* out) const {
+void StyledString::Print(std::ostream* out) const {
*out << "(styled string) \"" << *value->str << "\"";
for (const StringPool::Span& span : value->spans) {
- *out << " " << *span.name << ":" << span.firstChar << "," << span.lastChar;
+ *out << " " << *span.name << ":" << span.first_char << ","
+ << span.last_char;
}
}
FileReference::FileReference(const StringPool::Ref& _path) : path(_path) {}
-bool FileReference::equals(const Value* value) const {
- const FileReference* other = valueCast<FileReference>(value);
+bool FileReference::Equals(const Value* value) const {
+ const FileReference* other = ValueCast<FileReference>(value);
if (!other) {
return false;
}
return *path == *other->path;
}
-bool FileReference::flatten(android::Res_value* outValue) const {
- if (path.getIndex() > std::numeric_limits<uint32_t>::max()) {
+bool FileReference::Flatten(android::Res_value* out_value) const {
+ if (path.index() > std::numeric_limits<uint32_t>::max()) {
return false;
}
- outValue->dataType = android::Res_value::TYPE_STRING;
- outValue->data = util::hostToDevice32(static_cast<uint32_t>(path.getIndex()));
+ out_value->dataType = android::Res_value::TYPE_STRING;
+ out_value->data = util::HostToDevice32(static_cast<uint32_t>(path.index()));
return true;
}
-FileReference* FileReference::clone(StringPool* newPool) const {
- FileReference* fr = new FileReference(newPool->makeRef(*path));
+FileReference* FileReference::Clone(StringPool* new_pool) const {
+ FileReference* fr = new FileReference(new_pool->MakeRef(*path));
fr->file = file;
- fr->mComment = mComment;
- fr->mSource = mSource;
+ fr->comment_ = comment_;
+ fr->source_ = source_;
return fr;
}
-void FileReference::print(std::ostream* out) const {
+void FileReference::Print(std::ostream* out) const {
*out << "(file) " << *path;
}
@@ -250,8 +250,8 @@
value.data = data;
}
-bool BinaryPrimitive::equals(const Value* value) const {
- const BinaryPrimitive* other = valueCast<BinaryPrimitive>(value);
+bool BinaryPrimitive::Equals(const Value* value) const {
+ const BinaryPrimitive* other = ValueCast<BinaryPrimitive>(value);
if (!other) {
return false;
}
@@ -259,17 +259,17 @@
this->value.data == other->value.data;
}
-bool BinaryPrimitive::flatten(android::Res_value* outValue) const {
- outValue->dataType = value.dataType;
- outValue->data = util::hostToDevice32(value.data);
+bool BinaryPrimitive::Flatten(android::Res_value* out_value) const {
+ out_value->dataType = value.dataType;
+ out_value->data = util::HostToDevice32(value.data);
return true;
}
-BinaryPrimitive* BinaryPrimitive::clone(StringPool* /*newPool*/) const {
+BinaryPrimitive* BinaryPrimitive::Clone(StringPool* /*new_pool*/) const {
return new BinaryPrimitive(*this);
}
-void BinaryPrimitive::print(std::ostream* out) const {
+void BinaryPrimitive::Print(std::ostream* out) const {
switch (value.dataType) {
case android::Res_value::TYPE_NULL:
*out << "(null)";
@@ -297,10 +297,10 @@
}
Attribute::Attribute(bool w, uint32_t t)
- : typeMask(t),
- minInt(std::numeric_limits<int32_t>::min()),
- maxInt(std::numeric_limits<int32_t>::max()) {
- mWeak = w;
+ : type_mask(t),
+ min_int(std::numeric_limits<int32_t>::min()),
+ max_int(std::numeric_limits<int32_t>::max()) {
+ weak_ = w;
}
template <typename T>
@@ -308,8 +308,8 @@
return &val;
}
-bool Attribute::equals(const Value* value) const {
- const Attribute* other = valueCast<Attribute>(value);
+bool Attribute::Equals(const Value* value) const {
+ const Attribute* other = ValueCast<Attribute>(value);
if (!other) {
return false;
}
@@ -318,46 +318,46 @@
return false;
}
- if (typeMask != other->typeMask || minInt != other->minInt ||
- maxInt != other->maxInt) {
+ if (type_mask != other->type_mask || min_int != other->min_int ||
+ max_int != other->max_int) {
return false;
}
- std::vector<const Symbol*> sortedA;
- std::transform(symbols.begin(), symbols.end(), std::back_inserter(sortedA),
+ std::vector<const Symbol*> sorted_a;
+ std::transform(symbols.begin(), symbols.end(), std::back_inserter(sorted_a),
addPointer<const Symbol>);
- std::sort(sortedA.begin(), sortedA.end(),
+ std::sort(sorted_a.begin(), sorted_a.end(),
[](const Symbol* a, const Symbol* b) -> bool {
return a->symbol.name < b->symbol.name;
});
- std::vector<const Symbol*> sortedB;
+ std::vector<const Symbol*> sorted_b;
std::transform(other->symbols.begin(), other->symbols.end(),
- std::back_inserter(sortedB), addPointer<const Symbol>);
- std::sort(sortedB.begin(), sortedB.end(),
+ std::back_inserter(sorted_b), addPointer<const Symbol>);
+ std::sort(sorted_b.begin(), sorted_b.end(),
[](const Symbol* a, const Symbol* b) -> bool {
return a->symbol.name < b->symbol.name;
});
- return std::equal(sortedA.begin(), sortedA.end(), sortedB.begin(),
+ return std::equal(sorted_a.begin(), sorted_a.end(), sorted_b.begin(),
[](const Symbol* a, const Symbol* b) -> bool {
- return a->symbol.equals(&b->symbol) &&
+ return a->symbol.Equals(&b->symbol) &&
a->value == b->value;
});
}
-Attribute* Attribute::clone(StringPool* /*newPool*/) const {
+Attribute* Attribute::Clone(StringPool* /*new_pool*/) const {
return new Attribute(*this);
}
-void Attribute::printMask(std::ostream* out) const {
- if (typeMask == android::ResTable_map::TYPE_ANY) {
+void Attribute::PrintMask(std::ostream* out) const {
+ if (type_mask == android::ResTable_map::TYPE_ANY) {
*out << "any";
return;
}
bool set = false;
- if ((typeMask & android::ResTable_map::TYPE_REFERENCE) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_REFERENCE) != 0) {
if (!set) {
set = true;
} else {
@@ -366,7 +366,7 @@
*out << "reference";
}
- if ((typeMask & android::ResTable_map::TYPE_STRING) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_STRING) != 0) {
if (!set) {
set = true;
} else {
@@ -375,7 +375,7 @@
*out << "string";
}
- if ((typeMask & android::ResTable_map::TYPE_INTEGER) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_INTEGER) != 0) {
if (!set) {
set = true;
} else {
@@ -384,7 +384,7 @@
*out << "integer";
}
- if ((typeMask & android::ResTable_map::TYPE_BOOLEAN) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_BOOLEAN) != 0) {
if (!set) {
set = true;
} else {
@@ -393,7 +393,7 @@
*out << "boolean";
}
- if ((typeMask & android::ResTable_map::TYPE_COLOR) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_COLOR) != 0) {
if (!set) {
set = true;
} else {
@@ -402,7 +402,7 @@
*out << "color";
}
- if ((typeMask & android::ResTable_map::TYPE_FLOAT) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_FLOAT) != 0) {
if (!set) {
set = true;
} else {
@@ -411,7 +411,7 @@
*out << "float";
}
- if ((typeMask & android::ResTable_map::TYPE_DIMENSION) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_DIMENSION) != 0) {
if (!set) {
set = true;
} else {
@@ -420,7 +420,7 @@
*out << "dimension";
}
- if ((typeMask & android::ResTable_map::TYPE_FRACTION) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_FRACTION) != 0) {
if (!set) {
set = true;
} else {
@@ -429,7 +429,7 @@
*out << "fraction";
}
- if ((typeMask & android::ResTable_map::TYPE_ENUM) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_ENUM) != 0) {
if (!set) {
set = true;
} else {
@@ -438,7 +438,7 @@
*out << "enum";
}
- if ((typeMask & android::ResTable_map::TYPE_FLAGS) != 0) {
+ if ((type_mask & android::ResTable_map::TYPE_FLAGS) != 0) {
if (!set) {
set = true;
} else {
@@ -448,96 +448,96 @@
}
}
-void Attribute::print(std::ostream* out) const {
+void Attribute::Print(std::ostream* out) const {
*out << "(attr) ";
- printMask(out);
+ PrintMask(out);
if (!symbols.empty()) {
- *out << " [" << util::joiner(symbols, ", ") << "]";
+ *out << " [" << util::Joiner(symbols, ", ") << "]";
}
- if (minInt != std::numeric_limits<int32_t>::min()) {
- *out << " min=" << minInt;
+ if (min_int != std::numeric_limits<int32_t>::min()) {
+ *out << " min=" << min_int;
}
- if (maxInt != std::numeric_limits<int32_t>::max()) {
- *out << " max=" << maxInt;
+ if (max_int != std::numeric_limits<int32_t>::max()) {
+ *out << " max=" << max_int;
}
- if (isWeak()) {
+ if (IsWeak()) {
*out << " [weak]";
}
}
-static void buildAttributeMismatchMessage(DiagMessage* msg,
+static void BuildAttributeMismatchMessage(DiagMessage* msg,
const Attribute* attr,
const Item* value) {
*msg << "expected";
- if (attr->typeMask & android::ResTable_map::TYPE_BOOLEAN) {
+ if (attr->type_mask & android::ResTable_map::TYPE_BOOLEAN) {
*msg << " boolean";
}
- if (attr->typeMask & android::ResTable_map::TYPE_COLOR) {
+ if (attr->type_mask & android::ResTable_map::TYPE_COLOR) {
*msg << " color";
}
- if (attr->typeMask & android::ResTable_map::TYPE_DIMENSION) {
+ if (attr->type_mask & android::ResTable_map::TYPE_DIMENSION) {
*msg << " dimension";
}
- if (attr->typeMask & android::ResTable_map::TYPE_ENUM) {
+ if (attr->type_mask & android::ResTable_map::TYPE_ENUM) {
*msg << " enum";
}
- if (attr->typeMask & android::ResTable_map::TYPE_FLAGS) {
+ if (attr->type_mask & android::ResTable_map::TYPE_FLAGS) {
*msg << " flags";
}
- if (attr->typeMask & android::ResTable_map::TYPE_FLOAT) {
+ if (attr->type_mask & android::ResTable_map::TYPE_FLOAT) {
*msg << " float";
}
- if (attr->typeMask & android::ResTable_map::TYPE_FRACTION) {
+ if (attr->type_mask & android::ResTable_map::TYPE_FRACTION) {
*msg << " fraction";
}
- if (attr->typeMask & android::ResTable_map::TYPE_INTEGER) {
+ if (attr->type_mask & android::ResTable_map::TYPE_INTEGER) {
*msg << " integer";
}
- if (attr->typeMask & android::ResTable_map::TYPE_REFERENCE) {
+ if (attr->type_mask & android::ResTable_map::TYPE_REFERENCE) {
*msg << " reference";
}
- if (attr->typeMask & android::ResTable_map::TYPE_STRING) {
+ if (attr->type_mask & android::ResTable_map::TYPE_STRING) {
*msg << " string";
}
*msg << " but got " << *value;
}
-bool Attribute::matches(const Item* item, DiagMessage* outMsg) const {
+bool Attribute::Matches(const Item* item, DiagMessage* out_msg) const {
android::Res_value val = {};
- item->flatten(&val);
+ item->Flatten(&val);
// Always allow references.
- const uint32_t mask = typeMask | android::ResTable_map::TYPE_REFERENCE;
- if (!(mask & ResourceUtils::androidTypeToAttributeTypeMask(val.dataType))) {
- if (outMsg) {
- buildAttributeMismatchMessage(outMsg, this, item);
+ const uint32_t mask = type_mask | android::ResTable_map::TYPE_REFERENCE;
+ if (!(mask & ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType))) {
+ if (out_msg) {
+ BuildAttributeMismatchMessage(out_msg, this, item);
}
return false;
- } else if (ResourceUtils::androidTypeToAttributeTypeMask(val.dataType) &
+ } else if (ResourceUtils::AndroidTypeToAttributeTypeMask(val.dataType) &
android::ResTable_map::TYPE_INTEGER) {
- if (static_cast<int32_t>(util::deviceToHost32(val.data)) < minInt) {
- if (outMsg) {
- *outMsg << *item << " is less than minimum integer " << minInt;
+ if (static_cast<int32_t>(util::DeviceToHost32(val.data)) < min_int) {
+ if (out_msg) {
+ *out_msg << *item << " is less than minimum integer " << min_int;
}
return false;
- } else if (static_cast<int32_t>(util::deviceToHost32(val.data)) > maxInt) {
- if (outMsg) {
- *outMsg << *item << " is greater than maximum integer " << maxInt;
+ } else if (static_cast<int32_t>(util::DeviceToHost32(val.data)) > max_int) {
+ if (out_msg) {
+ *out_msg << *item << " is greater than maximum integer " << max_int;
}
return false;
}
@@ -545,14 +545,14 @@
return true;
}
-bool Style::equals(const Value* value) const {
- const Style* other = valueCast<Style>(value);
+bool Style::Equals(const Value* value) const {
+ const Style* other = ValueCast<Style>(value);
if (!other) {
return false;
}
if (bool(parent) != bool(other->parent) ||
(parent && other->parent &&
- !parent.value().equals(&other->parent.value()))) {
+ !parent.value().Equals(&other->parent.value()))) {
return false;
}
@@ -560,51 +560,51 @@
return false;
}
- std::vector<const Entry*> sortedA;
- std::transform(entries.begin(), entries.end(), std::back_inserter(sortedA),
+ std::vector<const Entry*> sorted_a;
+ std::transform(entries.begin(), entries.end(), std::back_inserter(sorted_a),
addPointer<const Entry>);
- std::sort(sortedA.begin(), sortedA.end(),
+ std::sort(sorted_a.begin(), sorted_a.end(),
[](const Entry* a, const Entry* b) -> bool {
return a->key.name < b->key.name;
});
- std::vector<const Entry*> sortedB;
+ std::vector<const Entry*> sorted_b;
std::transform(other->entries.begin(), other->entries.end(),
- std::back_inserter(sortedB), addPointer<const Entry>);
- std::sort(sortedB.begin(), sortedB.end(),
+ std::back_inserter(sorted_b), addPointer<const Entry>);
+ std::sort(sorted_b.begin(), sorted_b.end(),
[](const Entry* a, const Entry* b) -> bool {
return a->key.name < b->key.name;
});
- return std::equal(sortedA.begin(), sortedA.end(), sortedB.begin(),
+ return std::equal(sorted_a.begin(), sorted_a.end(), sorted_b.begin(),
[](const Entry* a, const Entry* b) -> bool {
- return a->key.equals(&b->key) &&
- a->value->equals(b->value.get());
+ return a->key.Equals(&b->key) &&
+ a->value->Equals(b->value.get());
});
}
-Style* Style::clone(StringPool* newPool) const {
+Style* Style::Clone(StringPool* new_pool) const {
Style* style = new Style();
style->parent = parent;
- style->parentInferred = parentInferred;
- style->mComment = mComment;
- style->mSource = mSource;
+ style->parent_inferred = parent_inferred;
+ style->comment_ = comment_;
+ style->source_ = source_;
for (auto& entry : entries) {
style->entries.push_back(
- Entry{entry.key, std::unique_ptr<Item>(entry.value->clone(newPool))});
+ Entry{entry.key, std::unique_ptr<Item>(entry.value->Clone(new_pool))});
}
return style;
}
-void Style::print(std::ostream* out) const {
+void Style::Print(std::ostream* out) const {
*out << "(style) ";
if (parent && parent.value().name) {
- if (parent.value().privateReference) {
+ if (parent.value().private_reference) {
*out << "*";
}
*out << parent.value().name.value();
}
- *out << " [" << util::joiner(entries, ", ") << "]";
+ *out << " [" << util::Joiner(entries, ", ") << "]";
}
static ::std::ostream& operator<<(::std::ostream& out,
@@ -617,12 +617,12 @@
out << "???";
}
out << " = ";
- value.value->print(&out);
+ value.value->Print(&out);
return out;
}
-bool Array::equals(const Value* value) const {
- const Array* other = valueCast<Array>(value);
+bool Array::Equals(const Value* value) const {
+ const Array* other = ValueCast<Array>(value);
if (!other) {
return false;
}
@@ -634,26 +634,26 @@
return std::equal(items.begin(), items.end(), other->items.begin(),
[](const std::unique_ptr<Item>& a,
const std::unique_ptr<Item>& b) -> bool {
- return a->equals(b.get());
+ return a->Equals(b.get());
});
}
-Array* Array::clone(StringPool* newPool) const {
+Array* Array::Clone(StringPool* new_pool) const {
Array* array = new Array();
- array->mComment = mComment;
- array->mSource = mSource;
+ array->comment_ = comment_;
+ array->source_ = source_;
for (auto& item : items) {
- array->items.emplace_back(std::unique_ptr<Item>(item->clone(newPool)));
+ array->items.emplace_back(std::unique_ptr<Item>(item->Clone(new_pool)));
}
return array;
}
-void Array::print(std::ostream* out) const {
- *out << "(array) [" << util::joiner(items, ", ") << "]";
+void Array::Print(std::ostream* out) const {
+ *out << "(array) [" << util::Joiner(items, ", ") << "]";
}
-bool Plural::equals(const Value* value) const {
- const Plural* other = valueCast<Plural>(value);
+bool Plural::Equals(const Value* value) const {
+ const Plural* other = ValueCast<Plural>(value);
if (!other) {
return false;
}
@@ -668,24 +668,24 @@
if (bool(a) != bool(b)) {
return false;
}
- return bool(a) == bool(b) || a->equals(b.get());
+ return bool(a) == bool(b) || a->Equals(b.get());
});
}
-Plural* Plural::clone(StringPool* newPool) const {
+Plural* Plural::Clone(StringPool* new_pool) const {
Plural* p = new Plural();
- p->mComment = mComment;
- p->mSource = mSource;
+ p->comment_ = comment_;
+ p->source_ = source_;
const size_t count = values.size();
for (size_t i = 0; i < count; i++) {
if (values[i]) {
- p->values[i] = std::unique_ptr<Item>(values[i]->clone(newPool));
+ p->values[i] = std::unique_ptr<Item>(values[i]->Clone(new_pool));
}
}
return p;
}
-void Plural::print(std::ostream* out) const {
+void Plural::Print(std::ostream* out) const {
*out << "(plural)";
if (values[Zero]) {
*out << " zero=" << *values[Zero];
@@ -713,8 +713,8 @@
return out << *item;
}
-bool Styleable::equals(const Value* value) const {
- const Styleable* other = valueCast<Styleable>(value);
+bool Styleable::Equals(const Value* value) const {
+ const Styleable* other = ValueCast<Styleable>(value);
if (!other) {
return false;
}
@@ -725,21 +725,21 @@
return std::equal(entries.begin(), entries.end(), other->entries.begin(),
[](const Reference& a, const Reference& b) -> bool {
- return a.equals(&b);
+ return a.Equals(&b);
});
}
-Styleable* Styleable::clone(StringPool* /*newPool*/) const {
+Styleable* Styleable::Clone(StringPool* /*new_pool*/) const {
return new Styleable(*this);
}
-void Styleable::print(std::ostream* out) const {
+void Styleable::Print(std::ostream* out) const {
*out << "(styleable) "
- << " [" << util::joiner(entries, ", ") << "]";
+ << " [" << util::Joiner(entries, ", ") << "]";
}
bool operator<(const Reference& a, const Reference& b) {
- int cmp = a.name.valueOrDefault({}).compare(b.name.valueOrDefault({}));
+ int cmp = a.name.value_or_default({}).compare(b.name.value_or_default({}));
if (cmp != 0) return cmp < 0;
return a.id < b.id;
}
@@ -758,7 +758,7 @@
}
};
-void Styleable::mergeWith(Styleable* other) {
+void Styleable::MergeWith(Styleable* other) {
// Compare only names, because some References may already have their IDs
// assigned
// (framework IDs that don't change).
diff --git a/tools/aapt2/ResourceValues.h b/tools/aapt2/ResourceValues.h
index a28ffe5..ea73615 100644
--- a/tools/aapt2/ResourceValues.h
+++ b/tools/aapt2/ResourceValues.h
@@ -17,17 +17,18 @@
#ifndef AAPT_RESOURCE_VALUES_H
#define AAPT_RESOURCE_VALUES_H
+#include <array>
+#include <ostream>
+#include <vector>
+
+#include "androidfw/ResourceTypes.h"
+
#include "Diagnostics.h"
#include "Resource.h"
#include "StringPool.h"
#include "io/File.h"
#include "util/Maybe.h"
-#include <androidfw/ResourceTypes.h>
-#include <array>
-#include <ostream>
-#include <vector>
-
namespace aapt {
struct RawValueVisitor;
@@ -46,58 +47,59 @@
* Whether this value is weak and can be overridden without
* warning or error. Default is false.
*/
- bool isWeak() const { return mWeak; }
+ bool IsWeak() const { return weak_; }
- void setWeak(bool val) { mWeak = val; }
+ void SetWeak(bool val) { weak_ = val; }
// Whether the value is marked as translateable.
// This does not persist when flattened.
// It is only used during compilation phase.
- void setTranslateable(bool val) { mTranslateable = val; }
+ void SetTranslateable(bool val) { translateable_ = val; }
// Default true.
- bool isTranslateable() const { return mTranslateable; }
+ bool IsTranslateable() const { return translateable_; }
/**
* Returns the source where this value was defined.
*/
- const Source& getSource() const { return mSource; }
+ const Source& GetSource() const { return source_; }
- void setSource(const Source& source) { mSource = source; }
+ void SetSource(const Source& source) { source_ = source; }
- void setSource(Source&& source) { mSource = std::move(source); }
+ void SetSource(Source&& source) { source_ = std::move(source); }
/**
* Returns the comment that was associated with this resource.
*/
- const std::string& getComment() const { return mComment; }
+ const std::string& GetComment() const { return comment_; }
- void setComment(const StringPiece& str) { mComment = str.toString(); }
+ void SetComment(const StringPiece& str) { comment_ = str.ToString(); }
- void setComment(std::string&& str) { mComment = std::move(str); }
+ void SetComment(std::string&& str) { comment_ = std::move(str); }
- virtual bool equals(const Value* value) const = 0;
+ virtual bool Equals(const Value* value) const = 0;
/**
* Calls the appropriate overload of ValueVisitor.
*/
- virtual void accept(RawValueVisitor* visitor) = 0;
+ virtual void Accept(RawValueVisitor* visitor) = 0;
/**
- * Clone the value.
+ * Clone the value. new_pool is the new StringPool that
+ * any resources with strings should use when copying their string.
*/
- virtual Value* clone(StringPool* newPool) const = 0;
+ virtual Value* Clone(StringPool* new_pool) const = 0;
/**
* Human readable printout of this value.
*/
- virtual void print(std::ostream* out) const = 0;
+ virtual void Print(std::ostream* out) const = 0;
protected:
- Source mSource;
- std::string mComment;
- bool mWeak = false;
- bool mTranslateable = true;
+ Source source_;
+ std::string comment_;
+ bool weak_ = false;
+ bool translateable_ = true;
};
/**
@@ -105,7 +107,7 @@
*/
template <typename Derived>
struct BaseValue : public Value {
- void accept(RawValueVisitor* visitor) override;
+ void Accept(RawValueVisitor* visitor) override;
};
/**
@@ -115,14 +117,14 @@
/**
* Clone the Item.
*/
- virtual Item* clone(StringPool* newPool) const override = 0;
+ virtual Item* Clone(StringPool* new_pool) const override = 0;
/**
* Fills in an android::Res_value structure with this Item's binary
* representation.
* Returns false if an error occurred.
*/
- virtual bool flatten(android::Res_value* outValue) const = 0;
+ virtual bool Flatten(android::Res_value* out_value) const = 0;
};
/**
@@ -130,7 +132,7 @@
*/
template <typename Derived>
struct BaseItem : public Item {
- void accept(RawValueVisitor* visitor) override;
+ void Accept(RawValueVisitor* visitor) override;
};
/**
@@ -149,18 +151,18 @@
Maybe<ResourceName> name;
Maybe<ResourceId> id;
- Reference::Type referenceType;
- bool privateReference = false;
+ Reference::Type reference_type;
+ bool private_reference = false;
Reference();
explicit Reference(const ResourceNameRef& n, Type type = Type::kResource);
explicit Reference(const ResourceId& i, Type type = Type::kResource);
- explicit Reference(const ResourceNameRef& n, const ResourceId& i);
+ Reference(const ResourceNameRef& n, const ResourceId& i);
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* outValue) const override;
- Reference* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out_value) const override;
+ Reference* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
bool operator<(const Reference&, const Reference&);
@@ -170,11 +172,11 @@
* An ID resource. Has no real value, just a place holder.
*/
struct Id : public BaseItem<Id> {
- Id() { mWeak = true; }
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* out) const override;
- Id* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ Id() { weak_ = true; }
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out) const override;
+ Id* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
/**
@@ -187,10 +189,10 @@
explicit RawString(const StringPool::Ref& ref);
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* outValue) const override;
- RawString* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out_value) const override;
+ RawString* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct String : public BaseItem<String> {
@@ -198,10 +200,10 @@
explicit String(const StringPool::Ref& ref);
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* outValue) const override;
- String* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out_value) const override;
+ String* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct StyledString : public BaseItem<StyledString> {
@@ -209,10 +211,10 @@
explicit StyledString(const StringPool::StyleRef& ref);
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* outValue) const override;
- StyledString* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out_value) const override;
+ StyledString* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct FileReference : public BaseItem<FileReference> {
@@ -226,10 +228,10 @@
FileReference() = default;
explicit FileReference(const StringPool::Ref& path);
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* outValue) const override;
- FileReference* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out_value) const override;
+ FileReference* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
/**
@@ -242,10 +244,10 @@
explicit BinaryPrimitive(const android::Res_value& val);
BinaryPrimitive(uint8_t dataType, uint32_t data);
- bool equals(const Value* value) const override;
- bool flatten(android::Res_value* outValue) const override;
- BinaryPrimitive* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ bool Flatten(android::Res_value* out_value) const override;
+ BinaryPrimitive* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct Attribute : public BaseValue<Attribute> {
@@ -254,18 +256,18 @@
uint32_t value;
};
- uint32_t typeMask;
- int32_t minInt;
- int32_t maxInt;
+ uint32_t type_mask;
+ int32_t min_int;
+ int32_t max_int;
std::vector<Symbol> symbols;
explicit Attribute(bool w, uint32_t t = 0u);
- bool equals(const Value* value) const override;
- Attribute* clone(StringPool* newPool) const override;
- void printMask(std::ostream* out) const;
- void print(std::ostream* out) const override;
- bool matches(const Item* item, DiagMessage* outMsg) const;
+ bool Equals(const Value* value) const override;
+ Attribute* Clone(StringPool* new_pool) const override;
+ void PrintMask(std::ostream* out) const;
+ void Print(std::ostream* out) const override;
+ bool Matches(const Item* item, DiagMessage* out_msg) const;
};
struct Style : public BaseValue<Style> {
@@ -280,21 +282,21 @@
* If set to true, the parent was auto inferred from the
* style's name.
*/
- bool parentInferred = false;
+ bool parent_inferred = false;
std::vector<Entry> entries;
- bool equals(const Value* value) const override;
- Style* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ Style* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct Array : public BaseValue<Array> {
std::vector<std::unique_ptr<Item>> items;
- bool equals(const Value* value) const override;
- Array* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ Array* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct Plural : public BaseValue<Plural> {
@@ -302,25 +304,25 @@
std::array<std::unique_ptr<Item>, Count> values;
- bool equals(const Value* value) const override;
- Plural* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
+ bool Equals(const Value* value) const override;
+ Plural* Clone(StringPool* new_pool) const override;
+ void Print(std::ostream* out) const override;
};
struct Styleable : public BaseValue<Styleable> {
std::vector<Reference> entries;
- bool equals(const Value* value) const override;
- Styleable* clone(StringPool* newPool) const override;
- void print(std::ostream* out) const override;
- void mergeWith(Styleable* styleable);
+ bool Equals(const Value* value) const override;
+ Styleable* Clone(StringPool* newPool) const override;
+ void Print(std::ostream* out) const override;
+ void MergeWith(Styleable* styleable);
};
/**
* Stream operator for printing Value objects.
*/
inline ::std::ostream& operator<<(::std::ostream& out, const Value& value) {
- value.print(&out);
+ value.Print(&out);
return out;
}
diff --git a/tools/aapt2/Resource_test.cpp b/tools/aapt2/Resource_test.cpp
index 4b6b122..720ab91 100644
--- a/tools/aapt2/Resource_test.cpp
+++ b/tools/aapt2/Resource_test.cpp
@@ -15,100 +15,101 @@
*/
#include "Resource.h"
+
#include "test/Test.h"
namespace aapt {
TEST(ResourceTypeTest, ParseResourceTypes) {
- const ResourceType* type = parseResourceType("anim");
+ const ResourceType* type = ParseResourceType("anim");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kAnim);
- type = parseResourceType("animator");
+ type = ParseResourceType("animator");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kAnimator);
- type = parseResourceType("array");
+ type = ParseResourceType("array");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kArray);
- type = parseResourceType("attr");
+ type = ParseResourceType("attr");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kAttr);
- type = parseResourceType("^attr-private");
+ type = ParseResourceType("^attr-private");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kAttrPrivate);
- type = parseResourceType("bool");
+ type = ParseResourceType("bool");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kBool);
- type = parseResourceType("color");
+ type = ParseResourceType("color");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kColor);
- type = parseResourceType("dimen");
+ type = ParseResourceType("dimen");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kDimen);
- type = parseResourceType("drawable");
+ type = ParseResourceType("drawable");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kDrawable);
- type = parseResourceType("fraction");
+ type = ParseResourceType("fraction");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kFraction);
- type = parseResourceType("id");
+ type = ParseResourceType("id");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kId);
- type = parseResourceType("integer");
+ type = ParseResourceType("integer");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kInteger);
- type = parseResourceType("interpolator");
+ type = ParseResourceType("interpolator");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kInterpolator);
- type = parseResourceType("layout");
+ type = ParseResourceType("layout");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kLayout);
- type = parseResourceType("menu");
+ type = ParseResourceType("menu");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kMenu);
- type = parseResourceType("mipmap");
+ type = ParseResourceType("mipmap");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kMipmap);
- type = parseResourceType("plurals");
+ type = ParseResourceType("plurals");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kPlurals);
- type = parseResourceType("raw");
+ type = ParseResourceType("raw");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kRaw);
- type = parseResourceType("string");
+ type = ParseResourceType("string");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kString);
- type = parseResourceType("style");
+ type = ParseResourceType("style");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kStyle);
- type = parseResourceType("transition");
+ type = ParseResourceType("transition");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kTransition);
- type = parseResourceType("xml");
+ type = ParseResourceType("xml");
ASSERT_NE(type, nullptr);
EXPECT_EQ(*type, ResourceType::kXml);
- type = parseResourceType("blahaha");
+ type = ParseResourceType("blahaha");
EXPECT_EQ(type, nullptr);
}
diff --git a/tools/aapt2/SdkConstants.cpp b/tools/aapt2/SdkConstants.cpp
index 75375da..c7f920a 100644
--- a/tools/aapt2/SdkConstants.cpp
+++ b/tools/aapt2/SdkConstants.cpp
@@ -48,17 +48,17 @@
{0x04ce, SDK_LOLLIPOP},
};
-static bool lessEntryId(const std::pair<uint16_t, size_t>& p,
+static bool less_entry_id(const std::pair<uint16_t, size_t>& p,
uint16_t entryId) {
return p.first < entryId;
}
-size_t findAttributeSdkLevel(const ResourceId& id) {
- if (id.packageId() != 0x01 && id.typeId() != 0x01) {
+size_t FindAttributeSdkLevel(const ResourceId& id) {
+ if (id.package_id() != 0x01 && id.type_id() != 0x01) {
return 0;
}
auto iter = std::lower_bound(sAttrIdMap.begin(), sAttrIdMap.end(),
- id.entryId(), lessEntryId);
+ id.entry_id(), less_entry_id);
if (iter == sAttrIdMap.end()) {
return SDK_LOLLIPOP_MR1;
}
@@ -727,7 +727,7 @@
{"windowActivityTransitions", 21},
{"colorEdgeEffect", 21}};
-size_t findAttributeSdkLevel(const ResourceName& name) {
+size_t FindAttributeSdkLevel(const ResourceName& name) {
if (name.package != "android" && name.type != ResourceType::kAttr) {
return 0;
}
@@ -739,7 +739,7 @@
return SDK_LOLLIPOP_MR1;
}
-std::pair<StringPiece, int> getDevelopmentSdkCodeNameAndVersion() {
+std::pair<StringPiece, int> GetDevelopmentSdkCodeNameAndVersion() {
return std::make_pair(StringPiece(sDevelopmentSdkCodeName),
sDevelopmentSdkLevel);
}
diff --git a/tools/aapt2/SdkConstants.h b/tools/aapt2/SdkConstants.h
index bd17fe4..9b38ecb 100644
--- a/tools/aapt2/SdkConstants.h
+++ b/tools/aapt2/SdkConstants.h
@@ -17,10 +17,10 @@
#ifndef AAPT_SDK_CONSTANTS_H
#define AAPT_SDK_CONSTANTS_H
-#include "Resource.h"
-
#include <utility>
+#include "Resource.h"
+
namespace aapt {
enum {
@@ -47,9 +47,9 @@
SDK_MARSHMALLOW = 23,
};
-size_t findAttributeSdkLevel(const ResourceId& id);
-size_t findAttributeSdkLevel(const ResourceName& name);
-std::pair<StringPiece, int> getDevelopmentSdkCodeNameAndVersion();
+size_t FindAttributeSdkLevel(const ResourceId& id);
+size_t FindAttributeSdkLevel(const ResourceName& name);
+std::pair<StringPiece, int> GetDevelopmentSdkCodeNameAndVersion();
} // namespace aapt
diff --git a/tools/aapt2/SdkConstants_test.cpp b/tools/aapt2/SdkConstants_test.cpp
index 3b70acb..716d922 100644
--- a/tools/aapt2/SdkConstants_test.cpp
+++ b/tools/aapt2/SdkConstants_test.cpp
@@ -16,23 +16,23 @@
#include "SdkConstants.h"
-#include <gtest/gtest.h>
+#include "gtest/gtest.h"
namespace aapt {
TEST(SdkConstantsTest, FirstAttributeIsSdk1) {
- EXPECT_EQ(1u, findAttributeSdkLevel(ResourceId(0x01010000)));
+ EXPECT_EQ(1u, FindAttributeSdkLevel(ResourceId(0x01010000)));
}
TEST(SdkConstantsTest, AllAttributesAfterLollipopAreLollipopMR1) {
- EXPECT_EQ(SDK_LOLLIPOP, findAttributeSdkLevel(ResourceId(0x010103f7)));
- EXPECT_EQ(SDK_LOLLIPOP, findAttributeSdkLevel(ResourceId(0x010104ce)));
+ EXPECT_EQ(SDK_LOLLIPOP, FindAttributeSdkLevel(ResourceId(0x010103f7)));
+ EXPECT_EQ(SDK_LOLLIPOP, FindAttributeSdkLevel(ResourceId(0x010104ce)));
- EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x010104cf)));
- EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x010104d8)));
+ EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x010104cf)));
+ EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x010104d8)));
- EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x010104d9)));
- EXPECT_EQ(SDK_LOLLIPOP_MR1, findAttributeSdkLevel(ResourceId(0x0101ffff)));
+ EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x010104d9)));
+ EXPECT_EQ(SDK_LOLLIPOP_MR1, FindAttributeSdkLevel(ResourceId(0x0101ffff)));
}
} // namespace aapt
diff --git a/tools/aapt2/Source.h b/tools/aapt2/Source.h
index 422b361..459a8e6 100644
--- a/tools/aapt2/Source.h
+++ b/tools/aapt2/Source.h
@@ -17,12 +17,12 @@
#ifndef AAPT_SOURCE_H
#define AAPT_SOURCE_H
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-
#include <ostream>
#include <string>
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+
namespace aapt {
/**
@@ -36,13 +36,13 @@
Source() = default;
inline Source(const StringPiece& path)
- : path(path.toString()) { // NOLINT(implicit)
+ : path(path.ToString()) { // NOLINT(implicit)
}
inline Source(const StringPiece& path, size_t line)
- : path(path.toString()), line(line) {}
+ : path(path.ToString()), line(line) {}
- inline Source withLine(size_t line) const { return Source(path, line); }
+ inline Source WithLine(size_t line) const { return Source(path, line); }
};
//
diff --git a/tools/aapt2/StringPool.cpp b/tools/aapt2/StringPool.cpp
index a167a6a..3032829 100644
--- a/tools/aapt2/StringPool.cpp
+++ b/tools/aapt2/StringPool.cpp
@@ -15,263 +15,266 @@
*/
#include "StringPool.h"
-#include "util/BigBuffer.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
#include <algorithm>
#include <memory>
#include <string>
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
+#include "util/BigBuffer.h"
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
namespace aapt {
-StringPool::Ref::Ref() : mEntry(nullptr) {}
+StringPool::Ref::Ref() : entry_(nullptr) {}
-StringPool::Ref::Ref(const StringPool::Ref& rhs) : mEntry(rhs.mEntry) {
- if (mEntry != nullptr) {
- mEntry->ref++;
+StringPool::Ref::Ref(const StringPool::Ref& rhs) : entry_(rhs.entry_) {
+ if (entry_ != nullptr) {
+ entry_->ref_++;
}
}
-StringPool::Ref::Ref(StringPool::Entry* entry) : mEntry(entry) {
- if (mEntry != nullptr) {
- mEntry->ref++;
+StringPool::Ref::Ref(StringPool::Entry* entry) : entry_(entry) {
+ if (entry_ != nullptr) {
+ entry_->ref_++;
}
}
StringPool::Ref::~Ref() {
- if (mEntry != nullptr) {
- mEntry->ref--;
+ if (entry_ != nullptr) {
+ entry_->ref_--;
}
}
StringPool::Ref& StringPool::Ref::operator=(const StringPool::Ref& rhs) {
- if (rhs.mEntry != nullptr) {
- rhs.mEntry->ref++;
+ if (rhs.entry_ != nullptr) {
+ rhs.entry_->ref_++;
}
- if (mEntry != nullptr) {
- mEntry->ref--;
+ if (entry_ != nullptr) {
+ entry_->ref_--;
}
- mEntry = rhs.mEntry;
+ entry_ = rhs.entry_;
return *this;
}
const std::string* StringPool::Ref::operator->() const {
- return &mEntry->value;
+ return &entry_->value;
}
-const std::string& StringPool::Ref::operator*() const { return mEntry->value; }
+const std::string& StringPool::Ref::operator*() const { return entry_->value; }
-size_t StringPool::Ref::getIndex() const { return mEntry->index; }
+size_t StringPool::Ref::index() const { return entry_->index; }
-const StringPool::Context& StringPool::Ref::getContext() const {
- return mEntry->context;
+const StringPool::Context& StringPool::Ref::GetContext() const {
+ return entry_->context;
}
-StringPool::StyleRef::StyleRef() : mEntry(nullptr) {}
+StringPool::StyleRef::StyleRef() : entry_(nullptr) {}
StringPool::StyleRef::StyleRef(const StringPool::StyleRef& rhs)
- : mEntry(rhs.mEntry) {
- if (mEntry != nullptr) {
- mEntry->ref++;
+ : entry_(rhs.entry_) {
+ if (entry_ != nullptr) {
+ entry_->ref_++;
}
}
-StringPool::StyleRef::StyleRef(StringPool::StyleEntry* entry) : mEntry(entry) {
- if (mEntry != nullptr) {
- mEntry->ref++;
+StringPool::StyleRef::StyleRef(StringPool::StyleEntry* entry) : entry_(entry) {
+ if (entry_ != nullptr) {
+ entry_->ref_++;
}
}
StringPool::StyleRef::~StyleRef() {
- if (mEntry != nullptr) {
- mEntry->ref--;
+ if (entry_ != nullptr) {
+ entry_->ref_--;
}
}
StringPool::StyleRef& StringPool::StyleRef::operator=(
const StringPool::StyleRef& rhs) {
- if (rhs.mEntry != nullptr) {
- rhs.mEntry->ref++;
+ if (rhs.entry_ != nullptr) {
+ rhs.entry_->ref_++;
}
- if (mEntry != nullptr) {
- mEntry->ref--;
+ if (entry_ != nullptr) {
+ entry_->ref_--;
}
- mEntry = rhs.mEntry;
+ entry_ = rhs.entry_;
return *this;
}
const StringPool::StyleEntry* StringPool::StyleRef::operator->() const {
- return mEntry;
+ return entry_;
}
const StringPool::StyleEntry& StringPool::StyleRef::operator*() const {
- return *mEntry;
+ return *entry_;
}
-size_t StringPool::StyleRef::getIndex() const { return mEntry->str.getIndex(); }
+size_t StringPool::StyleRef::index() const { return entry_->str.index(); }
-const StringPool::Context& StringPool::StyleRef::getContext() const {
- return mEntry->str.getContext();
+const StringPool::Context& StringPool::StyleRef::GetContext() const {
+ return entry_->str.GetContext();
}
-StringPool::Ref StringPool::makeRef(const StringPiece& str) {
- return makeRefImpl(str, Context{}, true);
+StringPool::Ref StringPool::MakeRef(const StringPiece& str) {
+ return MakeRefImpl(str, Context{}, true);
}
-StringPool::Ref StringPool::makeRef(const StringPiece& str,
+StringPool::Ref StringPool::MakeRef(const StringPiece& str,
const Context& context) {
- return makeRefImpl(str, context, true);
+ return MakeRefImpl(str, context, true);
}
-StringPool::Ref StringPool::makeRefImpl(const StringPiece& str,
+StringPool::Ref StringPool::MakeRefImpl(const StringPiece& str,
const Context& context, bool unique) {
if (unique) {
- auto iter = mIndexedStrings.find(str);
- if (iter != std::end(mIndexedStrings)) {
+ auto iter = indexed_strings_.find(str);
+ if (iter != std::end(indexed_strings_)) {
return Ref(iter->second);
}
}
Entry* entry = new Entry();
- entry->value = str.toString();
+ entry->value = str.ToString();
entry->context = context;
- entry->index = mStrings.size();
- entry->ref = 0;
- mStrings.emplace_back(entry);
- mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
+ entry->index = strings_.size();
+ entry->ref_ = 0;
+ strings_.emplace_back(entry);
+ indexed_strings_.insert(std::make_pair(StringPiece(entry->value), entry));
return Ref(entry);
}
-StringPool::StyleRef StringPool::makeRef(const StyleString& str) {
- return makeRef(str, Context{});
+StringPool::StyleRef StringPool::MakeRef(const StyleString& str) {
+ return MakeRef(str, Context{});
}
-StringPool::StyleRef StringPool::makeRef(const StyleString& str,
+StringPool::StyleRef StringPool::MakeRef(const StyleString& str,
const Context& context) {
Entry* entry = new Entry();
entry->value = str.str;
entry->context = context;
- entry->index = mStrings.size();
- entry->ref = 0;
- mStrings.emplace_back(entry);
- mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
+ entry->index = strings_.size();
+ entry->ref_ = 0;
+ strings_.emplace_back(entry);
+ indexed_strings_.insert(std::make_pair(StringPiece(entry->value), entry));
- StyleEntry* styleEntry = new StyleEntry();
- styleEntry->str = Ref(entry);
+ StyleEntry* style_entry = new StyleEntry();
+ style_entry->str = Ref(entry);
for (const aapt::Span& span : str.spans) {
- styleEntry->spans.emplace_back(
- Span{makeRef(span.name), span.firstChar, span.lastChar});
+ style_entry->spans.emplace_back(
+ Span{MakeRef(span.name), span.first_char, span.last_char});
}
- styleEntry->ref = 0;
- mStyles.emplace_back(styleEntry);
- return StyleRef(styleEntry);
+ style_entry->ref_ = 0;
+ styles_.emplace_back(style_entry);
+ return StyleRef(style_entry);
}
-StringPool::StyleRef StringPool::makeRef(const StyleRef& ref) {
+StringPool::StyleRef StringPool::MakeRef(const StyleRef& ref) {
Entry* entry = new Entry();
- entry->value = *ref.mEntry->str;
- entry->context = ref.mEntry->str.mEntry->context;
- entry->index = mStrings.size();
- entry->ref = 0;
- mStrings.emplace_back(entry);
- mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
+ entry->value = *ref.entry_->str;
+ entry->context = ref.entry_->str.entry_->context;
+ entry->index = strings_.size();
+ entry->ref_ = 0;
+ strings_.emplace_back(entry);
+ indexed_strings_.insert(std::make_pair(StringPiece(entry->value), entry));
- StyleEntry* styleEntry = new StyleEntry();
- styleEntry->str = Ref(entry);
- for (const Span& span : ref.mEntry->spans) {
- styleEntry->spans.emplace_back(
- Span{makeRef(*span.name), span.firstChar, span.lastChar});
+ StyleEntry* style_entry = new StyleEntry();
+ style_entry->str = Ref(entry);
+ for (const Span& span : ref.entry_->spans) {
+ style_entry->spans.emplace_back(
+ Span{MakeRef(*span.name), span.first_char, span.last_char});
}
- styleEntry->ref = 0;
- mStyles.emplace_back(styleEntry);
- return StyleRef(styleEntry);
+ style_entry->ref_ = 0;
+ styles_.emplace_back(style_entry);
+ return StyleRef(style_entry);
}
-void StringPool::merge(StringPool&& pool) {
- mIndexedStrings.insert(pool.mIndexedStrings.begin(),
- pool.mIndexedStrings.end());
- pool.mIndexedStrings.clear();
- std::move(pool.mStrings.begin(), pool.mStrings.end(),
- std::back_inserter(mStrings));
- pool.mStrings.clear();
- std::move(pool.mStyles.begin(), pool.mStyles.end(),
- std::back_inserter(mStyles));
- pool.mStyles.clear();
+void StringPool::Merge(StringPool&& pool) {
+ indexed_strings_.insert(pool.indexed_strings_.begin(),
+ pool.indexed_strings_.end());
+ pool.indexed_strings_.clear();
+ std::move(pool.strings_.begin(), pool.strings_.end(),
+ std::back_inserter(strings_));
+ pool.strings_.clear();
+ std::move(pool.styles_.begin(), pool.styles_.end(),
+ std::back_inserter(styles_));
+ pool.styles_.clear();
// Assign the indices.
- const size_t len = mStrings.size();
+ const size_t len = strings_.size();
for (size_t index = 0; index < len; index++) {
- mStrings[index]->index = index;
+ strings_[index]->index = index;
}
}
-void StringPool::hintWillAdd(size_t stringCount, size_t styleCount) {
- mStrings.reserve(mStrings.size() + stringCount);
- mStyles.reserve(mStyles.size() + styleCount);
+void StringPool::HintWillAdd(size_t stringCount, size_t styleCount) {
+ strings_.reserve(strings_.size() + stringCount);
+ styles_.reserve(styles_.size() + styleCount);
}
-void StringPool::prune() {
- const auto iterEnd = std::end(mIndexedStrings);
- auto indexIter = std::begin(mIndexedStrings);
- while (indexIter != iterEnd) {
- if (indexIter->second->ref <= 0) {
- indexIter = mIndexedStrings.erase(indexIter);
+void StringPool::Prune() {
+ const auto iter_end = indexed_strings_.end();
+ auto index_iter = indexed_strings_.begin();
+ while (index_iter != iter_end) {
+ if (index_iter->second->ref_ <= 0) {
+ index_iter = indexed_strings_.erase(index_iter);
} else {
- ++indexIter;
+ ++index_iter;
}
}
- auto endIter2 =
- std::remove_if(std::begin(mStrings), std::end(mStrings),
+ auto end_iter2 =
+ std::remove_if(strings_.begin(), strings_.end(),
[](const std::unique_ptr<Entry>& entry) -> bool {
- return entry->ref <= 0;
+ return entry->ref_ <= 0;
});
- auto endIter3 =
- std::remove_if(std::begin(mStyles), std::end(mStyles),
+ auto end_iter3 =
+ std::remove_if(styles_.begin(), styles_.end(),
[](const std::unique_ptr<StyleEntry>& entry) -> bool {
- return entry->ref <= 0;
+ return entry->ref_ <= 0;
});
// Remove the entries at the end or else we'll be accessing
// a deleted string from the StyleEntry.
- mStrings.erase(endIter2, std::end(mStrings));
- mStyles.erase(endIter3, std::end(mStyles));
+ strings_.erase(end_iter2, strings_.end());
+ styles_.erase(end_iter3, styles_.end());
// Reassign the indices.
- const size_t len = mStrings.size();
+ const size_t len = strings_.size();
for (size_t index = 0; index < len; index++) {
- mStrings[index]->index = index;
+ strings_[index]->index = index;
}
}
-void StringPool::sort(
+void StringPool::Sort(
const std::function<bool(const Entry&, const Entry&)>& cmp) {
std::sort(
- std::begin(mStrings), std::end(mStrings),
+ strings_.begin(), strings_.end(),
[&cmp](const std::unique_ptr<Entry>& a,
const std::unique_ptr<Entry>& b) -> bool { return cmp(*a, *b); });
// Assign the indices.
- const size_t len = mStrings.size();
+ const size_t len = strings_.size();
for (size_t index = 0; index < len; index++) {
- mStrings[index]->index = index;
+ strings_[index]->index = index;
}
// Reorder the styles.
- std::sort(std::begin(mStyles), std::end(mStyles),
+ std::sort(styles_.begin(), styles_.end(),
[](const std::unique_ptr<StyleEntry>& lhs,
const std::unique_ptr<StyleEntry>& rhs) -> bool {
- return lhs->str.getIndex() < rhs->str.getIndex();
+ return lhs->str.index() < rhs->str.index();
});
}
template <typename T>
-static T* encodeLength(T* data, size_t length) {
+static T* EncodeLength(T* data, size_t length) {
static_assert(std::is_integral<T>::value, "wat.");
constexpr size_t kMask = 1 << ((sizeof(T) * 8) - 1);
@@ -284,7 +287,7 @@
}
template <typename T>
-static size_t encodedLengthUnits(size_t length) {
+static size_t EncodedLengthUnits(size_t length) {
static_assert(std::is_integral<T>::value, "wat.");
constexpr size_t kMask = 1 << ((sizeof(T) * 8) - 1);
@@ -292,10 +295,10 @@
return length > kMaxSize ? 2 : 1;
}
-bool StringPool::flatten(BigBuffer* out, const StringPool& pool, bool utf8) {
- const size_t startIndex = out->size();
+bool StringPool::Flatten(BigBuffer* out, const StringPool& pool, bool utf8) {
+ const size_t start_index = out->size();
android::ResStringPool_header* header =
- out->nextBlock<android::ResStringPool_header>();
+ out->NextBlock<android::ResStringPool_header>();
header->header.type = android::RES_STRING_POOL_TYPE;
header->header.headerSize = sizeof(*header);
header->stringCount = pool.size();
@@ -304,92 +307,90 @@
}
uint32_t* indices =
- pool.size() != 0 ? out->nextBlock<uint32_t>(pool.size()) : nullptr;
+ pool.size() != 0 ? out->NextBlock<uint32_t>(pool.size()) : nullptr;
- uint32_t* styleIndices = nullptr;
- if (!pool.mStyles.empty()) {
- header->styleCount = pool.mStyles.back()->str.getIndex() + 1;
- styleIndices = out->nextBlock<uint32_t>(header->styleCount);
+ uint32_t* style_indices = nullptr;
+ if (!pool.styles_.empty()) {
+ header->styleCount = pool.styles_.back()->str.index() + 1;
+ style_indices = out->NextBlock<uint32_t>(header->styleCount);
}
- const size_t beforeStringsIndex = out->size();
- header->stringsStart = beforeStringsIndex - startIndex;
+ const size_t before_strings_index = out->size();
+ header->stringsStart = before_strings_index - start_index;
for (const auto& entry : pool) {
- *indices = out->size() - beforeStringsIndex;
+ *indices = out->size() - before_strings_index;
indices++;
if (utf8) {
const std::string& encoded = entry->value;
- const ssize_t utf16Length = utf8_to_utf16_length(
+ const ssize_t utf16_length = utf8_to_utf16_length(
reinterpret_cast<const uint8_t*>(entry->value.data()),
entry->value.size());
- assert(utf16Length >= 0);
+ CHECK(utf16_length >= 0);
- const size_t totalSize = encodedLengthUnits<char>(utf16Length) +
- encodedLengthUnits<char>(encoded.length()) +
- encoded.size() + 1;
+ const size_t total_size = EncodedLengthUnits<char>(utf16_length) +
+ EncodedLengthUnits<char>(encoded.length()) +
+ encoded.size() + 1;
- char* data = out->nextBlock<char>(totalSize);
+ char* data = out->NextBlock<char>(total_size);
// First encode the UTF16 string length.
- data = encodeLength(data, utf16Length);
+ data = EncodeLength(data, utf16_length);
// Now encode the size of the real UTF8 string.
- data = encodeLength(data, encoded.length());
+ data = EncodeLength(data, encoded.length());
strncpy(data, encoded.data(), encoded.size());
} else {
- const std::u16string encoded = util::utf8ToUtf16(entry->value);
- const ssize_t utf16Length = encoded.size();
+ const std::u16string encoded = util::Utf8ToUtf16(entry->value);
+ const ssize_t utf16_length = encoded.size();
// Total number of 16-bit words to write.
- const size_t totalSize =
- encodedLengthUnits<char16_t>(utf16Length) + encoded.size() + 1;
+ const size_t total_size =
+ EncodedLengthUnits<char16_t>(utf16_length) + encoded.size() + 1;
- char16_t* data = out->nextBlock<char16_t>(totalSize);
+ char16_t* data = out->NextBlock<char16_t>(total_size);
// Encode the actual UTF16 string length.
- data = encodeLength(data, utf16Length);
- const size_t byteLength = encoded.size() * sizeof(char16_t);
+ data = EncodeLength(data, utf16_length);
+ const size_t byte_length = encoded.size() * sizeof(char16_t);
// NOTE: For some reason, strncpy16(data, entry->value.data(),
- // entry->value.size())
- // truncates the string.
- memcpy(data, encoded.data(), byteLength);
+ // entry->value.size()) truncates the string.
+ memcpy(data, encoded.data(), byte_length);
// The null-terminating character is already here due to the block of data
- // being set
- // to 0s on allocation.
+ // being set to 0s on allocation.
}
}
- out->align4();
+ out->Align4();
- if (!pool.mStyles.empty()) {
- const size_t beforeStylesIndex = out->size();
- header->stylesStart = beforeStylesIndex - startIndex;
+ if (!pool.styles_.empty()) {
+ const size_t before_styles_index = out->size();
+ header->stylesStart = before_styles_index - start_index;
- size_t currentIndex = 0;
- for (const auto& entry : pool.mStyles) {
- while (entry->str.getIndex() > currentIndex) {
- styleIndices[currentIndex++] = out->size() - beforeStylesIndex;
+ size_t current_index = 0;
+ for (const auto& entry : pool.styles_) {
+ while (entry->str.index() > current_index) {
+ style_indices[current_index++] = out->size() - before_styles_index;
- uint32_t* spanOffset = out->nextBlock<uint32_t>();
- *spanOffset = android::ResStringPool_span::END;
+ uint32_t* span_offset = out->NextBlock<uint32_t>();
+ *span_offset = android::ResStringPool_span::END;
}
- styleIndices[currentIndex++] = out->size() - beforeStylesIndex;
+ style_indices[current_index++] = out->size() - before_styles_index;
android::ResStringPool_span* span =
- out->nextBlock<android::ResStringPool_span>(entry->spans.size());
+ out->NextBlock<android::ResStringPool_span>(entry->spans.size());
for (const auto& s : entry->spans) {
- span->name.index = s.name.getIndex();
- span->firstChar = s.firstChar;
- span->lastChar = s.lastChar;
+ span->name.index = s.name.index();
+ span->firstChar = s.first_char;
+ span->lastChar = s.last_char;
span++;
}
- uint32_t* spanEnd = out->nextBlock<uint32_t>();
+ uint32_t* spanEnd = out->NextBlock<uint32_t>();
*spanEnd = android::ResStringPool_span::END;
}
@@ -397,22 +398,22 @@
// ResStringPool_span structure worth of 0xFFFFFFFF at the end
// of the style block, so fill in the remaining 2 32bit words
// with 0xFFFFFFFF.
- const size_t paddingLength = sizeof(android::ResStringPool_span) -
- sizeof(android::ResStringPool_span::name);
- uint8_t* padding = out->nextBlock<uint8_t>(paddingLength);
- memset(padding, 0xff, paddingLength);
- out->align4();
+ const size_t padding_length = sizeof(android::ResStringPool_span) -
+ sizeof(android::ResStringPool_span::name);
+ uint8_t* padding = out->NextBlock<uint8_t>(padding_length);
+ memset(padding, 0xff, padding_length);
+ out->Align4();
}
- header->header.size = out->size() - startIndex;
+ header->header.size = out->size() - start_index;
return true;
}
-bool StringPool::flattenUtf8(BigBuffer* out, const StringPool& pool) {
- return flatten(out, pool, true);
+bool StringPool::FlattenUtf8(BigBuffer* out, const StringPool& pool) {
+ return Flatten(out, pool, true);
}
-bool StringPool::flattenUtf16(BigBuffer* out, const StringPool& pool) {
- return flatten(out, pool, false);
+bool StringPool::FlattenUtf16(BigBuffer* out, const StringPool& pool) {
+ return Flatten(out, pool, false);
}
} // namespace aapt
diff --git a/tools/aapt2/StringPool.h b/tools/aapt2/StringPool.h
index 6e0d646..a4f556c 100644
--- a/tools/aapt2/StringPool.h
+++ b/tools/aapt2/StringPool.h
@@ -17,22 +17,22 @@
#ifndef AAPT_STRING_POOL_H
#define AAPT_STRING_POOL_H
-#include "ConfigDescription.h"
-#include "util/BigBuffer.h"
-#include "util/StringPiece.h"
-
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
+#include "ConfigDescription.h"
+#include "util/BigBuffer.h"
+#include "util/StringPiece.h"
+
namespace aapt {
struct Span {
std::string name;
- uint32_t firstChar;
- uint32_t lastChar;
+ uint32_t first_char;
+ uint32_t last_char;
};
struct StyleString {
@@ -72,15 +72,15 @@
const std::string* operator->() const;
const std::string& operator*() const;
- size_t getIndex() const;
- const Context& getContext() const;
+ size_t index() const;
+ const Context& GetContext() const;
private:
friend class StringPool;
explicit Ref(Entry* entry);
- Entry* mEntry;
+ Entry* entry_;
};
class StyleEntry;
@@ -95,15 +95,15 @@
const StyleEntry* operator->() const;
const StyleEntry& operator*() const;
- size_t getIndex() const;
- const Context& getContext() const;
+ size_t index() const;
+ const Context& GetContext() const;
private:
friend class StringPool;
explicit StyleRef(StyleEntry* entry);
- StyleEntry* mEntry;
+ StyleEntry* entry_;
};
class Entry {
@@ -116,13 +116,13 @@
friend class StringPool;
friend class Ref;
- int ref;
+ int ref_;
};
struct Span {
Ref name;
- uint32_t firstChar;
- uint32_t lastChar;
+ uint32_t first_char;
+ uint32_t last_char;
};
class StyleEntry {
@@ -134,13 +134,13 @@
friend class StringPool;
friend class StyleRef;
- int ref;
+ int ref_;
};
using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator;
- static bool flattenUtf8(BigBuffer* out, const StringPool& pool);
- static bool flattenUtf16(BigBuffer* out, const StringPool& pool);
+ static bool FlattenUtf8(BigBuffer* out, const StringPool& pool);
+ static bool FlattenUtf16(BigBuffer* out, const StringPool& pool);
StringPool() = default;
StringPool(const StringPool&) = delete;
@@ -149,84 +149,84 @@
* Adds a string to the pool, unless it already exists. Returns
* a reference to the string in the pool.
*/
- Ref makeRef(const StringPiece& str);
+ Ref MakeRef(const StringPiece& str);
/**
* Adds a string to the pool, unless it already exists, with a context
* object that can be used when sorting the string pool. Returns
* a reference to the string in the pool.
*/
- Ref makeRef(const StringPiece& str, const Context& context);
+ Ref MakeRef(const StringPiece& str, const Context& context);
/**
* Adds a style to the string pool and returns a reference to it.
*/
- StyleRef makeRef(const StyleString& str);
+ StyleRef MakeRef(const StyleString& str);
/**
* Adds a style to the string pool with a context object that
* can be used when sorting the string pool. Returns a reference
* to the style in the string pool.
*/
- StyleRef makeRef(const StyleString& str, const Context& context);
+ StyleRef MakeRef(const StyleString& str, const Context& context);
/**
* Adds a style from another string pool. Returns a reference to the
* style in the string pool.
*/
- StyleRef makeRef(const StyleRef& ref);
+ StyleRef MakeRef(const StyleRef& ref);
/**
* Moves pool into this one without coalescing strings. When this
* function returns, pool will be empty.
*/
- void merge(StringPool&& pool);
+ void Merge(StringPool&& pool);
/**
- * Retuns the number of strings in the table.
+ * Returns the number of strings in the table.
*/
inline size_t size() const;
/**
* Reserves space for strings and styles as an optimization.
*/
- void hintWillAdd(size_t stringCount, size_t styleCount);
+ void HintWillAdd(size_t string_count, size_t style_count);
/**
* Sorts the strings according to some comparison function.
*/
- void sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
+ void Sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
/**
* Removes any strings that have no references.
*/
- void prune();
+ void Prune();
private:
friend const_iterator begin(const StringPool& pool);
friend const_iterator end(const StringPool& pool);
- static bool flatten(BigBuffer* out, const StringPool& pool, bool utf8);
+ static bool Flatten(BigBuffer* out, const StringPool& pool, bool utf8);
- Ref makeRefImpl(const StringPiece& str, const Context& context, bool unique);
+ Ref MakeRefImpl(const StringPiece& str, const Context& context, bool unique);
- std::vector<std::unique_ptr<Entry>> mStrings;
- std::vector<std::unique_ptr<StyleEntry>> mStyles;
- std::unordered_multimap<StringPiece, Entry*> mIndexedStrings;
+ std::vector<std::unique_ptr<Entry>> strings_;
+ std::vector<std::unique_ptr<StyleEntry>> styles_;
+ std::unordered_multimap<StringPiece, Entry*> indexed_strings_;
};
//
// Inline implementation
//
-inline size_t StringPool::size() const { return mStrings.size(); }
+inline size_t StringPool::size() const { return strings_.size(); }
inline StringPool::const_iterator begin(const StringPool& pool) {
- return pool.mStrings.begin();
+ return pool.strings_.begin();
}
inline StringPool::const_iterator end(const StringPool& pool) {
- return pool.mStrings.end();
+ return pool.strings_.end();
}
} // namespace aapt
diff --git a/tools/aapt2/StringPool_test.cpp b/tools/aapt2/StringPool_test.cpp
index 2a7e1dd..e1394fc 100644
--- a/tools/aapt2/StringPool_test.cpp
+++ b/tools/aapt2/StringPool_test.cpp
@@ -15,25 +15,26 @@
*/
#include "StringPool.h"
-#include "test/Test.h"
-#include "util/Util.h"
#include <string>
+#include "test/Test.h"
+#include "util/Util.h"
+
namespace aapt {
TEST(StringPoolTest, InsertOneString) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("wut");
+ StringPool::Ref ref = pool.MakeRef("wut");
EXPECT_EQ(*ref, "wut");
}
TEST(StringPoolTest, InsertTwoUniqueStrings) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("wut");
- StringPool::Ref ref2 = pool.makeRef("hey");
+ StringPool::Ref ref = pool.MakeRef("wut");
+ StringPool::Ref ref2 = pool.MakeRef("hey");
EXPECT_EQ(*ref, "wut");
EXPECT_EQ(*ref2, "hey");
@@ -42,8 +43,8 @@
TEST(StringPoolTest, DoNotInsertNewDuplicateString) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("wut");
- StringPool::Ref ref2 = pool.makeRef("wut");
+ StringPool::Ref ref = pool.MakeRef("wut");
+ StringPool::Ref ref2 = pool.MakeRef("wut");
EXPECT_EQ(*ref, "wut");
EXPECT_EQ(*ref2, "wut");
@@ -53,28 +54,28 @@
TEST(StringPoolTest, MaintainInsertionOrderIndex) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("z");
- StringPool::Ref ref2 = pool.makeRef("a");
- StringPool::Ref ref3 = pool.makeRef("m");
+ StringPool::Ref ref = pool.MakeRef("z");
+ StringPool::Ref ref2 = pool.MakeRef("a");
+ StringPool::Ref ref3 = pool.MakeRef("m");
- EXPECT_EQ(0u, ref.getIndex());
- EXPECT_EQ(1u, ref2.getIndex());
- EXPECT_EQ(2u, ref3.getIndex());
+ EXPECT_EQ(0u, ref.index());
+ EXPECT_EQ(1u, ref2.index());
+ EXPECT_EQ(2u, ref3.index());
}
TEST(StringPoolTest, PruneStringsWithNoReferences) {
StringPool pool;
- StringPool::Ref refA = pool.makeRef("foo");
+ StringPool::Ref refA = pool.MakeRef("foo");
{
- StringPool::Ref ref = pool.makeRef("wut");
+ StringPool::Ref ref = pool.MakeRef("wut");
EXPECT_EQ(*ref, "wut");
EXPECT_EQ(2u, pool.size());
}
- StringPool::Ref refB = pool.makeRef("bar");
+ StringPool::Ref refB = pool.MakeRef("bar");
EXPECT_EQ(3u, pool.size());
- pool.prune();
+ pool.Prune();
EXPECT_EQ(2u, pool.size());
StringPool::const_iterator iter = begin(pool);
EXPECT_EQ((*iter)->value, "foo");
@@ -87,51 +88,51 @@
TEST(StringPoolTest, SortAndMaintainIndexesInReferences) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("z");
- StringPool::StyleRef ref2 = pool.makeRef(StyleString{{"a"}});
- StringPool::Ref ref3 = pool.makeRef("m");
+ StringPool::Ref ref = pool.MakeRef("z");
+ StringPool::StyleRef ref2 = pool.MakeRef(StyleString{{"a"}});
+ StringPool::Ref ref3 = pool.MakeRef("m");
EXPECT_EQ(*ref, "z");
- EXPECT_EQ(0u, ref.getIndex());
+ EXPECT_EQ(0u, ref.index());
EXPECT_EQ(*(ref2->str), "a");
- EXPECT_EQ(1u, ref2.getIndex());
+ EXPECT_EQ(1u, ref2.index());
EXPECT_EQ(*ref3, "m");
- EXPECT_EQ(2u, ref3.getIndex());
+ EXPECT_EQ(2u, ref3.index());
- pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+ pool.Sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
return a.value < b.value;
});
EXPECT_EQ(*ref, "z");
- EXPECT_EQ(2u, ref.getIndex());
+ EXPECT_EQ(2u, ref.index());
EXPECT_EQ(*(ref2->str), "a");
- EXPECT_EQ(0u, ref2.getIndex());
+ EXPECT_EQ(0u, ref2.index());
EXPECT_EQ(*ref3, "m");
- EXPECT_EQ(1u, ref3.getIndex());
+ EXPECT_EQ(1u, ref3.index());
}
TEST(StringPoolTest, SortAndStillDedupe) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("z");
- StringPool::Ref ref2 = pool.makeRef("a");
- StringPool::Ref ref3 = pool.makeRef("m");
+ StringPool::Ref ref = pool.MakeRef("z");
+ StringPool::Ref ref2 = pool.MakeRef("a");
+ StringPool::Ref ref3 = pool.MakeRef("m");
- pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+ pool.Sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
return a.value < b.value;
});
- StringPool::Ref ref4 = pool.makeRef("z");
- StringPool::Ref ref5 = pool.makeRef("a");
- StringPool::Ref ref6 = pool.makeRef("m");
+ StringPool::Ref ref4 = pool.MakeRef("z");
+ StringPool::Ref ref5 = pool.MakeRef("a");
+ StringPool::Ref ref6 = pool.MakeRef("m");
- EXPECT_EQ(ref4.getIndex(), ref.getIndex());
- EXPECT_EQ(ref5.getIndex(), ref2.getIndex());
- EXPECT_EQ(ref6.getIndex(), ref3.getIndex());
+ EXPECT_EQ(ref4.index(), ref.index());
+ EXPECT_EQ(ref5.index(), ref2.index());
+ EXPECT_EQ(ref6.index(), ref3.index());
}
TEST(StringPoolTest, AddStyles) {
@@ -139,27 +140,27 @@
StyleString str{{"android"}, {Span{{"b"}, 2, 6}}};
- StringPool::StyleRef ref = pool.makeRef(str);
+ StringPool::StyleRef ref = pool.MakeRef(str);
- EXPECT_EQ(0u, ref.getIndex());
+ EXPECT_EQ(0u, ref.index());
EXPECT_EQ(std::string("android"), *(ref->str));
ASSERT_EQ(1u, ref->spans.size());
const StringPool::Span& span = ref->spans.front();
EXPECT_EQ(*(span.name), "b");
- EXPECT_EQ(2u, span.firstChar);
- EXPECT_EQ(6u, span.lastChar);
+ EXPECT_EQ(2u, span.first_char);
+ EXPECT_EQ(6u, span.last_char);
}
TEST(StringPoolTest, DoNotDedupeStyleWithSameStringAsNonStyle) {
StringPool pool;
- StringPool::Ref ref = pool.makeRef("android");
+ StringPool::Ref ref = pool.MakeRef("android");
StyleString str{{"android"}};
- StringPool::StyleRef styleRef = pool.makeRef(str);
+ StringPool::StyleRef styleRef = pool.MakeRef(str);
- EXPECT_NE(ref.getIndex(), styleRef.getIndex());
+ EXPECT_NE(ref.index(), styleRef.index());
}
TEST(StringPoolTest, FlattenEmptyStringPoolUtf8) {
@@ -167,9 +168,9 @@
StringPool pool;
BigBuffer buffer(1024);
- StringPool::flattenUtf8(&buffer, pool);
+ StringPool::FlattenUtf8(&buffer, pool);
- std::unique_ptr<uint8_t[]> data = util::copy(buffer);
+ std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
ResStringPool test;
ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
}
@@ -178,11 +179,11 @@
using namespace android; // For NO_ERROR on Windows.
StringPool pool;
- pool.makeRef("\u093f");
+ pool.MakeRef("\u093f");
BigBuffer buffer(1024);
- StringPool::flattenUtf16(&buffer, pool);
+ StringPool::FlattenUtf16(&buffer, pool);
- std::unique_ptr<uint8_t[]> data = util::copy(buffer);
+ std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
ResStringPool test;
ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
size_t len = 0;
@@ -204,58 +205,58 @@
StringPool pool;
- StringPool::Ref ref1 = pool.makeRef("hello");
- StringPool::Ref ref2 = pool.makeRef("goodbye");
- StringPool::Ref ref3 = pool.makeRef(sLongString);
- StringPool::Ref ref4 = pool.makeRef("");
- StringPool::StyleRef ref5 = pool.makeRef(
+ StringPool::Ref ref1 = pool.MakeRef("hello");
+ StringPool::Ref ref2 = pool.MakeRef("goodbye");
+ StringPool::Ref ref3 = pool.MakeRef(sLongString);
+ StringPool::Ref ref4 = pool.MakeRef("");
+ StringPool::StyleRef ref5 = pool.MakeRef(
StyleString{{"style"}, {Span{{"b"}, 0, 1}, Span{{"i"}, 2, 3}}});
- EXPECT_EQ(0u, ref1.getIndex());
- EXPECT_EQ(1u, ref2.getIndex());
- EXPECT_EQ(2u, ref3.getIndex());
- EXPECT_EQ(3u, ref4.getIndex());
- EXPECT_EQ(4u, ref5.getIndex());
+ EXPECT_EQ(0u, ref1.index());
+ EXPECT_EQ(1u, ref2.index());
+ EXPECT_EQ(2u, ref3.index());
+ EXPECT_EQ(3u, ref4.index());
+ EXPECT_EQ(4u, ref5.index());
BigBuffer buffers[2] = {BigBuffer(1024), BigBuffer(1024)};
- StringPool::flattenUtf8(&buffers[0], pool);
- StringPool::flattenUtf16(&buffers[1], pool);
+ StringPool::FlattenUtf8(&buffers[0], pool);
+ StringPool::FlattenUtf16(&buffers[1], pool);
// Test both UTF-8 and UTF-16 buffers.
for (const BigBuffer& buffer : buffers) {
- std::unique_ptr<uint8_t[]> data = util::copy(buffer);
+ std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
ResStringPool test;
ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
- EXPECT_EQ(std::string("hello"), util::getString(test, 0));
- EXPECT_EQ(StringPiece16(u"hello"), util::getString16(test, 0));
+ EXPECT_EQ(std::string("hello"), util::GetString(test, 0));
+ EXPECT_EQ(StringPiece16(u"hello"), util::GetString16(test, 0));
- EXPECT_EQ(std::string("goodbye"), util::getString(test, 1));
- EXPECT_EQ(StringPiece16(u"goodbye"), util::getString16(test, 1));
+ EXPECT_EQ(std::string("goodbye"), util::GetString(test, 1));
+ EXPECT_EQ(StringPiece16(u"goodbye"), util::GetString16(test, 1));
- EXPECT_EQ(StringPiece(sLongString), util::getString(test, 2));
- EXPECT_EQ(util::utf8ToUtf16(sLongString),
- util::getString16(test, 2).toString());
+ EXPECT_EQ(StringPiece(sLongString), util::GetString(test, 2));
+ EXPECT_EQ(util::Utf8ToUtf16(sLongString),
+ util::GetString16(test, 2).ToString());
size_t len;
EXPECT_TRUE(test.stringAt(3, &len) != nullptr ||
test.string8At(3, &len) != nullptr);
- EXPECT_EQ(std::string("style"), util::getString(test, 4));
- EXPECT_EQ(StringPiece16(u"style"), util::getString16(test, 4));
+ EXPECT_EQ(std::string("style"), util::GetString(test, 4));
+ EXPECT_EQ(StringPiece16(u"style"), util::GetString16(test, 4));
const ResStringPool_span* span = test.styleAt(4);
ASSERT_NE(nullptr, span);
- EXPECT_EQ(std::string("b"), util::getString(test, span->name.index));
- EXPECT_EQ(StringPiece16(u"b"), util::getString16(test, span->name.index));
+ EXPECT_EQ(std::string("b"), util::GetString(test, span->name.index));
+ EXPECT_EQ(StringPiece16(u"b"), util::GetString16(test, span->name.index));
EXPECT_EQ(0u, span->firstChar);
EXPECT_EQ(1u, span->lastChar);
span++;
ASSERT_NE(ResStringPool_span::END, span->name.index);
- EXPECT_EQ(std::string("i"), util::getString(test, span->name.index));
- EXPECT_EQ(StringPiece16(u"i"), util::getString16(test, span->name.index));
+ EXPECT_EQ(std::string("i"), util::GetString(test, span->name.index));
+ EXPECT_EQ(StringPiece16(u"i"), util::GetString16(test, span->name.index));
EXPECT_EQ(2u, span->firstChar);
EXPECT_EQ(3u, span->lastChar);
span++;
diff --git a/tools/aapt2/ValueVisitor.h b/tools/aapt2/ValueVisitor.h
index 121c337..1cb6aa1 100644
--- a/tools/aapt2/ValueVisitor.h
+++ b/tools/aapt2/ValueVisitor.h
@@ -24,32 +24,31 @@
/**
* Visits a value and invokes the appropriate method based on its type. Does not
- * traverse
- * into compound types. Use ValueVisitor for that.
+ * traverse into compound types. Use ValueVisitor for that.
*/
struct RawValueVisitor {
virtual ~RawValueVisitor() = default;
- virtual void visitItem(Item* value) {}
- virtual void visit(Reference* value) { visitItem(value); }
- virtual void visit(RawString* value) { visitItem(value); }
- virtual void visit(String* value) { visitItem(value); }
- virtual void visit(StyledString* value) { visitItem(value); }
- virtual void visit(FileReference* value) { visitItem(value); }
- virtual void visit(Id* value) { visitItem(value); }
- virtual void visit(BinaryPrimitive* value) { visitItem(value); }
+ virtual void VisitItem(Item* value) {}
+ virtual void Visit(Reference* value) { VisitItem(value); }
+ virtual void Visit(RawString* value) { VisitItem(value); }
+ virtual void Visit(String* value) { VisitItem(value); }
+ virtual void Visit(StyledString* value) { VisitItem(value); }
+ virtual void Visit(FileReference* value) { VisitItem(value); }
+ virtual void Visit(Id* value) { VisitItem(value); }
+ virtual void Visit(BinaryPrimitive* value) { VisitItem(value); }
- virtual void visit(Attribute* value) {}
- virtual void visit(Style* value) {}
- virtual void visit(Array* value) {}
- virtual void visit(Plural* value) {}
- virtual void visit(Styleable* value) {}
+ virtual void Visit(Attribute* value) {}
+ virtual void Visit(Style* value) {}
+ virtual void Visit(Array* value) {}
+ virtual void Visit(Plural* value) {}
+ virtual void Visit(Styleable* value) {}
};
// NOLINT, do not add parentheses around T.
-#define DECL_VISIT_COMPOUND_VALUE(T) \
- virtual void visit(T* value) { /* NOLINT */ \
- visitSubValues(value); \
+#define DECL_VISIT_COMPOUND_VALUE(T) \
+ virtual void Visit(T* value) override { /* NOLINT */ \
+ VisitSubValues(value); \
}
/**
@@ -59,44 +58,43 @@
struct ValueVisitor : public RawValueVisitor {
// The compiler will think we're hiding an overload, when we actually intend
// to call into RawValueVisitor. This will expose the visit methods in the
- // super
- // class so the compiler knows we are trying to call them.
- using RawValueVisitor::visit;
+ // super class so the compiler knows we are trying to call them.
+ using RawValueVisitor::Visit;
- void visitSubValues(Attribute* attribute) {
+ void VisitSubValues(Attribute* attribute) {
for (Attribute::Symbol& symbol : attribute->symbols) {
- visit(&symbol.symbol);
+ Visit(&symbol.symbol);
}
}
- void visitSubValues(Style* style) {
+ void VisitSubValues(Style* style) {
if (style->parent) {
- visit(&style->parent.value());
+ Visit(&style->parent.value());
}
for (Style::Entry& entry : style->entries) {
- visit(&entry.key);
- entry.value->accept(this);
+ Visit(&entry.key);
+ entry.value->Accept(this);
}
}
- void visitSubValues(Array* array) {
+ void VisitSubValues(Array* array) {
for (std::unique_ptr<Item>& item : array->items) {
- item->accept(this);
+ item->Accept(this);
}
}
- void visitSubValues(Plural* plural) {
+ void VisitSubValues(Plural* plural) {
for (std::unique_ptr<Item>& item : plural->values) {
if (item) {
- item->accept(this);
+ item->Accept(this);
}
}
}
- void visitSubValues(Styleable* styleable) {
+ void VisitSubValues(Styleable* styleable) {
for (Reference& reference : styleable->entries) {
- visit(&reference);
+ Visit(&reference);
}
}
@@ -114,7 +112,7 @@
struct DynCastVisitor : public RawValueVisitor {
T* value = nullptr;
- void visit(T* v) override { value = v; }
+ void Visit(T* v) override { value = v; }
};
/**
@@ -124,12 +122,12 @@
struct DynCastVisitor<Item> : public RawValueVisitor {
Item* value = nullptr;
- void visitItem(Item* item) override { value = item; }
+ void VisitItem(Item* item) override { value = item; }
};
template <typename T>
-const T* valueCast(const Value* value) {
- return valueCast<T>(const_cast<Value*>(value));
+const T* ValueCast(const Value* value) {
+ return ValueCast<T>(const_cast<Value*>(value));
}
/**
@@ -137,30 +135,30 @@
* Otherwise, returns nullptr.
*/
template <typename T>
-T* valueCast(Value* value) {
+T* ValueCast(Value* value) {
if (!value) {
return nullptr;
}
DynCastVisitor<T> visitor;
- value->accept(&visitor);
+ value->Accept(&visitor);
return visitor.value;
}
-inline void visitAllValuesInPackage(ResourceTablePackage* pkg,
+inline void VisitAllValuesInPackage(ResourceTablePackage* pkg,
RawValueVisitor* visitor) {
for (auto& type : pkg->types) {
for (auto& entry : type->entries) {
- for (auto& configValue : entry->values) {
- configValue->value->accept(visitor);
+ for (auto& config_value : entry->values) {
+ config_value->value->Accept(visitor);
}
}
}
}
-inline void visitAllValuesInTable(ResourceTable* table,
+inline void VisitAllValuesInTable(ResourceTable* table,
RawValueVisitor* visitor) {
for (auto& pkg : table->packages) {
- visitAllValuesInPackage(pkg.get(), visitor);
+ VisitAllValuesInPackage(pkg.get(), visitor);
}
}
diff --git a/tools/aapt2/ValueVisitor_test.cpp b/tools/aapt2/ValueVisitor_test.cpp
index ed9c7f6..eb75b10 100644
--- a/tools/aapt2/ValueVisitor_test.cpp
+++ b/tools/aapt2/ValueVisitor_test.cpp
@@ -15,40 +15,41 @@
*/
#include "ValueVisitor.h"
+
+#include <string>
+
#include "ResourceValues.h"
#include "test/Test.h"
#include "util/Util.h"
-#include <string>
-
namespace aapt {
struct SingleReferenceVisitor : public ValueVisitor {
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
Reference* visited = nullptr;
- void visit(Reference* ref) override { visited = ref; }
+ void Visit(Reference* ref) override { visited = ref; }
};
struct StyleVisitor : public ValueVisitor {
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
- std::list<Reference*> visitedRefs;
- Style* visitedStyle = nullptr;
+ std::list<Reference*> visited_refs;
+ Style* visited_style = nullptr;
- void visit(Reference* ref) override { visitedRefs.push_back(ref); }
+ void Visit(Reference* ref) override { visited_refs.push_back(ref); }
- void visit(Style* style) override {
- visitedStyle = style;
- ValueVisitor::visit(style);
+ void Visit(Style* style) override {
+ visited_style = style;
+ ValueVisitor::Visit(style);
}
};
TEST(ValueVisitorTest, VisitsReference) {
Reference ref(ResourceName{"android", ResourceType::kAttr, "foo"});
SingleReferenceVisitor visitor;
- ref.accept(&visitor);
+ ref.Accept(&visitor);
EXPECT_EQ(visitor.visited, &ref);
}
@@ -56,31 +57,31 @@
TEST(ValueVisitorTest, VisitsReferencesInStyle) {
std::unique_ptr<Style> style =
test::StyleBuilder()
- .setParent("android:style/foo")
- .addItem("android:attr/one", test::buildReference("android:id/foo"))
- .build();
+ .SetParent("android:style/foo")
+ .AddItem("android:attr/one", test::BuildReference("android:id/foo"))
+ .Build();
StyleVisitor visitor;
- style->accept(&visitor);
+ style->Accept(&visitor);
- ASSERT_EQ(style.get(), visitor.visitedStyle);
+ ASSERT_EQ(style.get(), visitor.visited_style);
// Entry attribute references, plus the parent reference, plus one value
// reference.
- ASSERT_EQ(style->entries.size() + 2, visitor.visitedRefs.size());
+ ASSERT_EQ(style->entries.size() + 2, visitor.visited_refs.size());
}
TEST(ValueVisitorTest, ValueCast) {
- std::unique_ptr<Reference> ref = test::buildReference("android:color/white");
- EXPECT_NE(valueCast<Reference>(ref.get()), nullptr);
+ std::unique_ptr<Reference> ref = test::BuildReference("android:color/white");
+ EXPECT_NE(ValueCast<Reference>(ref.get()), nullptr);
std::unique_ptr<Style> style =
test::StyleBuilder()
- .addItem("android:attr/foo",
- test::buildReference("android:color/black"))
- .build();
- EXPECT_NE(valueCast<Style>(style.get()), nullptr);
- EXPECT_EQ(valueCast<Reference>(style.get()), nullptr);
+ .AddItem("android:attr/foo",
+ test::BuildReference("android:color/black"))
+ .Build();
+ EXPECT_NE(ValueCast<Style>(style.get()), nullptr);
+ EXPECT_EQ(ValueCast<Reference>(style.get()), nullptr);
}
} // namespace aapt
diff --git a/tools/aapt2/compile/Compile.cpp b/tools/aapt2/compile/Compile.cpp
index 2ea63d0..a06140c 100644
--- a/tools/aapt2/compile/Compile.cpp
+++ b/tools/aapt2/compile/Compile.cpp
@@ -14,6 +14,11 @@
* limitations under the License.
*/
+#include <dirent.h>
+
+#include <fstream>
+#include <string>
+
#include "ConfigDescription.h"
#include "Diagnostics.h"
#include "Flags.h"
@@ -33,14 +38,10 @@
#include "xml/XmlDom.h"
#include "xml/XmlPullParser.h"
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-
-#include <android-base/errors.h>
-#include <android-base/file.h>
-#include <dirent.h>
-#include <fstream>
-#include <string>
+#include "android-base/errors.h"
+#include "android-base/file.h"
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
using google::protobuf::io::CopyingOutputStreamAdaptor;
using google::protobuf::io::ZeroCopyOutputStream;
@@ -49,7 +50,7 @@
struct ResourcePathData {
Source source;
- std::string resourceDir;
+ std::string resource_dir;
std::string name;
std::string extension;
@@ -58,7 +59,7 @@
// version qualifiers. We want to preserve the original input so the output is
// easily
// computed before hand.
- std::string configStr;
+ std::string config_str;
ConfigDescription config;
};
@@ -66,60 +67,60 @@
* Resource file paths are expected to look like:
* [--/res/]type[-config]/name
*/
-static Maybe<ResourcePathData> extractResourcePathData(const std::string& path,
- std::string* outError) {
- std::vector<std::string> parts = util::split(path, file::sDirSep);
+static Maybe<ResourcePathData> ExtractResourcePathData(const std::string& path,
+ std::string* out_error) {
+ std::vector<std::string> parts = util::Split(path, file::sDirSep);
if (parts.size() < 2) {
- if (outError) *outError = "bad resource path";
+ if (out_error) *out_error = "bad resource path";
return {};
}
std::string& dir = parts[parts.size() - 2];
- StringPiece dirStr = dir;
+ StringPiece dir_str = dir;
- StringPiece configStr;
+ StringPiece config_str;
ConfigDescription config;
- size_t dashPos = dir.find('-');
- if (dashPos != std::string::npos) {
- configStr = dirStr.substr(dashPos + 1, dir.size() - (dashPos + 1));
- if (!ConfigDescription::parse(configStr, &config)) {
- if (outError) {
- std::stringstream errStr;
- errStr << "invalid configuration '" << configStr << "'";
- *outError = errStr.str();
+ size_t dash_pos = dir.find('-');
+ if (dash_pos != std::string::npos) {
+ config_str = dir_str.substr(dash_pos + 1, dir.size() - (dash_pos + 1));
+ if (!ConfigDescription::Parse(config_str, &config)) {
+ if (out_error) {
+ std::stringstream err_str;
+ err_str << "invalid configuration '" << config_str << "'";
+ *out_error = err_str.str();
}
return {};
}
- dirStr = dirStr.substr(0, dashPos);
+ dir_str = dir_str.substr(0, dash_pos);
}
std::string& filename = parts[parts.size() - 1];
StringPiece name = filename;
StringPiece extension;
- size_t dotPos = filename.find('.');
- if (dotPos != std::string::npos) {
- extension = name.substr(dotPos + 1, filename.size() - (dotPos + 1));
- name = name.substr(0, dotPos);
+ size_t dot_pos = filename.find('.');
+ if (dot_pos != std::string::npos) {
+ extension = name.substr(dot_pos + 1, filename.size() - (dot_pos + 1));
+ name = name.substr(0, dot_pos);
}
- return ResourcePathData{Source(path), dirStr.toString(),
- name.toString(), extension.toString(),
- configStr.toString(), config};
+ return ResourcePathData{Source(path), dir_str.ToString(),
+ name.ToString(), extension.ToString(),
+ config_str.ToString(), config};
}
struct CompileOptions {
- std::string outputPath;
- Maybe<std::string> resDir;
+ std::string output_path;
+ Maybe<std::string> res_dir;
bool pseudolocalize = false;
- bool legacyMode = false;
+ bool legacy_mode = false;
bool verbose = false;
};
-static std::string buildIntermediateFilename(const ResourcePathData& data) {
+static std::string BuildIntermediateFilename(const ResourcePathData& data) {
std::stringstream name;
- name << data.resourceDir;
- if (!data.configStr.empty()) {
- name << "-" << data.configStr;
+ name << data.resource_dir;
+ if (!data.config_str.empty()) {
+ name << "-" << data.config_str;
}
name << "_" << data.name;
if (!data.extension.empty()) {
@@ -129,92 +130,93 @@
return name.str();
}
-static bool isHidden(const StringPiece& filename) {
- return util::stringStartsWith(filename, ".");
+static bool IsHidden(const StringPiece& filename) {
+ return util::StartsWith(filename, ".");
}
/**
* Walks the res directory structure, looking for resource files.
*/
-static bool loadInputFilesFromDir(IAaptContext* context,
- const CompileOptions& options,
- std::vector<ResourcePathData>* outPathData) {
- const std::string& rootDir = options.resDir.value();
- std::unique_ptr<DIR, decltype(closedir)*> d(opendir(rootDir.data()),
+static bool LoadInputFilesFromDir(
+ IAaptContext* context, const CompileOptions& options,
+ std::vector<ResourcePathData>* out_path_data) {
+ const std::string& root_dir = options.res_dir.value();
+ std::unique_ptr<DIR, decltype(closedir)*> d(opendir(root_dir.data()),
closedir);
if (!d) {
- context->getDiagnostics()->error(DiagMessage() << strerror(errno));
+ context->GetDiagnostics()->Error(DiagMessage() << strerror(errno));
return false;
}
while (struct dirent* entry = readdir(d.get())) {
- if (isHidden(entry->d_name)) {
+ if (IsHidden(entry->d_name)) {
continue;
}
- std::string prefixPath = rootDir;
- file::appendPath(&prefixPath, entry->d_name);
+ std::string prefix_path = root_dir;
+ file::AppendPath(&prefix_path, entry->d_name);
- if (file::getFileType(prefixPath) != file::FileType::kDirectory) {
+ if (file::GetFileType(prefix_path) != file::FileType::kDirectory) {
continue;
}
- std::unique_ptr<DIR, decltype(closedir)*> subDir(opendir(prefixPath.data()),
- closedir);
- if (!subDir) {
- context->getDiagnostics()->error(DiagMessage() << strerror(errno));
+ std::unique_ptr<DIR, decltype(closedir)*> subdir(
+ opendir(prefix_path.data()), closedir);
+ if (!subdir) {
+ context->GetDiagnostics()->Error(DiagMessage() << strerror(errno));
return false;
}
- while (struct dirent* leafEntry = readdir(subDir.get())) {
- if (isHidden(leafEntry->d_name)) {
+ while (struct dirent* leaf_entry = readdir(subdir.get())) {
+ if (IsHidden(leaf_entry->d_name)) {
continue;
}
- std::string fullPath = prefixPath;
- file::appendPath(&fullPath, leafEntry->d_name);
+ std::string full_path = prefix_path;
+ file::AppendPath(&full_path, leaf_entry->d_name);
- std::string errStr;
- Maybe<ResourcePathData> pathData =
- extractResourcePathData(fullPath, &errStr);
- if (!pathData) {
- context->getDiagnostics()->error(DiagMessage() << errStr);
+ std::string err_str;
+ Maybe<ResourcePathData> path_data =
+ ExtractResourcePathData(full_path, &err_str);
+ if (!path_data) {
+ context->GetDiagnostics()->Error(DiagMessage() << err_str);
return false;
}
- outPathData->push_back(std::move(pathData.value()));
+ out_path_data->push_back(std::move(path_data.value()));
}
}
return true;
}
-static bool compileTable(IAaptContext* context, const CompileOptions& options,
- const ResourcePathData& pathData,
+static bool CompileTable(IAaptContext* context, const CompileOptions& options,
+ const ResourcePathData& path_data,
IArchiveWriter* writer,
- const std::string& outputPath) {
+ const std::string& output_path) {
ResourceTable table;
{
- std::ifstream fin(pathData.source.path, std::ifstream::binary);
+ std::ifstream fin(path_data.source.path, std::ifstream::binary);
if (!fin) {
- context->getDiagnostics()->error(DiagMessage(pathData.source)
+ context->GetDiagnostics()->Error(DiagMessage(path_data.source)
<< strerror(errno));
return false;
}
// Parse the values file from XML.
- xml::XmlPullParser xmlParser(fin);
+ xml::XmlPullParser xml_parser(fin);
- ResourceParserOptions parserOptions;
- parserOptions.errorOnPositionalArguments = !options.legacyMode;
+ ResourceParserOptions parser_options;
+ parser_options.error_on_positional_arguments = !options.legacy_mode;
// If the filename includes donottranslate, then the default translatable is
// false.
- parserOptions.translatable =
- pathData.name.find("donottranslate") == std::string::npos;
+ parser_options.translatable =
+ path_data.name.find("donottranslate") == std::string::npos;
- ResourceParser resParser(context->getDiagnostics(), &table, pathData.source,
- pathData.config, parserOptions);
- if (!resParser.parse(&xmlParser)) {
+ ResourceParser res_parser(context->GetDiagnostics(), &table,
+ path_data.source, path_data.config,
+ parser_options);
+ if (!res_parser.Parse(&xml_parser)) {
return false;
}
@@ -226,242 +228,241 @@
// These are created as weak symbols, and are only generated from default
// configuration
// strings and plurals.
- PseudolocaleGenerator pseudolocaleGenerator;
- if (!pseudolocaleGenerator.consume(context, &table)) {
+ PseudolocaleGenerator pseudolocale_generator;
+ if (!pseudolocale_generator.Consume(context, &table)) {
return false;
}
}
// Ensure we have the compilation package at least.
- table.createPackage(context->getCompilationPackage());
+ table.CreatePackage(context->GetCompilationPackage());
// Assign an ID to any package that has resources.
for (auto& pkg : table.packages) {
if (!pkg->id) {
// If no package ID was set while parsing (public identifiers), auto
// assign an ID.
- pkg->id = context->getPackageId();
+ pkg->id = context->GetPackageId();
}
}
// Create the file/zip entry.
- if (!writer->startEntry(outputPath, 0)) {
- context->getDiagnostics()->error(DiagMessage(outputPath)
+ if (!writer->StartEntry(output_path, 0)) {
+ context->GetDiagnostics()->Error(DiagMessage(output_path)
<< "failed to open");
return false;
}
// Make sure CopyingOutputStreamAdaptor is deleted before we call
- // writer->finishEntry().
+ // writer->FinishEntry().
{
// Wrap our IArchiveWriter with an adaptor that implements the
// ZeroCopyOutputStream
// interface.
- CopyingOutputStreamAdaptor copyingAdaptor(writer);
+ CopyingOutputStreamAdaptor copying_adaptor(writer);
- std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(&table);
- if (!pbTable->SerializeToZeroCopyStream(©ingAdaptor)) {
- context->getDiagnostics()->error(DiagMessage(outputPath)
+ std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(&table);
+ if (!pb_table->SerializeToZeroCopyStream(©ing_adaptor)) {
+ context->GetDiagnostics()->Error(DiagMessage(output_path)
<< "failed to write");
return false;
}
}
- if (!writer->finishEntry()) {
- context->getDiagnostics()->error(DiagMessage(outputPath)
+ if (!writer->FinishEntry()) {
+ context->GetDiagnostics()->Error(DiagMessage(output_path)
<< "failed to finish entry");
return false;
}
return true;
}
-static bool writeHeaderAndBufferToWriter(const StringPiece& outputPath,
+static bool WriteHeaderAndBufferToWriter(const StringPiece& output_path,
const ResourceFile& file,
const BigBuffer& buffer,
IArchiveWriter* writer,
IDiagnostics* diag) {
// Start the entry so we can write the header.
- if (!writer->startEntry(outputPath, 0)) {
- diag->error(DiagMessage(outputPath) << "failed to open file");
+ if (!writer->StartEntry(output_path, 0)) {
+ diag->Error(DiagMessage(output_path) << "failed to open file");
return false;
}
// Make sure CopyingOutputStreamAdaptor is deleted before we call
- // writer->finishEntry().
+ // writer->FinishEntry().
{
// Wrap our IArchiveWriter with an adaptor that implements the
// ZeroCopyOutputStream
// interface.
- CopyingOutputStreamAdaptor copyingAdaptor(writer);
- CompiledFileOutputStream outputStream(©ingAdaptor);
+ CopyingOutputStreamAdaptor copying_adaptor(writer);
+ CompiledFileOutputStream output_stream(©ing_adaptor);
// Number of CompiledFiles.
- outputStream.WriteLittleEndian32(1);
+ output_stream.WriteLittleEndian32(1);
- std::unique_ptr<pb::CompiledFile> compiledFile =
- serializeCompiledFileToPb(file);
- outputStream.WriteCompiledFile(compiledFile.get());
- outputStream.WriteData(&buffer);
+ std::unique_ptr<pb::CompiledFile> compiled_file =
+ SerializeCompiledFileToPb(file);
+ output_stream.WriteCompiledFile(compiled_file.get());
+ output_stream.WriteData(&buffer);
- if (outputStream.HadError()) {
- diag->error(DiagMessage(outputPath) << "failed to write data");
+ if (output_stream.HadError()) {
+ diag->Error(DiagMessage(output_path) << "failed to write data");
return false;
}
}
- if (!writer->finishEntry()) {
- diag->error(DiagMessage(outputPath) << "failed to finish writing data");
+ if (!writer->FinishEntry()) {
+ diag->Error(DiagMessage(output_path) << "failed to finish writing data");
return false;
}
return true;
}
-static bool writeHeaderAndMmapToWriter(const StringPiece& outputPath,
+static bool WriteHeaderAndMmapToWriter(const StringPiece& output_path,
const ResourceFile& file,
const android::FileMap& map,
IArchiveWriter* writer,
IDiagnostics* diag) {
// Start the entry so we can write the header.
- if (!writer->startEntry(outputPath, 0)) {
- diag->error(DiagMessage(outputPath) << "failed to open file");
+ if (!writer->StartEntry(output_path, 0)) {
+ diag->Error(DiagMessage(output_path) << "failed to open file");
return false;
}
// Make sure CopyingOutputStreamAdaptor is deleted before we call
- // writer->finishEntry().
+ // writer->FinishEntry().
{
// Wrap our IArchiveWriter with an adaptor that implements the
- // ZeroCopyOutputStream
- // interface.
- CopyingOutputStreamAdaptor copyingAdaptor(writer);
- CompiledFileOutputStream outputStream(©ingAdaptor);
+ // ZeroCopyOutputStream interface.
+ CopyingOutputStreamAdaptor copying_adaptor(writer);
+ CompiledFileOutputStream output_stream(©ing_adaptor);
// Number of CompiledFiles.
- outputStream.WriteLittleEndian32(1);
+ output_stream.WriteLittleEndian32(1);
- std::unique_ptr<pb::CompiledFile> compiledFile =
- serializeCompiledFileToPb(file);
- outputStream.WriteCompiledFile(compiledFile.get());
- outputStream.WriteData(map.getDataPtr(), map.getDataLength());
+ std::unique_ptr<pb::CompiledFile> compiled_file =
+ SerializeCompiledFileToPb(file);
+ output_stream.WriteCompiledFile(compiled_file.get());
+ output_stream.WriteData(map.getDataPtr(), map.getDataLength());
- if (outputStream.HadError()) {
- diag->error(DiagMessage(outputPath) << "failed to write data");
+ if (output_stream.HadError()) {
+ diag->Error(DiagMessage(output_path) << "failed to write data");
return false;
}
}
- if (!writer->finishEntry()) {
- diag->error(DiagMessage(outputPath) << "failed to finish writing data");
+ if (!writer->FinishEntry()) {
+ diag->Error(DiagMessage(output_path) << "failed to finish writing data");
return false;
}
return true;
}
-static bool flattenXmlToOutStream(IAaptContext* context,
- const StringPiece& outputPath,
- xml::XmlResource* xmlRes,
+static bool FlattenXmlToOutStream(IAaptContext* context,
+ const StringPiece& output_path,
+ xml::XmlResource* xmlres,
CompiledFileOutputStream* out) {
BigBuffer buffer(1024);
- XmlFlattenerOptions xmlFlattenerOptions;
- xmlFlattenerOptions.keepRawValues = true;
- XmlFlattener flattener(&buffer, xmlFlattenerOptions);
- if (!flattener.consume(context, xmlRes)) {
+ XmlFlattenerOptions xml_flattener_options;
+ xml_flattener_options.keep_raw_values = true;
+ XmlFlattener flattener(&buffer, xml_flattener_options);
+ if (!flattener.Consume(context, xmlres)) {
return false;
}
- std::unique_ptr<pb::CompiledFile> pbCompiledFile =
- serializeCompiledFileToPb(xmlRes->file);
- out->WriteCompiledFile(pbCompiledFile.get());
+ std::unique_ptr<pb::CompiledFile> pb_compiled_file =
+ SerializeCompiledFileToPb(xmlres->file);
+ out->WriteCompiledFile(pb_compiled_file.get());
out->WriteData(&buffer);
if (out->HadError()) {
- context->getDiagnostics()->error(DiagMessage(outputPath)
+ context->GetDiagnostics()->Error(DiagMessage(output_path)
<< "failed to write data");
return false;
}
return true;
}
-static bool compileXml(IAaptContext* context, const CompileOptions& options,
- const ResourcePathData& pathData, IArchiveWriter* writer,
- const std::string& outputPath) {
- if (context->verbose()) {
- context->getDiagnostics()->note(DiagMessage(pathData.source)
+static bool CompileXml(IAaptContext* context, const CompileOptions& options,
+ const ResourcePathData& path_data,
+ IArchiveWriter* writer, const std::string& output_path) {
+ if (context->IsVerbose()) {
+ context->GetDiagnostics()->Note(DiagMessage(path_data.source)
<< "compiling XML");
}
- std::unique_ptr<xml::XmlResource> xmlRes;
+ std::unique_ptr<xml::XmlResource> xmlres;
{
- std::ifstream fin(pathData.source.path, std::ifstream::binary);
+ std::ifstream fin(path_data.source.path, std::ifstream::binary);
if (!fin) {
- context->getDiagnostics()->error(DiagMessage(pathData.source)
+ context->GetDiagnostics()->Error(DiagMessage(path_data.source)
<< strerror(errno));
return false;
}
- xmlRes = xml::inflate(&fin, context->getDiagnostics(), pathData.source);
+ xmlres = xml::Inflate(&fin, context->GetDiagnostics(), path_data.source);
fin.close();
}
- if (!xmlRes) {
+ if (!xmlres) {
return false;
}
- xmlRes->file.name =
- ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
- xmlRes->file.config = pathData.config;
- xmlRes->file.source = pathData.source;
+ xmlres->file.name = ResourceName(
+ {}, *ParseResourceType(path_data.resource_dir), path_data.name);
+ xmlres->file.config = path_data.config;
+ xmlres->file.source = path_data.source;
// Collect IDs that are defined here.
XmlIdCollector collector;
- if (!collector.consume(context, xmlRes.get())) {
+ if (!collector.Consume(context, xmlres.get())) {
return false;
}
// Look for and process any <aapt:attr> tags and create sub-documents.
- InlineXmlFormatParser inlineXmlFormatParser;
- if (!inlineXmlFormatParser.consume(context, xmlRes.get())) {
+ InlineXmlFormatParser inline_xml_format_parser;
+ if (!inline_xml_format_parser.Consume(context, xmlres.get())) {
return false;
}
// Start the entry so we can write the header.
- if (!writer->startEntry(outputPath, 0)) {
- context->getDiagnostics()->error(DiagMessage(outputPath)
+ if (!writer->StartEntry(output_path, 0)) {
+ context->GetDiagnostics()->Error(DiagMessage(output_path)
<< "failed to open file");
return false;
}
// Make sure CopyingOutputStreamAdaptor is deleted before we call
- // writer->finishEntry().
+ // writer->FinishEntry().
{
// Wrap our IArchiveWriter with an adaptor that implements the
// ZeroCopyOutputStream
// interface.
- CopyingOutputStreamAdaptor copyingAdaptor(writer);
- CompiledFileOutputStream outputStream(©ingAdaptor);
+ CopyingOutputStreamAdaptor copying_adaptor(writer);
+ CompiledFileOutputStream output_stream(©ing_adaptor);
- std::vector<std::unique_ptr<xml::XmlResource>>& inlineDocuments =
- inlineXmlFormatParser.getExtractedInlineXmlDocuments();
+ std::vector<std::unique_ptr<xml::XmlResource>>& inline_documents =
+ inline_xml_format_parser.GetExtractedInlineXmlDocuments();
// Number of CompiledFiles.
- outputStream.WriteLittleEndian32(1 + inlineDocuments.size());
+ output_stream.WriteLittleEndian32(1 + inline_documents.size());
- if (!flattenXmlToOutStream(context, outputPath, xmlRes.get(),
- &outputStream)) {
+ if (!FlattenXmlToOutStream(context, output_path, xmlres.get(),
+ &output_stream)) {
return false;
}
- for (auto& inlineXmlDoc : inlineDocuments) {
- if (!flattenXmlToOutStream(context, outputPath, inlineXmlDoc.get(),
- &outputStream)) {
+ for (auto& inline_xml_doc : inline_documents) {
+ if (!FlattenXmlToOutStream(context, output_path, inline_xml_doc.get(),
+ &output_stream)) {
return false;
}
}
}
- if (!writer->finishEntry()) {
- context->getDiagnostics()->error(DiagMessage(outputPath)
+ if (!writer->FinishEntry()) {
+ context->GetDiagnostics()->Error(DiagMessage(output_path)
<< "failed to finish writing data");
return false;
}
@@ -470,69 +471,69 @@
class BigBufferOutputStream : public io::OutputStream {
public:
- explicit BigBufferOutputStream(BigBuffer* buffer) : mBuffer(buffer) {}
+ explicit BigBufferOutputStream(BigBuffer* buffer) : buffer_(buffer) {}
bool Next(void** data, int* len) override {
size_t count;
- *data = mBuffer->nextBlock(&count);
+ *data = buffer_->NextBlock(&count);
*len = static_cast<int>(count);
return true;
}
- void BackUp(int count) override { mBuffer->backUp(count); }
+ void BackUp(int count) override { buffer_->BackUp(count); }
- int64_t ByteCount() const override { return mBuffer->size(); }
+ int64_t ByteCount() const override { return buffer_->size(); }
bool HadError() const override { return false; }
private:
- BigBuffer* mBuffer;
+ BigBuffer* buffer_;
DISALLOW_COPY_AND_ASSIGN(BigBufferOutputStream);
};
-static bool compilePng(IAaptContext* context, const CompileOptions& options,
- const ResourcePathData& pathData, IArchiveWriter* writer,
- const std::string& outputPath) {
- if (context->verbose()) {
- context->getDiagnostics()->note(DiagMessage(pathData.source)
+static bool CompilePng(IAaptContext* context, const CompileOptions& options,
+ const ResourcePathData& path_data,
+ IArchiveWriter* writer, const std::string& output_path) {
+ if (context->IsVerbose()) {
+ context->GetDiagnostics()->Note(DiagMessage(path_data.source)
<< "compiling PNG");
}
BigBuffer buffer(4096);
- ResourceFile resFile;
- resFile.name =
- ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
- resFile.config = pathData.config;
- resFile.source = pathData.source;
+ ResourceFile res_file;
+ res_file.name = ResourceName({}, *ParseResourceType(path_data.resource_dir),
+ path_data.name);
+ res_file.config = path_data.config;
+ res_file.source = path_data.source;
{
std::string content;
- if (!android::base::ReadFileToString(pathData.source.path, &content)) {
- context->getDiagnostics()->error(
- DiagMessage(pathData.source)
+ if (!android::base::ReadFileToString(path_data.source.path, &content)) {
+ context->GetDiagnostics()->Error(
+ DiagMessage(path_data.source)
<< android::base::SystemErrorCodeToString(errno));
return false;
}
- BigBuffer crunchedPngBuffer(4096);
- BigBufferOutputStream crunchedPngBufferOut(&crunchedPngBuffer);
+ BigBuffer crunched_png_buffer(4096);
+ BigBufferOutputStream crunched_png_buffer_out(&crunched_png_buffer);
// Ensure that we only keep the chunks we care about if we end up
// using the original PNG instead of the crunched one.
- PngChunkFilter pngChunkFilter(content);
- std::unique_ptr<Image> image = readPng(context, &pngChunkFilter);
+ PngChunkFilter png_chunk_filter(content);
+ std::unique_ptr<Image> image = ReadPng(context, &png_chunk_filter);
if (!image) {
return false;
}
- std::unique_ptr<NinePatch> ninePatch;
- if (pathData.extension == "9.png") {
+ std::unique_ptr<NinePatch> nine_patch;
+ if (path_data.extension == "9.png") {
std::string err;
- ninePatch = NinePatch::create(image->rows.get(), image->width,
- image->height, &err);
- if (!ninePatch) {
- context->getDiagnostics()->error(DiagMessage() << err);
+ nine_patch = NinePatch::Create(image->rows.get(), image->width,
+ image->height, &err);
+ if (!nine_patch) {
+ context->GetDiagnostics()->Error(DiagMessage() << err);
return false;
}
@@ -549,89 +550,91 @@
memmove(image->rows[h], image->rows[h] + 4, image->width * 4);
}
- if (context->verbose()) {
- context->getDiagnostics()->note(DiagMessage(pathData.source)
- << "9-patch: " << *ninePatch);
+ if (context->IsVerbose()) {
+ context->GetDiagnostics()->Note(DiagMessage(path_data.source)
+ << "9-patch: " << *nine_patch);
}
}
// Write the crunched PNG.
- if (!writePng(context, image.get(), ninePatch.get(), &crunchedPngBufferOut,
- {})) {
+ if (!WritePng(context, image.get(), nine_patch.get(),
+ &crunched_png_buffer_out, {})) {
return false;
}
- if (ninePatch != nullptr ||
- crunchedPngBufferOut.ByteCount() <= pngChunkFilter.ByteCount()) {
+ if (nine_patch != nullptr ||
+ crunched_png_buffer_out.ByteCount() <= png_chunk_filter.ByteCount()) {
// No matter what, we must use the re-encoded PNG, even if it is larger.
// 9-patch images must be re-encoded since their borders are stripped.
- buffer.appendBuffer(std::move(crunchedPngBuffer));
+ buffer.AppendBuffer(std::move(crunched_png_buffer));
} else {
// The re-encoded PNG is larger than the original, and there is
// no mandatory transformation. Use the original.
- if (context->verbose()) {
- context->getDiagnostics()->note(
- DiagMessage(pathData.source)
+ if (context->IsVerbose()) {
+ context->GetDiagnostics()->Note(
+ DiagMessage(path_data.source)
<< "original PNG is smaller than crunched PNG"
<< ", using original");
}
- PngChunkFilter pngChunkFilterAgain(content);
- BigBuffer filteredPngBuffer(4096);
- BigBufferOutputStream filteredPngBufferOut(&filteredPngBuffer);
- io::copy(&filteredPngBufferOut, &pngChunkFilterAgain);
- buffer.appendBuffer(std::move(filteredPngBuffer));
+ PngChunkFilter png_chunk_filter_again(content);
+ BigBuffer filtered_png_buffer(4096);
+ BigBufferOutputStream filtered_png_buffer_out(&filtered_png_buffer);
+ io::Copy(&filtered_png_buffer_out, &png_chunk_filter_again);
+ buffer.AppendBuffer(std::move(filtered_png_buffer));
}
- if (context->verbose()) {
+ if (context->IsVerbose()) {
// For debugging only, use the legacy PNG cruncher and compare the
// resulting file sizes.
// This will help catch exotic cases where the new code may generate
// larger PNGs.
- std::stringstream legacyStream(content);
- BigBuffer legacyBuffer(4096);
- Png png(context->getDiagnostics());
- if (!png.process(pathData.source, &legacyStream, &legacyBuffer, {})) {
+ std::stringstream legacy_stream(content);
+ BigBuffer legacy_buffer(4096);
+ Png png(context->GetDiagnostics());
+ if (!png.process(path_data.source, &legacy_stream, &legacy_buffer, {})) {
return false;
}
- context->getDiagnostics()->note(DiagMessage(pathData.source)
- << "legacy=" << legacyBuffer.size()
+ context->GetDiagnostics()->Note(DiagMessage(path_data.source)
+ << "legacy=" << legacy_buffer.size()
<< " new=" << buffer.size());
}
}
- if (!writeHeaderAndBufferToWriter(outputPath, resFile, buffer, writer,
- context->getDiagnostics())) {
+ if (!WriteHeaderAndBufferToWriter(output_path, res_file, buffer, writer,
+ context->GetDiagnostics())) {
return false;
}
return true;
}
-static bool compileFile(IAaptContext* context, const CompileOptions& options,
- const ResourcePathData& pathData,
- IArchiveWriter* writer, const std::string& outputPath) {
- if (context->verbose()) {
- context->getDiagnostics()->note(DiagMessage(pathData.source)
+static bool CompileFile(IAaptContext* context, const CompileOptions& options,
+ const ResourcePathData& path_data,
+ IArchiveWriter* writer,
+ const std::string& output_path) {
+ if (context->IsVerbose()) {
+ context->GetDiagnostics()->Note(DiagMessage(path_data.source)
<< "compiling file");
}
BigBuffer buffer(256);
- ResourceFile resFile;
- resFile.name =
- ResourceName({}, *parseResourceType(pathData.resourceDir), pathData.name);
- resFile.config = pathData.config;
- resFile.source = pathData.source;
+ ResourceFile res_file;
+ res_file.name = ResourceName({}, *ParseResourceType(path_data.resource_dir),
+ path_data.name);
+ res_file.config = path_data.config;
+ res_file.source = path_data.source;
- std::string errorStr;
- Maybe<android::FileMap> f = file::mmapPath(pathData.source.path, &errorStr);
+ std::string error_str;
+ Maybe<android::FileMap> f = file::MmapPath(path_data.source.path, &error_str);
if (!f) {
- context->getDiagnostics()->error(DiagMessage(pathData.source) << errorStr);
+ context->GetDiagnostics()->Error(DiagMessage(path_data.source)
+ << error_str);
return false;
}
- if (!writeHeaderAndMmapToWriter(outputPath, resFile, f.value(), writer,
- context->getDiagnostics())) {
+ if (!WriteHeaderAndMmapToWriter(output_path, res_file, f.value(), writer,
+ context->GetDiagnostics())) {
return false;
}
return true;
@@ -639,155 +642,156 @@
class CompileContext : public IAaptContext {
public:
- void setVerbose(bool val) { mVerbose = val; }
+ void SetVerbose(bool val) { verbose_ = val; }
- bool verbose() override { return mVerbose; }
+ bool IsVerbose() override { return verbose_; }
- IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+ IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
- NameMangler* getNameMangler() override {
+ NameMangler* GetNameMangler() override {
abort();
return nullptr;
}
- const std::string& getCompilationPackage() override {
+ const std::string& GetCompilationPackage() override {
static std::string empty;
return empty;
}
- uint8_t getPackageId() override { return 0x0; }
+ uint8_t GetPackageId() override { return 0x0; }
- SymbolTable* getExternalSymbols() override {
+ SymbolTable* GetExternalSymbols() override {
abort();
return nullptr;
}
- int getMinSdkVersion() override { return 0; }
+ int GetMinSdkVersion() override { return 0; }
private:
- StdErrDiagnostics mDiagnostics;
- bool mVerbose = false;
+ StdErrDiagnostics diagnostics_;
+ bool verbose_ = false;
};
/**
* Entry point for compilation phase. Parses arguments and dispatches to the
* correct steps.
*/
-int compile(const std::vector<StringPiece>& args) {
+int Compile(const std::vector<StringPiece>& args) {
CompileContext context;
CompileOptions options;
bool verbose = false;
Flags flags =
Flags()
- .requiredFlag("-o", "Output path", &options.outputPath)
- .optionalFlag("--dir", "Directory to scan for resources",
- &options.resDir)
- .optionalSwitch("--pseudo-localize",
+ .RequiredFlag("-o", "Output path", &options.output_path)
+ .OptionalFlag("--dir", "Directory to scan for resources",
+ &options.res_dir)
+ .OptionalSwitch("--pseudo-localize",
"Generate resources for pseudo-locales "
"(en-XA and ar-XB)",
&options.pseudolocalize)
- .optionalSwitch(
+ .OptionalSwitch(
"--legacy",
"Treat errors that used to be valid in AAPT as warnings",
- &options.legacyMode)
- .optionalSwitch("-v", "Enables verbose logging", &verbose);
- if (!flags.parse("aapt2 compile", args, &std::cerr)) {
+ &options.legacy_mode)
+ .OptionalSwitch("-v", "Enables verbose logging", &verbose);
+ if (!flags.Parse("aapt2 compile", args, &std::cerr)) {
return 1;
}
- context.setVerbose(verbose);
+ context.SetVerbose(verbose);
- std::unique_ptr<IArchiveWriter> archiveWriter;
+ std::unique_ptr<IArchiveWriter> archive_writer;
- std::vector<ResourcePathData> inputData;
- if (options.resDir) {
- if (!flags.getArgs().empty()) {
+ std::vector<ResourcePathData> input_data;
+ if (options.res_dir) {
+ if (!flags.GetArgs().empty()) {
// Can't have both files and a resource directory.
- context.getDiagnostics()->error(DiagMessage()
+ context.GetDiagnostics()->Error(DiagMessage()
<< "files given but --dir specified");
- flags.usage("aapt2 compile", &std::cerr);
+ flags.Usage("aapt2 compile", &std::cerr);
return 1;
}
- if (!loadInputFilesFromDir(&context, options, &inputData)) {
+ if (!LoadInputFilesFromDir(&context, options, &input_data)) {
return 1;
}
- archiveWriter = createZipFileArchiveWriter(context.getDiagnostics(),
- options.outputPath);
+ archive_writer = CreateZipFileArchiveWriter(context.GetDiagnostics(),
+ options.output_path);
} else {
- inputData.reserve(flags.getArgs().size());
+ input_data.reserve(flags.GetArgs().size());
// Collect data from the path for each input file.
- for (const std::string& arg : flags.getArgs()) {
- std::string errorStr;
- if (Maybe<ResourcePathData> pathData =
- extractResourcePathData(arg, &errorStr)) {
- inputData.push_back(std::move(pathData.value()));
+ for (const std::string& arg : flags.GetArgs()) {
+ std::string error_str;
+ if (Maybe<ResourcePathData> path_data =
+ ExtractResourcePathData(arg, &error_str)) {
+ input_data.push_back(std::move(path_data.value()));
} else {
- context.getDiagnostics()->error(DiagMessage() << errorStr << " (" << arg
- << ")");
+ context.GetDiagnostics()->Error(DiagMessage() << error_str << " ("
+ << arg << ")");
return 1;
}
}
- archiveWriter = createDirectoryArchiveWriter(context.getDiagnostics(),
- options.outputPath);
+ archive_writer = CreateDirectoryArchiveWriter(context.GetDiagnostics(),
+ options.output_path);
}
- if (!archiveWriter) {
+ if (!archive_writer) {
return 1;
}
bool error = false;
- for (ResourcePathData& pathData : inputData) {
+ for (ResourcePathData& path_data : input_data) {
if (options.verbose) {
- context.getDiagnostics()->note(DiagMessage(pathData.source)
+ context.GetDiagnostics()->Note(DiagMessage(path_data.source)
<< "processing");
}
- if (pathData.resourceDir == "values") {
+ if (path_data.resource_dir == "values") {
// Overwrite the extension.
- pathData.extension = "arsc";
+ path_data.extension = "arsc";
- const std::string outputFilename = buildIntermediateFilename(pathData);
- if (!compileTable(&context, options, pathData, archiveWriter.get(),
- outputFilename)) {
+ const std::string output_filename = BuildIntermediateFilename(path_data);
+ if (!CompileTable(&context, options, path_data, archive_writer.get(),
+ output_filename)) {
error = true;
}
} else {
- const std::string outputFilename = buildIntermediateFilename(pathData);
- if (const ResourceType* type = parseResourceType(pathData.resourceDir)) {
+ const std::string output_filename = BuildIntermediateFilename(path_data);
+ if (const ResourceType* type =
+ ParseResourceType(path_data.resource_dir)) {
if (*type != ResourceType::kRaw) {
- if (pathData.extension == "xml") {
- if (!compileXml(&context, options, pathData, archiveWriter.get(),
- outputFilename)) {
+ if (path_data.extension == "xml") {
+ if (!CompileXml(&context, options, path_data, archive_writer.get(),
+ output_filename)) {
error = true;
}
- } else if (pathData.extension == "png" ||
- pathData.extension == "9.png") {
- if (!compilePng(&context, options, pathData, archiveWriter.get(),
- outputFilename)) {
+ } else if (path_data.extension == "png" ||
+ path_data.extension == "9.png") {
+ if (!CompilePng(&context, options, path_data, archive_writer.get(),
+ output_filename)) {
error = true;
}
} else {
- if (!compileFile(&context, options, pathData, archiveWriter.get(),
- outputFilename)) {
+ if (!CompileFile(&context, options, path_data, archive_writer.get(),
+ output_filename)) {
error = true;
}
}
} else {
- if (!compileFile(&context, options, pathData, archiveWriter.get(),
- outputFilename)) {
+ if (!CompileFile(&context, options, path_data, archive_writer.get(),
+ output_filename)) {
error = true;
}
}
} else {
- context.getDiagnostics()->error(
- DiagMessage() << "invalid file path '" << pathData.source << "'");
+ context.GetDiagnostics()->Error(
+ DiagMessage() << "invalid file path '" << path_data.source << "'");
error = true;
}
}
diff --git a/tools/aapt2/compile/IdAssigner.cpp b/tools/aapt2/compile/IdAssigner.cpp
index 73eb066..17c22c5 100644
--- a/tools/aapt2/compile/IdAssigner.cpp
+++ b/tools/aapt2/compile/IdAssigner.cpp
@@ -15,13 +15,15 @@
*/
#include "compile/IdAssigner.h"
+
+#include <map>
+
+#include "android-base/logging.h"
+
#include "ResourceTable.h"
#include "process/IResourceTableConsumer.h"
#include "util/Util.h"
-#include <cassert>
-#include <map>
-
namespace aapt {
/**
@@ -29,44 +31,44 @@
* ResourceEntry,
* as long as there is no existing ID or the ID is the same.
*/
-static bool assignId(IDiagnostics* diag, const ResourceId& id,
+static bool AssignId(IDiagnostics* diag, const ResourceId& id,
const ResourceName& name, ResourceTablePackage* pkg,
ResourceTableType* type, ResourceEntry* entry) {
- if (pkg->id.value() == id.packageId()) {
- if (!type->id || type->id.value() == id.typeId()) {
- type->id = id.typeId();
+ if (pkg->id.value() == id.package_id()) {
+ if (!type->id || type->id.value() == id.type_id()) {
+ type->id = id.type_id();
- if (!entry->id || entry->id.value() == id.entryId()) {
- entry->id = id.entryId();
+ if (!entry->id || entry->id.value() == id.entry_id()) {
+ entry->id = id.entry_id();
return true;
}
}
}
- const ResourceId existingId(pkg->id.value(), type->id ? type->id.value() : 0,
- entry->id ? entry->id.value() : 0);
- diag->error(DiagMessage() << "can't assign ID " << id << " to resource "
- << name << " with conflicting ID " << existingId);
+ const ResourceId existing_id(pkg->id.value(), type->id ? type->id.value() : 0,
+ entry->id ? entry->id.value() : 0);
+ diag->Error(DiagMessage() << "can't assign ID " << id << " to resource "
+ << name << " with conflicting ID " << existing_id);
return false;
}
-bool IdAssigner::consume(IAaptContext* context, ResourceTable* table) {
- std::map<ResourceId, ResourceName> assignedIds;
+bool IdAssigner::Consume(IAaptContext* context, ResourceTable* table) {
+ std::map<ResourceId, ResourceName> assigned_ids;
for (auto& package : table->packages) {
- assert(package->id && "packages must have manually assigned IDs");
+ CHECK(bool(package->id)) << "packages must have manually assigned IDs";
for (auto& type : package->types) {
for (auto& entry : type->entries) {
const ResourceName name(package->name, type->type, entry->name);
- if (mAssignedIdMap) {
+ if (assigned_id_map_) {
// Assign the pre-assigned stable ID meant for this resource.
- const auto iter = mAssignedIdMap->find(name);
- if (iter != mAssignedIdMap->end()) {
- const ResourceId assignedId = iter->second;
+ const auto iter = assigned_id_map_->find(name);
+ if (iter != assigned_id_map_->end()) {
+ const ResourceId assigned_id = iter->second;
const bool result =
- assignId(context->getDiagnostics(), assignedId, name,
+ AssignId(context->GetDiagnostics(), assigned_id, name,
package.get(), type.get(), entry.get());
if (!result) {
return false;
@@ -76,14 +78,14 @@
if (package->id && type->id && entry->id) {
// If the ID is set for this resource, then reserve it.
- ResourceId resourceId(package->id.value(), type->id.value(),
- entry->id.value());
- auto result = assignedIds.insert({resourceId, name});
- const ResourceName& existingName = result.first->second;
+ ResourceId resource_id(package->id.value(), type->id.value(),
+ entry->id.value());
+ auto result = assigned_ids.insert({resource_id, name});
+ const ResourceName& existing_name = result.first->second;
if (!result.second) {
- context->getDiagnostics()->error(
+ context->GetDiagnostics()->Error(
DiagMessage() << "resource " << name << " has same ID "
- << resourceId << " as " << existingName);
+ << resource_id << " as " << existing_name);
return false;
}
}
@@ -91,20 +93,20 @@
}
}
- if (mAssignedIdMap) {
+ if (assigned_id_map_) {
// Reserve all the IDs mentioned in the stable ID map. That way we won't
// assign
// IDs that were listed in the map if they don't exist in the table.
- for (const auto& stableIdEntry : *mAssignedIdMap) {
- const ResourceName& preAssignedName = stableIdEntry.first;
- const ResourceId& preAssignedId = stableIdEntry.second;
- auto result = assignedIds.insert({preAssignedId, preAssignedName});
- const ResourceName& existingName = result.first->second;
- if (!result.second && existingName != preAssignedName) {
- context->getDiagnostics()->error(
- DiagMessage() << "stable ID " << preAssignedId << " for resource "
- << preAssignedName << " is already taken by resource "
- << existingName);
+ for (const auto& stable_id_entry : *assigned_id_map_) {
+ const ResourceName& pre_assigned_name = stable_id_entry.first;
+ const ResourceId& pre_assigned_id = stable_id_entry.second;
+ auto result = assigned_ids.insert({pre_assigned_id, pre_assigned_name});
+ const ResourceName& existing_name = result.first->second;
+ if (!result.second && existing_name != pre_assigned_name) {
+ context->GetDiagnostics()->Error(
+ DiagMessage() << "stable ID " << pre_assigned_id << " for resource "
+ << pre_assigned_name
+ << " is already taken by resource " << existing_name);
return false;
}
}
@@ -114,21 +116,21 @@
// if possible,
// unless those IDs have been reserved.
- const auto assignedIdsIterEnd = assignedIds.end();
+ const auto assigned_ids_iter_end = assigned_ids.end();
for (auto& package : table->packages) {
- assert(package->id && "packages must have manually assigned IDs");
+ CHECK(bool(package->id)) << "packages must have manually assigned IDs";
// Build a half filled ResourceId object, which will be used to find the
// closest matching
// reserved ID in the assignedId map. From that point the next available
// type ID can be
// found.
- ResourceId resourceId(package->id.value(), 0, 0);
- uint8_t nextExpectedTypeId = 1;
+ ResourceId resource_id(package->id.value(), 0, 0);
+ uint8_t next_expected_type_id = 1;
// Find the closest matching ResourceId that is <= the one with only the
// package set.
- auto nextTypeIter = assignedIds.lower_bound(resourceId);
+ auto next_type_iter = assigned_ids.lower_bound(resource_id);
for (auto& type : package->types) {
if (!type->id) {
// We need to assign a type ID. Iterate over the reserved IDs until we
@@ -136,41 +138,41 @@
// some type ID that is a distance of 2 greater than the last one we've
// seen.
// That means there is an available type ID between these reserved IDs.
- while (nextTypeIter != assignedIdsIterEnd) {
- if (nextTypeIter->first.packageId() != package->id.value()) {
+ while (next_type_iter != assigned_ids_iter_end) {
+ if (next_type_iter->first.package_id() != package->id.value()) {
break;
}
- const uint8_t typeId = nextTypeIter->first.typeId();
- if (typeId > nextExpectedTypeId) {
+ const uint8_t type_id = next_type_iter->first.type_id();
+ if (type_id > next_expected_type_id) {
// There is a gap in the type IDs, so use the missing one.
- type->id = nextExpectedTypeId++;
+ type->id = next_expected_type_id++;
break;
}
// Set our expectation to be the next type ID after the reserved one
// we
// just saw.
- nextExpectedTypeId = typeId + 1;
+ next_expected_type_id = type_id + 1;
// Move to the next reserved ID.
- ++nextTypeIter;
+ ++next_type_iter;
}
if (!type->id) {
// We must have hit the end of the reserved IDs and not found a gap.
// That means the next ID is available.
- type->id = nextExpectedTypeId++;
+ type->id = next_expected_type_id++;
}
}
- resourceId = ResourceId(package->id.value(), type->id.value(), 0);
- uint16_t nextExpectedEntryId = 0;
+ resource_id = ResourceId(package->id.value(), type->id.value(), 0);
+ uint16_t next_expected_entry_id = 0;
// Find the closest matching ResourceId that is <= the one with only the
// package
// and type set.
- auto nextEntryIter = assignedIds.lower_bound(resourceId);
+ auto next_entry_iter = assigned_ids.lower_bound(resource_id);
for (auto& entry : type->entries) {
if (!entry->id) {
// We need to assign an entry ID. Iterate over the reserved IDs until
@@ -179,32 +181,32 @@
// we've seen.
// That means there is an available entry ID between these reserved
// IDs.
- while (nextEntryIter != assignedIdsIterEnd) {
- if (nextEntryIter->first.packageId() != package->id.value() ||
- nextEntryIter->first.typeId() != type->id.value()) {
+ while (next_entry_iter != assigned_ids_iter_end) {
+ if (next_entry_iter->first.package_id() != package->id.value() ||
+ next_entry_iter->first.type_id() != type->id.value()) {
break;
}
- const uint16_t entryId = nextEntryIter->first.entryId();
- if (entryId > nextExpectedEntryId) {
+ const uint16_t entry_id = next_entry_iter->first.entry_id();
+ if (entry_id > next_expected_entry_id) {
// There is a gap in the entry IDs, so use the missing one.
- entry->id = nextExpectedEntryId++;
+ entry->id = next_expected_entry_id++;
break;
}
// Set our expectation to be the next type ID after the reserved one
// we
// just saw.
- nextExpectedEntryId = entryId + 1;
+ next_expected_entry_id = entry_id + 1;
// Move to the next reserved entry ID.
- ++nextEntryIter;
+ ++next_entry_iter;
}
if (!entry->id) {
// We must have hit the end of the reserved IDs and not found a gap.
// That means the next ID is available.
- entry->id = nextExpectedEntryId++;
+ entry->id = next_expected_entry_id++;
}
}
}
diff --git a/tools/aapt2/compile/IdAssigner.h b/tools/aapt2/compile/IdAssigner.h
index d399064..371ec01 100644
--- a/tools/aapt2/compile/IdAssigner.h
+++ b/tools/aapt2/compile/IdAssigner.h
@@ -17,11 +17,12 @@
#ifndef AAPT_COMPILE_IDASSIGNER_H
#define AAPT_COMPILE_IDASSIGNER_H
+#include <unordered_map>
+
#include "Resource.h"
#include "process/IResourceTableConsumer.h"
-#include <android-base/macros.h>
-#include <unordered_map>
+#include "android-base/macros.h"
namespace aapt {
@@ -34,12 +35,13 @@
public:
IdAssigner() = default;
explicit IdAssigner(const std::unordered_map<ResourceName, ResourceId>* map)
- : mAssignedIdMap(map) {}
+ : assigned_id_map_(map) {}
- bool consume(IAaptContext* context, ResourceTable* table) override;
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
private:
- const std::unordered_map<ResourceName, ResourceId>* mAssignedIdMap = nullptr;
+ const std::unordered_map<ResourceName, ResourceId>* assigned_id_map_ =
+ nullptr;
};
} // namespace aapt
diff --git a/tools/aapt2/compile/IdAssigner_test.cpp b/tools/aapt2/compile/IdAssigner_test.cpp
index ff7bf5c..d465091 100644
--- a/tools/aapt2/compile/IdAssigner_test.cpp
+++ b/tools/aapt2/compile/IdAssigner_test.cpp
@@ -15,128 +15,129 @@
*/
#include "compile/IdAssigner.h"
+
#include "test/Test.h"
namespace aapt {
-::testing::AssertionResult verifyIds(ResourceTable* table);
+::testing::AssertionResult VerifyIds(ResourceTable* table);
TEST(IdAssignerTest, AssignIds) {
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addSimple("android:attr/foo")
- .addSimple("android:attr/bar")
- .addSimple("android:id/foo")
- .setPackageId("android", 0x01)
- .build();
+ .AddSimple("android:attr/foo")
+ .AddSimple("android:attr/bar")
+ .AddSimple("android:id/foo")
+ .SetPackageId("android", 0x01)
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
IdAssigner assigner;
- ASSERT_TRUE(assigner.consume(context.get(), table.get()));
- ASSERT_TRUE(verifyIds(table.get()));
+ ASSERT_TRUE(assigner.Consume(context.get(), table.get()));
+ ASSERT_TRUE(VerifyIds(table.get()));
}
TEST(IdAssignerTest, AssignIdsWithReservedIds) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addSimple("android:id/foo", ResourceId(0x01010000))
- .addSimple("android:dimen/two")
- .addSimple("android:integer/three")
- .addSimple("android:string/five")
- .addSimple("android:attr/fun", ResourceId(0x01040000))
- .addSimple("android:attr/foo", ResourceId(0x01040006))
- .addSimple("android:attr/bar")
- .addSimple("android:attr/baz")
- .addSimple("app:id/biz")
- .setPackageId("android", 0x01)
- .setPackageId("app", 0x7f)
- .build();
+ .AddSimple("android:id/foo", ResourceId(0x01010000))
+ .AddSimple("android:dimen/two")
+ .AddSimple("android:integer/three")
+ .AddSimple("android:string/five")
+ .AddSimple("android:attr/fun", ResourceId(0x01040000))
+ .AddSimple("android:attr/foo", ResourceId(0x01040006))
+ .AddSimple("android:attr/bar")
+ .AddSimple("android:attr/baz")
+ .AddSimple("app:id/biz")
+ .SetPackageId("android", 0x01)
+ .SetPackageId("app", 0x7f)
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
IdAssigner assigner;
- ASSERT_TRUE(assigner.consume(context.get(), table.get()));
- ASSERT_TRUE(verifyIds(table.get()));
+ ASSERT_TRUE(assigner.Consume(context.get(), table.get()));
+ ASSERT_TRUE(VerifyIds(table.get()));
- Maybe<ResourceTable::SearchResult> maybeResult;
+ Maybe<ResourceTable::SearchResult> maybe_result;
// Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX.
- maybeResult = table->findResource(test::parseNameOrDie("android:dimen/two"));
- AAPT_ASSERT_TRUE(maybeResult);
- EXPECT_EQ(make_value<uint8_t>(2), maybeResult.value().type->id);
+ maybe_result = table->FindResource(test::ParseNameOrDie("android:dimen/two"));
+ AAPT_ASSERT_TRUE(maybe_result);
+ EXPECT_EQ(make_value<uint8_t>(2), maybe_result.value().type->id);
- maybeResult =
- table->findResource(test::parseNameOrDie("android:integer/three"));
- AAPT_ASSERT_TRUE(maybeResult);
- EXPECT_EQ(make_value<uint8_t>(3), maybeResult.value().type->id);
+ maybe_result =
+ table->FindResource(test::ParseNameOrDie("android:integer/three"));
+ AAPT_ASSERT_TRUE(maybe_result);
+ EXPECT_EQ(make_value<uint8_t>(3), maybe_result.value().type->id);
// Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX
// IDs.
- maybeResult =
- table->findResource(test::parseNameOrDie("android:string/five"));
- AAPT_ASSERT_TRUE(maybeResult);
- EXPECT_EQ(make_value<uint8_t>(5), maybeResult.value().type->id);
+ maybe_result =
+ table->FindResource(test::ParseNameOrDie("android:string/five"));
+ AAPT_ASSERT_TRUE(maybe_result);
+ EXPECT_EQ(make_value<uint8_t>(5), maybe_result.value().type->id);
// Expect to fill in the gaps between 0x01040000 and 0x01040006.
- maybeResult = table->findResource(test::parseNameOrDie("android:attr/bar"));
- AAPT_ASSERT_TRUE(maybeResult);
- EXPECT_EQ(make_value<uint16_t>(1), maybeResult.value().entry->id);
+ maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/bar"));
+ AAPT_ASSERT_TRUE(maybe_result);
+ EXPECT_EQ(make_value<uint16_t>(1), maybe_result.value().entry->id);
- maybeResult = table->findResource(test::parseNameOrDie("android:attr/baz"));
- AAPT_ASSERT_TRUE(maybeResult);
- EXPECT_EQ(make_value<uint16_t>(2), maybeResult.value().entry->id);
+ maybe_result = table->FindResource(test::ParseNameOrDie("android:attr/baz"));
+ AAPT_ASSERT_TRUE(maybe_result);
+ EXPECT_EQ(make_value<uint16_t>(2), maybe_result.value().entry->id);
}
TEST(IdAssignerTest, FailWhenNonUniqueIdsAssigned) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addSimple("android:attr/foo", ResourceId(0x01040006))
- .addSimple("android:attr/bar", ResourceId(0x01040006))
- .setPackageId("android", 0x01)
- .setPackageId("app", 0x7f)
- .build();
+ .AddSimple("android:attr/foo", ResourceId(0x01040006))
+ .AddSimple("android:attr/bar", ResourceId(0x01040006))
+ .SetPackageId("android", 0x01)
+ .SetPackageId("app", 0x7f)
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
IdAssigner assigner;
- ASSERT_FALSE(assigner.consume(context.get(), table.get()));
+ ASSERT_FALSE(assigner.Consume(context.get(), table.get()));
}
TEST(IdAssignerTest, AssignIdsWithIdMap) {
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addSimple("android:attr/foo")
- .addSimple("android:attr/bar")
- .setPackageId("android", 0x01)
- .build();
+ .AddSimple("android:attr/foo")
+ .AddSimple("android:attr/bar")
+ .SetPackageId("android", 0x01)
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unordered_map<ResourceName, ResourceId> idMap = {
- {test::parseNameOrDie("android:attr/foo"), ResourceId(0x01010002)}};
- IdAssigner assigner(&idMap);
- ASSERT_TRUE(assigner.consume(context.get(), table.get()));
- ASSERT_TRUE(verifyIds(table.get()));
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unordered_map<ResourceName, ResourceId> id_map = {
+ {test::ParseNameOrDie("android:attr/foo"), ResourceId(0x01010002)}};
+ IdAssigner assigner(&id_map);
+ ASSERT_TRUE(assigner.Consume(context.get(), table.get()));
+ ASSERT_TRUE(VerifyIds(table.get()));
Maybe<ResourceTable::SearchResult> result =
- table->findResource(test::parseNameOrDie("android:attr/foo"));
+ table->FindResource(test::ParseNameOrDie("android:attr/foo"));
AAPT_ASSERT_TRUE(result);
- const ResourceTable::SearchResult& searchResult = result.value();
- EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.package->id);
- EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.type->id);
- EXPECT_EQ(make_value<uint16_t>(0x0002), searchResult.entry->id);
+ const ResourceTable::SearchResult& search_result = result.value();
+ EXPECT_EQ(make_value<uint8_t>(0x01), search_result.package->id);
+ EXPECT_EQ(make_value<uint8_t>(0x01), search_result.type->id);
+ EXPECT_EQ(make_value<uint16_t>(0x0002), search_result.entry->id);
}
-::testing::AssertionResult verifyIds(ResourceTable* table) {
- std::set<uint8_t> packageIds;
+::testing::AssertionResult VerifyIds(ResourceTable* table) {
+ std::set<uint8_t> package_ids;
for (auto& package : table->packages) {
if (!package->id) {
return ::testing::AssertionFailure() << "package " << package->name
<< " has no ID";
}
- if (!packageIds.insert(package->id.value()).second) {
+ if (!package_ids.insert(package->id.value()).second) {
return ::testing::AssertionFailure()
<< "package " << package->name << " has non-unique ID " << std::hex
<< (int)package->id.value() << std::dec;
@@ -144,7 +145,7 @@
}
for (auto& package : table->packages) {
- std::set<uint8_t> typeIds;
+ std::set<uint8_t> type_ids;
for (auto& type : package->types) {
if (!type->id) {
return ::testing::AssertionFailure() << "type " << type->type
@@ -152,7 +153,7 @@
<< " has no ID";
}
- if (!typeIds.insert(type->id.value()).second) {
+ if (!type_ids.insert(type->id.value()).second) {
return ::testing::AssertionFailure()
<< "type " << type->type << " of package " << package->name
<< " has non-unique ID " << std::hex << (int)type->id.value()
@@ -161,7 +162,7 @@
}
for (auto& type : package->types) {
- std::set<uint16_t> entryIds;
+ std::set<uint16_t> entry_ids;
for (auto& entry : type->entries) {
if (!entry->id) {
return ::testing::AssertionFailure()
@@ -169,7 +170,7 @@
<< " of package " << package->name << " has no ID";
}
- if (!entryIds.insert(entry->id.value()).second) {
+ if (!entry_ids.insert(entry->id.value()).second) {
return ::testing::AssertionFailure()
<< "entry " << entry->name << " of type " << type->type
<< " of package " << package->name << " has non-unique ID "
diff --git a/tools/aapt2/compile/Image.h b/tools/aapt2/compile/Image.h
index 4cf2ea7..db0b945 100644
--- a/tools/aapt2/compile/Image.h
+++ b/tools/aapt2/compile/Image.h
@@ -17,12 +17,13 @@
#ifndef AAPT_COMPILE_IMAGE_H
#define AAPT_COMPILE_IMAGE_H
-#include <android-base/macros.h>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
+#include "android-base/macros.h"
+
namespace aapt {
/**
@@ -113,15 +114,15 @@
*/
class NinePatch {
public:
- static std::unique_ptr<NinePatch> create(uint8_t** rows, const int32_t width,
+ static std::unique_ptr<NinePatch> Create(uint8_t** rows, const int32_t width,
const int32_t height,
- std::string* errOut);
+ std::string* err_out);
/**
* Packs the RGBA_8888 data pointed to by pixel into a uint32_t
* with format 0xAARRGGBB (the way 9-patch expects it).
*/
- static uint32_t packRGBA(const uint8_t* pixel);
+ static uint32_t PackRGBA(const uint8_t* pixel);
/**
* 9-patch content padding/insets. All positions are relative to the 9-patch
@@ -136,7 +137,7 @@
* See
* https://developer.android.com/about/versions/android-4.3.html#OpticalBounds
*/
- Bounds layoutBounds;
+ Bounds layout_bounds;
/**
* Outline of the image, calculated based on opacity.
@@ -147,51 +148,51 @@
* The computed radius of the outline. If non-zero, the outline is a
* rounded-rect.
*/
- float outlineRadius = 0.0f;
+ float outline_radius = 0.0f;
/**
* The largest alpha value within the outline.
*/
- uint32_t outlineAlpha = 0x000000ffu;
+ uint32_t outline_alpha = 0x000000ffu;
/**
* Horizontal regions of the image that are stretchable.
* All positions are relative to the 9-patch
* NOT including the 1px thick source border.
*/
- std::vector<Range> horizontalStretchRegions;
+ std::vector<Range> horizontal_stretch_regions;
/**
* Vertical regions of the image that are stretchable.
* All positions are relative to the 9-patch
* NOT including the 1px thick source border.
*/
- std::vector<Range> verticalStretchRegions;
+ std::vector<Range> vertical_stretch_regions;
/**
* The colors within each region, fixed or stretchable.
* For w*h regions, the color of region (x,y) is addressable
* via index y*w + x.
*/
- std::vector<uint32_t> regionColors;
+ std::vector<uint32_t> region_colors;
/**
* Returns serialized data containing the original basic 9-patch meta data.
* Optical layout bounds and round rect outline data must be serialized
- * separately using serializeOpticalLayoutBounds() and
- * serializeRoundedRectOutline().
+ * separately using SerializeOpticalLayoutBounds() and
+ * SerializeRoundedRectOutline().
*/
- std::unique_ptr<uint8_t[]> serializeBase(size_t* outLen) const;
+ std::unique_ptr<uint8_t[]> SerializeBase(size_t* out_len) const;
/**
* Serializes the layout bounds.
*/
- std::unique_ptr<uint8_t[]> serializeLayoutBounds(size_t* outLen) const;
+ std::unique_ptr<uint8_t[]> SerializeLayoutBounds(size_t* out_len) const;
/**
* Serializes the rounded-rect outline.
*/
- std::unique_ptr<uint8_t[]> serializeRoundedRectOutline(size_t* outLen) const;
+ std::unique_ptr<uint8_t[]> SerializeRoundedRectOutline(size_t* out_len) const;
private:
explicit NinePatch() = default;
@@ -201,7 +202,7 @@
::std::ostream& operator<<(::std::ostream& out, const Range& range);
::std::ostream& operator<<(::std::ostream& out, const Bounds& bounds);
-::std::ostream& operator<<(::std::ostream& out, const NinePatch& ninePatch);
+::std::ostream& operator<<(::std::ostream& out, const NinePatch& nine_patch);
} // namespace aapt
diff --git a/tools/aapt2/compile/InlineXmlFormatParser.cpp b/tools/aapt2/compile/InlineXmlFormatParser.cpp
index 56f72b5..786494b 100644
--- a/tools/aapt2/compile/InlineXmlFormatParser.cpp
+++ b/tools/aapt2/compile/InlineXmlFormatParser.cpp
@@ -15,16 +15,18 @@
*/
#include "compile/InlineXmlFormatParser.h"
+
+#include <sstream>
+#include <string>
+
+#include "android-base/macros.h"
+
#include "Debug.h"
#include "ResourceUtils.h"
#include "util/Util.h"
#include "xml/XmlDom.h"
#include "xml/XmlUtil.h"
-#include <android-base/macros.h>
-#include <sstream>
-#include <string>
-
namespace aapt {
namespace {
@@ -34,38 +36,38 @@
*/
class Visitor : public xml::PackageAwareVisitor {
public:
- using xml::PackageAwareVisitor::visit;
+ using xml::PackageAwareVisitor::Visit;
struct InlineDeclaration {
xml::Element* el;
- std::string attrNamespaceUri;
- std::string attrName;
+ std::string attr_namespace_uri;
+ std::string attr_name;
};
- explicit Visitor(IAaptContext* context, xml::XmlResource* xmlResource)
- : mContext(context), mXmlResource(xmlResource) {}
+ explicit Visitor(IAaptContext* context, xml::XmlResource* xml_resource)
+ : context_(context), xml_resource_(xml_resource) {}
- void visit(xml::Element* el) override {
- if (el->namespaceUri != xml::kSchemaAapt || el->name != "attr") {
- xml::PackageAwareVisitor::visit(el);
+ void Visit(xml::Element* el) override {
+ if (el->namespace_uri != xml::kSchemaAapt || el->name != "attr") {
+ xml::PackageAwareVisitor::Visit(el);
return;
}
- const Source& src = mXmlResource->file.source.withLine(el->lineNumber);
+ const Source& src = xml_resource_->file.source.WithLine(el->line_number);
- xml::Attribute* attr = el->findAttribute({}, "name");
+ xml::Attribute* attr = el->FindAttribute({}, "name");
if (!attr) {
- mContext->getDiagnostics()->error(DiagMessage(src)
+ context_->GetDiagnostics()->Error(DiagMessage(src)
<< "missing 'name' attribute");
- mError = true;
+ error_ = true;
return;
}
- Maybe<Reference> ref = ResourceUtils::parseXmlAttributeName(attr->value);
+ Maybe<Reference> ref = ResourceUtils::ParseXmlAttributeName(attr->value);
if (!ref) {
- mContext->getDiagnostics()->error(
+ context_->GetDiagnostics()->Error(
DiagMessage(src) << "invalid XML attribute '" << attr->value << "'");
- mError = true;
+ error_ = true;
return;
}
@@ -76,63 +78,63 @@
// the local package if the user specified name="style" or something. This
// should just
// be the default namespace.
- Maybe<xml::ExtractedPackage> maybePkg =
- transformPackageAlias(name.package, {});
- if (!maybePkg) {
- mContext->getDiagnostics()->error(DiagMessage(src)
+ Maybe<xml::ExtractedPackage> maybe_pkg =
+ TransformPackageAlias(name.package, {});
+ if (!maybe_pkg) {
+ context_->GetDiagnostics()->Error(DiagMessage(src)
<< "invalid namespace prefix '"
<< name.package << "'");
- mError = true;
+ error_ = true;
return;
}
- const xml::ExtractedPackage& pkg = maybePkg.value();
- const bool privateNamespace =
- pkg.privateNamespace || ref.value().privateReference;
+ const xml::ExtractedPackage& pkg = maybe_pkg.value();
+ const bool private_namespace =
+ pkg.private_namespace || ref.value().private_reference;
InlineDeclaration decl;
decl.el = el;
- decl.attrName = name.entry;
+ decl.attr_name = name.entry;
if (!pkg.package.empty()) {
- decl.attrNamespaceUri =
- xml::buildPackageNamespace(pkg.package, privateNamespace);
+ decl.attr_namespace_uri =
+ xml::BuildPackageNamespace(pkg.package, private_namespace);
}
- mInlineDeclarations.push_back(std::move(decl));
+ inline_declarations_.push_back(std::move(decl));
}
- const std::vector<InlineDeclaration>& getInlineDeclarations() const {
- return mInlineDeclarations;
+ const std::vector<InlineDeclaration>& GetInlineDeclarations() const {
+ return inline_declarations_;
}
- bool hasError() const { return mError; }
+ bool HasError() const { return error_; }
private:
DISALLOW_COPY_AND_ASSIGN(Visitor);
- IAaptContext* mContext;
- xml::XmlResource* mXmlResource;
- std::vector<InlineDeclaration> mInlineDeclarations;
- bool mError = false;
+ IAaptContext* context_;
+ xml::XmlResource* xml_resource_;
+ std::vector<InlineDeclaration> inline_declarations_;
+ bool error_ = false;
};
} // namespace
-bool InlineXmlFormatParser::consume(IAaptContext* context,
+bool InlineXmlFormatParser::Consume(IAaptContext* context,
xml::XmlResource* doc) {
Visitor visitor(context, doc);
- doc->root->accept(&visitor);
- if (visitor.hasError()) {
+ doc->root->Accept(&visitor);
+ if (visitor.HasError()) {
return false;
}
- size_t nameSuffixCounter = 0;
+ size_t name_suffix_counter = 0;
for (const Visitor::InlineDeclaration& decl :
- visitor.getInlineDeclarations()) {
- auto newDoc = util::make_unique<xml::XmlResource>();
- newDoc->file.config = doc->file.config;
- newDoc->file.source = doc->file.source.withLine(decl.el->lineNumber);
- newDoc->file.name = doc->file.name;
+ visitor.GetInlineDeclarations()) {
+ auto new_doc = util::make_unique<xml::XmlResource>();
+ new_doc->file.config = doc->file.config;
+ new_doc->file.source = doc->file.source.WithLine(decl.el->line_number);
+ new_doc->file.name = doc->file.name;
// Modify the new entry name. We need to suffix the entry with a number to
// avoid
@@ -140,63 +142,64 @@
// won't show up
// in R.java.
- newDoc->file.name.entry = NameMangler::mangleEntry(
- {}, newDoc->file.name.entry + "__" + std::to_string(nameSuffixCounter));
+ new_doc->file.name.entry =
+ NameMangler::MangleEntry({}, new_doc->file.name.entry + "__" +
+ std::to_string(name_suffix_counter));
// Extracted elements must be the only child of <aapt:attr>.
// Make sure there is one root node in the children (ignore empty text).
for (auto& child : decl.el->children) {
- const Source childSource = doc->file.source.withLine(child->lineNumber);
- if (xml::Text* t = xml::nodeCast<xml::Text>(child.get())) {
- if (!util::trimWhitespace(t->text).empty()) {
- context->getDiagnostics()->error(
- DiagMessage(childSource)
+ const Source child_source = doc->file.source.WithLine(child->line_number);
+ if (xml::Text* t = xml::NodeCast<xml::Text>(child.get())) {
+ if (!util::TrimWhitespace(t->text).empty()) {
+ context->GetDiagnostics()->Error(
+ DiagMessage(child_source)
<< "can't extract text into its own resource");
return false;
}
- } else if (newDoc->root) {
- context->getDiagnostics()->error(
- DiagMessage(childSource)
+ } else if (new_doc->root) {
+ context->GetDiagnostics()->Error(
+ DiagMessage(child_source)
<< "inline XML resources must have a single root");
return false;
} else {
- newDoc->root = std::move(child);
- newDoc->root->parent = nullptr;
+ new_doc->root = std::move(child);
+ new_doc->root->parent = nullptr;
}
}
// Walk up and find the parent element.
xml::Node* node = decl.el;
- xml::Element* parentEl = nullptr;
+ xml::Element* parent_el = nullptr;
while (node->parent &&
- (parentEl = xml::nodeCast<xml::Element>(node->parent)) == nullptr) {
+ (parent_el = xml::NodeCast<xml::Element>(node->parent)) == nullptr) {
node = node->parent;
}
- if (!parentEl) {
- context->getDiagnostics()->error(
- DiagMessage(newDoc->file.source)
+ if (!parent_el) {
+ context->GetDiagnostics()->Error(
+ DiagMessage(new_doc->file.source)
<< "no suitable parent for inheriting attribute");
return false;
}
// Add the inline attribute to the parent.
- parentEl->attributes.push_back(
- xml::Attribute{decl.attrNamespaceUri, decl.attrName,
- "@" + newDoc->file.name.toString()});
+ parent_el->attributes.push_back(
+ xml::Attribute{decl.attr_namespace_uri, decl.attr_name,
+ "@" + new_doc->file.name.ToString()});
// Delete the subtree.
- for (auto iter = parentEl->children.begin();
- iter != parentEl->children.end(); ++iter) {
+ for (auto iter = parent_el->children.begin();
+ iter != parent_el->children.end(); ++iter) {
if (iter->get() == node) {
- parentEl->children.erase(iter);
+ parent_el->children.erase(iter);
break;
}
}
- mQueue.push_back(std::move(newDoc));
+ queue_.push_back(std::move(new_doc));
- nameSuffixCounter++;
+ name_suffix_counter++;
}
return true;
}
diff --git a/tools/aapt2/compile/InlineXmlFormatParser.h b/tools/aapt2/compile/InlineXmlFormatParser.h
index cd8794b..1a658fd 100644
--- a/tools/aapt2/compile/InlineXmlFormatParser.h
+++ b/tools/aapt2/compile/InlineXmlFormatParser.h
@@ -17,12 +17,13 @@
#ifndef AAPT_COMPILE_INLINEXMLFORMATPARSER_H
#define AAPT_COMPILE_INLINEXMLFORMATPARSER_H
-#include "process/IResourceTableConsumer.h"
-
-#include <android-base/macros.h>
#include <memory>
#include <vector>
+#include "android-base/macros.h"
+
+#include "process/IResourceTableConsumer.h"
+
namespace aapt {
/**
@@ -50,17 +51,17 @@
public:
explicit InlineXmlFormatParser() = default;
- bool consume(IAaptContext* context, xml::XmlResource* doc) override;
+ bool Consume(IAaptContext* context, xml::XmlResource* doc) override;
std::vector<std::unique_ptr<xml::XmlResource>>&
- getExtractedInlineXmlDocuments() {
- return mQueue;
+ GetExtractedInlineXmlDocuments() {
+ return queue_;
}
private:
DISALLOW_COPY_AND_ASSIGN(InlineXmlFormatParser);
- std::vector<std::unique_ptr<xml::XmlResource>> mQueue;
+ std::vector<std::unique_ptr<xml::XmlResource>> queue_;
};
} // namespace aapt
diff --git a/tools/aapt2/compile/InlineXmlFormatParser_test.cpp b/tools/aapt2/compile/InlineXmlFormatParser_test.cpp
index 4adb21c..348796c 100644
--- a/tools/aapt2/compile/InlineXmlFormatParser_test.cpp
+++ b/tools/aapt2/compile/InlineXmlFormatParser_test.cpp
@@ -15,13 +15,14 @@
*/
#include "compile/InlineXmlFormatParser.h"
+
#include "test/Test.h"
namespace aapt {
TEST(InlineXmlFormatParserTest, PassThrough) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android">
<View android:text="hey">
<View android:id="hi" />
@@ -29,13 +30,13 @@
</View>)EOF");
InlineXmlFormatParser parser;
- ASSERT_TRUE(parser.consume(context.get(), doc.get()));
- EXPECT_EQ(0u, parser.getExtractedInlineXmlDocuments().size());
+ ASSERT_TRUE(parser.Consume(context.get(), doc.get()));
+ EXPECT_EQ(0u, parser.GetExtractedInlineXmlDocuments().size());
}
TEST(InlineXmlFormatParserTest, ExtractOneXmlResource) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View1 xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:aapt="http://schemas.android.com/aapt">
<aapt:attr name="android:text">
@@ -45,48 +46,48 @@
</aapt:attr>
</View1>)EOF");
- doc->file.name = test::parseNameOrDie("layout/main");
+ doc->file.name = test::ParseNameOrDie("layout/main");
InlineXmlFormatParser parser;
- ASSERT_TRUE(parser.consume(context.get(), doc.get()));
+ ASSERT_TRUE(parser.Consume(context.get(), doc.get()));
// One XML resource should have been extracted.
- EXPECT_EQ(1u, parser.getExtractedInlineXmlDocuments().size());
+ EXPECT_EQ(1u, parser.GetExtractedInlineXmlDocuments().size());
- xml::Element* el = xml::findRootElement(doc.get());
+ xml::Element* el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
EXPECT_EQ("View1", el->name);
// The <aapt:attr> tag should be extracted.
- EXPECT_EQ(nullptr, el->findChild(xml::kSchemaAapt, "attr"));
+ EXPECT_EQ(nullptr, el->FindChild(xml::kSchemaAapt, "attr"));
// The 'android:text' attribute should be set with a reference.
- xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "text");
+ xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "text");
ASSERT_NE(nullptr, attr);
- ResourceNameRef nameRef;
- ASSERT_TRUE(ResourceUtils::parseReference(attr->value, &nameRef));
+ ResourceNameRef name_ref;
+ ASSERT_TRUE(ResourceUtils::ParseReference(attr->value, &name_ref));
- xml::XmlResource* extractedDoc =
- parser.getExtractedInlineXmlDocuments()[0].get();
- ASSERT_NE(nullptr, extractedDoc);
+ xml::XmlResource* extracted_doc =
+ parser.GetExtractedInlineXmlDocuments()[0].get();
+ ASSERT_NE(nullptr, extracted_doc);
// Make sure the generated reference is correct.
- EXPECT_EQ(nameRef.package, extractedDoc->file.name.package);
- EXPECT_EQ(nameRef.type, extractedDoc->file.name.type);
- EXPECT_EQ(nameRef.entry, extractedDoc->file.name.entry);
+ EXPECT_EQ(name_ref.package, extracted_doc->file.name.package);
+ EXPECT_EQ(name_ref.type, extracted_doc->file.name.type);
+ EXPECT_EQ(name_ref.entry, extracted_doc->file.name.entry);
// Verify the structure of the extracted XML.
- el = xml::findRootElement(extractedDoc);
+ el = xml::FindRootElement(extracted_doc);
ASSERT_NE(nullptr, el);
EXPECT_EQ("View2", el->name);
- EXPECT_NE(nullptr, el->findChild({}, "View3"));
+ EXPECT_NE(nullptr, el->FindChild({}, "View3"));
}
TEST(InlineXmlFormatParserTest, ExtractTwoXmlResources) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View1 xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:aapt="http://schemas.android.com/aapt">
<aapt:attr name="android:text">
@@ -100,41 +101,41 @@
</aapt:attr>
</View1>)EOF");
- doc->file.name = test::parseNameOrDie("layout/main");
+ doc->file.name = test::ParseNameOrDie("layout/main");
InlineXmlFormatParser parser;
- ASSERT_TRUE(parser.consume(context.get(), doc.get()));
- ASSERT_EQ(2u, parser.getExtractedInlineXmlDocuments().size());
+ ASSERT_TRUE(parser.Consume(context.get(), doc.get()));
+ ASSERT_EQ(2u, parser.GetExtractedInlineXmlDocuments().size());
- xml::Element* el = xml::findRootElement(doc.get());
+ xml::Element* el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
EXPECT_EQ("View1", el->name);
- xml::Attribute* attrText = el->findAttribute(xml::kSchemaAndroid, "text");
- ASSERT_NE(nullptr, attrText);
+ xml::Attribute* attr_text = el->FindAttribute(xml::kSchemaAndroid, "text");
+ ASSERT_NE(nullptr, attr_text);
- xml::Attribute* attrDrawable =
- el->findAttribute(xml::kSchemaAndroid, "drawable");
- ASSERT_NE(nullptr, attrDrawable);
+ xml::Attribute* attr_drawable =
+ el->FindAttribute(xml::kSchemaAndroid, "drawable");
+ ASSERT_NE(nullptr, attr_drawable);
// The two extracted resources should have different names.
- EXPECT_NE(attrText->value, attrDrawable->value);
+ EXPECT_NE(attr_text->value, attr_drawable->value);
// The child <aapt:attr> elements should be gone.
- EXPECT_EQ(nullptr, el->findChild(xml::kSchemaAapt, "attr"));
+ EXPECT_EQ(nullptr, el->FindChild(xml::kSchemaAapt, "attr"));
- xml::XmlResource* extractedDocText =
- parser.getExtractedInlineXmlDocuments()[0].get();
- ASSERT_NE(nullptr, extractedDocText);
- el = xml::findRootElement(extractedDocText);
+ xml::XmlResource* extracted_doc_text =
+ parser.GetExtractedInlineXmlDocuments()[0].get();
+ ASSERT_NE(nullptr, extracted_doc_text);
+ el = xml::FindRootElement(extracted_doc_text);
ASSERT_NE(nullptr, el);
EXPECT_EQ("View2", el->name);
- xml::XmlResource* extractedDocDrawable =
- parser.getExtractedInlineXmlDocuments()[1].get();
- ASSERT_NE(nullptr, extractedDocDrawable);
- el = xml::findRootElement(extractedDocDrawable);
+ xml::XmlResource* extracted_doc_drawable =
+ parser.GetExtractedInlineXmlDocuments()[1].get();
+ ASSERT_NE(nullptr, extracted_doc_drawable);
+ el = xml::FindRootElement(extracted_doc_drawable);
ASSERT_NE(nullptr, el);
EXPECT_EQ("vector", el->name);
}
diff --git a/tools/aapt2/compile/NinePatch.cpp b/tools/aapt2/compile/NinePatch.cpp
index 8842eb7..eab5c97 100644
--- a/tools/aapt2/compile/NinePatch.cpp
+++ b/tools/aapt2/compile/NinePatch.cpp
@@ -15,14 +15,16 @@
*/
#include "compile/Image.h"
-#include "util/StringPiece.h"
-#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
#include <sstream>
#include <string>
#include <vector>
+#include "androidfw/ResourceTypes.h"
+
+#include "util/StringPiece.h"
+#include "util/Util.h"
+
namespace aapt {
// Colors in the format 0xAARRGGBB (the way 9-patch expects it).
@@ -36,7 +38,7 @@
/**
* Returns the alpha value encoded in the 0xAARRGBB encoded pixel.
*/
-static uint32_t getAlpha(uint32_t color);
+static uint32_t get_alpha(uint32_t color);
/**
* Determines whether a color on an ImageLine is valid.
@@ -53,19 +55,19 @@
* Returns true if the color specified is a neutral color
* (no padding, stretching, or optical bounds).
*/
- virtual bool isNeutralColor(uint32_t color) const = 0;
+ virtual bool IsNeutralColor(uint32_t color) const = 0;
/**
* Returns true if the color is either a neutral color
* or one denoting padding, stretching, or optical bounds.
*/
- bool isValidColor(uint32_t color) const {
+ bool IsValidColor(uint32_t color) const {
switch (color) {
case kPrimaryColor:
case kSecondaryColor:
return true;
}
- return isNeutralColor(color);
+ return IsNeutralColor(color);
}
};
@@ -81,42 +83,43 @@
//
// class ImageLine {
// public:
-// virtual int32_t getLength() const = 0;
-// virtual uint32_t getColor(int32_t idx) const = 0;
+// virtual int32_t GetLength() const = 0;
+// virtual uint32_t GetColor(int32_t idx) const = 0;
// };
//
template <typename ImageLine>
-static bool fillRanges(const ImageLine* imageLine,
- const ColorValidator* colorValidator,
- std::vector<Range>* primaryRanges,
- std::vector<Range>* secondaryRanges, std::string* err) {
- const int32_t length = imageLine->getLength();
+static bool FillRanges(const ImageLine* image_line,
+ const ColorValidator* color_validator,
+ std::vector<Range>* primary_ranges,
+ std::vector<Range>* secondary_ranges,
+ std::string* out_err) {
+ const int32_t length = image_line->GetLength();
- uint32_t lastColor = 0xffffffffu;
+ uint32_t last_color = 0xffffffffu;
for (int32_t idx = 1; idx < length - 1; idx++) {
- const uint32_t color = imageLine->getColor(idx);
- if (!colorValidator->isValidColor(color)) {
- *err = "found an invalid color";
+ const uint32_t color = image_line->GetColor(idx);
+ if (!color_validator->IsValidColor(color)) {
+ *out_err = "found an invalid color";
return false;
}
- if (color != lastColor) {
+ if (color != last_color) {
// We are ending a range. Which range?
// note: encode the x offset without the final 1 pixel border.
- if (lastColor == kPrimaryColor) {
- primaryRanges->back().end = idx - 1;
- } else if (lastColor == kSecondaryColor) {
- secondaryRanges->back().end = idx - 1;
+ if (last_color == kPrimaryColor) {
+ primary_ranges->back().end = idx - 1;
+ } else if (last_color == kSecondaryColor) {
+ secondary_ranges->back().end = idx - 1;
}
// We are starting a range. Which range?
// note: encode the x offset without the final 1 pixel border.
if (color == kPrimaryColor) {
- primaryRanges->push_back(Range(idx - 1, length - 2));
+ primary_ranges->push_back(Range(idx - 1, length - 2));
} else if (color == kSecondaryColor) {
- secondaryRanges->push_back(Range(idx - 1, length - 2));
+ secondary_ranges->push_back(Range(idx - 1, length - 2));
}
- lastColor = color;
+ last_color = color;
}
}
return true;
@@ -128,19 +131,19 @@
*/
class HorizontalImageLine {
public:
- explicit HorizontalImageLine(uint8_t** rows, int32_t xOffset, int32_t yOffset,
+ explicit HorizontalImageLine(uint8_t** rows, int32_t xoffset, int32_t yoffset,
int32_t length)
- : mRows(rows), mXOffset(xOffset), mYOffset(yOffset), mLength(length) {}
+ : rows_(rows), xoffset_(xoffset), yoffset_(yoffset), length_(length) {}
- inline int32_t getLength() const { return mLength; }
+ inline int32_t GetLength() const { return length_; }
- inline uint32_t getColor(int32_t idx) const {
- return NinePatch::packRGBA(mRows[mYOffset] + (idx + mXOffset) * 4);
+ inline uint32_t GetColor(int32_t idx) const {
+ return NinePatch::PackRGBA(rows_[yoffset_] + (idx + xoffset_) * 4);
}
private:
- uint8_t** mRows;
- int32_t mXOffset, mYOffset, mLength;
+ uint8_t** rows_;
+ int32_t xoffset_, yoffset_, length_;
DISALLOW_COPY_AND_ASSIGN(HorizontalImageLine);
};
@@ -151,179 +154,180 @@
*/
class VerticalImageLine {
public:
- explicit VerticalImageLine(uint8_t** rows, int32_t xOffset, int32_t yOffset,
+ explicit VerticalImageLine(uint8_t** rows, int32_t xoffset, int32_t yoffset,
int32_t length)
- : mRows(rows), mXOffset(xOffset), mYOffset(yOffset), mLength(length) {}
+ : rows_(rows), xoffset_(xoffset), yoffset_(yoffset), length_(length) {}
- inline int32_t getLength() const { return mLength; }
+ inline int32_t GetLength() const { return length_; }
- inline uint32_t getColor(int32_t idx) const {
- return NinePatch::packRGBA(mRows[mYOffset + idx] + (mXOffset * 4));
+ inline uint32_t GetColor(int32_t idx) const {
+ return NinePatch::PackRGBA(rows_[yoffset_ + idx] + (xoffset_ * 4));
}
private:
- uint8_t** mRows;
- int32_t mXOffset, mYOffset, mLength;
+ uint8_t** rows_;
+ int32_t xoffset_, yoffset_, length_;
DISALLOW_COPY_AND_ASSIGN(VerticalImageLine);
};
class DiagonalImageLine {
public:
- explicit DiagonalImageLine(uint8_t** rows, int32_t xOffset, int32_t yOffset,
- int32_t xStep, int32_t yStep, int32_t length)
- : mRows(rows),
- mXOffset(xOffset),
- mYOffset(yOffset),
- mXStep(xStep),
- mYStep(yStep),
- mLength(length) {}
+ explicit DiagonalImageLine(uint8_t** rows, int32_t xoffset, int32_t yoffset,
+ int32_t xstep, int32_t ystep, int32_t length)
+ : rows_(rows),
+ xoffset_(xoffset),
+ yoffset_(yoffset),
+ xstep_(xstep),
+ ystep_(ystep),
+ length_(length) {}
- inline int32_t getLength() const { return mLength; }
+ inline int32_t GetLength() const { return length_; }
- inline uint32_t getColor(int32_t idx) const {
- return NinePatch::packRGBA(mRows[mYOffset + (idx * mYStep)] +
- ((idx + mXOffset) * mXStep) * 4);
+ inline uint32_t GetColor(int32_t idx) const {
+ return NinePatch::PackRGBA(rows_[yoffset_ + (idx * ystep_)] +
+ ((idx + xoffset_) * xstep_) * 4);
}
private:
- uint8_t** mRows;
- int32_t mXOffset, mYOffset, mXStep, mYStep, mLength;
+ uint8_t** rows_;
+ int32_t xoffset_, yoffset_, xstep_, ystep_, length_;
DISALLOW_COPY_AND_ASSIGN(DiagonalImageLine);
};
class TransparentNeutralColorValidator : public ColorValidator {
public:
- bool isNeutralColor(uint32_t color) const override {
- return getAlpha(color) == 0;
+ bool IsNeutralColor(uint32_t color) const override {
+ return get_alpha(color) == 0;
}
};
class WhiteNeutralColorValidator : public ColorValidator {
public:
- bool isNeutralColor(uint32_t color) const override {
+ bool IsNeutralColor(uint32_t color) const override {
return color == kColorOpaqueWhite;
}
};
-inline static uint32_t getAlpha(uint32_t color) {
+inline static uint32_t get_alpha(uint32_t color) {
return (color & 0xff000000u) >> 24;
}
-static bool populateBounds(const std::vector<Range>& padding,
- const std::vector<Range>& layoutBounds,
- const std::vector<Range>& stretchRegions,
- const int32_t length, int32_t* paddingStart,
- int32_t* paddingEnd, int32_t* layoutStart,
- int32_t* layoutEnd, const StringPiece& edgeName,
- std::string* err) {
+static bool PopulateBounds(const std::vector<Range>& padding,
+ const std::vector<Range>& layout_bounds,
+ const std::vector<Range>& stretch_regions,
+ const int32_t length, int32_t* padding_start,
+ int32_t* padding_end, int32_t* layout_start,
+ int32_t* layout_end, const StringPiece& edge_name,
+ std::string* out_err) {
if (padding.size() > 1) {
- std::stringstream errStream;
- errStream << "too many padding sections on " << edgeName << " border";
- *err = errStream.str();
+ std::stringstream err_stream;
+ err_stream << "too many padding sections on " << edge_name << " border";
+ *out_err = err_stream.str();
return false;
}
- *paddingStart = 0;
- *paddingEnd = 0;
+ *padding_start = 0;
+ *padding_end = 0;
if (!padding.empty()) {
const Range& range = padding.front();
- *paddingStart = range.start;
- *paddingEnd = length - range.end;
- } else if (!stretchRegions.empty()) {
+ *padding_start = range.start;
+ *padding_end = length - range.end;
+ } else if (!stretch_regions.empty()) {
// No padding was defined. Compute the padding from the first and last
// stretch regions.
- *paddingStart = stretchRegions.front().start;
- *paddingEnd = length - stretchRegions.back().end;
+ *padding_start = stretch_regions.front().start;
+ *padding_end = length - stretch_regions.back().end;
}
- if (layoutBounds.size() > 2) {
- std::stringstream errStream;
- errStream << "too many layout bounds sections on " << edgeName << " border";
- *err = errStream.str();
+ if (layout_bounds.size() > 2) {
+ std::stringstream err_stream;
+ err_stream << "too many layout bounds sections on " << edge_name
+ << " border";
+ *out_err = err_stream.str();
return false;
}
- *layoutStart = 0;
- *layoutEnd = 0;
- if (layoutBounds.size() >= 1) {
- const Range& range = layoutBounds.front();
+ *layout_start = 0;
+ *layout_end = 0;
+ if (layout_bounds.size() >= 1) {
+ const Range& range = layout_bounds.front();
// If there is only one layout bound segment, it might not start at 0, but
// then it should
// end at length.
if (range.start != 0 && range.end != length) {
- std::stringstream errStream;
- errStream << "layout bounds on " << edgeName
- << " border must start at edge";
- *err = errStream.str();
+ std::stringstream err_stream;
+ err_stream << "layout bounds on " << edge_name
+ << " border must start at edge";
+ *out_err = err_stream.str();
return false;
}
- *layoutStart = range.end;
+ *layout_start = range.end;
- if (layoutBounds.size() >= 2) {
- const Range& range = layoutBounds.back();
+ if (layout_bounds.size() >= 2) {
+ const Range& range = layout_bounds.back();
if (range.end != length) {
- std::stringstream errStream;
- errStream << "layout bounds on " << edgeName
- << " border must start at edge";
- *err = errStream.str();
+ std::stringstream err_stream;
+ err_stream << "layout bounds on " << edge_name
+ << " border must start at edge";
+ *out_err = err_stream.str();
return false;
}
- *layoutEnd = length - range.start;
+ *layout_end = length - range.start;
}
}
return true;
}
-static int32_t calculateSegmentCount(const std::vector<Range>& stretchRegions,
+static int32_t CalculateSegmentCount(const std::vector<Range>& stretch_regions,
int32_t length) {
- if (stretchRegions.size() == 0) {
+ if (stretch_regions.size() == 0) {
return 0;
}
- const bool startIsFixed = stretchRegions.front().start != 0;
- const bool endIsFixed = stretchRegions.back().end != length;
+ const bool start_is_fixed = stretch_regions.front().start != 0;
+ const bool end_is_fixed = stretch_regions.back().end != length;
int32_t modifier = 0;
- if (startIsFixed && endIsFixed) {
+ if (start_is_fixed && end_is_fixed) {
modifier = 1;
- } else if (!startIsFixed && !endIsFixed) {
+ } else if (!start_is_fixed && !end_is_fixed) {
modifier = -1;
}
- return static_cast<int32_t>(stretchRegions.size()) * 2 + modifier;
+ return static_cast<int32_t>(stretch_regions.size()) * 2 + modifier;
}
-static uint32_t getRegionColor(uint8_t** rows, const Bounds& region) {
+static uint32_t GetRegionColor(uint8_t** rows, const Bounds& region) {
// Sample the first pixel to compare against.
- const uint32_t expectedColor =
- NinePatch::packRGBA(rows[region.top] + region.left * 4);
+ const uint32_t expected_color =
+ NinePatch::PackRGBA(rows[region.top] + region.left * 4);
for (int32_t y = region.top; y < region.bottom; y++) {
const uint8_t* row = rows[y];
for (int32_t x = region.left; x < region.right; x++) {
- const uint32_t color = NinePatch::packRGBA(row + x * 4);
- if (getAlpha(color) == 0) {
+ const uint32_t color = NinePatch::PackRGBA(row + x * 4);
+ if (get_alpha(color) == 0) {
// The color is transparent.
// If the expectedColor is not transparent, NO_COLOR.
- if (getAlpha(expectedColor) != 0) {
+ if (get_alpha(expected_color) != 0) {
return android::Res_png_9patch::NO_COLOR;
}
- } else if (color != expectedColor) {
+ } else if (color != expected_color) {
return android::Res_png_9patch::NO_COLOR;
}
}
}
- if (getAlpha(expectedColor) == 0) {
+ if (get_alpha(expected_color) == 0) {
return android::Res_png_9patch::TRANSPARENT_COLOR;
}
- return expectedColor;
+ return expected_color;
}
-// Fills outColors with each 9-patch section's colour. If the whole section is
+// Fills out_colors with each 9-patch section's color. If the whole section is
// transparent,
-// it gets the special TRANSPARENT colour. If the whole section is the same
-// colour, it is assigned
-// that colour. Otherwise it gets the special NO_COLOR colour.
+// it gets the special TRANSPARENT color. If the whole section is the same
+// color, it is assigned
+// that color. Otherwise it gets the special NO_COLOR color.
//
// Note that the rows contain the 9-patch 1px border, and the indices in the
// stretch regions are
@@ -332,63 +336,63 @@
// the indices must be offset by 1.
//
// width and height also include the 9-patch 1px border.
-static void calculateRegionColors(
- uint8_t** rows, const std::vector<Range>& horizontalStretchRegions,
- const std::vector<Range>& verticalStretchRegions, const int32_t width,
- const int32_t height, std::vector<uint32_t>* outColors) {
- int32_t nextTop = 0;
+static void CalculateRegionColors(
+ uint8_t** rows, const std::vector<Range>& horizontal_stretch_regions,
+ const std::vector<Range>& vertical_stretch_regions, const int32_t width,
+ const int32_t height, std::vector<uint32_t>* out_colors) {
+ int32_t next_top = 0;
Bounds bounds;
- auto rowIter = verticalStretchRegions.begin();
- while (nextTop != height) {
- if (rowIter != verticalStretchRegions.end()) {
- if (nextTop != rowIter->start) {
+ auto row_iter = vertical_stretch_regions.begin();
+ while (next_top != height) {
+ if (row_iter != vertical_stretch_regions.end()) {
+ if (next_top != row_iter->start) {
// This is a fixed segment.
// Offset the bounds by 1 to accommodate the border.
- bounds.top = nextTop + 1;
- bounds.bottom = rowIter->start + 1;
- nextTop = rowIter->start;
+ bounds.top = next_top + 1;
+ bounds.bottom = row_iter->start + 1;
+ next_top = row_iter->start;
} else {
// This is a stretchy segment.
// Offset the bounds by 1 to accommodate the border.
- bounds.top = rowIter->start + 1;
- bounds.bottom = rowIter->end + 1;
- nextTop = rowIter->end;
- ++rowIter;
+ bounds.top = row_iter->start + 1;
+ bounds.bottom = row_iter->end + 1;
+ next_top = row_iter->end;
+ ++row_iter;
}
} else {
// This is the end, fixed section.
// Offset the bounds by 1 to accommodate the border.
- bounds.top = nextTop + 1;
+ bounds.top = next_top + 1;
bounds.bottom = height + 1;
- nextTop = height;
+ next_top = height;
}
- int32_t nextLeft = 0;
- auto colIter = horizontalStretchRegions.begin();
- while (nextLeft != width) {
- if (colIter != horizontalStretchRegions.end()) {
- if (nextLeft != colIter->start) {
+ int32_t next_left = 0;
+ auto col_iter = horizontal_stretch_regions.begin();
+ while (next_left != width) {
+ if (col_iter != horizontal_stretch_regions.end()) {
+ if (next_left != col_iter->start) {
// This is a fixed segment.
// Offset the bounds by 1 to accommodate the border.
- bounds.left = nextLeft + 1;
- bounds.right = colIter->start + 1;
- nextLeft = colIter->start;
+ bounds.left = next_left + 1;
+ bounds.right = col_iter->start + 1;
+ next_left = col_iter->start;
} else {
// This is a stretchy segment.
// Offset the bounds by 1 to accommodate the border.
- bounds.left = colIter->start + 1;
- bounds.right = colIter->end + 1;
- nextLeft = colIter->end;
- ++colIter;
+ bounds.left = col_iter->start + 1;
+ bounds.right = col_iter->end + 1;
+ next_left = col_iter->end;
+ ++col_iter;
}
} else {
// This is the end, fixed section.
// Offset the bounds by 1 to accommodate the border.
- bounds.left = nextLeft + 1;
+ bounds.left = next_left + 1;
bounds.right = width + 1;
- nextLeft = width;
+ next_left = width;
}
- outColors->push_back(getRegionColor(rows, bounds));
+ out_colors->push_back(GetRegionColor(rows, bounds));
}
}
}
@@ -397,12 +401,12 @@
// alpha value begins
// (on both sides).
template <typename ImageLine>
-static void findOutlineInsets(const ImageLine* imageLine, int32_t* outStart,
- int32_t* outEnd) {
- *outStart = 0;
- *outEnd = 0;
+static void FindOutlineInsets(const ImageLine* image_line, int32_t* out_start,
+ int32_t* out_end) {
+ *out_start = 0;
+ *out_end = 0;
- const int32_t length = imageLine->getLength();
+ const int32_t length = image_line->GetLength();
if (length < 3) {
return;
}
@@ -413,179 +417,181 @@
const int32_t mid2 = length / 2;
const int32_t mid1 = mid2 + (length % 2);
- uint32_t maxAlpha = 0;
- for (int32_t i = 0; i < mid1 && maxAlpha != 0xff; i++) {
- uint32_t alpha = getAlpha(imageLine->getColor(i));
- if (alpha > maxAlpha) {
- maxAlpha = alpha;
- *outStart = i;
+ uint32_t max_alpha = 0;
+ for (int32_t i = 0; i < mid1 && max_alpha != 0xff; i++) {
+ uint32_t alpha = get_alpha(image_line->GetColor(i));
+ if (alpha > max_alpha) {
+ max_alpha = alpha;
+ *out_start = i;
}
}
- maxAlpha = 0;
- for (int32_t i = length - 1; i >= mid2 && maxAlpha != 0xff; i--) {
- uint32_t alpha = getAlpha(imageLine->getColor(i));
- if (alpha > maxAlpha) {
- maxAlpha = alpha;
- *outEnd = length - (i + 1);
+ max_alpha = 0;
+ for (int32_t i = length - 1; i >= mid2 && max_alpha != 0xff; i--) {
+ uint32_t alpha = get_alpha(image_line->GetColor(i));
+ if (alpha > max_alpha) {
+ max_alpha = alpha;
+ *out_end = length - (i + 1);
}
}
return;
}
template <typename ImageLine>
-static uint32_t findMaxAlpha(const ImageLine* imageLine) {
- const int32_t length = imageLine->getLength();
- uint32_t maxAlpha = 0;
- for (int32_t idx = 0; idx < length && maxAlpha != 0xff; idx++) {
- uint32_t alpha = getAlpha(imageLine->getColor(idx));
- if (alpha > maxAlpha) {
- maxAlpha = alpha;
+static uint32_t FindMaxAlpha(const ImageLine* image_line) {
+ const int32_t length = image_line->GetLength();
+ uint32_t max_alpha = 0;
+ for (int32_t idx = 0; idx < length && max_alpha != 0xff; idx++) {
+ uint32_t alpha = get_alpha(image_line->GetColor(idx));
+ if (alpha > max_alpha) {
+ max_alpha = alpha;
}
}
- return maxAlpha;
+ return max_alpha;
}
// Pack the pixels in as 0xAARRGGBB (as 9-patch expects it).
-uint32_t NinePatch::packRGBA(const uint8_t* pixel) {
+uint32_t NinePatch::PackRGBA(const uint8_t* pixel) {
return (pixel[3] << 24) | (pixel[0] << 16) | (pixel[1] << 8) | pixel[2];
}
-std::unique_ptr<NinePatch> NinePatch::create(uint8_t** rows,
+std::unique_ptr<NinePatch> NinePatch::Create(uint8_t** rows,
const int32_t width,
const int32_t height,
- std::string* err) {
+ std::string* out_err) {
if (width < 3 || height < 3) {
- *err = "image must be at least 3x3 (1x1 image with 1 pixel border)";
+ *out_err = "image must be at least 3x3 (1x1 image with 1 pixel border)";
return {};
}
- std::vector<Range> horizontalPadding;
- std::vector<Range> horizontalOpticalBounds;
- std::vector<Range> verticalPadding;
- std::vector<Range> verticalOpticalBounds;
- std::vector<Range> unexpectedRanges;
- std::unique_ptr<ColorValidator> colorValidator;
+ std::vector<Range> horizontal_padding;
+ std::vector<Range> horizontal_layout_bounds;
+ std::vector<Range> vertical_padding;
+ std::vector<Range> vertical_layout_bounds;
+ std::vector<Range> unexpected_ranges;
+ std::unique_ptr<ColorValidator> color_validator;
if (rows[0][3] == 0) {
- colorValidator = util::make_unique<TransparentNeutralColorValidator>();
- } else if (packRGBA(rows[0]) == kColorOpaqueWhite) {
- colorValidator = util::make_unique<WhiteNeutralColorValidator>();
+ color_validator = util::make_unique<TransparentNeutralColorValidator>();
+ } else if (PackRGBA(rows[0]) == kColorOpaqueWhite) {
+ color_validator = util::make_unique<WhiteNeutralColorValidator>();
} else {
- *err = "top-left corner pixel must be either opaque white or transparent";
+ *out_err =
+ "top-left corner pixel must be either opaque white or transparent";
return {};
}
// Private constructor, can't use make_unique.
- auto ninePatch = std::unique_ptr<NinePatch>(new NinePatch());
+ auto nine_patch = std::unique_ptr<NinePatch>(new NinePatch());
- HorizontalImageLine topRow(rows, 0, 0, width);
- if (!fillRanges(&topRow, colorValidator.get(),
- &ninePatch->horizontalStretchRegions, &unexpectedRanges,
- err)) {
+ HorizontalImageLine top_row(rows, 0, 0, width);
+ if (!FillRanges(&top_row, color_validator.get(),
+ &nine_patch->horizontal_stretch_regions, &unexpected_ranges,
+ out_err)) {
return {};
}
- if (!unexpectedRanges.empty()) {
- const Range& range = unexpectedRanges[0];
- std::stringstream errStream;
- errStream << "found unexpected optical bounds (red pixel) on top border "
- << "at x=" << range.start + 1;
- *err = errStream.str();
+ if (!unexpected_ranges.empty()) {
+ const Range& range = unexpected_ranges[0];
+ std::stringstream err_stream;
+ err_stream << "found unexpected optical bounds (red pixel) on top border "
+ << "at x=" << range.start + 1;
+ *out_err = err_stream.str();
return {};
}
- VerticalImageLine leftCol(rows, 0, 0, height);
- if (!fillRanges(&leftCol, colorValidator.get(),
- &ninePatch->verticalStretchRegions, &unexpectedRanges, err)) {
+ VerticalImageLine left_col(rows, 0, 0, height);
+ if (!FillRanges(&left_col, color_validator.get(),
+ &nine_patch->vertical_stretch_regions, &unexpected_ranges,
+ out_err)) {
return {};
}
- if (!unexpectedRanges.empty()) {
- const Range& range = unexpectedRanges[0];
- std::stringstream errStream;
- errStream << "found unexpected optical bounds (red pixel) on left border "
- << "at y=" << range.start + 1;
+ if (!unexpected_ranges.empty()) {
+ const Range& range = unexpected_ranges[0];
+ std::stringstream err_stream;
+ err_stream << "found unexpected optical bounds (red pixel) on left border "
+ << "at y=" << range.start + 1;
return {};
}
- HorizontalImageLine bottomRow(rows, 0, height - 1, width);
- if (!fillRanges(&bottomRow, colorValidator.get(), &horizontalPadding,
- &horizontalOpticalBounds, err)) {
+ HorizontalImageLine bottom_row(rows, 0, height - 1, width);
+ if (!FillRanges(&bottom_row, color_validator.get(), &horizontal_padding,
+ &horizontal_layout_bounds, out_err)) {
return {};
}
- if (!populateBounds(horizontalPadding, horizontalOpticalBounds,
- ninePatch->horizontalStretchRegions, width - 2,
- &ninePatch->padding.left, &ninePatch->padding.right,
- &ninePatch->layoutBounds.left,
- &ninePatch->layoutBounds.right, "bottom", err)) {
+ if (!PopulateBounds(horizontal_padding, horizontal_layout_bounds,
+ nine_patch->horizontal_stretch_regions, width - 2,
+ &nine_patch->padding.left, &nine_patch->padding.right,
+ &nine_patch->layout_bounds.left,
+ &nine_patch->layout_bounds.right, "bottom", out_err)) {
return {};
}
- VerticalImageLine rightCol(rows, width - 1, 0, height);
- if (!fillRanges(&rightCol, colorValidator.get(), &verticalPadding,
- &verticalOpticalBounds, err)) {
+ VerticalImageLine right_col(rows, width - 1, 0, height);
+ if (!FillRanges(&right_col, color_validator.get(), &vertical_padding,
+ &vertical_layout_bounds, out_err)) {
return {};
}
- if (!populateBounds(verticalPadding, verticalOpticalBounds,
- ninePatch->verticalStretchRegions, height - 2,
- &ninePatch->padding.top, &ninePatch->padding.bottom,
- &ninePatch->layoutBounds.top,
- &ninePatch->layoutBounds.bottom, "right", err)) {
+ if (!PopulateBounds(vertical_padding, vertical_layout_bounds,
+ nine_patch->vertical_stretch_regions, height - 2,
+ &nine_patch->padding.top, &nine_patch->padding.bottom,
+ &nine_patch->layout_bounds.top,
+ &nine_patch->layout_bounds.bottom, "right", out_err)) {
return {};
}
// Fill the region colors of the 9-patch.
- const int32_t numRows =
- calculateSegmentCount(ninePatch->horizontalStretchRegions, width - 2);
- const int32_t numCols =
- calculateSegmentCount(ninePatch->verticalStretchRegions, height - 2);
- if ((int64_t)numRows * (int64_t)numCols > 0x7f) {
- *err = "too many regions in 9-patch";
+ const int32_t num_rows =
+ CalculateSegmentCount(nine_patch->horizontal_stretch_regions, width - 2);
+ const int32_t num_cols =
+ CalculateSegmentCount(nine_patch->vertical_stretch_regions, height - 2);
+ if ((int64_t)num_rows * (int64_t)num_cols > 0x7f) {
+ *out_err = "too many regions in 9-patch";
return {};
}
- ninePatch->regionColors.reserve(numRows * numCols);
- calculateRegionColors(rows, ninePatch->horizontalStretchRegions,
- ninePatch->verticalStretchRegions, width - 2,
- height - 2, &ninePatch->regionColors);
+ nine_patch->region_colors.reserve(num_rows * num_cols);
+ CalculateRegionColors(rows, nine_patch->horizontal_stretch_regions,
+ nine_patch->vertical_stretch_regions, width - 2,
+ height - 2, &nine_patch->region_colors);
// Compute the outline based on opacity.
// Find left and right extent of 9-patch content on center row.
- HorizontalImageLine midRow(rows, 1, height / 2, width - 2);
- findOutlineInsets(&midRow, &ninePatch->outline.left,
- &ninePatch->outline.right);
+ HorizontalImageLine mid_row(rows, 1, height / 2, width - 2);
+ FindOutlineInsets(&mid_row, &nine_patch->outline.left,
+ &nine_patch->outline.right);
// Find top and bottom extent of 9-patch content on center column.
- VerticalImageLine midCol(rows, width / 2, 1, height - 2);
- findOutlineInsets(&midCol, &ninePatch->outline.top,
- &ninePatch->outline.bottom);
+ VerticalImageLine mid_col(rows, width / 2, 1, height - 2);
+ FindOutlineInsets(&mid_col, &nine_patch->outline.top,
+ &nine_patch->outline.bottom);
- const int32_t outlineWidth =
- (width - 2) - ninePatch->outline.left - ninePatch->outline.right;
- const int32_t outlineHeight =
- (height - 2) - ninePatch->outline.top - ninePatch->outline.bottom;
+ const int32_t outline_width =
+ (width - 2) - nine_patch->outline.left - nine_patch->outline.right;
+ const int32_t outline_height =
+ (height - 2) - nine_patch->outline.top - nine_patch->outline.bottom;
// Find the largest alpha value within the outline area.
- HorizontalImageLine outlineMidRow(
- rows, 1 + ninePatch->outline.left,
- 1 + ninePatch->outline.top + (outlineHeight / 2), outlineWidth);
- VerticalImageLine outlineMidCol(
- rows, 1 + ninePatch->outline.left + (outlineWidth / 2),
- 1 + ninePatch->outline.top, outlineHeight);
- ninePatch->outlineAlpha =
- std::max(findMaxAlpha(&outlineMidRow), findMaxAlpha(&outlineMidCol));
+ HorizontalImageLine outline_mid_row(
+ rows, 1 + nine_patch->outline.left,
+ 1 + nine_patch->outline.top + (outline_height / 2), outline_width);
+ VerticalImageLine outline_mid_col(
+ rows, 1 + nine_patch->outline.left + (outline_width / 2),
+ 1 + nine_patch->outline.top, outline_height);
+ nine_patch->outline_alpha =
+ std::max(FindMaxAlpha(&outline_mid_row), FindMaxAlpha(&outline_mid_col));
// Assuming the image is a round rect, compute the radius by marching
// diagonally from the top left corner towards the center.
- DiagonalImageLine diagonal(rows, 1 + ninePatch->outline.left,
- 1 + ninePatch->outline.top, 1, 1,
- std::min(outlineWidth, outlineHeight));
- int32_t topLeft, bottomRight;
- findOutlineInsets(&diagonal, &topLeft, &bottomRight);
+ DiagonalImageLine diagonal(rows, 1 + nine_patch->outline.left,
+ 1 + nine_patch->outline.top, 1, 1,
+ std::min(outline_width, outline_height));
+ int32_t top_left, bottom_right;
+ FindOutlineInsets(&diagonal, &top_left, &bottom_right);
/* Determine source radius based upon inset:
* sqrt(r^2 + r^2) = sqrt(i^2 + i^2) + r
@@ -593,15 +599,15 @@
* (sqrt(2) - 1) * r = sqrt(2) * i
* r = sqrt(2) / (sqrt(2) - 1) * i
*/
- ninePatch->outlineRadius = 3.4142f * topLeft;
- return ninePatch;
+ nine_patch->outline_radius = 3.4142f * top_left;
+ return nine_patch;
}
-std::unique_ptr<uint8_t[]> NinePatch::serializeBase(size_t* outLen) const {
+std::unique_ptr<uint8_t[]> NinePatch::SerializeBase(size_t* outLen) const {
android::Res_png_9patch data;
- data.numXDivs = static_cast<uint8_t>(horizontalStretchRegions.size()) * 2;
- data.numYDivs = static_cast<uint8_t>(verticalStretchRegions.size()) * 2;
- data.numColors = static_cast<uint8_t>(regionColors.size());
+ data.numXDivs = static_cast<uint8_t>(horizontal_stretch_regions.size()) * 2;
+ data.numYDivs = static_cast<uint8_t>(vertical_stretch_regions.size()) * 2;
+ data.numColors = static_cast<uint8_t>(region_colors.size());
data.paddingLeft = padding.left;
data.paddingRight = padding.right;
data.paddingTop = padding.top;
@@ -609,8 +615,8 @@
auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[data.serializedSize()]);
android::Res_png_9patch::serialize(
- data, (const int32_t*)horizontalStretchRegions.data(),
- (const int32_t*)verticalStretchRegions.data(), regionColors.data(),
+ data, (const int32_t*)horizontal_stretch_regions.data(),
+ (const int32_t*)vertical_stretch_regions.data(), region_colors.data(),
buffer.get());
// Convert to file endianness.
reinterpret_cast<android::Res_png_9patch*>(buffer.get())->deviceToFile();
@@ -619,32 +625,32 @@
return buffer;
}
-std::unique_ptr<uint8_t[]> NinePatch::serializeLayoutBounds(
- size_t* outLen) const {
- size_t chunkLen = sizeof(uint32_t) * 4;
- auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunkLen]);
+std::unique_ptr<uint8_t[]> NinePatch::SerializeLayoutBounds(
+ size_t* out_len) const {
+ size_t chunk_len = sizeof(uint32_t) * 4;
+ auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunk_len]);
uint8_t* cursor = buffer.get();
- memcpy(cursor, &layoutBounds.left, sizeof(layoutBounds.left));
- cursor += sizeof(layoutBounds.left);
+ memcpy(cursor, &layout_bounds.left, sizeof(layout_bounds.left));
+ cursor += sizeof(layout_bounds.left);
- memcpy(cursor, &layoutBounds.top, sizeof(layoutBounds.top));
- cursor += sizeof(layoutBounds.top);
+ memcpy(cursor, &layout_bounds.top, sizeof(layout_bounds.top));
+ cursor += sizeof(layout_bounds.top);
- memcpy(cursor, &layoutBounds.right, sizeof(layoutBounds.right));
- cursor += sizeof(layoutBounds.right);
+ memcpy(cursor, &layout_bounds.right, sizeof(layout_bounds.right));
+ cursor += sizeof(layout_bounds.right);
- memcpy(cursor, &layoutBounds.bottom, sizeof(layoutBounds.bottom));
- cursor += sizeof(layoutBounds.bottom);
+ memcpy(cursor, &layout_bounds.bottom, sizeof(layout_bounds.bottom));
+ cursor += sizeof(layout_bounds.bottom);
- *outLen = chunkLen;
+ *out_len = chunk_len;
return buffer;
}
-std::unique_ptr<uint8_t[]> NinePatch::serializeRoundedRectOutline(
- size_t* outLen) const {
- size_t chunkLen = sizeof(uint32_t) * 6;
- auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunkLen]);
+std::unique_ptr<uint8_t[]> NinePatch::SerializeRoundedRectOutline(
+ size_t* out_len) const {
+ size_t chunk_len = sizeof(uint32_t) * 6;
+ auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[chunk_len]);
uint8_t* cursor = buffer.get();
memcpy(cursor, &outline.left, sizeof(outline.left));
@@ -659,12 +665,12 @@
memcpy(cursor, &outline.bottom, sizeof(outline.bottom));
cursor += sizeof(outline.bottom);
- *((float*)cursor) = outlineRadius;
- cursor += sizeof(outlineRadius);
+ *((float*)cursor) = outline_radius;
+ cursor += sizeof(outline_radius);
- *((uint32_t*)cursor) = outlineAlpha;
+ *((uint32_t*)cursor) = outline_alpha;
- *outLen = chunkLen;
+ *out_len = chunk_len;
return buffer;
}
@@ -677,16 +683,16 @@
<< " r=" << bounds.right << " b=" << bounds.bottom;
}
-::std::ostream& operator<<(::std::ostream& out, const NinePatch& ninePatch) {
+::std::ostream& operator<<(::std::ostream& out, const NinePatch& nine_patch) {
return out << "horizontalStretch:"
- << util::joiner(ninePatch.horizontalStretchRegions, " ")
+ << util::Joiner(nine_patch.horizontal_stretch_regions, " ")
<< " verticalStretch:"
- << util::joiner(ninePatch.verticalStretchRegions, " ")
- << " padding: " << ninePatch.padding
- << ", bounds: " << ninePatch.layoutBounds
- << ", outline: " << ninePatch.outline
- << " rad=" << ninePatch.outlineRadius
- << " alpha=" << ninePatch.outlineAlpha;
+ << util::Joiner(nine_patch.vertical_stretch_regions, " ")
+ << " padding: " << nine_patch.padding
+ << ", bounds: " << nine_patch.layout_bounds
+ << ", outline: " << nine_patch.outline
+ << " rad=" << nine_patch.outline_radius
+ << " alpha=" << nine_patch.outline_alpha;
}
} // namespace aapt
diff --git a/tools/aapt2/compile/NinePatch_test.cpp b/tools/aapt2/compile/NinePatch_test.cpp
index b8eda09..f54bb2e 100644
--- a/tools/aapt2/compile/NinePatch_test.cpp
+++ b/tools/aapt2/compile/NinePatch_test.cpp
@@ -15,6 +15,7 @@
*/
#include "compile/Image.h"
+
#include "test/Test.h"
namespace aapt {
@@ -182,169 +183,168 @@
TEST(NinePatchTest, Minimum3x3) {
std::string err;
- EXPECT_EQ(nullptr, NinePatch::create(k2x2, 2, 2, &err));
+ EXPECT_EQ(nullptr, NinePatch::Create(k2x2, 2, 2, &err));
EXPECT_FALSE(err.empty());
}
TEST(NinePatchTest, MixedNeutralColors) {
std::string err;
- EXPECT_EQ(nullptr, NinePatch::create(kMixedNeutralColor3x3, 3, 3, &err));
+ EXPECT_EQ(nullptr, NinePatch::Create(kMixedNeutralColor3x3, 3, 3, &err));
EXPECT_FALSE(err.empty());
}
TEST(NinePatchTest, TransparentNeutralColor) {
std::string err;
EXPECT_NE(nullptr,
- NinePatch::create(kTransparentNeutralColor3x3, 3, 3, &err));
+ NinePatch::Create(kTransparentNeutralColor3x3, 3, 3, &err));
}
TEST(NinePatchTest, SingleStretchRegion) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kSingleStretch7x6, 7, 6, &err);
- ASSERT_NE(nullptr, ninePatch);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kSingleStretch7x6, 7, 6, &err);
+ ASSERT_NE(nullptr, nine_patch);
- ASSERT_EQ(1u, ninePatch->horizontalStretchRegions.size());
- ASSERT_EQ(1u, ninePatch->verticalStretchRegions.size());
+ ASSERT_EQ(1u, nine_patch->horizontal_stretch_regions.size());
+ ASSERT_EQ(1u, nine_patch->vertical_stretch_regions.size());
- EXPECT_EQ(Range(1, 4), ninePatch->horizontalStretchRegions.front());
- EXPECT_EQ(Range(1, 3), ninePatch->verticalStretchRegions.front());
+ EXPECT_EQ(Range(1, 4), nine_patch->horizontal_stretch_regions.front());
+ EXPECT_EQ(Range(1, 3), nine_patch->vertical_stretch_regions.front());
}
TEST(NinePatchTest, MultipleStretchRegions) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kMultipleStretch10x7, 10, 7, &err);
- ASSERT_NE(nullptr, ninePatch);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kMultipleStretch10x7, 10, 7, &err);
+ ASSERT_NE(nullptr, nine_patch);
- ASSERT_EQ(3u, ninePatch->horizontalStretchRegions.size());
- ASSERT_EQ(2u, ninePatch->verticalStretchRegions.size());
+ ASSERT_EQ(3u, nine_patch->horizontal_stretch_regions.size());
+ ASSERT_EQ(2u, nine_patch->vertical_stretch_regions.size());
- EXPECT_EQ(Range(1, 2), ninePatch->horizontalStretchRegions[0]);
- EXPECT_EQ(Range(3, 5), ninePatch->horizontalStretchRegions[1]);
- EXPECT_EQ(Range(6, 7), ninePatch->horizontalStretchRegions[2]);
+ EXPECT_EQ(Range(1, 2), nine_patch->horizontal_stretch_regions[0]);
+ EXPECT_EQ(Range(3, 5), nine_patch->horizontal_stretch_regions[1]);
+ EXPECT_EQ(Range(6, 7), nine_patch->horizontal_stretch_regions[2]);
- EXPECT_EQ(Range(0, 2), ninePatch->verticalStretchRegions[0]);
- EXPECT_EQ(Range(3, 5), ninePatch->verticalStretchRegions[1]);
+ EXPECT_EQ(Range(0, 2), nine_patch->vertical_stretch_regions[0]);
+ EXPECT_EQ(Range(3, 5), nine_patch->vertical_stretch_regions[1]);
}
TEST(NinePatchTest, InferPaddingFromStretchRegions) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kMultipleStretch10x7, 10, 7, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(1, 0, 1, 0), ninePatch->padding);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kMultipleStretch10x7, 10, 7, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(1, 0, 1, 0), nine_patch->padding);
}
TEST(NinePatchTest, Padding) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kPadding6x5, 6, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->padding);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kPadding6x5, 6, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->padding);
}
TEST(NinePatchTest, LayoutBoundsAreOnWrongEdge) {
std::string err;
- EXPECT_EQ(nullptr, NinePatch::create(kLayoutBoundsWrongEdge3x3, 3, 3, &err));
+ EXPECT_EQ(nullptr, NinePatch::Create(kLayoutBoundsWrongEdge3x3, 3, 3, &err));
EXPECT_FALSE(err.empty());
}
TEST(NinePatchTest, LayoutBoundsMustTouchEdges) {
std::string err;
EXPECT_EQ(nullptr,
- NinePatch::create(kLayoutBoundsNotEdgeAligned5x5, 5, 5, &err));
+ NinePatch::Create(kLayoutBoundsNotEdgeAligned5x5, 5, 5, &err));
EXPECT_FALSE(err.empty());
}
TEST(NinePatchTest, LayoutBounds) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kLayoutBounds5x5, 5, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->layoutBounds);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kLayoutBounds5x5, 5, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->layout_bounds);
- ninePatch = NinePatch::create(kAsymmetricLayoutBounds5x5, 5, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(1, 1, 0, 0), ninePatch->layoutBounds);
+ nine_patch = NinePatch::Create(kAsymmetricLayoutBounds5x5, 5, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(1, 1, 0, 0), nine_patch->layout_bounds);
}
TEST(NinePatchTest, PaddingAndLayoutBounds) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kPaddingAndLayoutBounds5x5, 5, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->padding);
- EXPECT_EQ(Bounds(1, 1, 1, 1), ninePatch->layoutBounds);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kPaddingAndLayoutBounds5x5, 5, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->padding);
+ EXPECT_EQ(Bounds(1, 1, 1, 1), nine_patch->layout_bounds);
}
TEST(NinePatchTest, RegionColorsAreCorrect) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kColorfulImage5x5, 5, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kColorfulImage5x5, 5, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
- std::vector<uint32_t> expectedColors = {
- NinePatch::packRGBA((uint8_t*)RED),
+ std::vector<uint32_t> expected_colors = {
+ NinePatch::PackRGBA((uint8_t*)RED),
(uint32_t)android::Res_png_9patch::NO_COLOR,
- NinePatch::packRGBA((uint8_t*)GREEN),
+ NinePatch::PackRGBA((uint8_t*)GREEN),
(uint32_t)android::Res_png_9patch::TRANSPARENT_COLOR,
- NinePatch::packRGBA((uint8_t*)BLUE),
- NinePatch::packRGBA((uint8_t*)GREEN),
+ NinePatch::PackRGBA((uint8_t*)BLUE),
+ NinePatch::PackRGBA((uint8_t*)GREEN),
};
- EXPECT_EQ(expectedColors, ninePatch->regionColors);
+ EXPECT_EQ(expected_colors, nine_patch->region_colors);
}
TEST(NinePatchTest, OutlineFromOpaqueImage) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kOutlineOpaque10x10, 10, 10, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(2, 2, 2, 2), ninePatch->outline);
- EXPECT_EQ(0x000000ffu, ninePatch->outlineAlpha);
- EXPECT_EQ(0.0f, ninePatch->outlineRadius);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kOutlineOpaque10x10, 10, 10, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(2, 2, 2, 2), nine_patch->outline);
+ EXPECT_EQ(0x000000ffu, nine_patch->outline_alpha);
+ EXPECT_EQ(0.0f, nine_patch->outline_radius);
}
TEST(NinePatchTest, OutlineFromTranslucentImage) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kOutlineTranslucent10x10, 10, 10, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(3, 3, 3, 3), ninePatch->outline);
- EXPECT_EQ(0x000000b3u, ninePatch->outlineAlpha);
- EXPECT_EQ(0.0f, ninePatch->outlineRadius);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kOutlineTranslucent10x10, 10, 10, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(3, 3, 3, 3), nine_patch->outline);
+ EXPECT_EQ(0x000000b3u, nine_patch->outline_alpha);
+ EXPECT_EQ(0.0f, nine_patch->outline_radius);
}
TEST(NinePatchTest, OutlineFromOffCenterImage) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kOutlineOffsetTranslucent12x10, 12, 10, &err);
- ASSERT_NE(nullptr, ninePatch);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kOutlineOffsetTranslucent12x10, 12, 10, &err);
+ ASSERT_NE(nullptr, nine_patch);
// TODO(adamlesinski): The old AAPT algorithm searches from the outside to the
- // middle
- // for each inset. If the outline is shifted, the search may not find a closer
- // bounds.
+ // middle for each inset. If the outline is shifted, the search may not find a
+ // closer bounds.
// This check should be:
// EXPECT_EQ(Bounds(5, 3, 3, 3), ninePatch->outline);
- // but until I know what behaviour I'm breaking, I will leave it at the
+ // but until I know what behavior I'm breaking, I will leave it at the
// incorrect:
- EXPECT_EQ(Bounds(4, 3, 3, 3), ninePatch->outline);
+ EXPECT_EQ(Bounds(4, 3, 3, 3), nine_patch->outline);
- EXPECT_EQ(0x000000b3u, ninePatch->outlineAlpha);
- EXPECT_EQ(0.0f, ninePatch->outlineRadius);
+ EXPECT_EQ(0x000000b3u, nine_patch->outline_alpha);
+ EXPECT_EQ(0.0f, nine_patch->outline_radius);
}
TEST(NinePatchTest, OutlineRadius) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kOutlineRadius5x5, 5, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
- EXPECT_EQ(Bounds(0, 0, 0, 0), ninePatch->outline);
- EXPECT_EQ(3.4142f, ninePatch->outlineRadius);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kOutlineRadius5x5, 5, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
+ EXPECT_EQ(Bounds(0, 0, 0, 0), nine_patch->outline);
+ EXPECT_EQ(3.4142f, nine_patch->outline_radius);
}
-::testing::AssertionResult bigEndianOne(uint8_t* cursor) {
+::testing::AssertionResult BigEndianOne(uint8_t* cursor) {
if (cursor[0] == 0 && cursor[1] == 0 && cursor[2] == 0 && cursor[3] == 1) {
return ::testing::AssertionSuccess();
}
@@ -353,12 +353,12 @@
TEST(NinePatchTest, SerializePngEndianness) {
std::string err;
- std::unique_ptr<NinePatch> ninePatch =
- NinePatch::create(kStretchAndPadding5x5, 5, 5, &err);
- ASSERT_NE(nullptr, ninePatch);
+ std::unique_ptr<NinePatch> nine_patch =
+ NinePatch::Create(kStretchAndPadding5x5, 5, 5, &err);
+ ASSERT_NE(nullptr, nine_patch);
size_t len;
- std::unique_ptr<uint8_t[]> data = ninePatch->serializeBase(&len);
+ std::unique_ptr<uint8_t[]> data = nine_patch->SerializeBase(&len);
ASSERT_NE(nullptr, data);
ASSERT_NE(0u, len);
@@ -368,10 +368,10 @@
uint8_t* cursor = data.get() + 12;
// Check that padding is big-endian. Expecting value 1.
- EXPECT_TRUE(bigEndianOne(cursor));
- EXPECT_TRUE(bigEndianOne(cursor + 4));
- EXPECT_TRUE(bigEndianOne(cursor + 8));
- EXPECT_TRUE(bigEndianOne(cursor + 12));
+ EXPECT_TRUE(BigEndianOne(cursor));
+ EXPECT_TRUE(BigEndianOne(cursor + 4));
+ EXPECT_TRUE(BigEndianOne(cursor + 8));
+ EXPECT_TRUE(BigEndianOne(cursor + 12));
}
} // namespace aapt
diff --git a/tools/aapt2/compile/Png.cpp b/tools/aapt2/compile/Png.cpp
index 9b5fa7e09..f1bc53e 100644
--- a/tools/aapt2/compile/Png.cpp
+++ b/tools/aapt2/compile/Png.cpp
@@ -89,7 +89,7 @@
static void writeDataToStream(png_structp writePtr, png_bytep data,
png_size_t length) {
BigBuffer* outBuffer = reinterpret_cast<BigBuffer*>(png_get_io_ptr(writePtr));
- png_bytep buf = outBuffer->nextBlock<png_byte>(length);
+ png_bytep buf = outBuffer->NextBlock<png_byte>(length);
memcpy(buf, data, length);
}
@@ -98,13 +98,13 @@
static void logWarning(png_structp readPtr, png_const_charp warningMessage) {
IDiagnostics* diag =
reinterpret_cast<IDiagnostics*>(png_get_error_ptr(readPtr));
- diag->warn(DiagMessage() << warningMessage);
+ diag->Warn(DiagMessage() << warningMessage);
}
static bool readPng(IDiagnostics* diag, png_structp readPtr, png_infop infoPtr,
PngInfo* outInfo) {
if (setjmp(png_jmpbuf(readPtr))) {
- diag->error(DiagMessage() << "failed reading png");
+ diag->Error(DiagMessage() << "failed reading png");
return false;
}
@@ -373,7 +373,7 @@
*colorType = PNG_COLOR_TYPE_PALETTE;
} else {
if (maxGrayDeviation <= grayscaleTolerance) {
- diag->note(DiagMessage() << "forcing image to gray (max deviation = "
+ diag->Note(DiagMessage() << "forcing image to gray (max deviation = "
<< maxGrayDeviation << ")");
*colorType = isOpaque ? PNG_COLOR_TYPE_GRAY : PNG_COLOR_TYPE_GRAY_ALPHA;
} else {
@@ -424,7 +424,7 @@
static bool writePng(IDiagnostics* diag, png_structp writePtr,
png_infop infoPtr, PngInfo* info, int grayScaleTolerance) {
if (setjmp(png_jmpbuf(writePtr))) {
- diag->error(DiagMessage() << "failed to write png");
+ diag->Error(DiagMessage() << "failed to write png");
return false;
}
@@ -453,7 +453,7 @@
png_set_compression_level(writePtr, Z_BEST_COMPRESSION);
if (kDebug) {
- diag->note(DiagMessage() << "writing image: w = " << info->width
+ diag->Note(DiagMessage() << "writing image: w = " << info->width
<< ", h = " << info->height);
}
@@ -476,23 +476,23 @@
if (kDebug) {
switch (colorType) {
case PNG_COLOR_TYPE_PALETTE:
- diag->note(DiagMessage() << "has " << paletteEntries << " colors"
+ diag->Note(DiagMessage() << "has " << paletteEntries << " colors"
<< (hasTransparency ? " (with alpha)" : "")
<< ", using PNG_COLOR_TYPE_PALLETTE");
break;
case PNG_COLOR_TYPE_GRAY:
- diag->note(DiagMessage()
+ diag->Note(DiagMessage()
<< "is opaque gray, using PNG_COLOR_TYPE_GRAY");
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
- diag->note(DiagMessage()
+ diag->Note(DiagMessage()
<< "is gray + alpha, using PNG_COLOR_TYPE_GRAY_ALPHA");
break;
case PNG_COLOR_TYPE_RGB:
- diag->note(DiagMessage() << "is opaque RGB, using PNG_COLOR_TYPE_RGB");
+ diag->Note(DiagMessage() << "is opaque RGB, using PNG_COLOR_TYPE_RGB");
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
- diag->note(DiagMessage()
+ diag->Note(DiagMessage()
<< "is RGB + alpha, using PNG_COLOR_TYPE_RGB_ALPHA");
break;
}
@@ -527,7 +527,7 @@
// base 9 patch data
if (kDebug) {
- diag->note(DiagMessage() << "adding 9-patch info..");
+ diag->Note(DiagMessage() << "adding 9-patch info..");
}
strcpy((char*)unknowns[pIndex].name, "npTc");
unknowns[pIndex].data = (png_byte*)info->serialize9Patch();
@@ -604,7 +604,7 @@
&interlaceType, &compressionType, nullptr);
if (kDebug) {
- diag->note(DiagMessage() << "image written: w = " << width
+ diag->Note(DiagMessage() << "image written: w = " << width
<< ", h = " << height << ", d = " << bitDepth
<< ", colors = " << colorType
<< ", inter = " << interlaceType
@@ -1228,13 +1228,13 @@
// Read the PNG signature first.
if (!input->read(reinterpret_cast<char*>(signature), kPngSignatureSize)) {
- mDiag->error(DiagMessage() << strerror(errno));
+ mDiag->Error(DiagMessage() << strerror(errno));
return false;
}
// If the PNG signature doesn't match, bail early.
if (png_sig_cmp(signature, 0, kPngSignatureSize) != 0) {
- mDiag->error(DiagMessage() << "not a valid png file");
+ mDiag->Error(DiagMessage() << "not a valid png file");
return false;
}
@@ -1247,13 +1247,13 @@
readPtr = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr);
if (!readPtr) {
- mDiag->error(DiagMessage() << "failed to allocate read ptr");
+ mDiag->Error(DiagMessage() << "failed to allocate read ptr");
goto bail;
}
infoPtr = png_create_info_struct(readPtr);
if (!infoPtr) {
- mDiag->error(DiagMessage() << "failed to allocate info ptr");
+ mDiag->Error(DiagMessage() << "failed to allocate info ptr");
goto bail;
}
@@ -1267,10 +1267,10 @@
goto bail;
}
- if (util::stringEndsWith(source.path, ".9.png")) {
+ if (util::EndsWith(source.path, ".9.png")) {
std::string errorMsg;
if (!do9Patch(&pngInfo, &errorMsg)) {
- mDiag->error(DiagMessage() << errorMsg);
+ mDiag->Error(DiagMessage() << errorMsg);
goto bail;
}
}
@@ -1278,13 +1278,13 @@
writePtr =
png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, nullptr, nullptr);
if (!writePtr) {
- mDiag->error(DiagMessage() << "failed to allocate write ptr");
+ mDiag->Error(DiagMessage() << "failed to allocate write ptr");
goto bail;
}
writeInfoPtr = png_create_info_struct(writePtr);
if (!writeInfoPtr) {
- mDiag->error(DiagMessage() << "failed to allocate write info ptr");
+ mDiag->Error(DiagMessage() << "failed to allocate write info ptr");
goto bail;
}
@@ -1295,7 +1295,7 @@
flushDataToStream);
if (!writePng(mDiag, writePtr, writeInfoPtr, &pngInfo,
- options.grayScaleTolerance)) {
+ options.grayscale_tolerance)) {
goto bail;
}
diff --git a/tools/aapt2/compile/Png.h b/tools/aapt2/compile/Png.h
index f9038af..01c9adb 100644
--- a/tools/aapt2/compile/Png.h
+++ b/tools/aapt2/compile/Png.h
@@ -17,6 +17,11 @@
#ifndef AAPT_PNG_H
#define AAPT_PNG_H
+#include <iostream>
+#include <string>
+
+#include "android-base/macros.h"
+
#include "Diagnostics.h"
#include "Source.h"
#include "compile/Image.h"
@@ -24,16 +29,15 @@
#include "process/IResourceTableConsumer.h"
#include "util/BigBuffer.h"
-#include <android-base/macros.h>
-#include <iostream>
-#include <string>
-
namespace aapt {
struct PngOptions {
- int grayScaleTolerance = 0;
+ int grayscale_tolerance = 0;
};
+/**
+ * Deprecated. Removing once new PNG crunching code is proved to be correct.
+ */
class Png {
public:
explicit Png(IDiagnostics* diag) : mDiag(diag) {}
@@ -59,18 +63,18 @@
bool Skip(int count) override;
int64_t ByteCount() const override {
- return static_cast<int64_t>(mWindowStart);
+ return static_cast<int64_t>(window_start_);
}
- bool HadError() const override { return mError; }
+ bool HadError() const override { return error_; }
private:
- bool consumeWindow(const void** buffer, int* len);
+ bool ConsumeWindow(const void** buffer, int* len);
- StringPiece mData;
- size_t mWindowStart = 0;
- size_t mWindowEnd = 0;
- bool mError = false;
+ StringPiece data_;
+ size_t window_start_ = 0;
+ size_t window_end_ = 0;
+ bool error_ = false;
DISALLOW_COPY_AND_ASSIGN(PngChunkFilter);
};
@@ -78,14 +82,14 @@
/**
* Reads a PNG from the InputStream into memory as an RGBA Image.
*/
-std::unique_ptr<Image> readPng(IAaptContext* context, io::InputStream* in);
+std::unique_ptr<Image> ReadPng(IAaptContext* context, io::InputStream* in);
/**
* Writes the RGBA Image, with optional 9-patch meta-data, into the OutputStream
* as a PNG.
*/
-bool writePng(IAaptContext* context, const Image* image,
- const NinePatch* ninePatch, io::OutputStream* out,
+bool WritePng(IAaptContext* context, const Image* image,
+ const NinePatch* nine_patch, io::OutputStream* out,
const PngOptions& options);
} // namespace aapt
diff --git a/tools/aapt2/compile/PngChunkFilter.cpp b/tools/aapt2/compile/PngChunkFilter.cpp
index fb7fe92..4cbefb9 100644
--- a/tools/aapt2/compile/PngChunkFilter.cpp
+++ b/tools/aapt2/compile/PngChunkFilter.cpp
@@ -15,6 +15,7 @@
*/
#include "compile/Png.h"
+
#include "io/Io.h"
#include "util/StringPiece.h"
@@ -39,7 +40,7 @@
kPngChunksRGB = u32(115, 82, 71, 66),
};
-static uint32_t peek32LE(const char* data) {
+static uint32_t Peek32LE(const char* data) {
uint32_t word = ((uint32_t)data[0]) & 0x000000ff;
word <<= 8;
word |= ((uint32_t)data[1]) & 0x000000ff;
@@ -50,7 +51,7 @@
return word;
}
-static bool isPngChunkWhitelisted(uint32_t type) {
+static bool IsPngChunkWhitelisted(uint32_t type) {
switch (type) {
case kPngChunkIHDR:
case kPngChunkIDAT:
@@ -64,93 +65,93 @@
}
}
-PngChunkFilter::PngChunkFilter(const StringPiece& data) : mData(data) {
- if (util::stringStartsWith(mData, kPngSignature)) {
- mWindowStart = 0;
- mWindowEnd = strlen(kPngSignature);
+PngChunkFilter::PngChunkFilter(const StringPiece& data) : data_(data) {
+ if (util::StartsWith(data_, kPngSignature)) {
+ window_start_ = 0;
+ window_end_ = strlen(kPngSignature);
} else {
- mError = true;
+ error_ = true;
}
}
-bool PngChunkFilter::consumeWindow(const void** buffer, int* len) {
- if (mWindowStart != mWindowEnd) {
+bool PngChunkFilter::ConsumeWindow(const void** buffer, int* len) {
+ if (window_start_ != window_end_) {
// We have bytes to give from our window.
- const int bytesRead = (int)(mWindowEnd - mWindowStart);
- *buffer = mData.data() + mWindowStart;
- *len = bytesRead;
- mWindowStart = mWindowEnd;
+ const int bytes_read = (int)(window_end_ - window_start_);
+ *buffer = data_.data() + window_start_;
+ *len = bytes_read;
+ window_start_ = window_end_;
return true;
}
return false;
}
bool PngChunkFilter::Next(const void** buffer, int* len) {
- if (mError) {
+ if (error_) {
return false;
}
// In case BackUp was called, we must consume the window.
- if (consumeWindow(buffer, len)) {
+ if (ConsumeWindow(buffer, len)) {
return true;
}
// Advance the window as far as possible (until we meet a chunk that
// we want to strip).
- while (mWindowEnd < mData.size()) {
+ while (window_end_ < data_.size()) {
// Chunk length (4 bytes) + type (4 bytes) + crc32 (4 bytes) = 12 bytes.
const size_t kMinChunkHeaderSize = 3 * sizeof(uint32_t);
// Is there enough room for a chunk header?
- if (mData.size() - mWindowStart < kMinChunkHeaderSize) {
- mError = true;
+ if (data_.size() - window_start_ < kMinChunkHeaderSize) {
+ error_ = true;
return false;
}
// Verify the chunk length.
- const uint32_t chunkLen = peek32LE(mData.data() + mWindowEnd);
- if (((uint64_t)chunkLen) + ((uint64_t)mWindowEnd) + sizeof(uint32_t) >
- mData.size()) {
+ const uint32_t chunk_len = Peek32LE(data_.data() + window_end_);
+ if (((uint64_t)chunk_len) + ((uint64_t)window_end_) + sizeof(uint32_t) >
+ data_.size()) {
// Overflow.
- mError = true;
+ error_ = true;
return false;
}
// Do we strip this chunk?
- const uint32_t chunkType =
- peek32LE(mData.data() + mWindowEnd + sizeof(uint32_t));
- if (isPngChunkWhitelisted(chunkType)) {
+ const uint32_t chunk_type =
+ Peek32LE(data_.data() + window_end_ + sizeof(uint32_t));
+ if (IsPngChunkWhitelisted(chunk_type)) {
// Advance the window to include this chunk.
- mWindowEnd += kMinChunkHeaderSize + chunkLen;
+ window_end_ += kMinChunkHeaderSize + chunk_len;
} else {
// We want to strip this chunk. If we accumulated a window,
// we must return the window now.
- if (mWindowStart != mWindowEnd) {
+ if (window_start_ != window_end_) {
break;
}
// The window is empty, so we can advance past this chunk
// and keep looking for the next good chunk,
- mWindowEnd += kMinChunkHeaderSize + chunkLen;
- mWindowStart = mWindowEnd;
+ window_end_ += kMinChunkHeaderSize + chunk_len;
+ window_start_ = window_end_;
}
}
- if (consumeWindow(buffer, len)) {
+ if (ConsumeWindow(buffer, len)) {
return true;
}
return false;
}
void PngChunkFilter::BackUp(int count) {
- if (mError) {
+ if (error_) {
return;
}
- mWindowStart -= count;
+ window_start_ -= count;
}
bool PngChunkFilter::Skip(int count) {
- if (mError) {
+ if (error_) {
return false;
}
diff --git a/tools/aapt2/compile/PngCrunch.cpp b/tools/aapt2/compile/PngCrunch.cpp
index 4a74f7af7..3b46d8b 100644
--- a/tools/aapt2/compile/PngCrunch.cpp
+++ b/tools/aapt2/compile/PngCrunch.cpp
@@ -16,14 +16,17 @@
#include "compile/Png.h"
-#include <android-base/errors.h>
-#include <android-base/macros.h>
#include <png.h>
#include <zlib.h>
+
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
+#include "android-base/errors.h"
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
namespace aapt {
// Size in bytes of the PNG signature.
@@ -34,16 +37,16 @@
*/
class PngReadStructDeleter {
public:
- explicit PngReadStructDeleter(png_structp readPtr, png_infop infoPtr)
- : mReadPtr(readPtr), mInfoPtr(infoPtr) {}
+ PngReadStructDeleter(png_structp read_ptr, png_infop info_ptr)
+ : read_ptr_(read_ptr), info_ptr_(info_ptr) {}
~PngReadStructDeleter() {
- png_destroy_read_struct(&mReadPtr, &mInfoPtr, nullptr);
+ png_destroy_read_struct(&read_ptr_, &info_ptr_, nullptr);
}
private:
- png_structp mReadPtr;
- png_infop mInfoPtr;
+ png_structp read_ptr_;
+ png_infop info_ptr_;
DISALLOW_COPY_AND_ASSIGN(PngReadStructDeleter);
};
@@ -53,226 +56,229 @@
*/
class PngWriteStructDeleter {
public:
- explicit PngWriteStructDeleter(png_structp writePtr, png_infop infoPtr)
- : mWritePtr(writePtr), mInfoPtr(infoPtr) {}
+ PngWriteStructDeleter(png_structp write_ptr, png_infop info_ptr)
+ : write_ptr_(write_ptr), info_ptr_(info_ptr) {}
- ~PngWriteStructDeleter() { png_destroy_write_struct(&mWritePtr, &mInfoPtr); }
+ ~PngWriteStructDeleter() {
+ png_destroy_write_struct(&write_ptr_, &info_ptr_);
+ }
private:
- png_structp mWritePtr;
- png_infop mInfoPtr;
+ png_structp write_ptr_;
+ png_infop info_ptr_;
DISALLOW_COPY_AND_ASSIGN(PngWriteStructDeleter);
};
// Custom warning logging method that uses IDiagnostics.
-static void logWarning(png_structp pngPtr, png_const_charp warningMsg) {
- IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(pngPtr);
- diag->warn(DiagMessage() << warningMsg);
+static void LogWarning(png_structp png_ptr, png_const_charp warning_msg) {
+ IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(png_ptr);
+ diag->Warn(DiagMessage() << warning_msg);
}
// Custom error logging method that uses IDiagnostics.
-static void logError(png_structp pngPtr, png_const_charp errorMsg) {
- IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(pngPtr);
- diag->error(DiagMessage() << errorMsg);
+static void LogError(png_structp png_ptr, png_const_charp error_msg) {
+ IDiagnostics* diag = (IDiagnostics*)png_get_error_ptr(png_ptr);
+ diag->Error(DiagMessage() << error_msg);
}
-static void readDataFromStream(png_structp pngPtr, png_bytep buffer,
+static void ReadDataFromStream(png_structp png_ptr, png_bytep buffer,
png_size_t len) {
- io::InputStream* in = (io::InputStream*)png_get_io_ptr(pngPtr);
+ io::InputStream* in = (io::InputStream*)png_get_io_ptr(png_ptr);
- const void* inBuffer;
- int inLen;
- if (!in->Next(&inBuffer, &inLen)) {
+ const void* in_buffer;
+ int in_len;
+ if (!in->Next(&in_buffer, &in_len)) {
if (in->HadError()) {
std::string err = in->GetError();
- png_error(pngPtr, err.c_str());
+ png_error(png_ptr, err.c_str());
}
return;
}
- const size_t bytesRead = std::min(static_cast<size_t>(inLen), len);
- memcpy(buffer, inBuffer, bytesRead);
- if (bytesRead != static_cast<size_t>(inLen)) {
- in->BackUp(inLen - static_cast<int>(bytesRead));
+ const size_t bytes_read = std::min(static_cast<size_t>(in_len), len);
+ memcpy(buffer, in_buffer, bytes_read);
+ if (bytes_read != static_cast<size_t>(in_len)) {
+ in->BackUp(in_len - static_cast<int>(bytes_read));
}
}
-static void writeDataToStream(png_structp pngPtr, png_bytep buffer,
+static void WriteDataToStream(png_structp png_ptr, png_bytep buffer,
png_size_t len) {
- io::OutputStream* out = (io::OutputStream*)png_get_io_ptr(pngPtr);
+ io::OutputStream* out = (io::OutputStream*)png_get_io_ptr(png_ptr);
- void* outBuffer;
- int outLen;
+ void* out_buffer;
+ int out_len;
while (len > 0) {
- if (!out->Next(&outBuffer, &outLen)) {
+ if (!out->Next(&out_buffer, &out_len)) {
if (out->HadError()) {
std::string err = out->GetError();
- png_error(pngPtr, err.c_str());
+ png_error(png_ptr, err.c_str());
}
return;
}
- const size_t bytesWritten = std::min(static_cast<size_t>(outLen), len);
- memcpy(outBuffer, buffer, bytesWritten);
+ const size_t bytes_written = std::min(static_cast<size_t>(out_len), len);
+ memcpy(out_buffer, buffer, bytes_written);
// Advance the input buffer.
- buffer += bytesWritten;
- len -= bytesWritten;
+ buffer += bytes_written;
+ len -= bytes_written;
// Advance the output buffer.
- outLen -= static_cast<int>(bytesWritten);
+ out_len -= static_cast<int>(bytes_written);
}
// If the entire output buffer wasn't used, backup.
- if (outLen > 0) {
- out->BackUp(outLen);
+ if (out_len > 0) {
+ out->BackUp(out_len);
}
}
-std::unique_ptr<Image> readPng(IAaptContext* context, io::InputStream* in) {
+std::unique_ptr<Image> ReadPng(IAaptContext* context, io::InputStream* in) {
// Read the first 8 bytes of the file looking for the PNG signature.
// Bail early if it does not match.
const png_byte* signature;
- int bufferSize;
- if (!in->Next((const void**)&signature, &bufferSize)) {
- context->getDiagnostics()->error(
+ int buffer_size;
+ if (!in->Next((const void**)&signature, &buffer_size)) {
+ context->GetDiagnostics()->Error(
DiagMessage() << android::base::SystemErrorCodeToString(errno));
return {};
}
- if (static_cast<size_t>(bufferSize) < kPngSignatureSize ||
+ if (static_cast<size_t>(buffer_size) < kPngSignatureSize ||
png_sig_cmp(signature, 0, kPngSignatureSize) != 0) {
- context->getDiagnostics()->error(
+ context->GetDiagnostics()->Error(
DiagMessage() << "file signature does not match PNG signature");
return {};
}
// Start at the beginning of the first chunk.
- in->BackUp(bufferSize - static_cast<int>(kPngSignatureSize));
+ in->BackUp(buffer_size - static_cast<int>(kPngSignatureSize));
// Create and initialize the png_struct with the default error and warning
// handlers.
// The header version is also passed in to ensure that this was built against
// the same
// version of libpng.
- png_structp readPtr =
+ png_structp read_ptr =
png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
- if (readPtr == nullptr) {
- context->getDiagnostics()->error(
+ if (read_ptr == nullptr) {
+ context->GetDiagnostics()->Error(
DiagMessage() << "failed to create libpng read png_struct");
return {};
}
// Create and initialize the memory for image header and data.
- png_infop infoPtr = png_create_info_struct(readPtr);
- if (infoPtr == nullptr) {
- context->getDiagnostics()->error(
+ png_infop info_ptr = png_create_info_struct(read_ptr);
+ if (info_ptr == nullptr) {
+ context->GetDiagnostics()->Error(
DiagMessage() << "failed to create libpng read png_info");
- png_destroy_read_struct(&readPtr, nullptr, nullptr);
+ png_destroy_read_struct(&read_ptr, nullptr, nullptr);
return {};
}
// Automatically release PNG resources at end of scope.
- PngReadStructDeleter pngReadDeleter(readPtr, infoPtr);
+ PngReadStructDeleter png_read_deleter(read_ptr, info_ptr);
// libpng uses longjmp to jump to an error handling routine.
// setjmp will only return true if it was jumped to, aka there was
// an error.
- if (setjmp(png_jmpbuf(readPtr))) {
+ if (setjmp(png_jmpbuf(read_ptr))) {
return {};
}
// Handle warnings ourselves via IDiagnostics.
- png_set_error_fn(readPtr, (png_voidp)context->getDiagnostics(), logError,
- logWarning);
+ png_set_error_fn(read_ptr, (png_voidp)context->GetDiagnostics(), LogError,
+ LogWarning);
// Set up the read functions which read from our custom data sources.
- png_set_read_fn(readPtr, (png_voidp)in, readDataFromStream);
+ png_set_read_fn(read_ptr, (png_voidp)in, ReadDataFromStream);
// Skip the signature that we already read.
- png_set_sig_bytes(readPtr, kPngSignatureSize);
+ png_set_sig_bytes(read_ptr, kPngSignatureSize);
// Read the chunk headers.
- png_read_info(readPtr, infoPtr);
+ png_read_info(read_ptr, info_ptr);
// Extract image meta-data from the various chunk headers.
uint32_t width, height;
- int bitDepth, colorType, interlaceMethod, compressionMethod, filterMethod;
- png_get_IHDR(readPtr, infoPtr, &width, &height, &bitDepth, &colorType,
- &interlaceMethod, &compressionMethod, &filterMethod);
+ int bit_depth, color_type, interlace_method, compression_method,
+ filter_method;
+ png_get_IHDR(read_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
+ &interlace_method, &compression_method, &filter_method);
// When the image is read, expand it so that it is in RGBA 8888 format
// so that image handling is uniform.
- if (colorType == PNG_COLOR_TYPE_PALETTE) {
- png_set_palette_to_rgb(readPtr);
+ if (color_type == PNG_COLOR_TYPE_PALETTE) {
+ png_set_palette_to_rgb(read_ptr);
}
- if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8) {
- png_set_expand_gray_1_2_4_to_8(readPtr);
+ if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
+ png_set_expand_gray_1_2_4_to_8(read_ptr);
}
- if (png_get_valid(readPtr, infoPtr, PNG_INFO_tRNS)) {
- png_set_tRNS_to_alpha(readPtr);
+ if (png_get_valid(read_ptr, info_ptr, PNG_INFO_tRNS)) {
+ png_set_tRNS_to_alpha(read_ptr);
}
- if (bitDepth == 16) {
- png_set_strip_16(readPtr);
+ if (bit_depth == 16) {
+ png_set_strip_16(read_ptr);
}
- if (!(colorType & PNG_COLOR_MASK_ALPHA)) {
- png_set_add_alpha(readPtr, 0xFF, PNG_FILLER_AFTER);
+ if (!(color_type & PNG_COLOR_MASK_ALPHA)) {
+ png_set_add_alpha(read_ptr, 0xFF, PNG_FILLER_AFTER);
}
- if (colorType == PNG_COLOR_TYPE_GRAY ||
- colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
- png_set_gray_to_rgb(readPtr);
+ if (color_type == PNG_COLOR_TYPE_GRAY ||
+ color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+ png_set_gray_to_rgb(read_ptr);
}
- if (interlaceMethod != PNG_INTERLACE_NONE) {
- png_set_interlace_handling(readPtr);
+ if (interlace_method != PNG_INTERLACE_NONE) {
+ png_set_interlace_handling(read_ptr);
}
// Once all the options for reading have been set, we need to flush
// them to libpng.
- png_read_update_info(readPtr, infoPtr);
+ png_read_update_info(read_ptr, info_ptr);
// 9-patch uses int32_t to index images, so we cap the image dimensions to
// something
// that can always be represented by 9-patch.
if (width > std::numeric_limits<int32_t>::max() ||
height > std::numeric_limits<int32_t>::max()) {
- context->getDiagnostics()->error(DiagMessage()
+ context->GetDiagnostics()->Error(DiagMessage()
<< "PNG image dimensions are too large: "
<< width << "x" << height);
return {};
}
- std::unique_ptr<Image> outputImage = util::make_unique<Image>();
- outputImage->width = static_cast<int32_t>(width);
- outputImage->height = static_cast<int32_t>(height);
+ std::unique_ptr<Image> output_image = util::make_unique<Image>();
+ output_image->width = static_cast<int32_t>(width);
+ output_image->height = static_cast<int32_t>(height);
- const size_t rowBytes = png_get_rowbytes(readPtr, infoPtr);
- assert(rowBytes == 4 * width); // RGBA
+ const size_t row_bytes = png_get_rowbytes(read_ptr, info_ptr);
+ CHECK(row_bytes == 4 * width); // RGBA
// Allocate one large block to hold the image.
- outputImage->data =
- std::unique_ptr<uint8_t[]>(new uint8_t[height * rowBytes]);
+ output_image->data =
+ std::unique_ptr<uint8_t[]>(new uint8_t[height * row_bytes]);
// Create an array of rows that index into the data block.
- outputImage->rows = std::unique_ptr<uint8_t* []>(new uint8_t*[height]);
+ output_image->rows = std::unique_ptr<uint8_t* []>(new uint8_t*[height]);
for (uint32_t h = 0; h < height; h++) {
- outputImage->rows[h] = outputImage->data.get() + (h * rowBytes);
+ output_image->rows[h] = output_image->data.get() + (h * row_bytes);
}
// Actually read the image pixels.
- png_read_image(readPtr, outputImage->rows.get());
+ png_read_image(read_ptr, output_image->rows.get());
// Finish reading. This will read any other chunks after the image data.
- png_read_end(readPtr, infoPtr);
+ png_read_end(read_ptr, info_ptr);
- return outputImage;
+ return output_image;
}
/**
@@ -309,57 +315,58 @@
// - Grayscale + cheap alpha
// - Grayscale + alpha
//
-static int pickColorType(int32_t width, int32_t height, bool grayScale,
- bool convertibleToGrayScale, bool hasNinePatch,
- size_t colorPaletteSize, size_t alphaPaletteSize) {
- const size_t paletteChunkSize = 16 + colorPaletteSize * 3;
- const size_t alphaChunkSize = 16 + alphaPaletteSize;
- const size_t colorAlphaDataChunkSize = 16 + 4 * width * height;
- const size_t colorDataChunkSize = 16 + 3 * width * height;
- const size_t grayScaleAlphaDataChunkSize = 16 + 2 * width * height;
- const size_t paletteDataChunkSize = 16 + width * height;
+static int PickColorType(int32_t width, int32_t height, bool grayscale,
+ bool convertible_to_grayscale, bool has_nine_patch,
+ size_t color_palette_size, size_t alpha_palette_size) {
+ const size_t palette_chunk_size = 16 + color_palette_size * 3;
+ const size_t alpha_chunk_size = 16 + alpha_palette_size;
+ const size_t color_alpha_data_chunk_size = 16 + 4 * width * height;
+ const size_t color_data_chunk_size = 16 + 3 * width * height;
+ const size_t grayscale_alpha_data_chunk_size = 16 + 2 * width * height;
+ const size_t palette_data_chunk_size = 16 + width * height;
- if (grayScale) {
- if (alphaPaletteSize == 0) {
+ if (grayscale) {
+ if (alpha_palette_size == 0) {
// This is the smallest the data can be.
return PNG_COLOR_TYPE_GRAY;
- } else if (colorPaletteSize <= 256 && !hasNinePatch) {
+ } else if (color_palette_size <= 256 && !has_nine_patch) {
// This grayscale has alpha and can fit within a palette.
// See if it is worth fitting into a palette.
- const size_t paletteThreshold = paletteChunkSize + alphaChunkSize +
- paletteDataChunkSize +
- kPaletteOverheadConstant;
- if (grayScaleAlphaDataChunkSize > paletteThreshold) {
+ const size_t palette_threshold = palette_chunk_size + alpha_chunk_size +
+ palette_data_chunk_size +
+ kPaletteOverheadConstant;
+ if (grayscale_alpha_data_chunk_size > palette_threshold) {
return PNG_COLOR_TYPE_PALETTE;
}
}
return PNG_COLOR_TYPE_GRAY_ALPHA;
}
- if (colorPaletteSize <= 256 && !hasNinePatch) {
+ if (color_palette_size <= 256 && !has_nine_patch) {
// This image can fit inside a palette. Let's see if it is worth it.
- size_t totalSizeWithPalette = paletteDataChunkSize + paletteChunkSize;
- size_t totalSizeWithoutPalette = colorDataChunkSize;
- if (alphaPaletteSize > 0) {
- totalSizeWithPalette += alphaPaletteSize;
- totalSizeWithoutPalette = colorAlphaDataChunkSize;
+ size_t total_size_with_palette =
+ palette_data_chunk_size + palette_chunk_size;
+ size_t total_size_without_palette = color_data_chunk_size;
+ if (alpha_palette_size > 0) {
+ total_size_with_palette += alpha_palette_size;
+ total_size_without_palette = color_alpha_data_chunk_size;
}
- if (totalSizeWithoutPalette >
- totalSizeWithPalette + kPaletteOverheadConstant) {
+ if (total_size_without_palette >
+ total_size_with_palette + kPaletteOverheadConstant) {
return PNG_COLOR_TYPE_PALETTE;
}
}
- if (convertibleToGrayScale) {
- if (alphaPaletteSize == 0) {
+ if (convertible_to_grayscale) {
+ if (alpha_palette_size == 0) {
return PNG_COLOR_TYPE_GRAY;
} else {
return PNG_COLOR_TYPE_GRAY_ALPHA;
}
}
- if (alphaPaletteSize == 0) {
+ if (alpha_palette_size == 0) {
return PNG_COLOR_TYPE_RGB;
}
return PNG_COLOR_TYPE_RGBA;
@@ -371,11 +378,11 @@
// This must be done before writing image data.
// Image data must be transformed to use the indices assigned within the
// palette.
-static void writePalette(png_structp writePtr, png_infop writeInfoPtr,
- std::unordered_map<uint32_t, int>* colorPalette,
- std::unordered_set<uint32_t>* alphaPalette) {
- assert(colorPalette->size() <= 256);
- assert(alphaPalette->size() <= 256);
+static void WritePalette(png_structp write_ptr, png_infop write_info_ptr,
+ std::unordered_map<uint32_t, int>* color_palette,
+ std::unordered_set<uint32_t>* alpha_palette) {
+ CHECK(color_palette->size() <= 256);
+ CHECK(alpha_palette->size() <= 256);
// Populate the PNG palette struct and assign indices to the color
// palette.
@@ -384,160 +391,161 @@
// This will ensure that we can truncate the alpha palette if it is
// smaller than the color palette.
int index = 0;
- for (uint32_t color : *alphaPalette) {
- (*colorPalette)[color] = index++;
+ for (uint32_t color : *alpha_palette) {
+ (*color_palette)[color] = index++;
}
// Assign the rest of the entries.
- for (auto& entry : *colorPalette) {
+ for (auto& entry : *color_palette) {
if (entry.second == -1) {
entry.second = index++;
}
}
// Create the PNG color palette struct.
- auto colorPaletteBytes =
- std::unique_ptr<png_color[]>(new png_color[colorPalette->size()]);
+ auto color_palette_bytes =
+ std::unique_ptr<png_color[]>(new png_color[color_palette->size()]);
- std::unique_ptr<png_byte[]> alphaPaletteBytes;
- if (!alphaPalette->empty()) {
- alphaPaletteBytes =
- std::unique_ptr<png_byte[]>(new png_byte[alphaPalette->size()]);
+ std::unique_ptr<png_byte[]> alpha_palette_bytes;
+ if (!alpha_palette->empty()) {
+ alpha_palette_bytes =
+ std::unique_ptr<png_byte[]>(new png_byte[alpha_palette->size()]);
}
- for (const auto& entry : *colorPalette) {
+ for (const auto& entry : *color_palette) {
const uint32_t color = entry.first;
const int index = entry.second;
- assert(index >= 0);
- assert(static_cast<size_t>(index) < colorPalette->size());
+ CHECK(index >= 0);
+ CHECK(static_cast<size_t>(index) < color_palette->size());
- png_colorp slot = colorPaletteBytes.get() + index;
+ png_colorp slot = color_palette_bytes.get() + index;
slot->red = color >> 24;
slot->green = color >> 16;
slot->blue = color >> 8;
const png_byte alpha = color & 0x000000ff;
- if (alpha != 0xff && alphaPaletteBytes) {
- assert(static_cast<size_t>(index) < alphaPalette->size());
- alphaPaletteBytes[index] = alpha;
+ if (alpha != 0xff && alpha_palette_bytes) {
+ CHECK(static_cast<size_t>(index) < alpha_palette->size());
+ alpha_palette_bytes[index] = alpha;
}
}
- // The bytes get copied here, so it is safe to release colorPaletteBytes at
+ // The bytes get copied here, so it is safe to release color_palette_bytes at
// the end of function
// scope.
- png_set_PLTE(writePtr, writeInfoPtr, colorPaletteBytes.get(),
- colorPalette->size());
+ png_set_PLTE(write_ptr, write_info_ptr, color_palette_bytes.get(),
+ color_palette->size());
- if (alphaPaletteBytes) {
- png_set_tRNS(writePtr, writeInfoPtr, alphaPaletteBytes.get(),
- alphaPalette->size(), nullptr);
+ if (alpha_palette_bytes) {
+ png_set_tRNS(write_ptr, write_info_ptr, alpha_palette_bytes.get(),
+ alpha_palette->size(), nullptr);
}
}
-// Write the 9-patch custom PNG chunks to writeInfoPtr. This must be done before
+// Write the 9-patch custom PNG chunks to write_info_ptr. This must be done
+// before
// writing image data.
-static void writeNinePatch(png_structp writePtr, png_infop writeInfoPtr,
- const NinePatch* ninePatch) {
+static void WriteNinePatch(png_structp write_ptr, png_infop write_info_ptr,
+ const NinePatch* nine_patch) {
// The order of the chunks is important.
// 9-patch code in older platforms expects the 9-patch chunk to
// be last.
- png_unknown_chunk unknownChunks[3];
- memset(unknownChunks, 0, sizeof(unknownChunks));
+ png_unknown_chunk unknown_chunks[3];
+ memset(unknown_chunks, 0, sizeof(unknown_chunks));
size_t index = 0;
- size_t chunkLen = 0;
+ size_t chunk_len = 0;
- std::unique_ptr<uint8_t[]> serializedOutline =
- ninePatch->serializeRoundedRectOutline(&chunkLen);
- strcpy((char*)unknownChunks[index].name, "npOl");
- unknownChunks[index].size = chunkLen;
- unknownChunks[index].data = (png_bytep)serializedOutline.get();
- unknownChunks[index].location = PNG_HAVE_PLTE;
+ std::unique_ptr<uint8_t[]> serialized_outline =
+ nine_patch->SerializeRoundedRectOutline(&chunk_len);
+ strcpy((char*)unknown_chunks[index].name, "npOl");
+ unknown_chunks[index].size = chunk_len;
+ unknown_chunks[index].data = (png_bytep)serialized_outline.get();
+ unknown_chunks[index].location = PNG_HAVE_PLTE;
index++;
- std::unique_ptr<uint8_t[]> serializedLayoutBounds;
- if (ninePatch->layoutBounds.nonZero()) {
- serializedLayoutBounds = ninePatch->serializeLayoutBounds(&chunkLen);
- strcpy((char*)unknownChunks[index].name, "npLb");
- unknownChunks[index].size = chunkLen;
- unknownChunks[index].data = (png_bytep)serializedLayoutBounds.get();
- unknownChunks[index].location = PNG_HAVE_PLTE;
+ std::unique_ptr<uint8_t[]> serialized_layout_bounds;
+ if (nine_patch->layout_bounds.nonZero()) {
+ serialized_layout_bounds = nine_patch->SerializeLayoutBounds(&chunk_len);
+ strcpy((char*)unknown_chunks[index].name, "npLb");
+ unknown_chunks[index].size = chunk_len;
+ unknown_chunks[index].data = (png_bytep)serialized_layout_bounds.get();
+ unknown_chunks[index].location = PNG_HAVE_PLTE;
index++;
}
- std::unique_ptr<uint8_t[]> serializedNinePatch =
- ninePatch->serializeBase(&chunkLen);
- strcpy((char*)unknownChunks[index].name, "npTc");
- unknownChunks[index].size = chunkLen;
- unknownChunks[index].data = (png_bytep)serializedNinePatch.get();
- unknownChunks[index].location = PNG_HAVE_PLTE;
+ std::unique_ptr<uint8_t[]> serialized_nine_patch =
+ nine_patch->SerializeBase(&chunk_len);
+ strcpy((char*)unknown_chunks[index].name, "npTc");
+ unknown_chunks[index].size = chunk_len;
+ unknown_chunks[index].data = (png_bytep)serialized_nine_patch.get();
+ unknown_chunks[index].location = PNG_HAVE_PLTE;
index++;
// Handle all unknown chunks. We are manually setting the chunks here,
// so we will only ever handle our custom chunks.
- png_set_keep_unknown_chunks(writePtr, PNG_HANDLE_CHUNK_ALWAYS, nullptr, 0);
+ png_set_keep_unknown_chunks(write_ptr, PNG_HANDLE_CHUNK_ALWAYS, nullptr, 0);
// Set the actual chunks here. The data gets copied, so our buffers can
// safely go out of scope.
- png_set_unknown_chunks(writePtr, writeInfoPtr, unknownChunks, index);
+ png_set_unknown_chunks(write_ptr, write_info_ptr, unknown_chunks, index);
}
-bool writePng(IAaptContext* context, const Image* image,
- const NinePatch* ninePatch, io::OutputStream* out,
+bool WritePng(IAaptContext* context, const Image* image,
+ const NinePatch* nine_patch, io::OutputStream* out,
const PngOptions& options) {
// Create and initialize the write png_struct with the default error and
// warning handlers.
// The header version is also passed in to ensure that this was built against
// the same
// version of libpng.
- png_structp writePtr =
+ png_structp write_ptr =
png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
- if (writePtr == nullptr) {
- context->getDiagnostics()->error(
+ if (write_ptr == nullptr) {
+ context->GetDiagnostics()->Error(
DiagMessage() << "failed to create libpng write png_struct");
return false;
}
// Allocate memory to store image header data.
- png_infop writeInfoPtr = png_create_info_struct(writePtr);
- if (writeInfoPtr == nullptr) {
- context->getDiagnostics()->error(
+ png_infop write_info_ptr = png_create_info_struct(write_ptr);
+ if (write_info_ptr == nullptr) {
+ context->GetDiagnostics()->Error(
DiagMessage() << "failed to create libpng write png_info");
- png_destroy_write_struct(&writePtr, nullptr);
+ png_destroy_write_struct(&write_ptr, nullptr);
return false;
}
// Automatically release PNG resources at end of scope.
- PngWriteStructDeleter pngWriteDeleter(writePtr, writeInfoPtr);
+ PngWriteStructDeleter png_write_deleter(write_ptr, write_info_ptr);
// libpng uses longjmp to jump to error handling routines.
// setjmp will return true only if it was jumped to, aka, there was an error.
- if (setjmp(png_jmpbuf(writePtr))) {
+ if (setjmp(png_jmpbuf(write_ptr))) {
return false;
}
// Handle warnings with our IDiagnostics.
- png_set_error_fn(writePtr, (png_voidp)context->getDiagnostics(), logError,
- logWarning);
+ png_set_error_fn(write_ptr, (png_voidp)context->GetDiagnostics(), LogError,
+ LogWarning);
// Set up the write functions which write to our custom data sources.
- png_set_write_fn(writePtr, (png_voidp)out, writeDataToStream, nullptr);
+ png_set_write_fn(write_ptr, (png_voidp)out, WriteDataToStream, nullptr);
// We want small files and can take the performance hit to achieve this goal.
- png_set_compression_level(writePtr, Z_BEST_COMPRESSION);
+ png_set_compression_level(write_ptr, Z_BEST_COMPRESSION);
// Begin analysis of the image data.
// Scan the entire image and determine if:
// 1. Every pixel has R == G == B (grayscale)
// 2. Every pixel has A == 255 (opaque)
// 3. There are no more than 256 distinct RGBA colors (palette).
- std::unordered_map<uint32_t, int> colorPalette;
- std::unordered_set<uint32_t> alphaPalette;
- bool needsToZeroRGBChannelsOfTransparentPixels = false;
- bool grayScale = true;
- int maxGrayDeviation = 0;
+ std::unordered_map<uint32_t, int> color_palette;
+ std::unordered_set<uint32_t> alpha_palette;
+ bool needs_to_zero_rgb_channels_of_transparent_pixels = false;
+ bool grayscale = true;
+ int max_gray_deviation = 0;
for (int32_t y = 0; y < image->height; y++) {
const uint8_t* row = image->rows[y];
@@ -551,60 +559,60 @@
// The color is completely transparent.
// For purposes of palettes and grayscale optimization,
// treat all channels as 0x00.
- needsToZeroRGBChannelsOfTransparentPixels =
- needsToZeroRGBChannelsOfTransparentPixels ||
+ needs_to_zero_rgb_channels_of_transparent_pixels =
+ needs_to_zero_rgb_channels_of_transparent_pixels ||
(red != 0 || green != 0 || blue != 0);
red = green = blue = 0;
}
// Insert the color into the color palette.
const uint32_t color = red << 24 | green << 16 | blue << 8 | alpha;
- colorPalette[color] = -1;
+ color_palette[color] = -1;
// If the pixel has non-opaque alpha, insert it into the
// alpha palette.
if (alpha != 0xff) {
- alphaPalette.insert(color);
+ alpha_palette.insert(color);
}
// Check if the image is indeed grayscale.
- if (grayScale) {
+ if (grayscale) {
if (red != green || red != blue) {
- grayScale = false;
+ grayscale = false;
}
}
// Calculate the gray scale deviation so that it can be compared
// with the threshold.
- maxGrayDeviation = std::max(std::abs(red - green), maxGrayDeviation);
- maxGrayDeviation = std::max(std::abs(green - blue), maxGrayDeviation);
- maxGrayDeviation = std::max(std::abs(blue - red), maxGrayDeviation);
+ max_gray_deviation = std::max(std::abs(red - green), max_gray_deviation);
+ max_gray_deviation = std::max(std::abs(green - blue), max_gray_deviation);
+ max_gray_deviation = std::max(std::abs(blue - red), max_gray_deviation);
}
}
- if (context->verbose()) {
+ if (context->IsVerbose()) {
DiagMessage msg;
- msg << " paletteSize=" << colorPalette.size()
- << " alphaPaletteSize=" << alphaPalette.size()
- << " maxGrayDeviation=" << maxGrayDeviation
- << " grayScale=" << (grayScale ? "true" : "false");
- context->getDiagnostics()->note(msg);
+ msg << " paletteSize=" << color_palette.size()
+ << " alphaPaletteSize=" << alpha_palette.size()
+ << " maxGrayDeviation=" << max_gray_deviation
+ << " grayScale=" << (grayscale ? "true" : "false");
+ context->GetDiagnostics()->Note(msg);
}
- const bool convertibleToGrayScale =
- maxGrayDeviation <= options.grayScaleTolerance;
+ const bool convertible_to_grayscale =
+ max_gray_deviation <= options.grayscale_tolerance;
- const int newColorType = pickColorType(
- image->width, image->height, grayScale, convertibleToGrayScale,
- ninePatch != nullptr, colorPalette.size(), alphaPalette.size());
+ const int new_color_type = PickColorType(
+ image->width, image->height, grayscale, convertible_to_grayscale,
+ nine_patch != nullptr, color_palette.size(), alpha_palette.size());
- if (context->verbose()) {
+ if (context->IsVerbose()) {
DiagMessage msg;
msg << "encoding PNG ";
- if (ninePatch) {
+ if (nine_patch) {
msg << "(with 9-patch) as ";
}
- switch (newColorType) {
+ switch (new_color_type) {
case PNG_COLOR_TYPE_GRAY:
msg << "GRAY";
break;
@@ -621,137 +629,138 @@
msg << "PALETTE";
break;
default:
- msg << "unknown type " << newColorType;
+ msg << "unknown type " << new_color_type;
break;
}
- context->getDiagnostics()->note(msg);
+ context->GetDiagnostics()->Note(msg);
}
- png_set_IHDR(writePtr, writeInfoPtr, image->width, image->height, 8,
- newColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+ png_set_IHDR(write_ptr, write_info_ptr, image->width, image->height, 8,
+ new_color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
- if (newColorType & PNG_COLOR_MASK_PALETTE) {
+ if (new_color_type & PNG_COLOR_MASK_PALETTE) {
// Assigns indices to the palette, and writes the encoded palette to the
// libpng writePtr.
- writePalette(writePtr, writeInfoPtr, &colorPalette, &alphaPalette);
- png_set_filter(writePtr, 0, PNG_NO_FILTERS);
+ WritePalette(write_ptr, write_info_ptr, &color_palette, &alpha_palette);
+ png_set_filter(write_ptr, 0, PNG_NO_FILTERS);
} else {
- png_set_filter(writePtr, 0, PNG_ALL_FILTERS);
+ png_set_filter(write_ptr, 0, PNG_ALL_FILTERS);
}
- if (ninePatch) {
- writeNinePatch(writePtr, writeInfoPtr, ninePatch);
+ if (nine_patch) {
+ WriteNinePatch(write_ptr, write_info_ptr, nine_patch);
}
// Flush our updates to the header.
- png_write_info(writePtr, writeInfoPtr);
+ png_write_info(write_ptr, write_info_ptr);
// Write out each row of image data according to its encoding.
- if (newColorType == PNG_COLOR_TYPE_PALETTE) {
+ if (new_color_type == PNG_COLOR_TYPE_PALETTE) {
// 1 byte/pixel.
- auto outRow = std::unique_ptr<png_byte[]>(new png_byte[image->width]);
+ auto out_row = std::unique_ptr<png_byte[]>(new png_byte[image->width]);
for (int32_t y = 0; y < image->height; y++) {
- png_const_bytep inRow = image->rows[y];
+ png_const_bytep in_row = image->rows[y];
for (int32_t x = 0; x < image->width; x++) {
- int rr = *inRow++;
- int gg = *inRow++;
- int bb = *inRow++;
- int aa = *inRow++;
+ int rr = *in_row++;
+ int gg = *in_row++;
+ int bb = *in_row++;
+ int aa = *in_row++;
if (aa == 0) {
// Zero out color channels when transparent.
rr = gg = bb = 0;
}
const uint32_t color = rr << 24 | gg << 16 | bb << 8 | aa;
- const int idx = colorPalette[color];
- assert(idx != -1);
- outRow[x] = static_cast<png_byte>(idx);
+ const int idx = color_palette[color];
+ CHECK(idx != -1);
+ out_row[x] = static_cast<png_byte>(idx);
}
- png_write_row(writePtr, outRow.get());
+ png_write_row(write_ptr, out_row.get());
}
- } else if (newColorType == PNG_COLOR_TYPE_GRAY ||
- newColorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
- const size_t bpp = newColorType == PNG_COLOR_TYPE_GRAY ? 1 : 2;
- auto outRow = std::unique_ptr<png_byte[]>(new png_byte[image->width * bpp]);
+ } else if (new_color_type == PNG_COLOR_TYPE_GRAY ||
+ new_color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+ const size_t bpp = new_color_type == PNG_COLOR_TYPE_GRAY ? 1 : 2;
+ auto out_row =
+ std::unique_ptr<png_byte[]>(new png_byte[image->width * bpp]);
for (int32_t y = 0; y < image->height; y++) {
- png_const_bytep inRow = image->rows[y];
+ png_const_bytep in_row = image->rows[y];
for (int32_t x = 0; x < image->width; x++) {
- int rr = inRow[x * 4];
- int gg = inRow[x * 4 + 1];
- int bb = inRow[x * 4 + 2];
- int aa = inRow[x * 4 + 3];
+ int rr = in_row[x * 4];
+ int gg = in_row[x * 4 + 1];
+ int bb = in_row[x * 4 + 2];
+ int aa = in_row[x * 4 + 3];
if (aa == 0) {
// Zero out the gray channel when transparent.
rr = gg = bb = 0;
}
- if (grayScale) {
+ if (grayscale) {
// The image was already grayscale, red == green == blue.
- outRow[x * bpp] = inRow[x * 4];
+ out_row[x * bpp] = in_row[x * 4];
} else {
// The image is convertible to grayscale, use linear-luminance of
// sRGB colorspace:
// https://en.wikipedia.org/wiki/Grayscale#Colorimetric_.28luminance-preserving.29_conversion_to_grayscale
- outRow[x * bpp] =
+ out_row[x * bpp] =
(png_byte)(rr * 0.2126f + gg * 0.7152f + bb * 0.0722f);
}
if (bpp == 2) {
// Write out alpha if we have it.
- outRow[x * bpp + 1] = aa;
+ out_row[x * bpp + 1] = aa;
}
}
- png_write_row(writePtr, outRow.get());
+ png_write_row(write_ptr, out_row.get());
}
- } else if (newColorType == PNG_COLOR_TYPE_RGB ||
- newColorType == PNG_COLOR_TYPE_RGBA) {
- const size_t bpp = newColorType == PNG_COLOR_TYPE_RGB ? 3 : 4;
- if (needsToZeroRGBChannelsOfTransparentPixels) {
+ } else if (new_color_type == PNG_COLOR_TYPE_RGB ||
+ new_color_type == PNG_COLOR_TYPE_RGBA) {
+ const size_t bpp = new_color_type == PNG_COLOR_TYPE_RGB ? 3 : 4;
+ if (needs_to_zero_rgb_channels_of_transparent_pixels) {
// The source RGBA data can't be used as-is, because we need to zero out
// the RGB
// values of transparent pixels.
- auto outRow =
+ auto out_row =
std::unique_ptr<png_byte[]>(new png_byte[image->width * bpp]);
for (int32_t y = 0; y < image->height; y++) {
- png_const_bytep inRow = image->rows[y];
+ png_const_bytep in_row = image->rows[y];
for (int32_t x = 0; x < image->width; x++) {
- int rr = *inRow++;
- int gg = *inRow++;
- int bb = *inRow++;
- int aa = *inRow++;
+ int rr = *in_row++;
+ int gg = *in_row++;
+ int bb = *in_row++;
+ int aa = *in_row++;
if (aa == 0) {
// Zero out the RGB channels when transparent.
rr = gg = bb = 0;
}
- outRow[x * bpp] = rr;
- outRow[x * bpp + 1] = gg;
- outRow[x * bpp + 2] = bb;
+ out_row[x * bpp] = rr;
+ out_row[x * bpp + 1] = gg;
+ out_row[x * bpp + 2] = bb;
if (bpp == 4) {
- outRow[x * bpp + 3] = aa;
+ out_row[x * bpp + 3] = aa;
}
}
- png_write_row(writePtr, outRow.get());
+ png_write_row(write_ptr, out_row.get());
}
} else {
// The source image can be used as-is, just tell libpng whether or not to
// ignore
// the alpha channel.
- if (newColorType == PNG_COLOR_TYPE_RGB) {
+ if (new_color_type == PNG_COLOR_TYPE_RGB) {
// Delete the extraneous alpha values that we appended to our buffer
// when reading the original values.
- png_set_filler(writePtr, 0, PNG_FILLER_AFTER);
+ png_set_filler(write_ptr, 0, PNG_FILLER_AFTER);
}
- png_write_image(writePtr, image->rows.get());
+ png_write_image(write_ptr, image->rows.get());
}
} else {
- assert(false && "unreachable");
+ LOG(FATAL) << "unreachable";
}
- png_write_end(writePtr, writeInfoPtr);
+ png_write_end(write_ptr, write_info_ptr);
return true;
}
diff --git a/tools/aapt2/compile/PseudolocaleGenerator.cpp b/tools/aapt2/compile/PseudolocaleGenerator.cpp
index d8ed0bb..055a725 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator.cpp
+++ b/tools/aapt2/compile/PseudolocaleGenerator.cpp
@@ -15,27 +15,29 @@
*/
#include "compile/PseudolocaleGenerator.h"
+
+#include <algorithm>
+
#include "ResourceTable.h"
#include "ResourceValues.h"
#include "ValueVisitor.h"
#include "compile/Pseudolocalizer.h"
-#include <algorithm>
-
namespace aapt {
-std::unique_ptr<StyledString> pseudolocalizeStyledString(
+std::unique_ptr<StyledString> PseudolocalizeStyledString(
StyledString* string, Pseudolocalizer::Method method, StringPool* pool) {
Pseudolocalizer localizer(method);
- const StringPiece originalText = *string->value->str;
+ const StringPiece original_text = *string->value->str;
StyleString localized;
// Copy the spans. We will update their offsets when we localize.
localized.spans.reserve(string->value->spans.size());
for (const StringPool::Span& span : string->value->spans) {
- localized.spans.push_back(Span{*span.name, span.firstChar, span.lastChar});
+ localized.spans.push_back(
+ Span{*span.name, span.first_char, span.last_char});
}
// The ranges are all represented with a single value. This is the start of
@@ -49,8 +51,8 @@
// Since this struct represents the start of one range and end of another,
// we have
// the two pointers respectively.
- uint32_t* updateStart;
- uint32_t* updateEnd;
+ uint32_t* update_start;
+ uint32_t* update_end;
};
auto cmp = [](const Range& r, size_t index) -> bool {
@@ -64,109 +66,113 @@
//
std::vector<Range> ranges;
ranges.push_back(Range{0});
- ranges.push_back(Range{originalText.size() - 1});
+ ranges.push_back(Range{original_text.size() - 1});
for (size_t i = 0; i < string->value->spans.size(); i++) {
const StringPool::Span& span = string->value->spans[i];
// Insert or update the Range marker for the start of this span.
auto iter =
- std::lower_bound(ranges.begin(), ranges.end(), span.firstChar, cmp);
- if (iter != ranges.end() && iter->start == span.firstChar) {
- iter->updateStart = &localized.spans[i].firstChar;
+ std::lower_bound(ranges.begin(), ranges.end(), span.first_char, cmp);
+ if (iter != ranges.end() && iter->start == span.first_char) {
+ iter->update_start = &localized.spans[i].first_char;
} else {
- ranges.insert(
- iter, Range{span.firstChar, &localized.spans[i].firstChar, nullptr});
+ ranges.insert(iter, Range{span.first_char, &localized.spans[i].first_char,
+ nullptr});
}
// Insert or update the Range marker for the end of this span.
- iter = std::lower_bound(ranges.begin(), ranges.end(), span.lastChar, cmp);
- if (iter != ranges.end() && iter->start == span.lastChar) {
- iter->updateEnd = &localized.spans[i].lastChar;
+ iter = std::lower_bound(ranges.begin(), ranges.end(), span.last_char, cmp);
+ if (iter != ranges.end() && iter->start == span.last_char) {
+ iter->update_end = &localized.spans[i].last_char;
} else {
ranges.insert(
- iter, Range{span.lastChar, nullptr, &localized.spans[i].lastChar});
+ iter, Range{span.last_char, nullptr, &localized.spans[i].last_char});
}
}
- localized.str += localizer.start();
+ localized.str += localizer.Start();
// Iterate over the ranges and localize each section.
for (size_t i = 0; i < ranges.size(); i++) {
const size_t start = ranges[i].start;
- size_t len = originalText.size() - start;
+ size_t len = original_text.size() - start;
if (i + 1 < ranges.size()) {
len = ranges[i + 1].start - start;
}
- if (ranges[i].updateStart) {
- *ranges[i].updateStart = localized.str.size();
+ if (ranges[i].update_start) {
+ *ranges[i].update_start = localized.str.size();
}
- if (ranges[i].updateEnd) {
- *ranges[i].updateEnd = localized.str.size();
+ if (ranges[i].update_end) {
+ *ranges[i].update_end = localized.str.size();
}
- localized.str += localizer.text(originalText.substr(start, len));
+ localized.str += localizer.Text(original_text.substr(start, len));
}
- localized.str += localizer.end();
+ localized.str += localizer.End();
- std::unique_ptr<StyledString> localizedString =
- util::make_unique<StyledString>(pool->makeRef(localized));
- localizedString->setSource(string->getSource());
- return localizedString;
+ std::unique_ptr<StyledString> localized_string =
+ util::make_unique<StyledString>(pool->MakeRef(localized));
+ localized_string->SetSource(string->GetSource());
+ return localized_string;
}
namespace {
-struct Visitor : public RawValueVisitor {
- StringPool* mPool;
- Pseudolocalizer::Method mMethod;
- Pseudolocalizer mLocalizer;
-
+class Visitor : public RawValueVisitor {
+ public:
// Either value or item will be populated upon visiting the value.
- std::unique_ptr<Value> mValue;
- std::unique_ptr<Item> mItem;
+ std::unique_ptr<Value> value;
+ std::unique_ptr<Item> item;
Visitor(StringPool* pool, Pseudolocalizer::Method method)
- : mPool(pool), mMethod(method), mLocalizer(method) {}
+ : pool_(pool), method_(method), localizer_(method) {}
- void visit(Plural* plural) override {
+ void Visit(Plural* plural) override {
std::unique_ptr<Plural> localized = util::make_unique<Plural>();
for (size_t i = 0; i < plural->values.size(); i++) {
- Visitor subVisitor(mPool, mMethod);
+ Visitor sub_visitor(pool_, method_);
if (plural->values[i]) {
- plural->values[i]->accept(&subVisitor);
- if (subVisitor.mValue) {
- localized->values[i] = std::move(subVisitor.mItem);
+ plural->values[i]->Accept(&sub_visitor);
+ if (sub_visitor.value) {
+ localized->values[i] = std::move(sub_visitor.item);
} else {
localized->values[i] =
- std::unique_ptr<Item>(plural->values[i]->clone(mPool));
+ std::unique_ptr<Item>(plural->values[i]->Clone(pool_));
}
}
}
- localized->setSource(plural->getSource());
- localized->setWeak(true);
- mValue = std::move(localized);
+ localized->SetSource(plural->GetSource());
+ localized->SetWeak(true);
+ value = std::move(localized);
}
- void visit(String* string) override {
+ void Visit(String* string) override {
std::string result =
- mLocalizer.start() + mLocalizer.text(*string->value) + mLocalizer.end();
+ localizer_.Start() + localizer_.Text(*string->value) + localizer_.End();
std::unique_ptr<String> localized =
- util::make_unique<String>(mPool->makeRef(result));
- localized->setSource(string->getSource());
- localized->setWeak(true);
- mItem = std::move(localized);
+ util::make_unique<String>(pool_->MakeRef(result));
+ localized->SetSource(string->GetSource());
+ localized->SetWeak(true);
+ item = std::move(localized);
}
- void visit(StyledString* string) override {
- mItem = pseudolocalizeStyledString(string, mMethod, mPool);
- mItem->setWeak(true);
+ void Visit(StyledString* string) override {
+ item = PseudolocalizeStyledString(string, method_, pool_);
+ item->SetWeak(true);
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(Visitor);
+
+ StringPool* pool_;
+ Pseudolocalizer::Method method_;
+ Pseudolocalizer localizer_;
};
-ConfigDescription modifyConfigForPseudoLocale(const ConfigDescription& base,
+ConfigDescription ModifyConfigForPseudoLocale(const ConfigDescription& base,
Pseudolocalizer::Method m) {
ConfigDescription modified = base;
switch (m) {
@@ -189,31 +195,31 @@
return modified;
}
-void pseudolocalizeIfNeeded(const Pseudolocalizer::Method method,
- ResourceConfigValue* originalValue,
+void PseudolocalizeIfNeeded(const Pseudolocalizer::Method method,
+ ResourceConfigValue* original_value,
StringPool* pool, ResourceEntry* entry) {
Visitor visitor(pool, method);
- originalValue->value->accept(&visitor);
+ original_value->value->Accept(&visitor);
- std::unique_ptr<Value> localizedValue;
- if (visitor.mValue) {
- localizedValue = std::move(visitor.mValue);
- } else if (visitor.mItem) {
- localizedValue = std::move(visitor.mItem);
+ std::unique_ptr<Value> localized_value;
+ if (visitor.value) {
+ localized_value = std::move(visitor.value);
+ } else if (visitor.item) {
+ localized_value = std::move(visitor.item);
}
- if (!localizedValue) {
+ if (!localized_value) {
return;
}
- ConfigDescription configWithAccent =
- modifyConfigForPseudoLocale(originalValue->config, method);
+ ConfigDescription config_with_accent =
+ ModifyConfigForPseudoLocale(original_value->config, method);
- ResourceConfigValue* newConfigValue =
- entry->findOrCreateValue(configWithAccent, originalValue->product);
- if (!newConfigValue->value) {
+ ResourceConfigValue* new_config_value =
+ entry->FindOrCreateValue(config_with_accent, original_value->product);
+ if (!new_config_value->value) {
// Only use auto-generated pseudo-localization if none is defined.
- newConfigValue->value = std::move(localizedValue);
+ new_config_value->value = std::move(localized_value);
}
}
@@ -222,29 +228,30 @@
* default locale)
* and is translateable.
*/
-static bool isPseudolocalizable(ResourceConfigValue* configValue) {
- const int diff = configValue->config.diff(ConfigDescription::defaultConfig());
+static bool IsPseudolocalizable(ResourceConfigValue* config_value) {
+ const int diff =
+ config_value->config.diff(ConfigDescription::DefaultConfig());
if (diff & ConfigDescription::CONFIG_LOCALE) {
return false;
}
- return configValue->value->isTranslateable();
+ return config_value->value->IsTranslateable();
}
} // namespace
-bool PseudolocaleGenerator::consume(IAaptContext* context,
+bool PseudolocaleGenerator::Consume(IAaptContext* context,
ResourceTable* table) {
for (auto& package : table->packages) {
for (auto& type : package->types) {
for (auto& entry : type->entries) {
std::vector<ResourceConfigValue*> values =
- entry->findValuesIf(isPseudolocalizable);
+ entry->FindValuesIf(IsPseudolocalizable);
for (ResourceConfigValue* value : values) {
- pseudolocalizeIfNeeded(Pseudolocalizer::Method::kAccent, value,
- &table->stringPool, entry.get());
- pseudolocalizeIfNeeded(Pseudolocalizer::Method::kBidi, value,
- &table->stringPool, entry.get());
+ PseudolocalizeIfNeeded(Pseudolocalizer::Method::kAccent, value,
+ &table->string_pool, entry.get());
+ PseudolocalizeIfNeeded(Pseudolocalizer::Method::kBidi, value,
+ &table->string_pool, entry.get());
}
}
}
diff --git a/tools/aapt2/compile/PseudolocaleGenerator.h b/tools/aapt2/compile/PseudolocaleGenerator.h
index 4e97cb9..ace3786 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator.h
+++ b/tools/aapt2/compile/PseudolocaleGenerator.h
@@ -23,11 +23,11 @@
namespace aapt {
-std::unique_ptr<StyledString> pseudolocalizeStyledString(
+std::unique_ptr<StyledString> PseudolocalizeStyledString(
StyledString* string, Pseudolocalizer::Method method, StringPool* pool);
struct PseudolocaleGenerator : public IResourceTableConsumer {
- bool consume(IAaptContext* context, ResourceTable* table) override;
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
};
} // namespace aapt
diff --git a/tools/aapt2/compile/PseudolocaleGenerator_test.cpp b/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
index 64a3e97..5a9884d 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
+++ b/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
@@ -15,118 +15,119 @@
*/
#include "compile/PseudolocaleGenerator.h"
+
#include "test/Test.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-
namespace aapt {
TEST(PseudolocaleGeneratorTest, PseudolocalizeStyledString) {
StringPool pool;
- StyleString originalStyle;
- originalStyle.str = "Hello world!";
- originalStyle.spans = {Span{"b", 2, 3}, Span{"b", 6, 7}, Span{"i", 1, 10}};
+ StyleString original_style;
+ original_style.str = "Hello world!";
+ original_style.spans = {Span{"b", 2, 3}, Span{"b", 6, 7}, Span{"i", 1, 10}};
- std::unique_ptr<StyledString> newString = pseudolocalizeStyledString(
- util::make_unique<StyledString>(pool.makeRef(originalStyle)).get(),
+ std::unique_ptr<StyledString> new_string = PseudolocalizeStyledString(
+ util::make_unique<StyledString>(pool.MakeRef(original_style)).get(),
Pseudolocalizer::Method::kNone, &pool);
- EXPECT_EQ(originalStyle.str, *newString->value->str);
- ASSERT_EQ(originalStyle.spans.size(), newString->value->spans.size());
+ EXPECT_EQ(original_style.str, *new_string->value->str);
+ ASSERT_EQ(original_style.spans.size(), new_string->value->spans.size());
- EXPECT_EQ(std::string("He").size(), newString->value->spans[0].firstChar);
- EXPECT_EQ(std::string("Hel").size(), newString->value->spans[0].lastChar);
- EXPECT_EQ(std::string("b"), *newString->value->spans[0].name);
+ EXPECT_EQ(std::string("He").size(), new_string->value->spans[0].first_char);
+ EXPECT_EQ(std::string("Hel").size(), new_string->value->spans[0].last_char);
+ EXPECT_EQ(std::string("b"), *new_string->value->spans[0].name);
- EXPECT_EQ(std::string("Hello ").size(), newString->value->spans[1].firstChar);
- EXPECT_EQ(std::string("Hello w").size(), newString->value->spans[1].lastChar);
- EXPECT_EQ(std::string("b"), *newString->value->spans[1].name);
+ EXPECT_EQ(std::string("Hello ").size(),
+ new_string->value->spans[1].first_char);
+ EXPECT_EQ(std::string("Hello w").size(),
+ new_string->value->spans[1].last_char);
+ EXPECT_EQ(std::string("b"), *new_string->value->spans[1].name);
- EXPECT_EQ(std::string("H").size(), newString->value->spans[2].firstChar);
+ EXPECT_EQ(std::string("H").size(), new_string->value->spans[2].first_char);
EXPECT_EQ(std::string("Hello worl").size(),
- newString->value->spans[2].lastChar);
- EXPECT_EQ(std::string("i"), *newString->value->spans[2].name);
+ new_string->value->spans[2].last_char);
+ EXPECT_EQ(std::string("i"), *new_string->value->spans[2].name);
- originalStyle.spans.push_back(Span{"em", 0, 11u});
+ original_style.spans.push_back(Span{"em", 0, 11u});
- newString = pseudolocalizeStyledString(
- util::make_unique<StyledString>(pool.makeRef(originalStyle)).get(),
+ new_string = PseudolocalizeStyledString(
+ util::make_unique<StyledString>(pool.MakeRef(original_style)).get(),
Pseudolocalizer::Method::kAccent, &pool);
- EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð¡ one two]"), *newString->value->str);
- ASSERT_EQ(originalStyle.spans.size(), newString->value->spans.size());
+ EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð¡ one two]"), *new_string->value->str);
+ ASSERT_EQ(original_style.spans.size(), new_string->value->spans.size());
- EXPECT_EQ(std::string("[Ĥé").size(), newString->value->spans[0].firstChar);
- EXPECT_EQ(std::string("[Ĥéļ").size(), newString->value->spans[0].lastChar);
+ EXPECT_EQ(std::string("[Ĥé").size(), new_string->value->spans[0].first_char);
+ EXPECT_EQ(std::string("[Ĥéļ").size(), new_string->value->spans[0].last_char);
EXPECT_EQ(std::string("[Ĥéļļö ").size(),
- newString->value->spans[1].firstChar);
+ new_string->value->spans[1].first_char);
EXPECT_EQ(std::string("[Ĥéļļö ŵ").size(),
- newString->value->spans[1].lastChar);
+ new_string->value->spans[1].last_char);
- EXPECT_EQ(std::string("[Ĥ").size(), newString->value->spans[2].firstChar);
+ EXPECT_EQ(std::string("[Ĥ").size(), new_string->value->spans[2].first_char);
EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļ").size(),
- newString->value->spans[2].lastChar);
+ new_string->value->spans[2].last_char);
- EXPECT_EQ(std::string("[").size(), newString->value->spans[3].firstChar);
+ EXPECT_EQ(std::string("[").size(), new_string->value->spans[3].first_char);
EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð").size(),
- newString->value->spans[3].lastChar);
+ new_string->value->spans[3].last_char);
}
TEST(PseudolocaleGeneratorTest, PseudolocalizeOnlyDefaultConfigs) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addString("android:string/one", "one")
- .addString("android:string/two", ResourceId{},
- test::parseConfigOrDie("en"), "two")
- .addString("android:string/three", "three")
- .addString("android:string/three", ResourceId{},
- test::parseConfigOrDie("en-rXA"), "three")
- .addString("android:string/four", "four")
- .build();
+ .AddString("android:string/one", "one")
+ .AddString("android:string/two", ResourceId{},
+ test::ParseConfigOrDie("en"), "two")
+ .AddString("android:string/three", "three")
+ .AddString("android:string/three", ResourceId{},
+ test::ParseConfigOrDie("en-rXA"), "three")
+ .AddString("android:string/four", "four")
+ .Build();
- String* val = test::getValue<String>(table.get(), "android:string/four");
+ String* val = test::GetValue<String>(table.get(), "android:string/four");
ASSERT_NE(nullptr, val);
- val->setTranslateable(false);
+ val->SetTranslateable(false);
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
PseudolocaleGenerator generator;
- ASSERT_TRUE(generator.consume(context.get(), table.get()));
+ ASSERT_TRUE(generator.Consume(context.get(), table.get()));
// Normal pseudolocalization should take place.
ASSERT_NE(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/one",
- test::parseConfigOrDie("en-rXA")));
+ test::GetValueForConfig<String>(table.get(), "android:string/one",
+ test::ParseConfigOrDie("en-rXA")));
ASSERT_NE(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/one",
- test::parseConfigOrDie("ar-rXB")));
+ test::GetValueForConfig<String>(table.get(), "android:string/one",
+ test::ParseConfigOrDie("ar-rXB")));
// No default config for android:string/two, so no pseudlocales should exist.
ASSERT_EQ(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/two",
- test::parseConfigOrDie("en-rXA")));
+ test::GetValueForConfig<String>(table.get(), "android:string/two",
+ test::ParseConfigOrDie("en-rXA")));
ASSERT_EQ(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/two",
- test::parseConfigOrDie("ar-rXB")));
+ test::GetValueForConfig<String>(table.get(), "android:string/two",
+ test::ParseConfigOrDie("ar-rXB")));
// Check that we didn't override manual pseudolocalization.
- val = test::getValueForConfig<String>(table.get(), "android:string/three",
- test::parseConfigOrDie("en-rXA"));
+ val = test::GetValueForConfig<String>(table.get(), "android:string/three",
+ test::ParseConfigOrDie("en-rXA"));
ASSERT_NE(nullptr, val);
EXPECT_EQ(std::string("three"), *val->value);
ASSERT_NE(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/three",
- test::parseConfigOrDie("ar-rXB")));
+ test::GetValueForConfig<String>(table.get(), "android:string/three",
+ test::ParseConfigOrDie("ar-rXB")));
// Check that four's translateable marker was honored.
ASSERT_EQ(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/four",
- test::parseConfigOrDie("en-rXA")));
+ test::GetValueForConfig<String>(table.get(), "android:string/four",
+ test::ParseConfigOrDie("en-rXA")));
ASSERT_EQ(nullptr,
- test::getValueForConfig<String>(table.get(), "android:string/four",
- test::parseConfigOrDie("ar-rXB")));
+ test::GetValueForConfig<String>(table.get(), "android:string/four",
+ test::ParseConfigOrDie("ar-rXB")));
}
} // namespace aapt
diff --git a/tools/aapt2/compile/Pseudolocalizer.cpp b/tools/aapt2/compile/Pseudolocalizer.cpp
index c3aec98..f89288f 100644
--- a/tools/aapt2/compile/Pseudolocalizer.cpp
+++ b/tools/aapt2/compile/Pseudolocalizer.cpp
@@ -15,77 +15,78 @@
*/
#include "compile/Pseudolocalizer.h"
+
#include "util/Util.h"
namespace aapt {
// String basis to generate expansion
-static const std::string k_expansion_string =
+static const std::string kExpansionString =
"one two three "
"four five six seven eight nine ten eleven twelve thirteen "
"fourteen fiveteen sixteen seventeen nineteen twenty";
// Special unicode characters to override directionality of the words
-static const std::string k_rlm = "\u200f";
-static const std::string k_rlo = "\u202e";
-static const std::string k_pdf = "\u202c";
+static const std::string kRlm = "\u200f";
+static const std::string kRlo = "\u202e";
+static const std::string kPdf = "\u202c";
// Placeholder marks
-static const std::string k_placeholder_open = "\u00bb";
-static const std::string k_placeholder_close = "\u00ab";
+static const std::string kPlaceholderOpen = "\u00bb";
+static const std::string kPlaceholderClose = "\u00ab";
-static const char k_arg_start = '{';
-static const char k_arg_end = '}';
+static const char kArgStart = '{';
+static const char kArgEnd = '}';
class PseudoMethodNone : public PseudoMethodImpl {
public:
- std::string text(const StringPiece& text) override { return text.toString(); }
- std::string placeholder(const StringPiece& text) override {
- return text.toString();
+ std::string Text(const StringPiece& text) override { return text.ToString(); }
+ std::string Placeholder(const StringPiece& text) override {
+ return text.ToString();
}
};
class PseudoMethodBidi : public PseudoMethodImpl {
public:
- std::string text(const StringPiece& text) override;
- std::string placeholder(const StringPiece& text) override;
+ std::string Text(const StringPiece& text) override;
+ std::string Placeholder(const StringPiece& text) override;
};
class PseudoMethodAccent : public PseudoMethodImpl {
public:
- PseudoMethodAccent() : mDepth(0), mWordCount(0), mLength(0) {}
- std::string start() override;
- std::string end() override;
- std::string text(const StringPiece& text) override;
- std::string placeholder(const StringPiece& text) override;
+ PseudoMethodAccent() : depth_(0), word_count_(0), length_(0) {}
+ std::string Start() override;
+ std::string End() override;
+ std::string Text(const StringPiece& text) override;
+ std::string Placeholder(const StringPiece& text) override;
private:
- size_t mDepth;
- size_t mWordCount;
- size_t mLength;
+ size_t depth_;
+ size_t word_count_;
+ size_t length_;
};
-Pseudolocalizer::Pseudolocalizer(Method method) : mLastDepth(0) {
- setMethod(method);
+Pseudolocalizer::Pseudolocalizer(Method method) : last_depth_(0) {
+ SetMethod(method);
}
-void Pseudolocalizer::setMethod(Method method) {
+void Pseudolocalizer::SetMethod(Method method) {
switch (method) {
case Method::kNone:
- mImpl = util::make_unique<PseudoMethodNone>();
+ impl_ = util::make_unique<PseudoMethodNone>();
break;
case Method::kAccent:
- mImpl = util::make_unique<PseudoMethodAccent>();
+ impl_ = util::make_unique<PseudoMethodAccent>();
break;
case Method::kBidi:
- mImpl = util::make_unique<PseudoMethodBidi>();
+ impl_ = util::make_unique<PseudoMethodBidi>();
break;
}
}
-std::string Pseudolocalizer::text(const StringPiece& text) {
+std::string Pseudolocalizer::Text(const StringPiece& text) {
std::string out;
- size_t depth = mLastDepth;
+ size_t depth = last_depth_;
size_t lastpos, pos;
const size_t length = text.size();
const char* str = text.data();
@@ -101,42 +102,41 @@
continue;
}
- if (c == k_arg_start) {
+ if (c == kArgStart) {
depth++;
- } else if (c == k_arg_end && depth) {
+ } else if (c == kArgEnd && depth) {
depth--;
}
- if (mLastDepth != depth || pos == length - 1) {
- bool pseudo = ((mLastDepth % 2) == 0);
+ if (last_depth_ != depth || pos == length - 1) {
+ bool pseudo = ((last_depth_ % 2) == 0);
size_t nextpos = pos;
- if (!pseudo || depth == mLastDepth) {
+ if (!pseudo || depth == last_depth_) {
nextpos++;
}
size_t size = nextpos - lastpos;
if (size) {
- std::string chunk = text.substr(lastpos, size).toString();
+ std::string chunk = text.substr(lastpos, size).ToString();
if (pseudo) {
- chunk = mImpl->text(chunk);
- } else if (str[lastpos] == k_arg_start &&
- str[nextpos - 1] == k_arg_end) {
- chunk = mImpl->placeholder(chunk);
+ chunk = impl_->Text(chunk);
+ } else if (str[lastpos] == kArgStart && str[nextpos - 1] == kArgEnd) {
+ chunk = impl_->Placeholder(chunk);
}
out.append(chunk);
}
- if (pseudo && depth < mLastDepth) { // End of message
- out.append(mImpl->end());
- } else if (!pseudo && depth > mLastDepth) { // Start of message
- out.append(mImpl->start());
+ if (pseudo && depth < last_depth_) { // End of message
+ out.append(impl_->End());
+ } else if (!pseudo && depth > last_depth_) { // Start of message
+ out.append(impl_->Start());
}
lastpos = nextpos;
- mLastDepth = depth;
+ last_depth_ = depth;
}
}
return out;
}
-static const char* pseudolocalizeChar(const char c) {
+static const char* PseudolocalizeChar(const char c) {
switch (c) {
case 'a':
return "\u00e5";
@@ -251,7 +251,7 @@
}
}
-static bool isPossibleNormalPlaceholderEnd(const char c) {
+static bool IsPossibleNormalPlaceholderEnd(const char c) {
switch (c) {
case 's':
return true;
@@ -300,12 +300,12 @@
}
}
-static std::string pseudoGenerateExpansion(const unsigned int length) {
- std::string result = k_expansion_string;
+static std::string PseudoGenerateExpansion(const unsigned int length) {
+ std::string result = kExpansionString;
const char* s = result.data();
if (result.size() < length) {
result += " ";
- result += pseudoGenerateExpansion(length - result.size());
+ result += PseudoGenerateExpansion(length - result.size());
} else {
int ext = 0;
// Should contain only whole words, so looking for a space
@@ -320,25 +320,25 @@
return result;
}
-std::string PseudoMethodAccent::start() {
+std::string PseudoMethodAccent::Start() {
std::string result;
- if (mDepth == 0) {
+ if (depth_ == 0) {
result = "[";
}
- mWordCount = mLength = 0;
- mDepth++;
+ word_count_ = length_ = 0;
+ depth_++;
return result;
}
-std::string PseudoMethodAccent::end() {
+std::string PseudoMethodAccent::End() {
std::string result;
- if (mLength) {
+ if (length_) {
result += " ";
- result += pseudoGenerateExpansion(mWordCount > 3 ? mLength : mLength / 2);
+ result += PseudoGenerateExpansion(word_count_ > 3 ? length_ : length_ / 2);
}
- mWordCount = mLength = 0;
- mDepth--;
- if (mDepth == 0) {
+ word_count_ = length_ = 0;
+ depth_--;
+ if (depth_ == 0) {
result += "]";
}
return result;
@@ -349,7 +349,7 @@
*
* Note: This leaves placeholder syntax untouched.
*/
-std::string PseudoMethodAccent::text(const StringPiece& source) {
+std::string PseudoMethodAccent::Text(const StringPiece& source) {
const char* s = source.data();
std::string result;
const size_t I = source.size();
@@ -365,7 +365,7 @@
++i;
c = s[i];
chunk.append(&c, 1);
- if (isPossibleNormalPlaceholderEnd(c)) {
+ if (IsPossibleNormalPlaceholderEnd(c)) {
end = true;
} else if (i + 1 < I && c == 't') {
++i;
@@ -375,24 +375,24 @@
}
}
// Treat chunk as a placeholder unless it ends with %.
- result += ((c == '%') ? chunk : placeholder(chunk));
+ result += ((c == '%') ? chunk : Placeholder(chunk));
} else if (c == '<' || c == '&') {
// html syntax, no need to pseudolocalize
bool tag_closed = false;
while (!tag_closed && i < I) {
if (c == '&') {
- std::string escapeText;
- escapeText.append(&c, 1);
+ std::string escape_text;
+ escape_text.append(&c, 1);
bool end = false;
- size_t htmlCodePos = i;
- while (!end && htmlCodePos < I) {
- ++htmlCodePos;
- c = s[htmlCodePos];
- escapeText.append(&c, 1);
+ size_t html_code_pos = i;
+ while (!end && html_code_pos < I) {
+ ++html_code_pos;
+ c = s[html_code_pos];
+ escape_text.append(&c, 1);
// Valid html code
if (c == ';') {
end = true;
- i = htmlCodePos;
+ i = html_code_pos;
}
// Wrong html code
else if (!((c == '#' || (c >= 'a' && c <= 'z') ||
@@ -400,8 +400,8 @@
end = true;
}
}
- result += escapeText;
- if (escapeText != "<") {
+ result += escape_text;
+ if (escape_text != "<") {
tag_closed = true;
}
continue;
@@ -417,30 +417,30 @@
}
} else {
// This is a pure text that should be pseudolocalized
- const char* p = pseudolocalizeChar(c);
+ const char* p = PseudolocalizeChar(c);
if (p != nullptr) {
result += p;
} else {
bool space = isspace(c);
if (lastspace && !space) {
- mWordCount++;
+ word_count_++;
}
lastspace = space;
result.append(&c, 1);
}
// Count only pseudolocalizable chars and delimiters
- mLength++;
+ length_++;
}
}
return result;
}
-std::string PseudoMethodAccent::placeholder(const StringPiece& source) {
+std::string PseudoMethodAccent::Placeholder(const StringPiece& source) {
// Surround a placeholder with brackets
- return k_placeholder_open + source.toString() + k_placeholder_close;
+ return kPlaceholderOpen + source.ToString() + kPlaceholderClose;
}
-std::string PseudoMethodBidi::text(const StringPiece& source) {
+std::string PseudoMethodBidi::Text(const StringPiece& source) {
const char* s = source.data();
std::string result;
bool lastspace = true;
@@ -450,24 +450,24 @@
space = isspace(c);
if (lastspace && !space) {
// Word start
- result += k_rlm + k_rlo;
+ result += kRlm + kRlo;
} else if (!lastspace && space) {
// Word end
- result += k_pdf + k_rlm;
+ result += kPdf + kRlm;
}
lastspace = space;
result.append(&c, 1);
}
if (!lastspace) {
// End of last word
- result += k_pdf + k_rlm;
+ result += kPdf + kRlm;
}
return result;
}
-std::string PseudoMethodBidi::placeholder(const StringPiece& source) {
+std::string PseudoMethodBidi::Placeholder(const StringPiece& source) {
// Surround a placeholder with directionality change sequence
- return k_rlm + k_rlo + source.toString() + k_pdf + k_rlm;
+ return kRlm + kRlo + source.ToString() + kPdf + kRlm;
}
} // namespace aapt
diff --git a/tools/aapt2/compile/Pseudolocalizer.h b/tools/aapt2/compile/Pseudolocalizer.h
index a526877..a6d2ad0 100644
--- a/tools/aapt2/compile/Pseudolocalizer.h
+++ b/tools/aapt2/compile/Pseudolocalizer.h
@@ -17,22 +17,23 @@
#ifndef AAPT_COMPILE_PSEUDOLOCALIZE_H
#define AAPT_COMPILE_PSEUDOLOCALIZE_H
+#include <memory>
+
+#include "android-base/macros.h"
+
#include "ResourceValues.h"
#include "StringPool.h"
#include "util/StringPiece.h"
-#include <android-base/macros.h>
-#include <memory>
-
namespace aapt {
class PseudoMethodImpl {
public:
virtual ~PseudoMethodImpl() {}
- virtual std::string start() { return {}; }
- virtual std::string end() { return {}; }
- virtual std::string text(const StringPiece& text) = 0;
- virtual std::string placeholder(const StringPiece& text) = 0;
+ virtual std::string Start() { return {}; }
+ virtual std::string End() { return {}; }
+ virtual std::string Text(const StringPiece& text) = 0;
+ virtual std::string Placeholder(const StringPiece& text) = 0;
};
class Pseudolocalizer {
@@ -44,14 +45,14 @@
};
explicit Pseudolocalizer(Method method);
- void setMethod(Method method);
- std::string start() { return mImpl->start(); }
- std::string end() { return mImpl->end(); }
- std::string text(const StringPiece& text);
+ void SetMethod(Method method);
+ std::string Start() { return impl_->Start(); }
+ std::string End() { return impl_->End(); }
+ std::string Text(const StringPiece& text);
private:
- std::unique_ptr<PseudoMethodImpl> mImpl;
- size_t mLastDepth;
+ std::unique_ptr<PseudoMethodImpl> impl_;
+ size_t last_depth_;
};
} // namespace aapt
diff --git a/tools/aapt2/compile/Pseudolocalizer_test.cpp b/tools/aapt2/compile/Pseudolocalizer_test.cpp
index a152ed6..92eb3b5 100644
--- a/tools/aapt2/compile/Pseudolocalizer_test.cpp
+++ b/tools/aapt2/compile/Pseudolocalizer_test.cpp
@@ -15,33 +15,32 @@
*/
#include "compile/Pseudolocalizer.h"
-#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-#include <gtest/gtest.h>
+#include "test/Test.h"
+#include "util/Util.h"
namespace aapt {
// In this context, 'Axis' represents a particular field in the configuration,
// such as language or density.
-static ::testing::AssertionResult simpleHelper(const char* input,
+static ::testing::AssertionResult SimpleHelper(const char* input,
const char* expected,
Pseudolocalizer::Method method) {
Pseudolocalizer pseudo(method);
- std::string result = pseudo.start() + pseudo.text(input) + pseudo.end();
+ std::string result = pseudo.Start() + pseudo.Text(input) + pseudo.End();
if (result != expected) {
return ::testing::AssertionFailure() << expected << " != " << result;
}
return ::testing::AssertionSuccess();
}
-static ::testing::AssertionResult compoundHelper(
+static ::testing::AssertionResult CompoundHelper(
const char* in1, const char* in2, const char* in3, const char* expected,
Pseudolocalizer::Method method) {
Pseudolocalizer pseudo(method);
- std::string result = pseudo.start() + pseudo.text(in1) + pseudo.text(in2) +
- pseudo.text(in3) + pseudo.end();
+ std::string result = pseudo.Start() + pseudo.Text(in1) + pseudo.Text(in2) +
+ pseudo.Text(in3) + pseudo.End();
if (result != expected) {
return ::testing::AssertionFailure() << expected << " != " << result;
}
@@ -49,49 +48,49 @@
}
TEST(PseudolocalizerTest, NoPseudolocalization) {
- EXPECT_TRUE(simpleHelper("", "", Pseudolocalizer::Method::kNone));
- EXPECT_TRUE(simpleHelper("Hello, world", "Hello, world",
+ EXPECT_TRUE(SimpleHelper("", "", Pseudolocalizer::Method::kNone));
+ EXPECT_TRUE(SimpleHelper("Hello, world", "Hello, world",
Pseudolocalizer::Method::kNone));
- EXPECT_TRUE(compoundHelper("Hello,", " world", "", "Hello, world",
+ EXPECT_TRUE(CompoundHelper("Hello,", " world", "", "Hello, world",
Pseudolocalizer::Method::kNone));
}
TEST(PseudolocalizerTest, PlaintextAccent) {
- EXPECT_TRUE(simpleHelper("", "[]", Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper("Hello, world", "[Ĥéļļö, ŵöŕļð one two]",
+ EXPECT_TRUE(SimpleHelper("", "[]", Pseudolocalizer::Method::kAccent));
+ EXPECT_TRUE(SimpleHelper("Hello, world", "[Ĥéļļö, ŵöŕļð one two]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper("Hello, %1d", "[Ĥéļļö, »%1d« one two]",
+ EXPECT_TRUE(SimpleHelper("Hello, %1d", "[Ĥéļļö, »%1d« one two]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper("Battery %1d%%", "[βåţţéŕý »%1d«%% one two]",
+ EXPECT_TRUE(SimpleHelper("Battery %1d%%", "[βåţţéŕý »%1d«%% one two]",
Pseudolocalizer::Method::kAccent));
EXPECT_TRUE(
- simpleHelper("^1 %", "[^1 % one]", Pseudolocalizer::Method::kAccent));
+ SimpleHelper("^1 %", "[^1 % one]", Pseudolocalizer::Method::kAccent));
EXPECT_TRUE(
- compoundHelper("", "", "", "[]", Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(compoundHelper("Hello,", " world", "", "[Ĥéļļö, ŵöŕļð one two]",
+ CompoundHelper("", "", "", "[]", Pseudolocalizer::Method::kAccent));
+ EXPECT_TRUE(CompoundHelper("Hello,", " world", "", "[Ĥéļļö, ŵöŕļð one two]",
Pseudolocalizer::Method::kAccent));
}
TEST(PseudolocalizerTest, PlaintextBidi) {
- EXPECT_TRUE(simpleHelper("", "", Pseudolocalizer::Method::kBidi));
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper("", "", Pseudolocalizer::Method::kBidi));
+ EXPECT_TRUE(SimpleHelper(
"word", "\xe2\x80\x8f\xE2\x80\xaeword\xE2\x80\xac\xe2\x80\x8f",
Pseudolocalizer::Method::kBidi));
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper(
" word ", " \xe2\x80\x8f\xE2\x80\xaeword\xE2\x80\xac\xe2\x80\x8f ",
Pseudolocalizer::Method::kBidi));
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper(
" word ", " \xe2\x80\x8f\xE2\x80\xaeword\xE2\x80\xac\xe2\x80\x8f ",
Pseudolocalizer::Method::kBidi));
EXPECT_TRUE(
- simpleHelper("hello\n world\n",
+ SimpleHelper("hello\n world\n",
"\xe2\x80\x8f\xE2\x80\xaehello\xE2\x80\xac\xe2\x80\x8f\n"
" \xe2\x80\x8f\xE2\x80\xaeworld\xE2\x80\xac\xe2\x80\x8f\n",
Pseudolocalizer::Method::kBidi));
- EXPECT_TRUE(compoundHelper(
+ EXPECT_TRUE(CompoundHelper(
"hello", "\n ", " world\n",
"\xe2\x80\x8f\xE2\x80\xaehello\xE2\x80\xac\xe2\x80\x8f\n"
" \xe2\x80\x8f\xE2\x80\xaeworld\xE2\x80\xac\xe2\x80\x8f\n",
@@ -100,33 +99,33 @@
TEST(PseudolocalizerTest, SimpleICU) {
// Single-fragment messages
- EXPECT_TRUE(simpleHelper("{placeholder}", "[»{placeholder}«]",
+ EXPECT_TRUE(SimpleHelper("{placeholder}", "[»{placeholder}«]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper("{USER} is offline", "[»{USER}« îš öƒƒļîñé one two]",
+ EXPECT_TRUE(SimpleHelper("{USER} is offline", "[»{USER}« îš öƒƒļîñé one two]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper("Copy from {path1} to {path2}",
+ EXPECT_TRUE(SimpleHelper("Copy from {path1} to {path2}",
"[Çöþý ƒŕöḿ »{path1}« ţö »{path2}« one two three]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper("Today is {1,date} {1,time}",
+ EXPECT_TRUE(SimpleHelper("Today is {1,date} {1,time}",
"[Ţöðåý îš »{1,date}« »{1,time}« one two]",
Pseudolocalizer::Method::kAccent));
// Multi-fragment messages
- EXPECT_TRUE(compoundHelper("{USER}", " ", "is offline",
+ EXPECT_TRUE(CompoundHelper("{USER}", " ", "is offline",
"[»{USER}« îš öƒƒļîñé one two]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(compoundHelper("Copy from ", "{path1}", " to {path2}",
+ EXPECT_TRUE(CompoundHelper("Copy from ", "{path1}", " to {path2}",
"[Çöþý ƒŕöḿ »{path1}« ţö »{path2}« one two three]",
Pseudolocalizer::Method::kAccent));
}
TEST(PseudolocalizerTest, ICUBidi) {
// Single-fragment messages
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper(
"{placeholder}",
"\xe2\x80\x8f\xE2\x80\xae{placeholder}\xE2\x80\xac\xe2\x80\x8f",
Pseudolocalizer::Method::kBidi));
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper(
"{COUNT, plural, one {one} other {other}}",
"{COUNT, plural, "
"one {\xe2\x80\x8f\xE2\x80\xaeone\xE2\x80\xac\xe2\x80\x8f} "
@@ -136,30 +135,30 @@
TEST(PseudolocalizerTest, Escaping) {
// Single-fragment messages
- EXPECT_TRUE(simpleHelper("'{USER'} is offline",
+ EXPECT_TRUE(SimpleHelper("'{USER'} is offline",
"['{ÛŠÉŔ'} îš öƒƒļîñé one two three]",
Pseudolocalizer::Method::kAccent));
// Multi-fragment messages
- EXPECT_TRUE(compoundHelper("'{USER}", " ", "''is offline",
+ EXPECT_TRUE(CompoundHelper("'{USER}", " ", "''is offline",
"['{ÛŠÉŔ} ''îš öƒƒļîñé one two three]",
Pseudolocalizer::Method::kAccent));
}
TEST(PseudolocalizerTest, PluralsAndSelects) {
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper(
"{COUNT, plural, one {Delete a file} other {Delete {COUNT} files}}",
"[{COUNT, plural, one {Ðéļéţé å ƒîļé one two} "
"other {Ðéļéţé »{COUNT}« ƒîļéš one two}}]",
Pseudolocalizer::Method::kAccent));
EXPECT_TRUE(
- simpleHelper("Distance is {COUNT, plural, one {# mile} other {# miles}}",
+ SimpleHelper("Distance is {COUNT, plural, one {# mile} other {# miles}}",
"[Ðîšţåñçé îš {COUNT, plural, one {# ḿîļé one two} "
"other {# ḿîļéš one two}}]",
Pseudolocalizer::Method::kAccent));
- EXPECT_TRUE(simpleHelper(
+ EXPECT_TRUE(SimpleHelper(
"{1, select, female {{1} added you} "
"male {{1} added you} other {{1} added you}}",
"[{1, select, female {»{1}« åððéð ýöû one two} "
@@ -167,7 +166,7 @@
Pseudolocalizer::Method::kAccent));
EXPECT_TRUE(
- compoundHelper("{COUNT, plural, one {Delete a file} "
+ CompoundHelper("{COUNT, plural, one {Delete a file} "
"other {Delete ",
"{COUNT}", " files}}",
"[{COUNT, plural, one {Ðéļéţé å ƒîļé one two} "
@@ -177,7 +176,7 @@
TEST(PseudolocalizerTest, NestedICU) {
EXPECT_TRUE(
- simpleHelper("{person, select, "
+ SimpleHelper("{person, select, "
"female {"
"{num_circles, plural,"
"=0{{person} didn't add you to any of her circles.}"
@@ -222,9 +221,9 @@
TEST(PseudolocalizerTest, RedefineMethod) {
Pseudolocalizer pseudo(Pseudolocalizer::Method::kAccent);
- std::string result = pseudo.text("Hello, ");
- pseudo.setMethod(Pseudolocalizer::Method::kNone);
- result += pseudo.text("world!");
+ std::string result = pseudo.Text("Hello, ");
+ pseudo.SetMethod(Pseudolocalizer::Method::kNone);
+ result += pseudo.Text("world!");
ASSERT_EQ(StringPiece("Ĥéļļö, world!"), result);
}
diff --git a/tools/aapt2/compile/XmlIdCollector.cpp b/tools/aapt2/compile/XmlIdCollector.cpp
index aa8b1df..d61a15a 100644
--- a/tools/aapt2/compile/XmlIdCollector.cpp
+++ b/tools/aapt2/compile/XmlIdCollector.cpp
@@ -15,55 +15,59 @@
*/
#include "compile/XmlIdCollector.h"
-#include "ResourceUtils.h"
-#include "ResourceValues.h"
-#include "xml/XmlDom.h"
#include <algorithm>
#include <vector>
+#include "ResourceUtils.h"
+#include "ResourceValues.h"
+#include "xml/XmlDom.h"
+
namespace aapt {
namespace {
-static bool cmpName(const SourcedResourceName& a, const ResourceNameRef& b) {
+static bool cmp_name(const SourcedResourceName& a, const ResourceNameRef& b) {
return a.name < b;
}
struct IdCollector : public xml::Visitor {
- using xml::Visitor::visit;
+ public:
+ using xml::Visitor::Visit;
- std::vector<SourcedResourceName>* mOutSymbols;
+ explicit IdCollector(std::vector<SourcedResourceName>* out_symbols)
+ : out_symbols_(out_symbols) {}
- explicit IdCollector(std::vector<SourcedResourceName>* outSymbols)
- : mOutSymbols(outSymbols) {}
-
- void visit(xml::Element* element) override {
+ void Visit(xml::Element* element) override {
for (xml::Attribute& attr : element->attributes) {
ResourceNameRef name;
bool create = false;
- if (ResourceUtils::parseReference(attr.value, &name, &create, nullptr)) {
+ if (ResourceUtils::ParseReference(attr.value, &name, &create, nullptr)) {
if (create && name.type == ResourceType::kId) {
- auto iter = std::lower_bound(mOutSymbols->begin(), mOutSymbols->end(),
- name, cmpName);
- if (iter == mOutSymbols->end() || iter->name != name) {
- mOutSymbols->insert(iter, SourcedResourceName{name.toResourceName(),
- element->lineNumber});
+ auto iter = std::lower_bound(out_symbols_->begin(),
+ out_symbols_->end(), name, cmp_name);
+ if (iter == out_symbols_->end() || iter->name != name) {
+ out_symbols_->insert(iter,
+ SourcedResourceName{name.ToResourceName(),
+ element->line_number});
}
}
}
}
- xml::Visitor::visit(element);
+ xml::Visitor::Visit(element);
}
+
+ private:
+ std::vector<SourcedResourceName>* out_symbols_;
};
} // namespace
-bool XmlIdCollector::consume(IAaptContext* context, xml::XmlResource* xmlRes) {
- xmlRes->file.exportedSymbols.clear();
- IdCollector collector(&xmlRes->file.exportedSymbols);
- xmlRes->root->accept(&collector);
+bool XmlIdCollector::Consume(IAaptContext* context, xml::XmlResource* xmlRes) {
+ xmlRes->file.exported_symbols.clear();
+ IdCollector collector(&xmlRes->file.exported_symbols);
+ xmlRes->root->Accept(&collector);
return true;
}
diff --git a/tools/aapt2/compile/XmlIdCollector.h b/tools/aapt2/compile/XmlIdCollector.h
index 8423f48..8febf0f 100644
--- a/tools/aapt2/compile/XmlIdCollector.h
+++ b/tools/aapt2/compile/XmlIdCollector.h
@@ -23,7 +23,7 @@
namespace aapt {
struct XmlIdCollector : public IXmlResourceConsumer {
- bool consume(IAaptContext* context, xml::XmlResource* xmlRes) override;
+ bool Consume(IAaptContext* context, xml::XmlResource* xml_res) override;
};
} // namespace aapt
diff --git a/tools/aapt2/compile/XmlIdCollector_test.cpp b/tools/aapt2/compile/XmlIdCollector_test.cpp
index 08ca7b1..98da56d 100644
--- a/tools/aapt2/compile/XmlIdCollector_test.cpp
+++ b/tools/aapt2/compile/XmlIdCollector_test.cpp
@@ -15,18 +15,17 @@
*/
#include "compile/XmlIdCollector.h"
-#include "test/Builders.h"
-#include "test/Context.h"
-#include <gtest/gtest.h>
#include <algorithm>
+#include "test/Test.h"
+
namespace aapt {
TEST(XmlIdCollectorTest, CollectsIds) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/foo"
text="@+id/bar">
@@ -35,34 +34,34 @@
</View>)EOF");
XmlIdCollector collector;
- ASSERT_TRUE(collector.consume(context.get(), doc.get()));
+ ASSERT_TRUE(collector.Consume(context.get(), doc.get()));
EXPECT_EQ(
- 1, std::count(doc->file.exportedSymbols.begin(),
- doc->file.exportedSymbols.end(),
- SourcedResourceName{test::parseNameOrDie("id/foo"), 3u}));
+ 1, std::count(doc->file.exported_symbols.begin(),
+ doc->file.exported_symbols.end(),
+ SourcedResourceName{test::ParseNameOrDie("id/foo"), 3u}));
EXPECT_EQ(
- 1, std::count(doc->file.exportedSymbols.begin(),
- doc->file.exportedSymbols.end(),
- SourcedResourceName{test::parseNameOrDie("id/bar"), 3u}));
+ 1, std::count(doc->file.exported_symbols.begin(),
+ doc->file.exported_symbols.end(),
+ SourcedResourceName{test::ParseNameOrDie("id/bar"), 3u}));
EXPECT_EQ(
- 1, std::count(doc->file.exportedSymbols.begin(),
- doc->file.exportedSymbols.end(),
- SourcedResourceName{test::parseNameOrDie("id/car"), 6u}));
+ 1, std::count(doc->file.exported_symbols.begin(),
+ doc->file.exported_symbols.end(),
+ SourcedResourceName{test::ParseNameOrDie("id/car"), 6u}));
}
TEST(XmlIdCollectorTest, DontCollectNonIds) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDom("<View foo=\"@+string/foo\"/>");
+ test::BuildXmlDom("<View foo=\"@+string/foo\"/>");
XmlIdCollector collector;
- ASSERT_TRUE(collector.consume(context.get(), doc.get()));
+ ASSERT_TRUE(collector.Consume(context.get(), doc.get()));
- EXPECT_TRUE(doc->file.exportedSymbols.empty());
+ EXPECT_TRUE(doc->file.exported_symbols.empty());
}
} // namespace aapt
diff --git a/tools/aapt2/diff/Diff.cpp b/tools/aapt2/diff/Diff.cpp
index 01f4539..593e7ab 100644
--- a/tools/aapt2/diff/Diff.cpp
+++ b/tools/aapt2/diff/Diff.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include "android-base/macros.h"
+
#include "Flags.h"
#include "ResourceTable.h"
#include "ValueVisitor.h"
@@ -22,74 +24,72 @@
#include "process/SymbolTable.h"
#include "unflatten/BinaryResourceParser.h"
-#include <android-base/macros.h>
-
namespace aapt {
class DiffContext : public IAaptContext {
public:
- const std::string& getCompilationPackage() override { return mEmpty; }
+ const std::string& GetCompilationPackage() override { return empty_; }
- uint8_t getPackageId() override { return 0x0; }
+ uint8_t GetPackageId() override { return 0x0; }
- IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+ IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
- NameMangler* getNameMangler() override { return &mNameMangler; }
+ NameMangler* GetNameMangler() override { return &name_mangler_; }
- SymbolTable* getExternalSymbols() override { return &mSymbolTable; }
+ SymbolTable* GetExternalSymbols() override { return &symbol_table_; }
- bool verbose() override { return false; }
+ bool IsVerbose() override { return false; }
- int getMinSdkVersion() override { return 0; }
+ int GetMinSdkVersion() override { return 0; }
private:
- std::string mEmpty;
- StdErrDiagnostics mDiagnostics;
- NameMangler mNameMangler = NameMangler(NameManglerPolicy{});
- SymbolTable mSymbolTable;
+ std::string empty_;
+ StdErrDiagnostics diagnostics_;
+ NameMangler name_mangler_ = NameMangler(NameManglerPolicy{});
+ SymbolTable symbol_table_;
};
class LoadedApk {
public:
LoadedApk(const Source& source, std::unique_ptr<io::IFileCollection> apk,
std::unique_ptr<ResourceTable> table)
- : mSource(source), mApk(std::move(apk)), mTable(std::move(table)) {}
+ : source_(source), apk_(std::move(apk)), table_(std::move(table)) {}
- io::IFileCollection* getFileCollection() { return mApk.get(); }
+ io::IFileCollection* GetFileCollection() { return apk_.get(); }
- ResourceTable* getResourceTable() { return mTable.get(); }
+ ResourceTable* GetResourceTable() { return table_.get(); }
- const Source& getSource() { return mSource; }
+ const Source& GetSource() { return source_; }
private:
- Source mSource;
- std::unique_ptr<io::IFileCollection> mApk;
- std::unique_ptr<ResourceTable> mTable;
+ Source source_;
+ std::unique_ptr<io::IFileCollection> apk_;
+ std::unique_ptr<ResourceTable> table_;
DISALLOW_COPY_AND_ASSIGN(LoadedApk);
};
-static std::unique_ptr<LoadedApk> loadApkFromPath(IAaptContext* context,
+static std::unique_ptr<LoadedApk> LoadApkFromPath(IAaptContext* context,
const StringPiece& path) {
Source source(path);
std::string error;
std::unique_ptr<io::ZipFileCollection> apk =
- io::ZipFileCollection::create(path, &error);
+ io::ZipFileCollection::Create(path, &error);
if (!apk) {
- context->getDiagnostics()->error(DiagMessage(source) << error);
+ context->GetDiagnostics()->Error(DiagMessage(source) << error);
return {};
}
- io::IFile* file = apk->findFile("resources.arsc");
+ io::IFile* file = apk->FindFile("resources.arsc");
if (!file) {
- context->getDiagnostics()->error(DiagMessage(source)
+ context->GetDiagnostics()->Error(DiagMessage(source)
<< "no resources.arsc found");
return {};
}
- std::unique_ptr<io::IData> data = file->openAsData();
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- context->getDiagnostics()->error(DiagMessage(source)
+ context->GetDiagnostics()->Error(DiagMessage(source)
<< "could not open resources.arsc");
return {};
}
@@ -97,276 +97,281 @@
std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
BinaryResourceParser parser(context, table.get(), source, data->data(),
data->size());
- if (!parser.parse()) {
+ if (!parser.Parse()) {
return {};
}
return util::make_unique<LoadedApk>(source, std::move(apk), std::move(table));
}
-static void emitDiffLine(const Source& source, const StringPiece& message) {
+static void EmitDiffLine(const Source& source, const StringPiece& message) {
std::cerr << source << ": " << message << "\n";
}
-static bool isSymbolVisibilityDifferent(const Symbol& symbolA,
- const Symbol& symbolB) {
- return symbolA.state != symbolB.state;
+static bool IsSymbolVisibilityDifferent(const Symbol& symbol_a,
+ const Symbol& symbol_b) {
+ return symbol_a.state != symbol_b.state;
}
template <typename Id>
-static bool isIdDiff(const Symbol& symbolA, const Maybe<Id>& idA,
- const Symbol& symbolB, const Maybe<Id>& idB) {
- if (symbolA.state == SymbolState::kPublic ||
- symbolB.state == SymbolState::kPublic) {
- return idA != idB;
+static bool IsIdDiff(const Symbol& symbol_a, const Maybe<Id>& id_a,
+ const Symbol& symbol_b, const Maybe<Id>& id_b) {
+ if (symbol_a.state == SymbolState::kPublic ||
+ symbol_b.state == SymbolState::kPublic) {
+ return id_a != id_b;
}
return false;
}
-static bool emitResourceConfigValueDiff(
- IAaptContext* context, LoadedApk* apkA, ResourceTablePackage* pkgA,
- ResourceTableType* typeA, ResourceEntry* entryA,
- ResourceConfigValue* configValueA, LoadedApk* apkB,
- ResourceTablePackage* pkgB, ResourceTableType* typeB, ResourceEntry* entryB,
- ResourceConfigValue* configValueB) {
- Value* valueA = configValueA->value.get();
- Value* valueB = configValueB->value.get();
- if (!valueA->equals(valueB)) {
- std::stringstream strStream;
- strStream << "value " << pkgA->name << ":" << typeA->type << "/"
- << entryA->name << " config=" << configValueA->config
- << " does not match:\n";
- valueA->print(&strStream);
- strStream << "\n vs \n";
- valueB->print(&strStream);
- emitDiffLine(apkB->getSource(), strStream.str());
+static bool EmitResourceConfigValueDiff(
+ IAaptContext* context, LoadedApk* apk_a, ResourceTablePackage* pkg_a,
+ ResourceTableType* type_a, ResourceEntry* entry_a,
+ ResourceConfigValue* config_value_a, LoadedApk* apk_b,
+ ResourceTablePackage* pkg_b, ResourceTableType* type_b,
+ ResourceEntry* entry_b, ResourceConfigValue* config_value_b) {
+ Value* value_a = config_value_a->value.get();
+ Value* value_b = config_value_b->value.get();
+ if (!value_a->Equals(value_b)) {
+ std::stringstream str_stream;
+ str_stream << "value " << pkg_a->name << ":" << type_a->type << "/"
+ << entry_a->name << " config=" << config_value_a->config
+ << " does not match:\n";
+ value_a->Print(&str_stream);
+ str_stream << "\n vs \n";
+ value_b->Print(&str_stream);
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
return true;
}
return false;
}
-static bool emitResourceEntryDiff(IAaptContext* context, LoadedApk* apkA,
- ResourceTablePackage* pkgA,
- ResourceTableType* typeA,
- ResourceEntry* entryA, LoadedApk* apkB,
- ResourceTablePackage* pkgB,
- ResourceTableType* typeB,
- ResourceEntry* entryB) {
+static bool EmitResourceEntryDiff(IAaptContext* context, LoadedApk* apk_a,
+ ResourceTablePackage* pkg_a,
+ ResourceTableType* type_a,
+ ResourceEntry* entry_a, LoadedApk* apk_b,
+ ResourceTablePackage* pkg_b,
+ ResourceTableType* type_b,
+ ResourceEntry* entry_b) {
bool diff = false;
- for (std::unique_ptr<ResourceConfigValue>& configValueA : entryA->values) {
- ResourceConfigValue* configValueB = entryB->findValue(configValueA->config);
- if (!configValueB) {
- std::stringstream strStream;
- strStream << "missing " << pkgA->name << ":" << typeA->type << "/"
- << entryA->name << " config=" << configValueA->config;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceConfigValue>& config_value_a : entry_a->values) {
+ ResourceConfigValue* config_value_b =
+ entry_b->FindValue(config_value_a->config);
+ if (!config_value_b) {
+ std::stringstream str_stream;
+ str_stream << "missing " << pkg_a->name << ":" << type_a->type << "/"
+ << entry_a->name << " config=" << config_value_a->config;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
} else {
- diff |= emitResourceConfigValueDiff(context, apkA, pkgA, typeA, entryA,
- configValueA.get(), apkB, pkgB, typeB,
- entryB, configValueB);
+ diff |= EmitResourceConfigValueDiff(
+ context, apk_a, pkg_a, type_a, entry_a, config_value_a.get(), apk_b,
+ pkg_b, type_b, entry_b, config_value_b);
}
}
// Check for any newly added config values.
- for (std::unique_ptr<ResourceConfigValue>& configValueB : entryB->values) {
- ResourceConfigValue* configValueA = entryA->findValue(configValueB->config);
- if (!configValueA) {
- std::stringstream strStream;
- strStream << "new config " << pkgB->name << ":" << typeB->type << "/"
- << entryB->name << " config=" << configValueB->config;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceConfigValue>& config_value_b : entry_b->values) {
+ ResourceConfigValue* config_value_a =
+ entry_a->FindValue(config_value_b->config);
+ if (!config_value_a) {
+ std::stringstream str_stream;
+ str_stream << "new config " << pkg_b->name << ":" << type_b->type << "/"
+ << entry_b->name << " config=" << config_value_b->config;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
}
return false;
}
-static bool emitResourceTypeDiff(IAaptContext* context, LoadedApk* apkA,
- ResourceTablePackage* pkgA,
- ResourceTableType* typeA, LoadedApk* apkB,
- ResourceTablePackage* pkgB,
- ResourceTableType* typeB) {
+static bool EmitResourceTypeDiff(IAaptContext* context, LoadedApk* apk_a,
+ ResourceTablePackage* pkg_a,
+ ResourceTableType* type_a, LoadedApk* apk_b,
+ ResourceTablePackage* pkg_b,
+ ResourceTableType* type_b) {
bool diff = false;
- for (std::unique_ptr<ResourceEntry>& entryA : typeA->entries) {
- ResourceEntry* entryB = typeB->findEntry(entryA->name);
- if (!entryB) {
- std::stringstream strStream;
- strStream << "missing " << pkgA->name << ":" << typeA->type << "/"
- << entryA->name;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceEntry>& entry_a : type_a->entries) {
+ ResourceEntry* entry_b = type_b->FindEntry(entry_a->name);
+ if (!entry_b) {
+ std::stringstream str_stream;
+ str_stream << "missing " << pkg_a->name << ":" << type_a->type << "/"
+ << entry_a->name;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
} else {
- if (isSymbolVisibilityDifferent(entryA->symbolStatus,
- entryB->symbolStatus)) {
- std::stringstream strStream;
- strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
- << " has different visibility (";
- if (entryB->symbolStatus.state == SymbolState::kPublic) {
- strStream << "PUBLIC";
+ if (IsSymbolVisibilityDifferent(entry_a->symbol_status,
+ entry_b->symbol_status)) {
+ std::stringstream str_stream;
+ str_stream << pkg_a->name << ":" << type_a->type << "/" << entry_a->name
+ << " has different visibility (";
+ if (entry_b->symbol_status.state == SymbolState::kPublic) {
+ str_stream << "PUBLIC";
} else {
- strStream << "PRIVATE";
+ str_stream << "PRIVATE";
}
- strStream << " vs ";
- if (entryA->symbolStatus.state == SymbolState::kPublic) {
- strStream << "PUBLIC";
+ str_stream << " vs ";
+ if (entry_a->symbol_status.state == SymbolState::kPublic) {
+ str_stream << "PUBLIC";
} else {
- strStream << "PRIVATE";
+ str_stream << "PRIVATE";
}
- strStream << ")";
- emitDiffLine(apkB->getSource(), strStream.str());
+ str_stream << ")";
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
- } else if (isIdDiff(entryA->symbolStatus, entryA->id,
- entryB->symbolStatus, entryB->id)) {
- std::stringstream strStream;
- strStream << pkgA->name << ":" << typeA->type << "/" << entryA->name
- << " has different public ID (";
- if (entryB->id) {
- strStream << "0x" << std::hex << entryB->id.value();
+ } else if (IsIdDiff(entry_a->symbol_status, entry_a->id,
+ entry_b->symbol_status, entry_b->id)) {
+ std::stringstream str_stream;
+ str_stream << pkg_a->name << ":" << type_a->type << "/" << entry_a->name
+ << " has different public ID (";
+ if (entry_b->id) {
+ str_stream << "0x" << std::hex << entry_b->id.value();
} else {
- strStream << "none";
+ str_stream << "none";
}
- strStream << " vs ";
- if (entryA->id) {
- strStream << "0x " << std::hex << entryA->id.value();
+ str_stream << " vs ";
+ if (entry_a->id) {
+ str_stream << "0x " << std::hex << entry_a->id.value();
} else {
- strStream << "none";
+ str_stream << "none";
}
- strStream << ")";
- emitDiffLine(apkB->getSource(), strStream.str());
+ str_stream << ")";
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
- diff |= emitResourceEntryDiff(context, apkA, pkgA, typeA, entryA.get(),
- apkB, pkgB, typeB, entryB);
+ diff |=
+ EmitResourceEntryDiff(context, apk_a, pkg_a, type_a, entry_a.get(),
+ apk_b, pkg_b, type_b, entry_b);
}
}
// Check for any newly added entries.
- for (std::unique_ptr<ResourceEntry>& entryB : typeB->entries) {
- ResourceEntry* entryA = typeA->findEntry(entryB->name);
- if (!entryA) {
- std::stringstream strStream;
- strStream << "new entry " << pkgB->name << ":" << typeB->type << "/"
- << entryB->name;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceEntry>& entry_b : type_b->entries) {
+ ResourceEntry* entry_a = type_a->FindEntry(entry_b->name);
+ if (!entry_a) {
+ std::stringstream str_stream;
+ str_stream << "new entry " << pkg_b->name << ":" << type_b->type << "/"
+ << entry_b->name;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
}
return diff;
}
-static bool emitResourcePackageDiff(IAaptContext* context, LoadedApk* apkA,
- ResourceTablePackage* pkgA, LoadedApk* apkB,
- ResourceTablePackage* pkgB) {
+static bool EmitResourcePackageDiff(IAaptContext* context, LoadedApk* apk_a,
+ ResourceTablePackage* pkg_a,
+ LoadedApk* apk_b,
+ ResourceTablePackage* pkg_b) {
bool diff = false;
- for (std::unique_ptr<ResourceTableType>& typeA : pkgA->types) {
- ResourceTableType* typeB = pkgB->findType(typeA->type);
- if (!typeB) {
- std::stringstream strStream;
- strStream << "missing " << pkgA->name << ":" << typeA->type;
- emitDiffLine(apkA->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceTableType>& type_a : pkg_a->types) {
+ ResourceTableType* type_b = pkg_b->FindType(type_a->type);
+ if (!type_b) {
+ std::stringstream str_stream;
+ str_stream << "missing " << pkg_a->name << ":" << type_a->type;
+ EmitDiffLine(apk_a->GetSource(), str_stream.str());
diff = true;
} else {
- if (isSymbolVisibilityDifferent(typeA->symbolStatus,
- typeB->symbolStatus)) {
- std::stringstream strStream;
- strStream << pkgA->name << ":" << typeA->type
- << " has different visibility (";
- if (typeB->symbolStatus.state == SymbolState::kPublic) {
- strStream << "PUBLIC";
+ if (IsSymbolVisibilityDifferent(type_a->symbol_status,
+ type_b->symbol_status)) {
+ std::stringstream str_stream;
+ str_stream << pkg_a->name << ":" << type_a->type
+ << " has different visibility (";
+ if (type_b->symbol_status.state == SymbolState::kPublic) {
+ str_stream << "PUBLIC";
} else {
- strStream << "PRIVATE";
+ str_stream << "PRIVATE";
}
- strStream << " vs ";
- if (typeA->symbolStatus.state == SymbolState::kPublic) {
- strStream << "PUBLIC";
+ str_stream << " vs ";
+ if (type_a->symbol_status.state == SymbolState::kPublic) {
+ str_stream << "PUBLIC";
} else {
- strStream << "PRIVATE";
+ str_stream << "PRIVATE";
}
- strStream << ")";
- emitDiffLine(apkB->getSource(), strStream.str());
+ str_stream << ")";
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
- } else if (isIdDiff(typeA->symbolStatus, typeA->id, typeB->symbolStatus,
- typeB->id)) {
- std::stringstream strStream;
- strStream << pkgA->name << ":" << typeA->type
- << " has different public ID (";
- if (typeB->id) {
- strStream << "0x" << std::hex << typeB->id.value();
+ } else if (IsIdDiff(type_a->symbol_status, type_a->id,
+ type_b->symbol_status, type_b->id)) {
+ std::stringstream str_stream;
+ str_stream << pkg_a->name << ":" << type_a->type
+ << " has different public ID (";
+ if (type_b->id) {
+ str_stream << "0x" << std::hex << type_b->id.value();
} else {
- strStream << "none";
+ str_stream << "none";
}
- strStream << " vs ";
- if (typeA->id) {
- strStream << "0x " << std::hex << typeA->id.value();
+ str_stream << " vs ";
+ if (type_a->id) {
+ str_stream << "0x " << std::hex << type_a->id.value();
} else {
- strStream << "none";
+ str_stream << "none";
}
- strStream << ")";
- emitDiffLine(apkB->getSource(), strStream.str());
+ str_stream << ")";
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
- diff |= emitResourceTypeDiff(context, apkA, pkgA, typeA.get(), apkB, pkgB,
- typeB);
+ diff |= EmitResourceTypeDiff(context, apk_a, pkg_a, type_a.get(), apk_b,
+ pkg_b, type_b);
}
}
// Check for any newly added types.
- for (std::unique_ptr<ResourceTableType>& typeB : pkgB->types) {
- ResourceTableType* typeA = pkgA->findType(typeB->type);
- if (!typeA) {
- std::stringstream strStream;
- strStream << "new type " << pkgB->name << ":" << typeB->type;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceTableType>& type_b : pkg_b->types) {
+ ResourceTableType* type_a = pkg_a->FindType(type_b->type);
+ if (!type_a) {
+ std::stringstream str_stream;
+ str_stream << "new type " << pkg_b->name << ":" << type_b->type;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
}
return diff;
}
-static bool emitResourceTableDiff(IAaptContext* context, LoadedApk* apkA,
- LoadedApk* apkB) {
- ResourceTable* tableA = apkA->getResourceTable();
- ResourceTable* tableB = apkB->getResourceTable();
+static bool EmitResourceTableDiff(IAaptContext* context, LoadedApk* apk_a,
+ LoadedApk* apk_b) {
+ ResourceTable* table_a = apk_a->GetResourceTable();
+ ResourceTable* table_b = apk_b->GetResourceTable();
bool diff = false;
- for (std::unique_ptr<ResourceTablePackage>& pkgA : tableA->packages) {
- ResourceTablePackage* pkgB = tableB->findPackage(pkgA->name);
- if (!pkgB) {
- std::stringstream strStream;
- strStream << "missing package " << pkgA->name;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceTablePackage>& pkg_a : table_a->packages) {
+ ResourceTablePackage* pkg_b = table_b->FindPackage(pkg_a->name);
+ if (!pkg_b) {
+ std::stringstream str_stream;
+ str_stream << "missing package " << pkg_a->name;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
} else {
- if (pkgA->id != pkgB->id) {
- std::stringstream strStream;
- strStream << "package '" << pkgA->name << "' has different id (";
- if (pkgB->id) {
- strStream << "0x" << std::hex << pkgB->id.value();
+ if (pkg_a->id != pkg_b->id) {
+ std::stringstream str_stream;
+ str_stream << "package '" << pkg_a->name << "' has different id (";
+ if (pkg_b->id) {
+ str_stream << "0x" << std::hex << pkg_b->id.value();
} else {
- strStream << "none";
+ str_stream << "none";
}
- strStream << " vs ";
- if (pkgA->id) {
- strStream << "0x" << std::hex << pkgA->id.value();
+ str_stream << " vs ";
+ if (pkg_a->id) {
+ str_stream << "0x" << std::hex << pkg_a->id.value();
} else {
- strStream << "none";
+ str_stream << "none";
}
- strStream << ")";
- emitDiffLine(apkB->getSource(), strStream.str());
+ str_stream << ")";
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
- diff |= emitResourcePackageDiff(context, apkA, pkgA.get(), apkB, pkgB);
+ diff |=
+ EmitResourcePackageDiff(context, apk_a, pkg_a.get(), apk_b, pkg_b);
}
}
// Check for any newly added packages.
- for (std::unique_ptr<ResourceTablePackage>& pkgB : tableB->packages) {
- ResourceTablePackage* pkgA = tableA->findPackage(pkgB->name);
- if (!pkgA) {
- std::stringstream strStream;
- strStream << "new package " << pkgB->name;
- emitDiffLine(apkB->getSource(), strStream.str());
+ for (std::unique_ptr<ResourceTablePackage>& pkg_b : table_b->packages) {
+ ResourceTablePackage* pkg_a = table_a->FindPackage(pkg_b->name);
+ if (!pkg_a) {
+ std::stringstream str_stream;
+ str_stream << "new package " << pkg_b->name;
+ EmitDiffLine(apk_b->GetSource(), str_stream.str());
diff = true;
}
}
@@ -375,49 +380,49 @@
class ZeroingReferenceVisitor : public ValueVisitor {
public:
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
- void visit(Reference* ref) override {
+ void Visit(Reference* ref) override {
if (ref->name && ref->id) {
- if (ref->id.value().packageId() == 0x7f) {
+ if (ref->id.value().package_id() == 0x7f) {
ref->id = {};
}
}
}
};
-static void zeroOutAppReferences(ResourceTable* table) {
+static void ZeroOutAppReferences(ResourceTable* table) {
ZeroingReferenceVisitor visitor;
- visitAllValuesInTable(table, &visitor);
+ VisitAllValuesInTable(table, &visitor);
}
-int diff(const std::vector<StringPiece>& args) {
+int Diff(const std::vector<StringPiece>& args) {
DiffContext context;
Flags flags;
- if (!flags.parse("aapt2 diff", args, &std::cerr)) {
+ if (!flags.Parse("aapt2 diff", args, &std::cerr)) {
return 1;
}
- if (flags.getArgs().size() != 2u) {
+ if (flags.GetArgs().size() != 2u) {
std::cerr << "must have two apks as arguments.\n\n";
- flags.usage("aapt2 diff", &std::cerr);
+ flags.Usage("aapt2 diff", &std::cerr);
return 1;
}
- std::unique_ptr<LoadedApk> apkA =
- loadApkFromPath(&context, flags.getArgs()[0]);
- std::unique_ptr<LoadedApk> apkB =
- loadApkFromPath(&context, flags.getArgs()[1]);
- if (!apkA || !apkB) {
+ std::unique_ptr<LoadedApk> apk_a =
+ LoadApkFromPath(&context, flags.GetArgs()[0]);
+ std::unique_ptr<LoadedApk> apk_b =
+ LoadApkFromPath(&context, flags.GetArgs()[1]);
+ if (!apk_a || !apk_b) {
return 1;
}
// Zero out Application IDs in references.
- zeroOutAppReferences(apkA->getResourceTable());
- zeroOutAppReferences(apkB->getResourceTable());
+ ZeroOutAppReferences(apk_a->GetResourceTable());
+ ZeroOutAppReferences(apk_b->GetResourceTable());
- if (emitResourceTableDiff(&context, apkA.get(), apkB.get())) {
+ if (EmitResourceTableDiff(&context, apk_a.get(), apk_b.get())) {
// We emitted a diff, so return 1 (failure).
return 1;
}
diff --git a/tools/aapt2/dump/Dump.cpp b/tools/aapt2/dump/Dump.cpp
index 3556cd88..2920c2a 100644
--- a/tools/aapt2/dump/Dump.cpp
+++ b/tools/aapt2/dump/Dump.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include <vector>
+
#include "Debug.h"
#include "Diagnostics.h"
#include "Flags.h"
@@ -24,20 +26,14 @@
#include "util/Files.h"
#include "util/StringPiece.h"
-#include <vector>
-
namespace aapt {
-// struct DumpOptions {
-//
-//};
-
-void dumpCompiledFile(const pb::CompiledFile& pbFile, const void* data,
+void DumpCompiledFile(const pb::CompiledFile& pb_file, const void* data,
size_t len, const Source& source, IAaptContext* context) {
std::unique_ptr<ResourceFile> file =
- deserializeCompiledFileFromPb(pbFile, source, context->getDiagnostics());
+ DeserializeCompiledFileFromPb(pb_file, source, context->GetDiagnostics());
if (!file) {
- context->getDiagnostics()->warn(DiagMessage()
+ context->GetDiagnostics()->Warn(DiagMessage()
<< "failed to read compiled file");
return;
}
@@ -47,50 +43,50 @@
<< "Source: " << file->source << "\n";
}
-void tryDumpFile(IAaptContext* context, const std::string& filePath) {
+void TryDumpFile(IAaptContext* context, const std::string& file_path) {
std::unique_ptr<ResourceTable> table;
std::string err;
std::unique_ptr<io::ZipFileCollection> zip =
- io::ZipFileCollection::create(filePath, &err);
+ io::ZipFileCollection::Create(file_path, &err);
if (zip) {
- io::IFile* file = zip->findFile("resources.arsc.flat");
+ io::IFile* file = zip->FindFile("resources.arsc.flat");
if (file) {
- std::unique_ptr<io::IData> data = file->openAsData();
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- context->getDiagnostics()->error(
- DiagMessage(filePath) << "failed to open resources.arsc.flat");
+ context->GetDiagnostics()->Error(
+ DiagMessage(file_path) << "failed to open resources.arsc.flat");
return;
}
- pb::ResourceTable pbTable;
- if (!pbTable.ParseFromArray(data->data(), data->size())) {
- context->getDiagnostics()->error(DiagMessage(filePath)
+ pb::ResourceTable pb_table;
+ if (!pb_table.ParseFromArray(data->data(), data->size())) {
+ context->GetDiagnostics()->Error(DiagMessage(file_path)
<< "invalid resources.arsc.flat");
return;
}
- table = deserializeTableFromPb(pbTable, Source(filePath),
- context->getDiagnostics());
+ table = DeserializeTableFromPb(pb_table, Source(file_path),
+ context->GetDiagnostics());
if (!table) {
return;
}
}
if (!table) {
- file = zip->findFile("resources.arsc");
+ file = zip->FindFile("resources.arsc");
if (file) {
- std::unique_ptr<io::IData> data = file->openAsData();
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- context->getDiagnostics()->error(DiagMessage(filePath)
+ context->GetDiagnostics()->Error(DiagMessage(file_path)
<< "failed to open resources.arsc");
return;
}
table = util::make_unique<ResourceTable>();
- BinaryResourceParser parser(context, table.get(), Source(filePath),
+ BinaryResourceParser parser(context, table.get(), Source(file_path),
data->data(), data->size());
- if (!parser.parse()) {
+ if (!parser.Parse()) {
return;
}
}
@@ -98,109 +94,109 @@
}
if (!table) {
- Maybe<android::FileMap> file = file::mmapPath(filePath, &err);
+ Maybe<android::FileMap> file = file::MmapPath(file_path, &err);
if (!file) {
- context->getDiagnostics()->error(DiagMessage(filePath) << err);
+ context->GetDiagnostics()->Error(DiagMessage(file_path) << err);
return;
}
- android::FileMap* fileMap = &file.value();
+ android::FileMap* file_map = &file.value();
// Try as a compiled table.
- pb::ResourceTable pbTable;
- if (pbTable.ParseFromArray(fileMap->getDataPtr(),
- fileMap->getDataLength())) {
- table = deserializeTableFromPb(pbTable, Source(filePath),
- context->getDiagnostics());
+ pb::ResourceTable pb_table;
+ if (pb_table.ParseFromArray(file_map->getDataPtr(),
+ file_map->getDataLength())) {
+ table = DeserializeTableFromPb(pb_table, Source(file_path),
+ context->GetDiagnostics());
}
if (!table) {
// Try as a compiled file.
- CompiledFileInputStream input(fileMap->getDataPtr(),
- fileMap->getDataLength());
+ CompiledFileInputStream input(file_map->getDataPtr(),
+ file_map->getDataLength());
- uint32_t numFiles = 0;
- if (!input.ReadLittleEndian32(&numFiles)) {
+ uint32_t num_files = 0;
+ if (!input.ReadLittleEndian32(&num_files)) {
return;
}
- for (uint32_t i = 0; i < numFiles; i++) {
- pb::CompiledFile compiledFile;
- if (!input.ReadCompiledFile(&compiledFile)) {
- context->getDiagnostics()->warn(DiagMessage()
+ for (uint32_t i = 0; i < num_files; i++) {
+ pb::CompiledFile compiled_file;
+ if (!input.ReadCompiledFile(&compiled_file)) {
+ context->GetDiagnostics()->Warn(DiagMessage()
<< "failed to read compiled file");
return;
}
uint64_t offset, len;
if (!input.ReadDataMetaData(&offset, &len)) {
- context->getDiagnostics()->warn(DiagMessage()
+ context->GetDiagnostics()->Warn(DiagMessage()
<< "failed to read meta data");
return;
}
const void* data =
- static_cast<const uint8_t*>(fileMap->getDataPtr()) + offset;
- dumpCompiledFile(compiledFile, data, len, Source(filePath), context);
+ static_cast<const uint8_t*>(file_map->getDataPtr()) + offset;
+ DumpCompiledFile(compiled_file, data, len, Source(file_path), context);
}
}
}
if (table) {
- DebugPrintTableOptions debugPrintTableOptions;
- debugPrintTableOptions.showSources = true;
- Debug::printTable(table.get(), debugPrintTableOptions);
+ DebugPrintTableOptions options;
+ options.show_sources = true;
+ Debug::PrintTable(table.get(), options);
}
}
class DumpContext : public IAaptContext {
public:
- IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+ IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
- NameMangler* getNameMangler() override {
+ NameMangler* GetNameMangler() override {
abort();
return nullptr;
}
- const std::string& getCompilationPackage() override {
+ const std::string& GetCompilationPackage() override {
static std::string empty;
return empty;
}
- uint8_t getPackageId() override { return 0; }
+ uint8_t GetPackageId() override { return 0; }
- SymbolTable* getExternalSymbols() override {
+ SymbolTable* GetExternalSymbols() override {
abort();
return nullptr;
}
- bool verbose() override { return mVerbose; }
+ bool IsVerbose() override { return verbose_; }
- void setVerbose(bool val) { mVerbose = val; }
+ void SetVerbose(bool val) { verbose_ = val; }
- int getMinSdkVersion() override { return 0; }
+ int GetMinSdkVersion() override { return 0; }
private:
- StdErrDiagnostics mDiagnostics;
- bool mVerbose = false;
+ StdErrDiagnostics diagnostics_;
+ bool verbose_ = false;
};
/**
* Entry point for dump command.
*/
-int dump(const std::vector<StringPiece>& args) {
+int Dump(const std::vector<StringPiece>& args) {
bool verbose = false;
Flags flags =
- Flags().optionalSwitch("-v", "increase verbosity of output", &verbose);
- if (!flags.parse("aapt2 dump", args, &std::cerr)) {
+ Flags().OptionalSwitch("-v", "increase verbosity of output", &verbose);
+ if (!flags.Parse("aapt2 dump", args, &std::cerr)) {
return 1;
}
DumpContext context;
- context.setVerbose(verbose);
+ context.SetVerbose(verbose);
- for (const std::string& arg : flags.getArgs()) {
- tryDumpFile(&context, arg);
+ for (const std::string& arg : flags.GetArgs()) {
+ TryDumpFile(&context, arg);
}
return 0;
}
diff --git a/tools/aapt2/filter/ConfigFilter.cpp b/tools/aapt2/filter/ConfigFilter.cpp
index 5af996c..66aff82 100644
--- a/tools/aapt2/filter/ConfigFilter.cpp
+++ b/tools/aapt2/filter/ConfigFilter.cpp
@@ -15,44 +15,45 @@
*/
#include "filter/ConfigFilter.h"
-#include "ConfigDescription.h"
-#include <androidfw/ResourceTypes.h>
+#include "androidfw/ResourceTypes.h"
+
+#include "ConfigDescription.h"
namespace aapt {
-void AxisConfigFilter::addConfig(ConfigDescription config) {
- uint32_t diffMask = ConfigDescription::defaultConfig().diff(config);
+void AxisConfigFilter::AddConfig(ConfigDescription config) {
+ uint32_t diff_mask = ConfigDescription::DefaultConfig().diff(config);
// Ignore the version
- diffMask &= ~android::ResTable_config::CONFIG_VERSION;
+ diff_mask &= ~android::ResTable_config::CONFIG_VERSION;
// Ignore any densities. Those are best handled in --preferred-density
- if ((diffMask & android::ResTable_config::CONFIG_DENSITY) != 0) {
+ if ((diff_mask & android::ResTable_config::CONFIG_DENSITY) != 0) {
config.density = 0;
- diffMask &= ~android::ResTable_config::CONFIG_DENSITY;
+ diff_mask &= ~android::ResTable_config::CONFIG_DENSITY;
}
- mConfigs.insert(std::make_pair(config, diffMask));
- mConfigMask |= diffMask;
+ configs_.insert(std::make_pair(config, diff_mask));
+ config_mask_ |= diff_mask;
}
-bool AxisConfigFilter::match(const ConfigDescription& config) const {
- const uint32_t mask = ConfigDescription::defaultConfig().diff(config);
- if ((mConfigMask & mask) == 0) {
+bool AxisConfigFilter::Match(const ConfigDescription& config) const {
+ const uint32_t mask = ConfigDescription::DefaultConfig().diff(config);
+ if ((config_mask_ & mask) == 0) {
// The two configurations don't have any common axis.
return true;
}
- uint32_t matchedAxis = 0;
- for (const auto& entry : mConfigs) {
+ uint32_t matched_axis = 0;
+ for (const auto& entry : configs_) {
const ConfigDescription& target = entry.first;
- const uint32_t diffMask = entry.second;
+ const uint32_t diff_mask = entry.second;
uint32_t diff = target.diff(config);
- if ((diff & diffMask) == 0) {
+ if ((diff & diff_mask) == 0) {
// Mark the axis that was matched.
- matchedAxis |= diffMask;
- } else if ((diff & diffMask) == android::ResTable_config::CONFIG_LOCALE) {
+ matched_axis |= diff_mask;
+ } else if ((diff & diff_mask) == android::ResTable_config::CONFIG_LOCALE) {
// If the locales differ, but the languages are the same and
// the locale we are matching only has a language specified,
// we match.
@@ -60,10 +61,10 @@
memcmp(config.language, target.language, sizeof(config.language)) ==
0) {
if (config.country[0] == 0) {
- matchedAxis |= android::ResTable_config::CONFIG_LOCALE;
+ matched_axis |= android::ResTable_config::CONFIG_LOCALE;
}
}
- } else if ((diff & diffMask) ==
+ } else if ((diff & diff_mask) ==
android::ResTable_config::CONFIG_SMALLEST_SCREEN_SIZE) {
// Special case if the smallest screen width doesn't match. We check that
// the
@@ -71,11 +72,11 @@
// specified.
if (config.smallestScreenWidthDp != 0 &&
config.smallestScreenWidthDp < target.smallestScreenWidthDp) {
- matchedAxis |= android::ResTable_config::CONFIG_SMALLEST_SCREEN_SIZE;
+ matched_axis |= android::ResTable_config::CONFIG_SMALLEST_SCREEN_SIZE;
}
}
}
- return matchedAxis == (mConfigMask & mask);
+ return matched_axis == (config_mask_ & mask);
}
} // namespace aapt
diff --git a/tools/aapt2/filter/ConfigFilter.h b/tools/aapt2/filter/ConfigFilter.h
index c50160b..3f13416 100644
--- a/tools/aapt2/filter/ConfigFilter.h
+++ b/tools/aapt2/filter/ConfigFilter.h
@@ -17,11 +17,11 @@
#ifndef AAPT_FILTER_CONFIGFILTER_H
#define AAPT_FILTER_CONFIGFILTER_H
-#include "ConfigDescription.h"
-
#include <set>
#include <utility>
+#include "ConfigDescription.h"
+
namespace aapt {
/**
@@ -34,7 +34,7 @@
/**
* Returns true if the filter matches the configuration, false otherwise.
*/
- virtual bool match(const ConfigDescription& config) const = 0;
+ virtual bool Match(const ConfigDescription& config) const = 0;
};
/**
@@ -50,13 +50,13 @@
*/
class AxisConfigFilter : public IConfigFilter {
public:
- void addConfig(ConfigDescription config);
+ void AddConfig(ConfigDescription config);
- bool match(const ConfigDescription& config) const override;
+ bool Match(const ConfigDescription& config) const override;
private:
- std::set<std::pair<ConfigDescription, uint32_t>> mConfigs;
- uint32_t mConfigMask = 0;
+ std::set<std::pair<ConfigDescription, uint32_t>> configs_;
+ uint32_t config_mask_ = 0;
};
} // namespace aapt
diff --git a/tools/aapt2/filter/ConfigFilter_test.cpp b/tools/aapt2/filter/ConfigFilter_test.cpp
index edb40a8..586dd5f 100644
--- a/tools/aapt2/filter/ConfigFilter_test.cpp
+++ b/tools/aapt2/filter/ConfigFilter_test.cpp
@@ -15,99 +15,98 @@
*/
#include "filter/ConfigFilter.h"
-#include "test/Common.h"
-#include <gtest/gtest.h>
+#include "test/Test.h"
namespace aapt {
TEST(ConfigFilterTest, EmptyFilterMatchesAnything) {
AxisConfigFilter filter;
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("320dpi")));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("320dpi")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr")));
}
TEST(ConfigFilterTest, MatchesConfigWithUnrelatedAxis) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("fr"));
+ filter.AddConfig(test::ParseConfigOrDie("fr"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("320dpi")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("320dpi")));
}
TEST(ConfigFilterTest, MatchesConfigWithSameValueAxis) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("fr"));
+ filter.AddConfig(test::ParseConfigOrDie("fr"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr")));
}
TEST(ConfigFilterTest, MatchesConfigWithSameValueAxisAndOtherUnrelatedAxis) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("fr"));
+ filter.AddConfig(test::ParseConfigOrDie("fr"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr-320dpi")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr-320dpi")));
}
TEST(ConfigFilterTest, MatchesConfigWithOneMatchingAxis) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("fr-rFR"));
- filter.addConfig(test::parseConfigOrDie("sw360dp"));
- filter.addConfig(test::parseConfigOrDie("normal"));
- filter.addConfig(test::parseConfigOrDie("en-rUS"));
+ filter.AddConfig(test::ParseConfigOrDie("fr-rFR"));
+ filter.AddConfig(test::ParseConfigOrDie("sw360dp"));
+ filter.AddConfig(test::ParseConfigOrDie("normal"));
+ filter.AddConfig(test::ParseConfigOrDie("en-rUS"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("en")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("en")));
}
TEST(ConfigFilterTest, DoesNotMatchConfigWithDifferentValueAxis) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("fr"));
+ filter.AddConfig(test::ParseConfigOrDie("fr"));
- EXPECT_FALSE(filter.match(test::parseConfigOrDie("de")));
+ EXPECT_FALSE(filter.Match(test::ParseConfigOrDie("de")));
}
TEST(ConfigFilterTest, DoesNotMatchWhenOneQualifierIsExplicitlyNotMatched) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("fr-rFR"));
- filter.addConfig(test::parseConfigOrDie("en-rUS"));
- filter.addConfig(test::parseConfigOrDie("normal"));
- filter.addConfig(test::parseConfigOrDie("large"));
- filter.addConfig(test::parseConfigOrDie("xxhdpi"));
- filter.addConfig(test::parseConfigOrDie("sw320dp"));
+ filter.AddConfig(test::ParseConfigOrDie("fr-rFR"));
+ filter.AddConfig(test::ParseConfigOrDie("en-rUS"));
+ filter.AddConfig(test::ParseConfigOrDie("normal"));
+ filter.AddConfig(test::ParseConfigOrDie("large"));
+ filter.AddConfig(test::ParseConfigOrDie("xxhdpi"));
+ filter.AddConfig(test::ParseConfigOrDie("sw320dp"));
- EXPECT_FALSE(filter.match(test::parseConfigOrDie("fr-sw600dp-v13")));
+ EXPECT_FALSE(filter.Match(test::ParseConfigOrDie("fr-sw600dp-v13")));
}
TEST(ConfigFilterTest, MatchesSmallestWidthWhenSmaller) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("sw600dp"));
+ filter.AddConfig(test::ParseConfigOrDie("sw600dp"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("fr-sw320dp-v13")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("fr-sw320dp-v13")));
}
TEST(ConfigFilterTest, MatchesConfigWithSameLanguageButNoRegionSpecified) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("de-rDE"));
+ filter.AddConfig(test::ParseConfigOrDie("de-rDE"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("de")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("de")));
}
TEST(ConfigFilterTest, IgnoresVersion) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("normal-v4"));
+ filter.AddConfig(test::ParseConfigOrDie("normal-v4"));
// The configs don't match on any axis besides version, which should be
// ignored.
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("sw600dp-v13")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("sw600dp-v13")));
}
TEST(ConfigFilterTest, MatchesConfigWithRegion) {
AxisConfigFilter filter;
- filter.addConfig(test::parseConfigOrDie("kok"));
- filter.addConfig(test::parseConfigOrDie("kok-rIN"));
- filter.addConfig(test::parseConfigOrDie("kok-v419"));
+ filter.AddConfig(test::ParseConfigOrDie("kok"));
+ filter.AddConfig(test::ParseConfigOrDie("kok-rIN"));
+ filter.AddConfig(test::ParseConfigOrDie("kok-v419"));
- EXPECT_TRUE(filter.match(test::parseConfigOrDie("kok-rIN")));
+ EXPECT_TRUE(filter.Match(test::ParseConfigOrDie("kok-rIN")));
}
} // namespace aapt
diff --git a/tools/aapt2/flatten/Archive.cpp b/tools/aapt2/flatten/Archive.cpp
index ae08f65..47de0a3 100644
--- a/tools/aapt2/flatten/Archive.cpp
+++ b/tools/aapt2/flatten/Archive.cpp
@@ -15,131 +15,139 @@
*/
#include "flatten/Archive.h"
-#include "util/Files.h"
-#include "util/StringPiece.h"
-#include <ziparchive/zip_writer.h>
#include <cstdio>
#include <memory>
#include <string>
#include <vector>
+#include "android-base/macros.h"
+#include "ziparchive/zip_writer.h"
+
+#include "util/Files.h"
+#include "util/StringPiece.h"
+
namespace aapt {
namespace {
-struct DirectoryWriter : public IArchiveWriter {
- std::string mOutDir;
- std::unique_ptr<FILE, decltype(fclose)*> mFile = {nullptr, fclose};
+class DirectoryWriter : public IArchiveWriter {
+ public:
+ DirectoryWriter() = default;
- bool open(IDiagnostics* diag, const StringPiece& outDir) {
- mOutDir = outDir.toString();
- file::FileType type = file::getFileType(mOutDir);
+ bool Open(IDiagnostics* diag, const StringPiece& out_dir) {
+ dir_ = out_dir.ToString();
+ file::FileType type = file::GetFileType(dir_);
if (type == file::FileType::kNonexistant) {
- diag->error(DiagMessage() << "directory " << mOutDir
- << " does not exist");
+ diag->Error(DiagMessage() << "directory " << dir_ << " does not exist");
return false;
} else if (type != file::FileType::kDirectory) {
- diag->error(DiagMessage() << mOutDir << " is not a directory");
+ diag->Error(DiagMessage() << dir_ << " is not a directory");
return false;
}
return true;
}
- bool startEntry(const StringPiece& path, uint32_t flags) override {
- if (mFile) {
+ bool StartEntry(const StringPiece& path, uint32_t flags) override {
+ if (file_) {
return false;
}
- std::string fullPath = mOutDir;
- file::appendPath(&fullPath, path);
- file::mkdirs(file::getStem(fullPath));
+ std::string full_path = dir_;
+ file::AppendPath(&full_path, path);
+ file::mkdirs(file::GetStem(full_path));
- mFile = {fopen(fullPath.data(), "wb"), fclose};
- if (!mFile) {
+ file_ = {fopen(full_path.data(), "wb"), fclose};
+ if (!file_) {
return false;
}
return true;
}
- bool writeEntry(const BigBuffer& buffer) override {
- if (!mFile) {
+ bool WriteEntry(const BigBuffer& buffer) override {
+ if (!file_) {
return false;
}
for (const BigBuffer::Block& b : buffer) {
- if (fwrite(b.buffer.get(), 1, b.size, mFile.get()) != b.size) {
- mFile.reset(nullptr);
+ if (fwrite(b.buffer.get(), 1, b.size, file_.get()) != b.size) {
+ file_.reset(nullptr);
return false;
}
}
return true;
}
- bool writeEntry(const void* data, size_t len) override {
- if (fwrite(data, 1, len, mFile.get()) != len) {
- mFile.reset(nullptr);
+ bool WriteEntry(const void* data, size_t len) override {
+ if (fwrite(data, 1, len, file_.get()) != len) {
+ file_.reset(nullptr);
return false;
}
return true;
}
- bool finishEntry() override {
- if (!mFile) {
+ bool FinishEntry() override {
+ if (!file_) {
return false;
}
- mFile.reset(nullptr);
+ file_.reset(nullptr);
return true;
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(DirectoryWriter);
+
+ std::string dir_;
+ std::unique_ptr<FILE, decltype(fclose)*> file_ = {nullptr, fclose};
};
-struct ZipFileWriter : public IArchiveWriter {
- std::unique_ptr<FILE, decltype(fclose)*> mFile = {nullptr, fclose};
- std::unique_ptr<ZipWriter> mWriter;
+class ZipFileWriter : public IArchiveWriter {
+ public:
+ ZipFileWriter() = default;
- bool open(IDiagnostics* diag, const StringPiece& path) {
- mFile = {fopen(path.data(), "w+b"), fclose};
- if (!mFile) {
- diag->error(DiagMessage() << "failed to open " << path << ": "
+ bool Open(IDiagnostics* diag, const StringPiece& path) {
+ file_ = {fopen(path.data(), "w+b"), fclose};
+ if (!file_) {
+ diag->Error(DiagMessage() << "failed to Open " << path << ": "
<< strerror(errno));
return false;
}
- mWriter = util::make_unique<ZipWriter>(mFile.get());
+ writer_ = util::make_unique<ZipWriter>(file_.get());
return true;
}
- bool startEntry(const StringPiece& path, uint32_t flags) override {
- if (!mWriter) {
+ bool StartEntry(const StringPiece& path, uint32_t flags) override {
+ if (!writer_) {
return false;
}
- size_t zipFlags = 0;
+ size_t zip_flags = 0;
if (flags & ArchiveEntry::kCompress) {
- zipFlags |= ZipWriter::kCompress;
+ zip_flags |= ZipWriter::kCompress;
}
if (flags & ArchiveEntry::kAlign) {
- zipFlags |= ZipWriter::kAlign32;
+ zip_flags |= ZipWriter::kAlign32;
}
- int32_t result = mWriter->StartEntry(path.data(), zipFlags);
+ int32_t result = writer_->StartEntry(path.data(), zip_flags);
if (result != 0) {
return false;
}
return true;
}
- bool writeEntry(const void* data, size_t len) override {
- int32_t result = mWriter->WriteBytes(data, len);
+ bool WriteEntry(const void* data, size_t len) override {
+ int32_t result = writer_->WriteBytes(data, len);
if (result != 0) {
return false;
}
return true;
}
- bool writeEntry(const BigBuffer& buffer) override {
+ bool WriteEntry(const BigBuffer& buffer) override {
for (const BigBuffer::Block& b : buffer) {
- int32_t result = mWriter->WriteBytes(b.buffer.get(), b.size);
+ int32_t result = writer_->WriteBytes(b.buffer.get(), b.size);
if (result != 0) {
return false;
}
@@ -147,8 +155,8 @@
return true;
}
- bool finishEntry() override {
- int32_t result = mWriter->FinishEntry();
+ bool FinishEntry() override {
+ int32_t result = writer_->FinishEntry();
if (result != 0) {
return false;
}
@@ -156,28 +164,34 @@
}
virtual ~ZipFileWriter() {
- if (mWriter) {
- mWriter->Finish();
+ if (writer_) {
+ writer_->Finish();
}
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ZipFileWriter);
+
+ std::unique_ptr<FILE, decltype(fclose)*> file_ = {nullptr, fclose};
+ std::unique_ptr<ZipWriter> writer_;
};
} // namespace
-std::unique_ptr<IArchiveWriter> createDirectoryArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateDirectoryArchiveWriter(
IDiagnostics* diag, const StringPiece& path) {
std::unique_ptr<DirectoryWriter> writer =
util::make_unique<DirectoryWriter>();
- if (!writer->open(diag, path)) {
+ if (!writer->Open(diag, path)) {
return {};
}
return std::move(writer);
}
-std::unique_ptr<IArchiveWriter> createZipFileArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateZipFileArchiveWriter(
IDiagnostics* diag, const StringPiece& path) {
std::unique_ptr<ZipFileWriter> writer = util::make_unique<ZipFileWriter>();
- if (!writer->open(diag, path)) {
+ if (!writer->Open(diag, path)) {
return {};
}
return std::move(writer);
diff --git a/tools/aapt2/flatten/Archive.h b/tools/aapt2/flatten/Archive.h
index 46cd0ac..4fcb3ff 100644
--- a/tools/aapt2/flatten/Archive.h
+++ b/tools/aapt2/flatten/Archive.h
@@ -17,17 +17,18 @@
#ifndef AAPT_FLATTEN_ARCHIVE_H
#define AAPT_FLATTEN_ARCHIVE_H
-#include "Diagnostics.h"
-#include "util/BigBuffer.h"
-#include "util/Files.h"
-#include "util/StringPiece.h"
-
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <fstream>
#include <memory>
#include <string>
#include <vector>
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+
+#include "Diagnostics.h"
+#include "util/BigBuffer.h"
+#include "util/Files.h"
+#include "util/StringPiece.h"
+
namespace aapt {
struct ArchiveEntry {
@@ -38,28 +39,28 @@
std::string path;
uint32_t flags;
- size_t uncompressedSize;
+ size_t uncompressed_size;
};
class IArchiveWriter : public google::protobuf::io::CopyingOutputStream {
public:
virtual ~IArchiveWriter() = default;
- virtual bool startEntry(const StringPiece& path, uint32_t flags) = 0;
- virtual bool writeEntry(const BigBuffer& buffer) = 0;
- virtual bool writeEntry(const void* data, size_t len) = 0;
- virtual bool finishEntry() = 0;
+ virtual bool StartEntry(const StringPiece& path, uint32_t flags) = 0;
+ virtual bool WriteEntry(const BigBuffer& buffer) = 0;
+ virtual bool WriteEntry(const void* data, size_t len) = 0;
+ virtual bool FinishEntry() = 0;
// CopyingOutputStream implementations.
bool Write(const void* buffer, int size) override {
- return writeEntry(buffer, size);
+ return WriteEntry(buffer, size);
}
};
-std::unique_ptr<IArchiveWriter> createDirectoryArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateDirectoryArchiveWriter(
IDiagnostics* diag, const StringPiece& path);
-std::unique_ptr<IArchiveWriter> createZipFileArchiveWriter(
+std::unique_ptr<IArchiveWriter> CreateZipFileArchiveWriter(
IDiagnostics* diag, const StringPiece& path);
} // namespace aapt
diff --git a/tools/aapt2/flatten/ChunkWriter.h b/tools/aapt2/flatten/ChunkWriter.h
index 852afd4..968d3ee 100644
--- a/tools/aapt2/flatten/ChunkWriter.h
+++ b/tools/aapt2/flatten/ChunkWriter.h
@@ -17,62 +17,62 @@
#ifndef AAPT_FLATTEN_CHUNKWRITER_H
#define AAPT_FLATTEN_CHUNKWRITER_H
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+
#include "util/BigBuffer.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-
namespace aapt {
class ChunkWriter {
- private:
- BigBuffer* mBuffer;
- size_t mStartSize = 0;
- android::ResChunk_header* mHeader = nullptr;
-
public:
- explicit inline ChunkWriter(BigBuffer* buffer) : mBuffer(buffer) {}
-
- ChunkWriter(const ChunkWriter&) = delete;
- ChunkWriter& operator=(const ChunkWriter&) = delete;
+ explicit inline ChunkWriter(BigBuffer* buffer) : buffer_(buffer) {}
ChunkWriter(ChunkWriter&&) = default;
ChunkWriter& operator=(ChunkWriter&&) = default;
template <typename T>
- inline T* startChunk(uint16_t type) {
- mStartSize = mBuffer->size();
- T* chunk = mBuffer->nextBlock<T>();
- mHeader = &chunk->header;
- mHeader->type = util::hostToDevice16(type);
- mHeader->headerSize = util::hostToDevice16(sizeof(T));
+ inline T* StartChunk(uint16_t type) {
+ start_size_ = buffer_->size();
+ T* chunk = buffer_->NextBlock<T>();
+ header_ = &chunk->header;
+ header_->type = util::HostToDevice16(type);
+ header_->headerSize = util::HostToDevice16(sizeof(T));
return chunk;
}
template <typename T>
- inline T* nextBlock(size_t count = 1) {
- return mBuffer->nextBlock<T>(count);
+ inline T* NextBlock(size_t count = 1) {
+ return buffer_->NextBlock<T>(count);
}
- inline BigBuffer* getBuffer() { return mBuffer; }
+ inline BigBuffer* buffer() { return buffer_; }
- inline android::ResChunk_header* getChunkHeader() { return mHeader; }
+ inline android::ResChunk_header* chunk_header() { return header_; }
- inline size_t size() { return mBuffer->size() - mStartSize; }
+ inline size_t size() { return buffer_->size() - start_size_; }
- inline android::ResChunk_header* finish() {
- mBuffer->align4();
- mHeader->size = util::hostToDevice32(mBuffer->size() - mStartSize);
- return mHeader;
+ inline android::ResChunk_header* Finish() {
+ buffer_->Align4();
+ header_->size = util::HostToDevice32(buffer_->size() - start_size_);
+ return header_;
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ChunkWriter);
+
+ BigBuffer* buffer_;
+ size_t start_size_ = 0;
+ android::ResChunk_header* header_ = nullptr;
};
template <>
-inline android::ResChunk_header* ChunkWriter::startChunk(uint16_t type) {
- mStartSize = mBuffer->size();
- mHeader = mBuffer->nextBlock<android::ResChunk_header>();
- mHeader->type = util::hostToDevice16(type);
- mHeader->headerSize = util::hostToDevice16(sizeof(android::ResChunk_header));
- return mHeader;
+inline android::ResChunk_header* ChunkWriter::StartChunk(uint16_t type) {
+ start_size_ = buffer_->size();
+ header_ = buffer_->NextBlock<android::ResChunk_header>();
+ header_->type = util::HostToDevice16(type);
+ header_->headerSize = util::HostToDevice16(sizeof(android::ResChunk_header));
+ return header_;
}
} // namespace aapt
diff --git a/tools/aapt2/flatten/ResourceTypeExtensions.h b/tools/aapt2/flatten/ResourceTypeExtensions.h
index 0b19240..6359b41 100644
--- a/tools/aapt2/flatten/ResourceTypeExtensions.h
+++ b/tools/aapt2/flatten/ResourceTypeExtensions.h
@@ -17,7 +17,7 @@
#ifndef AAPT_RESOURCE_TYPE_EXTENSIONS_H
#define AAPT_RESOURCE_TYPE_EXTENSIONS_H
-#include <androidfw/ResourceTypes.h>
+#include "androidfw/ResourceTypes.h"
namespace aapt {
diff --git a/tools/aapt2/flatten/TableFlattener.cpp b/tools/aapt2/flatten/TableFlattener.cpp
index d4ea6c0..19d030e 100644
--- a/tools/aapt2/flatten/TableFlattener.cpp
+++ b/tools/aapt2/flatten/TableFlattener.cpp
@@ -14,21 +14,23 @@
* limitations under the License.
*/
-#include "ResourceTable.h"
-#include "ResourceValues.h"
-#include "ValueVisitor.h"
-
-#include "flatten/ChunkWriter.h"
-#include "flatten/ResourceTypeExtensions.h"
#include "flatten/TableFlattener.h"
-#include "util/BigBuffer.h"
-#include <android-base/macros.h>
#include <algorithm>
#include <numeric>
#include <sstream>
#include <type_traits>
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "ValueVisitor.h"
+#include "flatten/ChunkWriter.h"
+#include "flatten/ResourceTypeExtensions.h"
+#include "util/BigBuffer.h"
+
using namespace android;
namespace aapt {
@@ -36,7 +38,7 @@
namespace {
template <typename T>
-static bool cmpIds(const T* a, const T* b) {
+static bool cmp_ids(const T* a, const T* b) {
return a->id.value() < b->id.value();
}
@@ -46,14 +48,14 @@
}
size_t i;
- const char16_t* srcData = src.data();
+ const char16_t* src_data = src.data();
for (i = 0; i < len - 1 && i < src.size(); i++) {
- dst[i] = util::hostToDevice16((uint16_t)srcData[i]);
+ dst[i] = util::HostToDevice16((uint16_t)src_data[i]);
}
dst[i] = 0;
}
-static bool cmpStyleEntries(const Style::Entry& a, const Style::Entry& b) {
+static bool cmp_style_entries(const Style::Entry& a, const Style::Entry& b) {
if (a.key.id) {
if (b.key.id) {
return a.key.id.value() < b.key.id.value();
@@ -70,75 +72,75 @@
Value* value;
// The entry string pool index to the entry's name.
- uint32_t entryKey;
+ uint32_t entry_key;
};
class MapFlattenVisitor : public RawValueVisitor {
public:
- using RawValueVisitor::visit;
+ using RawValueVisitor::Visit;
- MapFlattenVisitor(ResTable_entry_ext* outEntry, BigBuffer* buffer)
- : mOutEntry(outEntry), mBuffer(buffer) {}
+ MapFlattenVisitor(ResTable_entry_ext* out_entry, BigBuffer* buffer)
+ : out_entry_(out_entry), buffer_(buffer) {}
- void visit(Attribute* attr) override {
+ void Visit(Attribute* attr) override {
{
Reference key = Reference(ResourceId(ResTable_map::ATTR_TYPE));
- BinaryPrimitive val(Res_value::TYPE_INT_DEC, attr->typeMask);
- flattenEntry(&key, &val);
+ BinaryPrimitive val(Res_value::TYPE_INT_DEC, attr->type_mask);
+ FlattenEntry(&key, &val);
}
- if (attr->minInt != std::numeric_limits<int32_t>::min()) {
+ if (attr->min_int != std::numeric_limits<int32_t>::min()) {
Reference key = Reference(ResourceId(ResTable_map::ATTR_MIN));
BinaryPrimitive val(Res_value::TYPE_INT_DEC,
- static_cast<uint32_t>(attr->minInt));
- flattenEntry(&key, &val);
+ static_cast<uint32_t>(attr->min_int));
+ FlattenEntry(&key, &val);
}
- if (attr->maxInt != std::numeric_limits<int32_t>::max()) {
+ if (attr->max_int != std::numeric_limits<int32_t>::max()) {
Reference key = Reference(ResourceId(ResTable_map::ATTR_MAX));
BinaryPrimitive val(Res_value::TYPE_INT_DEC,
- static_cast<uint32_t>(attr->maxInt));
- flattenEntry(&key, &val);
+ static_cast<uint32_t>(attr->max_int));
+ FlattenEntry(&key, &val);
}
for (Attribute::Symbol& s : attr->symbols) {
BinaryPrimitive val(Res_value::TYPE_INT_DEC, s.value);
- flattenEntry(&s.symbol, &val);
+ FlattenEntry(&s.symbol, &val);
}
}
- void visit(Style* style) override {
+ void Visit(Style* style) override {
if (style->parent) {
- const Reference& parentRef = style->parent.value();
- assert(parentRef.id && "parent has no ID");
- mOutEntry->parent.ident = util::hostToDevice32(parentRef.id.value().id);
+ const Reference& parent_ref = style->parent.value();
+ CHECK(bool(parent_ref.id)) << "parent has no ID";
+ out_entry_->parent.ident = util::HostToDevice32(parent_ref.id.value().id);
}
// Sort the style.
- std::sort(style->entries.begin(), style->entries.end(), cmpStyleEntries);
+ std::sort(style->entries.begin(), style->entries.end(), cmp_style_entries);
for (Style::Entry& entry : style->entries) {
- flattenEntry(&entry.key, entry.value.get());
+ FlattenEntry(&entry.key, entry.value.get());
}
}
- void visit(Styleable* styleable) override {
- for (auto& attrRef : styleable->entries) {
+ void Visit(Styleable* styleable) override {
+ for (auto& attr_ref : styleable->entries) {
BinaryPrimitive val(Res_value{});
- flattenEntry(&attrRef, &val);
+ FlattenEntry(&attr_ref, &val);
}
}
- void visit(Array* array) override {
+ void Visit(Array* array) override {
for (auto& item : array->items) {
- ResTable_map* outEntry = mBuffer->nextBlock<ResTable_map>();
- flattenValue(item.get(), outEntry);
- outEntry->value.size = util::hostToDevice16(sizeof(outEntry->value));
- mEntryCount++;
+ ResTable_map* out_entry = buffer_->NextBlock<ResTable_map>();
+ FlattenValue(item.get(), out_entry);
+ out_entry->value.size = util::HostToDevice16(sizeof(out_entry->value));
+ entry_count_++;
}
}
- void visit(Plural* plural) override {
+ void Visit(Plural* plural) override {
const size_t count = plural->values.size();
for (size_t i = 0; i < count; i++) {
if (!plural->values[i]) {
@@ -172,12 +174,12 @@
break;
default:
- assert(false);
+ LOG(FATAL) << "unhandled plural type";
break;
}
Reference key(q);
- flattenEntry(&key, plural->values[i].get());
+ FlattenEntry(&key, plural->values[i].get());
}
}
@@ -185,267 +187,264 @@
* Call this after visiting a Value. This will finish any work that
* needs to be done to prepare the entry.
*/
- void finish() { mOutEntry->count = util::hostToDevice32(mEntryCount); }
+ void Finish() { out_entry_->count = util::HostToDevice32(entry_count_); }
private:
- void flattenKey(Reference* key, ResTable_map* outEntry) {
- assert(key->id && "key has no ID");
- outEntry->name.ident = util::hostToDevice32(key->id.value().id);
+ DISALLOW_COPY_AND_ASSIGN(MapFlattenVisitor);
+
+ void FlattenKey(Reference* key, ResTable_map* out_entry) {
+ CHECK(bool(key->id)) << "key has no ID";
+ out_entry->name.ident = util::HostToDevice32(key->id.value().id);
}
- void flattenValue(Item* value, ResTable_map* outEntry) {
- bool result = value->flatten(&outEntry->value);
- assert(result && "flatten failed");
+ void FlattenValue(Item* value, ResTable_map* out_entry) {
+ CHECK(value->Flatten(&out_entry->value)) << "flatten failed";
}
- void flattenEntry(Reference* key, Item* value) {
- ResTable_map* outEntry = mBuffer->nextBlock<ResTable_map>();
- flattenKey(key, outEntry);
- flattenValue(value, outEntry);
- outEntry->value.size = util::hostToDevice16(sizeof(outEntry->value));
- mEntryCount++;
+ void FlattenEntry(Reference* key, Item* value) {
+ ResTable_map* out_entry = buffer_->NextBlock<ResTable_map>();
+ FlattenKey(key, out_entry);
+ FlattenValue(value, out_entry);
+ out_entry->value.size = util::HostToDevice16(sizeof(out_entry->value));
+ entry_count_++;
}
- ResTable_entry_ext* mOutEntry;
- BigBuffer* mBuffer;
- size_t mEntryCount = 0;
+ ResTable_entry_ext* out_entry_;
+ BigBuffer* buffer_;
+ size_t entry_count_ = 0;
};
class PackageFlattener {
public:
PackageFlattener(IDiagnostics* diag, ResourceTablePackage* package)
- : mDiag(diag), mPackage(package) {}
+ : diag_(diag), package_(package) {}
- bool flattenPackage(BigBuffer* buffer) {
- ChunkWriter pkgWriter(buffer);
- ResTable_package* pkgHeader =
- pkgWriter.startChunk<ResTable_package>(RES_TABLE_PACKAGE_TYPE);
- pkgHeader->id = util::hostToDevice32(mPackage->id.value());
+ bool FlattenPackage(BigBuffer* buffer) {
+ ChunkWriter pkg_writer(buffer);
+ ResTable_package* pkg_header =
+ pkg_writer.StartChunk<ResTable_package>(RES_TABLE_PACKAGE_TYPE);
+ pkg_header->id = util::HostToDevice32(package_->id.value());
- if (mPackage->name.size() >= arraysize(pkgHeader->name)) {
- mDiag->error(DiagMessage() << "package name '" << mPackage->name
+ if (package_->name.size() >= arraysize(pkg_header->name)) {
+ diag_->Error(DiagMessage() << "package name '" << package_->name
<< "' is too long");
return false;
}
// Copy the package name in device endianness.
- strcpy16_htod(pkgHeader->name, arraysize(pkgHeader->name),
- util::utf8ToUtf16(mPackage->name));
+ strcpy16_htod(pkg_header->name, arraysize(pkg_header->name),
+ util::Utf8ToUtf16(package_->name));
// Serialize the types. We do this now so that our type and key strings
// are populated. We write those first.
- BigBuffer typeBuffer(1024);
- flattenTypes(&typeBuffer);
+ BigBuffer type_buffer(1024);
+ FlattenTypes(&type_buffer);
- pkgHeader->typeStrings = util::hostToDevice32(pkgWriter.size());
- StringPool::flattenUtf16(pkgWriter.getBuffer(), mTypePool);
+ pkg_header->typeStrings = util::HostToDevice32(pkg_writer.size());
+ StringPool::FlattenUtf16(pkg_writer.buffer(), type_pool_);
- pkgHeader->keyStrings = util::hostToDevice32(pkgWriter.size());
- StringPool::flattenUtf8(pkgWriter.getBuffer(), mKeyPool);
+ pkg_header->keyStrings = util::HostToDevice32(pkg_writer.size());
+ StringPool::FlattenUtf8(pkg_writer.buffer(), key_pool_);
// Append the types.
- buffer->appendBuffer(std::move(typeBuffer));
+ buffer->AppendBuffer(std::move(type_buffer));
- pkgWriter.finish();
+ pkg_writer.Finish();
return true;
}
private:
- IDiagnostics* mDiag;
- ResourceTablePackage* mPackage;
- StringPool mTypePool;
- StringPool mKeyPool;
+ DISALLOW_COPY_AND_ASSIGN(PackageFlattener);
template <typename T, bool IsItem>
- T* writeEntry(FlatEntry* entry, BigBuffer* buffer) {
+ T* WriteEntry(FlatEntry* entry, BigBuffer* buffer) {
static_assert(std::is_same<ResTable_entry, T>::value ||
std::is_same<ResTable_entry_ext, T>::value,
"T must be ResTable_entry or ResTable_entry_ext");
- T* result = buffer->nextBlock<T>();
- ResTable_entry* outEntry = (ResTable_entry*)(result);
- if (entry->entry->symbolStatus.state == SymbolState::kPublic) {
- outEntry->flags |= ResTable_entry::FLAG_PUBLIC;
+ T* result = buffer->NextBlock<T>();
+ ResTable_entry* out_entry = (ResTable_entry*)result;
+ if (entry->entry->symbol_status.state == SymbolState::kPublic) {
+ out_entry->flags |= ResTable_entry::FLAG_PUBLIC;
}
- if (entry->value->isWeak()) {
- outEntry->flags |= ResTable_entry::FLAG_WEAK;
+ if (entry->value->IsWeak()) {
+ out_entry->flags |= ResTable_entry::FLAG_WEAK;
}
if (!IsItem) {
- outEntry->flags |= ResTable_entry::FLAG_COMPLEX;
+ out_entry->flags |= ResTable_entry::FLAG_COMPLEX;
}
- outEntry->flags = util::hostToDevice16(outEntry->flags);
- outEntry->key.index = util::hostToDevice32(entry->entryKey);
- outEntry->size = util::hostToDevice16(sizeof(T));
+ out_entry->flags = util::HostToDevice16(out_entry->flags);
+ out_entry->key.index = util::HostToDevice32(entry->entry_key);
+ out_entry->size = util::HostToDevice16(sizeof(T));
return result;
}
- bool flattenValue(FlatEntry* entry, BigBuffer* buffer) {
- if (Item* item = valueCast<Item>(entry->value)) {
- writeEntry<ResTable_entry, true>(entry, buffer);
- Res_value* outValue = buffer->nextBlock<Res_value>();
- bool result = item->flatten(outValue);
- assert(result && "flatten failed");
- outValue->size = util::hostToDevice16(sizeof(*outValue));
+ bool FlattenValue(FlatEntry* entry, BigBuffer* buffer) {
+ if (Item* item = ValueCast<Item>(entry->value)) {
+ WriteEntry<ResTable_entry, true>(entry, buffer);
+ Res_value* outValue = buffer->NextBlock<Res_value>();
+ CHECK(item->Flatten(outValue)) << "flatten failed";
+ outValue->size = util::HostToDevice16(sizeof(*outValue));
} else {
- ResTable_entry_ext* outEntry =
- writeEntry<ResTable_entry_ext, false>(entry, buffer);
- MapFlattenVisitor visitor(outEntry, buffer);
- entry->value->accept(&visitor);
- visitor.finish();
+ ResTable_entry_ext* out_entry =
+ WriteEntry<ResTable_entry_ext, false>(entry, buffer);
+ MapFlattenVisitor visitor(out_entry, buffer);
+ entry->value->Accept(&visitor);
+ visitor.Finish();
}
return true;
}
- bool flattenConfig(const ResourceTableType* type,
+ bool FlattenConfig(const ResourceTableType* type,
const ConfigDescription& config,
std::vector<FlatEntry>* entries, BigBuffer* buffer) {
- ChunkWriter typeWriter(buffer);
- ResTable_type* typeHeader =
- typeWriter.startChunk<ResTable_type>(RES_TABLE_TYPE_TYPE);
- typeHeader->id = type->id.value();
- typeHeader->config = config;
- typeHeader->config.swapHtoD();
+ ChunkWriter type_writer(buffer);
+ ResTable_type* type_header =
+ type_writer.StartChunk<ResTable_type>(RES_TABLE_TYPE_TYPE);
+ type_header->id = type->id.value();
+ type_header->config = config;
+ type_header->config.swapHtoD();
- auto maxAccum = [](uint32_t max,
- const std::unique_ptr<ResourceEntry>& a) -> uint32_t {
+ auto max_accum = [](uint32_t max,
+ const std::unique_ptr<ResourceEntry>& a) -> uint32_t {
return std::max(max, (uint32_t)a->id.value());
};
// Find the largest entry ID. That is how many entries we will have.
- const uint32_t entryCount =
+ const uint32_t entry_count =
std::accumulate(type->entries.begin(), type->entries.end(), 0,
- maxAccum) +
+ max_accum) +
1;
- typeHeader->entryCount = util::hostToDevice32(entryCount);
- uint32_t* indices = typeWriter.nextBlock<uint32_t>(entryCount);
+ type_header->entryCount = util::HostToDevice32(entry_count);
+ uint32_t* indices = type_writer.NextBlock<uint32_t>(entry_count);
- assert((size_t)entryCount <= std::numeric_limits<uint16_t>::max() + 1);
- memset(indices, 0xff, entryCount * sizeof(uint32_t));
+ CHECK((size_t)entry_count <= std::numeric_limits<uint16_t>::max());
+ memset(indices, 0xff, entry_count * sizeof(uint32_t));
- typeHeader->entriesStart = util::hostToDevice32(typeWriter.size());
+ type_header->entriesStart = util::HostToDevice32(type_writer.size());
- const size_t entryStart = typeWriter.getBuffer()->size();
- for (FlatEntry& flatEntry : *entries) {
- assert(flatEntry.entry->id.value() < entryCount);
- indices[flatEntry.entry->id.value()] =
- util::hostToDevice32(typeWriter.getBuffer()->size() - entryStart);
- if (!flattenValue(&flatEntry, typeWriter.getBuffer())) {
- mDiag->error(DiagMessage()
+ const size_t entry_start = type_writer.buffer()->size();
+ for (FlatEntry& flat_entry : *entries) {
+ CHECK(flat_entry.entry->id.value() < entry_count);
+ indices[flat_entry.entry->id.value()] =
+ util::HostToDevice32(type_writer.buffer()->size() - entry_start);
+ if (!FlattenValue(&flat_entry, type_writer.buffer())) {
+ diag_->Error(DiagMessage()
<< "failed to flatten resource '"
- << ResourceNameRef(mPackage->name, type->type,
- flatEntry.entry->name)
+ << ResourceNameRef(package_->name, type->type,
+ flat_entry.entry->name)
<< "' for configuration '" << config << "'");
return false;
}
}
- typeWriter.finish();
+ type_writer.Finish();
return true;
}
- std::vector<ResourceTableType*> collectAndSortTypes() {
- std::vector<ResourceTableType*> sortedTypes;
- for (auto& type : mPackage->types) {
+ std::vector<ResourceTableType*> CollectAndSortTypes() {
+ std::vector<ResourceTableType*> sorted_types;
+ for (auto& type : package_->types) {
if (type->type == ResourceType::kStyleable) {
// Styleables aren't real Resource Types, they are represented in the
- // R.java
- // file.
+ // R.java file.
continue;
}
- assert(type->id && "type must have an ID set");
+ CHECK(bool(type->id)) << "type must have an ID set";
- sortedTypes.push_back(type.get());
+ sorted_types.push_back(type.get());
}
- std::sort(sortedTypes.begin(), sortedTypes.end(),
- cmpIds<ResourceTableType>);
- return sortedTypes;
+ std::sort(sorted_types.begin(), sorted_types.end(),
+ cmp_ids<ResourceTableType>);
+ return sorted_types;
}
- std::vector<ResourceEntry*> collectAndSortEntries(ResourceTableType* type) {
+ std::vector<ResourceEntry*> CollectAndSortEntries(ResourceTableType* type) {
// Sort the entries by entry ID.
- std::vector<ResourceEntry*> sortedEntries;
+ std::vector<ResourceEntry*> sorted_entries;
for (auto& entry : type->entries) {
- assert(entry->id && "entry must have an ID set");
- sortedEntries.push_back(entry.get());
+ CHECK(bool(entry->id)) << "entry must have an ID set";
+ sorted_entries.push_back(entry.get());
}
- std::sort(sortedEntries.begin(), sortedEntries.end(),
- cmpIds<ResourceEntry>);
- return sortedEntries;
+ std::sort(sorted_entries.begin(), sorted_entries.end(),
+ cmp_ids<ResourceEntry>);
+ return sorted_entries;
}
- bool flattenTypeSpec(ResourceTableType* type,
- std::vector<ResourceEntry*>* sortedEntries,
+ bool FlattenTypeSpec(ResourceTableType* type,
+ std::vector<ResourceEntry*>* sorted_entries,
BigBuffer* buffer) {
- ChunkWriter typeSpecWriter(buffer);
- ResTable_typeSpec* specHeader =
- typeSpecWriter.startChunk<ResTable_typeSpec>(RES_TABLE_TYPE_SPEC_TYPE);
- specHeader->id = type->id.value();
+ ChunkWriter type_spec_writer(buffer);
+ ResTable_typeSpec* spec_header =
+ type_spec_writer.StartChunk<ResTable_typeSpec>(
+ RES_TABLE_TYPE_SPEC_TYPE);
+ spec_header->id = type->id.value();
- if (sortedEntries->empty()) {
- typeSpecWriter.finish();
+ if (sorted_entries->empty()) {
+ type_spec_writer.Finish();
return true;
}
// We can't just take the size of the vector. There may be holes in the
// entry ID space.
// Since the entries are sorted by ID, the last one will be the biggest.
- const size_t numEntries = sortedEntries->back()->id.value() + 1;
+ const size_t num_entries = sorted_entries->back()->id.value() + 1;
- specHeader->entryCount = util::hostToDevice32(numEntries);
+ spec_header->entryCount = util::HostToDevice32(num_entries);
// Reserve space for the masks of each resource in this type. These
// show for which configuration axis the resource changes.
- uint32_t* configMasks = typeSpecWriter.nextBlock<uint32_t>(numEntries);
+ uint32_t* config_masks = type_spec_writer.NextBlock<uint32_t>(num_entries);
- const size_t actualNumEntries = sortedEntries->size();
- for (size_t entryIndex = 0; entryIndex < actualNumEntries; entryIndex++) {
- ResourceEntry* entry = sortedEntries->at(entryIndex);
+ const size_t actual_num_entries = sorted_entries->size();
+ for (size_t entryIndex = 0; entryIndex < actual_num_entries; entryIndex++) {
+ ResourceEntry* entry = sorted_entries->at(entryIndex);
// Populate the config masks for this entry.
- if (entry->symbolStatus.state == SymbolState::kPublic) {
- configMasks[entry->id.value()] |=
- util::hostToDevice32(ResTable_typeSpec::SPEC_PUBLIC);
+ if (entry->symbol_status.state == SymbolState::kPublic) {
+ config_masks[entry->id.value()] |=
+ util::HostToDevice32(ResTable_typeSpec::SPEC_PUBLIC);
}
- const size_t configCount = entry->values.size();
- for (size_t i = 0; i < configCount; i++) {
+ const size_t config_count = entry->values.size();
+ for (size_t i = 0; i < config_count; i++) {
const ConfigDescription& config = entry->values[i]->config;
- for (size_t j = i + 1; j < configCount; j++) {
- configMasks[entry->id.value()] |=
- util::hostToDevice32(config.diff(entry->values[j]->config));
+ for (size_t j = i + 1; j < config_count; j++) {
+ config_masks[entry->id.value()] |=
+ util::HostToDevice32(config.diff(entry->values[j]->config));
}
}
}
- typeSpecWriter.finish();
+ type_spec_writer.Finish();
return true;
}
- bool flattenTypes(BigBuffer* buffer) {
+ bool FlattenTypes(BigBuffer* buffer) {
// Sort the types by their IDs. They will be inserted into the StringPool in
// this order.
- std::vector<ResourceTableType*> sortedTypes = collectAndSortTypes();
+ std::vector<ResourceTableType*> sorted_types = CollectAndSortTypes();
- size_t expectedTypeId = 1;
- for (ResourceTableType* type : sortedTypes) {
+ size_t expected_type_id = 1;
+ for (ResourceTableType* type : sorted_types) {
// If there is a gap in the type IDs, fill in the StringPool
// with empty values until we reach the ID we expect.
- while (type->id.value() > expectedTypeId) {
- std::stringstream typeName;
- typeName << "?" << expectedTypeId;
- mTypePool.makeRef(typeName.str());
- expectedTypeId++;
+ while (type->id.value() > expected_type_id) {
+ std::stringstream type_name;
+ type_name << "?" << expected_type_id;
+ type_pool_.MakeRef(type_name.str());
+ expected_type_id++;
}
- expectedTypeId++;
- mTypePool.makeRef(toString(type->type));
+ expected_type_id++;
+ type_pool_.MakeRef(ToString(type->type));
- std::vector<ResourceEntry*> sortedEntries = collectAndSortEntries(type);
+ std::vector<ResourceEntry*> sorted_entries = CollectAndSortEntries(type);
- if (!flattenTypeSpec(type, &sortedEntries, buffer)) {
+ if (!FlattenTypeSpec(type, &sorted_entries, buffer)) {
return false;
}
@@ -455,35 +454,41 @@
// each
// configuration available. Here we reverse this to match the binary
// table.
- std::map<ConfigDescription, std::vector<FlatEntry>> configToEntryListMap;
- for (ResourceEntry* entry : sortedEntries) {
- const uint32_t keyIndex =
- (uint32_t)mKeyPool.makeRef(entry->name).getIndex();
+ std::map<ConfigDescription, std::vector<FlatEntry>>
+ config_to_entry_list_map;
+ for (ResourceEntry* entry : sorted_entries) {
+ const uint32_t key_index =
+ (uint32_t)key_pool_.MakeRef(entry->name).index();
// Group values by configuration.
- for (auto& configValue : entry->values) {
- configToEntryListMap[configValue->config].push_back(
- FlatEntry{entry, configValue->value.get(), keyIndex});
+ for (auto& config_value : entry->values) {
+ config_to_entry_list_map[config_value->config].push_back(
+ FlatEntry{entry, config_value->value.get(), key_index});
}
}
// Flatten a configuration value.
- for (auto& entry : configToEntryListMap) {
- if (!flattenConfig(type, entry.first, &entry.second, buffer)) {
+ for (auto& entry : config_to_entry_list_map) {
+ if (!FlattenConfig(type, entry.first, &entry.second, buffer)) {
return false;
}
}
}
return true;
}
+
+ IDiagnostics* diag_;
+ ResourceTablePackage* package_;
+ StringPool type_pool_;
+ StringPool key_pool_;
};
} // namespace
-bool TableFlattener::consume(IAaptContext* context, ResourceTable* table) {
+bool TableFlattener::Consume(IAaptContext* context, ResourceTable* table) {
// We must do this before writing the resources, since the string pool IDs may
// change.
- table->stringPool.sort(
+ table->string_pool.Sort(
[](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
int diff = a.context.priority - b.context.priority;
if (diff < 0) return true;
@@ -493,30 +498,30 @@
if (diff > 0) return false;
return a.value < b.value;
});
- table->stringPool.prune();
+ table->string_pool.Prune();
// Write the ResTable header.
- ChunkWriter tableWriter(mBuffer);
- ResTable_header* tableHeader =
- tableWriter.startChunk<ResTable_header>(RES_TABLE_TYPE);
- tableHeader->packageCount = util::hostToDevice32(table->packages.size());
+ ChunkWriter table_writer(buffer_);
+ ResTable_header* table_header =
+ table_writer.StartChunk<ResTable_header>(RES_TABLE_TYPE);
+ table_header->packageCount = util::HostToDevice32(table->packages.size());
// Flatten the values string pool.
- StringPool::flattenUtf8(tableWriter.getBuffer(), table->stringPool);
+ StringPool::FlattenUtf8(table_writer.buffer(), table->string_pool);
- BigBuffer packageBuffer(1024);
+ BigBuffer package_buffer(1024);
// Flatten each package.
for (auto& package : table->packages) {
- PackageFlattener flattener(context->getDiagnostics(), package.get());
- if (!flattener.flattenPackage(&packageBuffer)) {
+ PackageFlattener flattener(context->GetDiagnostics(), package.get());
+ if (!flattener.FlattenPackage(&package_buffer)) {
return false;
}
}
// Finally merge all the packages into the main buffer.
- tableWriter.getBuffer()->appendBuffer(std::move(packageBuffer));
- tableWriter.finish();
+ table_writer.buffer()->AppendBuffer(std::move(package_buffer));
+ table_writer.Finish();
return true;
}
diff --git a/tools/aapt2/flatten/TableFlattener.h b/tools/aapt2/flatten/TableFlattener.h
index 91f9654..53f52c2 100644
--- a/tools/aapt2/flatten/TableFlattener.h
+++ b/tools/aapt2/flatten/TableFlattener.h
@@ -17,21 +17,24 @@
#ifndef AAPT_FLATTEN_TABLEFLATTENER_H
#define AAPT_FLATTEN_TABLEFLATTENER_H
+#include "android-base/macros.h"
+
+#include "ResourceTable.h"
#include "process/IResourceTableConsumer.h"
+#include "util/BigBuffer.h"
namespace aapt {
-class BigBuffer;
-class ResourceTable;
-
class TableFlattener : public IResourceTableConsumer {
public:
- explicit TableFlattener(BigBuffer* buffer) : mBuffer(buffer) {}
+ explicit TableFlattener(BigBuffer* buffer) : buffer_(buffer) {}
- bool consume(IAaptContext* context, ResourceTable* table) override;
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
private:
- BigBuffer* mBuffer;
+ DISALLOW_COPY_AND_ASSIGN(TableFlattener);
+
+ BigBuffer* buffer_;
};
} // namespace aapt
diff --git a/tools/aapt2/flatten/TableFlattener_test.cpp b/tools/aapt2/flatten/TableFlattener_test.cpp
index a7706bd..c726240 100644
--- a/tools/aapt2/flatten/TableFlattener_test.cpp
+++ b/tools/aapt2/flatten/TableFlattener_test.cpp
@@ -15,6 +15,7 @@
*/
#include "flatten/TableFlattener.h"
+
#include "ResourceUtils.h"
#include "test/Test.h"
#include "unflatten/BinaryResourceParser.h"
@@ -27,162 +28,165 @@
class TableFlattenerTest : public ::testing::Test {
public:
void SetUp() override {
- mContext = test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .build();
+ context_ = test::ContextBuilder()
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .Build();
}
- ::testing::AssertionResult flatten(ResourceTable* table, ResTable* outTable) {
+ ::testing::AssertionResult Flatten(ResourceTable* table,
+ ResTable* out_table) {
BigBuffer buffer(1024);
TableFlattener flattener(&buffer);
- if (!flattener.consume(mContext.get(), table)) {
+ if (!flattener.Consume(context_.get(), table)) {
return ::testing::AssertionFailure() << "failed to flatten ResourceTable";
}
- std::unique_ptr<uint8_t[]> data = util::copy(buffer);
- if (outTable->add(data.get(), buffer.size(), -1, true) != NO_ERROR) {
+ std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
+ if (out_table->add(data.get(), buffer.size(), -1, true) != NO_ERROR) {
return ::testing::AssertionFailure() << "flattened ResTable is corrupt";
}
return ::testing::AssertionSuccess();
}
- ::testing::AssertionResult flatten(ResourceTable* table,
- ResourceTable* outTable) {
+ ::testing::AssertionResult Flatten(ResourceTable* table,
+ ResourceTable* out_table) {
BigBuffer buffer(1024);
TableFlattener flattener(&buffer);
- if (!flattener.consume(mContext.get(), table)) {
+ if (!flattener.Consume(context_.get(), table)) {
return ::testing::AssertionFailure() << "failed to flatten ResourceTable";
}
- std::unique_ptr<uint8_t[]> data = util::copy(buffer);
- BinaryResourceParser parser(mContext.get(), outTable, {}, data.get(),
+ std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
+ BinaryResourceParser parser(context_.get(), out_table, {}, data.get(),
buffer.size());
- if (!parser.parse()) {
+ if (!parser.Parse()) {
return ::testing::AssertionFailure() << "flattened ResTable is corrupt";
}
return ::testing::AssertionSuccess();
}
- ::testing::AssertionResult exists(ResTable* table,
- const StringPiece& expectedName,
- const ResourceId& expectedId,
- const ConfigDescription& expectedConfig,
- const uint8_t expectedDataType,
- const uint32_t expectedData,
- const uint32_t expectedSpecFlags) {
- const ResourceName expectedResName = test::parseNameOrDie(expectedName);
+ ::testing::AssertionResult Exists(ResTable* table,
+ const StringPiece& expected_name,
+ const ResourceId& expected_id,
+ const ConfigDescription& expected_config,
+ const uint8_t expected_data_type,
+ const uint32_t expected_data,
+ const uint32_t expected_spec_flags) {
+ const ResourceName expected_res_name = test::ParseNameOrDie(expected_name);
- table->setParameters(&expectedConfig);
+ table->setParameters(&expected_config);
ResTable_config config;
Res_value val;
- uint32_t specFlags;
- if (table->getResource(expectedId.id, &val, false, 0, &specFlags, &config) <
- 0) {
+ uint32_t spec_flags;
+ if (table->getResource(expected_id.id, &val, false, 0, &spec_flags,
+ &config) < 0) {
return ::testing::AssertionFailure() << "could not find resource with";
}
- if (expectedDataType != val.dataType) {
+ if (expected_data_type != val.dataType) {
return ::testing::AssertionFailure()
- << "expected data type " << std::hex << (int)expectedDataType
+ << "expected data type " << std::hex << (int)expected_data_type
<< " but got data type " << (int)val.dataType << std::dec
<< " instead";
}
- if (expectedData != val.data) {
+ if (expected_data != val.data) {
return ::testing::AssertionFailure()
- << "expected data " << std::hex << expectedData << " but got data "
- << val.data << std::dec << " instead";
+ << "expected data " << std::hex << expected_data
+ << " but got data " << val.data << std::dec << " instead";
}
- if (expectedSpecFlags != specFlags) {
+ if (expected_spec_flags != spec_flags) {
return ::testing::AssertionFailure()
- << "expected specFlags " << std::hex << expectedSpecFlags
- << " but got specFlags " << specFlags << std::dec << " instead";
+ << "expected specFlags " << std::hex << expected_spec_flags
+ << " but got specFlags " << spec_flags << std::dec << " instead";
}
- ResTable::resource_name actualName;
- if (!table->getResourceName(expectedId.id, false, &actualName)) {
+ ResTable::resource_name actual_name;
+ if (!table->getResourceName(expected_id.id, false, &actual_name)) {
return ::testing::AssertionFailure() << "failed to find resource name";
}
- Maybe<ResourceName> resName = ResourceUtils::toResourceName(actualName);
+ Maybe<ResourceName> resName = ResourceUtils::ToResourceName(actual_name);
if (!resName) {
return ::testing::AssertionFailure()
- << "expected name '" << expectedResName << "' but got '"
- << StringPiece16(actualName.package, actualName.packageLen) << ":"
- << StringPiece16(actualName.type, actualName.typeLen) << "/"
- << StringPiece16(actualName.name, actualName.nameLen) << "'";
+ << "expected name '" << expected_res_name << "' but got '"
+ << StringPiece16(actual_name.package, actual_name.packageLen)
+ << ":" << StringPiece16(actual_name.type, actual_name.typeLen)
+ << "/" << StringPiece16(actual_name.name, actual_name.nameLen)
+ << "'";
}
- if (expectedConfig != config) {
+ if (expected_config != config) {
return ::testing::AssertionFailure() << "expected config '"
- << expectedConfig << "' but got '"
+ << expected_config << "' but got '"
<< ConfigDescription(config) << "'";
}
return ::testing::AssertionSuccess();
}
private:
- std::unique_ptr<IAaptContext> mContext;
+ std::unique_ptr<IAaptContext> context_;
};
TEST_F(TableFlattenerTest, FlattenFullyLinkedTable) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addSimple("com.app.test:id/one", ResourceId(0x7f020000))
- .addSimple("com.app.test:id/two", ResourceId(0x7f020001))
- .addValue("com.app.test:id/three", ResourceId(0x7f020002),
- test::buildReference("com.app.test:id/one",
+ .SetPackageId("com.app.test", 0x7f)
+ .AddSimple("com.app.test:id/one", ResourceId(0x7f020000))
+ .AddSimple("com.app.test:id/two", ResourceId(0x7f020001))
+ .AddValue("com.app.test:id/three", ResourceId(0x7f020002),
+ test::BuildReference("com.app.test:id/one",
ResourceId(0x7f020000)))
- .addValue("com.app.test:integer/one", ResourceId(0x7f030000),
+ .AddValue("com.app.test:integer/one", ResourceId(0x7f030000),
util::make_unique<BinaryPrimitive>(
uint8_t(Res_value::TYPE_INT_DEC), 1u))
- .addValue("com.app.test:integer/one", test::parseConfigOrDie("v1"),
+ .AddValue("com.app.test:integer/one", test::ParseConfigOrDie("v1"),
ResourceId(0x7f030000),
util::make_unique<BinaryPrimitive>(
uint8_t(Res_value::TYPE_INT_DEC), 2u))
- .addString("com.app.test:string/test", ResourceId(0x7f040000), "foo")
- .addString("com.app.test:layout/bar", ResourceId(0x7f050000),
+ .AddString("com.app.test:string/test", ResourceId(0x7f040000), "foo")
+ .AddString("com.app.test:layout/bar", ResourceId(0x7f050000),
"res/layout/bar.xml")
- .build();
+ .Build();
- ResTable resTable;
- ASSERT_TRUE(flatten(table.get(), &resTable));
+ ResTable res_table;
+ ASSERT_TRUE(Flatten(table.get(), &res_table));
- EXPECT_TRUE(exists(&resTable, "com.app.test:id/one", ResourceId(0x7f020000),
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:id/one", ResourceId(0x7f020000),
{}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
- EXPECT_TRUE(exists(&resTable, "com.app.test:id/two", ResourceId(0x7f020001),
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:id/two", ResourceId(0x7f020001),
{}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
- EXPECT_TRUE(exists(&resTable, "com.app.test:id/three", ResourceId(0x7f020002),
- {}, Res_value::TYPE_REFERENCE, 0x7f020000u, 0u));
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:id/three",
+ ResourceId(0x7f020002), {}, Res_value::TYPE_REFERENCE,
+ 0x7f020000u, 0u));
- EXPECT_TRUE(exists(&resTable, "com.app.test:integer/one",
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:integer/one",
ResourceId(0x7f030000), {}, Res_value::TYPE_INT_DEC, 1u,
ResTable_config::CONFIG_VERSION));
- EXPECT_TRUE(exists(&resTable, "com.app.test:integer/one",
- ResourceId(0x7f030000), test::parseConfigOrDie("v1"),
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:integer/one",
+ ResourceId(0x7f030000), test::ParseConfigOrDie("v1"),
Res_value::TYPE_INT_DEC, 2u,
ResTable_config::CONFIG_VERSION));
- std::u16string fooStr = u"foo";
- ssize_t idx = resTable.getTableStringBlock(0)->indexOfString(fooStr.data(),
- fooStr.size());
+ std::u16string foo_str = u"foo";
+ ssize_t idx = res_table.getTableStringBlock(0)->indexOfString(foo_str.data(),
+ foo_str.size());
ASSERT_GE(idx, 0);
- EXPECT_TRUE(exists(&resTable, "com.app.test:string/test",
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:string/test",
ResourceId(0x7f040000), {}, Res_value::TYPE_STRING,
(uint32_t)idx, 0u));
- std::u16string barPath = u"res/layout/bar.xml";
- idx = resTable.getTableStringBlock(0)->indexOfString(barPath.data(),
- barPath.size());
+ std::u16string bar_path = u"res/layout/bar.xml";
+ idx = res_table.getTableStringBlock(0)->indexOfString(bar_path.data(),
+ bar_path.size());
ASSERT_GE(idx, 0);
- EXPECT_TRUE(exists(&resTable, "com.app.test:layout/bar",
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:layout/bar",
ResourceId(0x7f050000), {}, Res_value::TYPE_STRING,
(uint32_t)idx, 0u));
}
@@ -190,42 +194,43 @@
TEST_F(TableFlattenerTest, FlattenEntriesWithGapsInIds) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addSimple("com.app.test:id/one", ResourceId(0x7f020001))
- .addSimple("com.app.test:id/three", ResourceId(0x7f020003))
- .build();
+ .SetPackageId("com.app.test", 0x7f)
+ .AddSimple("com.app.test:id/one", ResourceId(0x7f020001))
+ .AddSimple("com.app.test:id/three", ResourceId(0x7f020003))
+ .Build();
- ResTable resTable;
- ASSERT_TRUE(flatten(table.get(), &resTable));
+ ResTable res_table;
+ ASSERT_TRUE(Flatten(table.get(), &res_table));
- EXPECT_TRUE(exists(&resTable, "com.app.test:id/one", ResourceId(0x7f020001),
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:id/one", ResourceId(0x7f020001),
{}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
- EXPECT_TRUE(exists(&resTable, "com.app.test:id/three", ResourceId(0x7f020003),
- {}, Res_value::TYPE_INT_BOOLEAN, 0u, 0u));
+ EXPECT_TRUE(Exists(&res_table, "com.app.test:id/three",
+ ResourceId(0x7f020003), {}, Res_value::TYPE_INT_BOOLEAN,
+ 0u, 0u));
}
TEST_F(TableFlattenerTest, FlattenMinMaxAttributes) {
Attribute attr(false);
- attr.typeMask = android::ResTable_map::TYPE_INTEGER;
- attr.minInt = 10;
- attr.maxInt = 23;
+ attr.type_mask = android::ResTable_map::TYPE_INTEGER;
+ attr.min_int = 10;
+ attr.max_int = 23;
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addValue("android:attr/foo", ResourceId(0x01010000),
+ .SetPackageId("android", 0x01)
+ .AddValue("android:attr/foo", ResourceId(0x01010000),
util::make_unique<Attribute>(attr))
- .build();
+ .Build();
ResourceTable result;
- ASSERT_TRUE(flatten(table.get(), &result));
+ ASSERT_TRUE(Flatten(table.get(), &result));
Attribute* actualAttr =
- test::getValue<Attribute>(&result, "android:attr/foo");
+ test::GetValue<Attribute>(&result, "android:attr/foo");
ASSERT_NE(nullptr, actualAttr);
- EXPECT_EQ(attr.isWeak(), actualAttr->isWeak());
- EXPECT_EQ(attr.typeMask, actualAttr->typeMask);
- EXPECT_EQ(attr.minInt, actualAttr->minInt);
- EXPECT_EQ(attr.maxInt, actualAttr->maxInt);
+ EXPECT_EQ(attr.IsWeak(), actualAttr->IsWeak());
+ EXPECT_EQ(attr.type_mask, actualAttr->type_mask);
+ EXPECT_EQ(attr.min_int, actualAttr->min_int);
+ EXPECT_EQ(attr.max_int, actualAttr->max_int);
}
} // namespace aapt
diff --git a/tools/aapt2/flatten/XmlFlattener.cpp b/tools/aapt2/flatten/XmlFlattener.cpp
index b1536d5..366c373 100644
--- a/tools/aapt2/flatten/XmlFlattener.cpp
+++ b/tools/aapt2/flatten/XmlFlattener.cpp
@@ -15,17 +15,21 @@
*/
#include "flatten/XmlFlattener.h"
+
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+#include "utils/misc.h"
+
#include "SdkConstants.h"
#include "flatten/ChunkWriter.h"
#include "flatten/ResourceTypeExtensions.h"
#include "xml/XmlDom.h"
-#include <androidfw/ResourceTypes.h>
-#include <utils/misc.h>
-#include <algorithm>
-#include <map>
-#include <vector>
-
using namespace android;
namespace aapt {
@@ -34,216 +38,215 @@
constexpr uint32_t kLowPriority = 0xffffffffu;
-struct XmlFlattenerVisitor : public xml::Visitor {
- using xml::Visitor::visit;
+static bool cmp_xml_attribute_by_id(const xml::Attribute* a,
+ const xml::Attribute* b) {
+ if (a->compiled_attribute && a->compiled_attribute.value().id) {
+ if (b->compiled_attribute && b->compiled_attribute.value().id) {
+ return a->compiled_attribute.value().id.value() <
+ b->compiled_attribute.value().id.value();
+ }
+ return true;
+ } else if (!b->compiled_attribute) {
+ int diff = a->namespace_uri.compare(b->namespace_uri);
+ if (diff < 0) {
+ return true;
+ } else if (diff > 0) {
+ return false;
+ }
+ return a->name < b->name;
+ }
+ return false;
+}
- BigBuffer* mBuffer;
- XmlFlattenerOptions mOptions;
- StringPool mPool;
- std::map<uint8_t, StringPool> mPackagePools;
+class XmlFlattenerVisitor : public xml::Visitor {
+ public:
+ using xml::Visitor::Visit;
+
+ StringPool pool;
+ std::map<uint8_t, StringPool> package_pools;
struct StringFlattenDest {
StringPool::Ref ref;
ResStringPool_ref* dest;
};
- std::vector<StringFlattenDest> mStringRefs;
- // Scratch vector to filter attributes. We avoid allocations
- // making this a member.
- std::vector<xml::Attribute*> mFilteredAttrs;
+ std::vector<StringFlattenDest> string_refs;
XmlFlattenerVisitor(BigBuffer* buffer, XmlFlattenerOptions options)
- : mBuffer(buffer), mOptions(options) {}
+ : buffer_(buffer), options_(options) {}
- void addString(const StringPiece& str, uint32_t priority,
- android::ResStringPool_ref* dest,
- bool treatEmptyStringAsNull = false) {
- if (str.empty() && treatEmptyStringAsNull) {
- // Some parts of the runtime treat null differently than empty string.
- dest->index = util::deviceToHost32(-1);
- } else {
- mStringRefs.push_back(StringFlattenDest{
- mPool.makeRef(str, StringPool::Context(priority)), dest});
- }
- }
-
- void addString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
- mStringRefs.push_back(StringFlattenDest{ref, dest});
- }
-
- void writeNamespace(xml::Namespace* node, uint16_t type) {
- ChunkWriter writer(mBuffer);
-
- ResXMLTree_node* flatNode = writer.startChunk<ResXMLTree_node>(type);
- flatNode->lineNumber = util::hostToDevice32(node->lineNumber);
- flatNode->comment.index = util::hostToDevice32(-1);
-
- ResXMLTree_namespaceExt* flatNs =
- writer.nextBlock<ResXMLTree_namespaceExt>();
- addString(node->namespacePrefix, kLowPriority, &flatNs->prefix);
- addString(node->namespaceUri, kLowPriority, &flatNs->uri);
-
- writer.finish();
- }
-
- void visit(xml::Namespace* node) override {
- if (node->namespaceUri == xml::kSchemaTools) {
+ void Visit(xml::Namespace* node) override {
+ if (node->namespace_uri == xml::kSchemaTools) {
// Skip dedicated tools namespace.
- xml::Visitor::visit(node);
+ xml::Visitor::Visit(node);
} else {
- writeNamespace(node, android::RES_XML_START_NAMESPACE_TYPE);
- xml::Visitor::visit(node);
- writeNamespace(node, android::RES_XML_END_NAMESPACE_TYPE);
+ WriteNamespace(node, android::RES_XML_START_NAMESPACE_TYPE);
+ xml::Visitor::Visit(node);
+ WriteNamespace(node, android::RES_XML_END_NAMESPACE_TYPE);
}
}
- void visit(xml::Text* node) override {
- if (util::trimWhitespace(node->text).empty()) {
+ void Visit(xml::Text* node) override {
+ if (util::TrimWhitespace(node->text).empty()) {
// Skip whitespace only text nodes.
return;
}
- ChunkWriter writer(mBuffer);
- ResXMLTree_node* flatNode =
- writer.startChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
- flatNode->lineNumber = util::hostToDevice32(node->lineNumber);
- flatNode->comment.index = util::hostToDevice32(-1);
+ ChunkWriter writer(buffer_);
+ ResXMLTree_node* flat_node =
+ writer.StartChunk<ResXMLTree_node>(RES_XML_CDATA_TYPE);
+ flat_node->lineNumber = util::HostToDevice32(node->line_number);
+ flat_node->comment.index = util::HostToDevice32(-1);
- ResXMLTree_cdataExt* flatText = writer.nextBlock<ResXMLTree_cdataExt>();
- addString(node->text, kLowPriority, &flatText->data);
+ ResXMLTree_cdataExt* flat_text = writer.NextBlock<ResXMLTree_cdataExt>();
+ AddString(node->text, kLowPriority, &flat_text->data);
- writer.finish();
+ writer.Finish();
}
- void visit(xml::Element* node) override {
+ void Visit(xml::Element* node) override {
{
- ChunkWriter startWriter(mBuffer);
- ResXMLTree_node* flatNode =
- startWriter.startChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
- flatNode->lineNumber = util::hostToDevice32(node->lineNumber);
- flatNode->comment.index = util::hostToDevice32(-1);
+ ChunkWriter start_writer(buffer_);
+ ResXMLTree_node* flat_node =
+ start_writer.StartChunk<ResXMLTree_node>(RES_XML_START_ELEMENT_TYPE);
+ flat_node->lineNumber = util::HostToDevice32(node->line_number);
+ flat_node->comment.index = util::HostToDevice32(-1);
- ResXMLTree_attrExt* flatElem =
- startWriter.nextBlock<ResXMLTree_attrExt>();
+ ResXMLTree_attrExt* flat_elem =
+ start_writer.NextBlock<ResXMLTree_attrExt>();
// A missing namespace must be null, not an empty string. Otherwise the
- // runtime
- // complains.
- addString(node->namespaceUri, kLowPriority, &flatElem->ns,
- true /* treatEmptyStringAsNull */);
- addString(node->name, kLowPriority, &flatElem->name,
- true /* treatEmptyStringAsNull */);
+ // runtime complains.
+ AddString(node->namespace_uri, kLowPriority, &flat_elem->ns,
+ true /* treat_empty_string_as_null */);
+ AddString(node->name, kLowPriority, &flat_elem->name,
+ true /* treat_empty_string_as_null */);
- flatElem->attributeStart = util::hostToDevice16(sizeof(*flatElem));
- flatElem->attributeSize =
- util::hostToDevice16(sizeof(ResXMLTree_attribute));
+ flat_elem->attributeStart = util::HostToDevice16(sizeof(*flat_elem));
+ flat_elem->attributeSize =
+ util::HostToDevice16(sizeof(ResXMLTree_attribute));
- writeAttributes(node, flatElem, &startWriter);
+ WriteAttributes(node, flat_elem, &start_writer);
- startWriter.finish();
+ start_writer.Finish();
}
- xml::Visitor::visit(node);
+ xml::Visitor::Visit(node);
{
- ChunkWriter endWriter(mBuffer);
- ResXMLTree_node* flatEndNode =
- endWriter.startChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
- flatEndNode->lineNumber = util::hostToDevice32(node->lineNumber);
- flatEndNode->comment.index = util::hostToDevice32(-1);
+ ChunkWriter end_writer(buffer_);
+ ResXMLTree_node* flat_end_node =
+ end_writer.StartChunk<ResXMLTree_node>(RES_XML_END_ELEMENT_TYPE);
+ flat_end_node->lineNumber = util::HostToDevice32(node->line_number);
+ flat_end_node->comment.index = util::HostToDevice32(-1);
- ResXMLTree_endElementExt* flatEndElem =
- endWriter.nextBlock<ResXMLTree_endElementExt>();
- addString(node->namespaceUri, kLowPriority, &flatEndElem->ns,
- true /* treatEmptyStringAsNull */);
- addString(node->name, kLowPriority, &flatEndElem->name);
+ ResXMLTree_endElementExt* flat_end_elem =
+ end_writer.NextBlock<ResXMLTree_endElementExt>();
+ AddString(node->namespace_uri, kLowPriority, &flat_end_elem->ns,
+ true /* treat_empty_string_as_null */);
+ AddString(node->name, kLowPriority, &flat_end_elem->name);
- endWriter.finish();
+ end_writer.Finish();
}
}
- static bool cmpXmlAttributeById(const xml::Attribute* a,
- const xml::Attribute* b) {
- if (a->compiledAttribute && a->compiledAttribute.value().id) {
- if (b->compiledAttribute && b->compiledAttribute.value().id) {
- return a->compiledAttribute.value().id.value() <
- b->compiledAttribute.value().id.value();
- }
- return true;
- } else if (!b->compiledAttribute) {
- int diff = a->namespaceUri.compare(b->namespaceUri);
- if (diff < 0) {
- return true;
- } else if (diff > 0) {
- return false;
- }
- return a->name < b->name;
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlFlattenerVisitor);
+
+ void AddString(const StringPiece& str, uint32_t priority,
+ android::ResStringPool_ref* dest,
+ bool treat_empty_string_as_null = false) {
+ if (str.empty() && treat_empty_string_as_null) {
+ // Some parts of the runtime treat null differently than empty string.
+ dest->index = util::DeviceToHost32(-1);
+ } else {
+ string_refs.push_back(StringFlattenDest{
+ pool.MakeRef(str, StringPool::Context(priority)), dest});
}
- return false;
}
- void writeAttributes(xml::Element* node, ResXMLTree_attrExt* flatElem,
+ void AddString(const StringPool::Ref& ref, android::ResStringPool_ref* dest) {
+ string_refs.push_back(StringFlattenDest{ref, dest});
+ }
+
+ void WriteNamespace(xml::Namespace* node, uint16_t type) {
+ ChunkWriter writer(buffer_);
+
+ ResXMLTree_node* flatNode = writer.StartChunk<ResXMLTree_node>(type);
+ flatNode->lineNumber = util::HostToDevice32(node->line_number);
+ flatNode->comment.index = util::HostToDevice32(-1);
+
+ ResXMLTree_namespaceExt* flat_ns =
+ writer.NextBlock<ResXMLTree_namespaceExt>();
+ AddString(node->namespace_prefix, kLowPriority, &flat_ns->prefix);
+ AddString(node->namespace_uri, kLowPriority, &flat_ns->uri);
+
+ writer.Finish();
+ }
+
+ void WriteAttributes(xml::Element* node, ResXMLTree_attrExt* flat_elem,
ChunkWriter* writer) {
- mFilteredAttrs.clear();
- mFilteredAttrs.reserve(node->attributes.size());
+ filtered_attrs_.clear();
+ filtered_attrs_.reserve(node->attributes.size());
// Filter the attributes.
for (xml::Attribute& attr : node->attributes) {
- if (mOptions.maxSdkLevel && attr.compiledAttribute &&
- attr.compiledAttribute.value().id) {
- size_t sdkLevel =
- findAttributeSdkLevel(attr.compiledAttribute.value().id.value());
- if (sdkLevel > mOptions.maxSdkLevel.value()) {
+ if (options_.max_sdk_level && attr.compiled_attribute &&
+ attr.compiled_attribute.value().id) {
+ size_t sdk_level =
+ FindAttributeSdkLevel(attr.compiled_attribute.value().id.value());
+ if (sdk_level > options_.max_sdk_level.value()) {
continue;
}
}
- if (attr.namespaceUri == xml::kSchemaTools) {
+ if (attr.namespace_uri == xml::kSchemaTools) {
continue;
}
- mFilteredAttrs.push_back(&attr);
+ filtered_attrs_.push_back(&attr);
}
- if (mFilteredAttrs.empty()) {
+ if (filtered_attrs_.empty()) {
return;
}
const ResourceId kIdAttr(0x010100d0);
- std::sort(mFilteredAttrs.begin(), mFilteredAttrs.end(),
- cmpXmlAttributeById);
+ std::sort(filtered_attrs_.begin(), filtered_attrs_.end(),
+ cmp_xml_attribute_by_id);
- flatElem->attributeCount = util::hostToDevice16(mFilteredAttrs.size());
+ flat_elem->attributeCount = util::HostToDevice16(filtered_attrs_.size());
- ResXMLTree_attribute* flatAttr =
- writer->nextBlock<ResXMLTree_attribute>(mFilteredAttrs.size());
- uint16_t attributeIndex = 1;
- for (const xml::Attribute* xmlAttr : mFilteredAttrs) {
+ ResXMLTree_attribute* flat_attr =
+ writer->NextBlock<ResXMLTree_attribute>(filtered_attrs_.size());
+ uint16_t attribute_index = 1;
+ for (const xml::Attribute* xml_attr : filtered_attrs_) {
// Assign the indices for specific attributes.
- if (xmlAttr->compiledAttribute && xmlAttr->compiledAttribute.value().id &&
- xmlAttr->compiledAttribute.value().id.value() == kIdAttr) {
- flatElem->idIndex = util::hostToDevice16(attributeIndex);
- } else if (xmlAttr->namespaceUri.empty()) {
- if (xmlAttr->name == "class") {
- flatElem->classIndex = util::hostToDevice16(attributeIndex);
- } else if (xmlAttr->name == "style") {
- flatElem->styleIndex = util::hostToDevice16(attributeIndex);
+ if (xml_attr->compiled_attribute &&
+ xml_attr->compiled_attribute.value().id &&
+ xml_attr->compiled_attribute.value().id.value() == kIdAttr) {
+ flat_elem->idIndex = util::HostToDevice16(attribute_index);
+ } else if (xml_attr->namespace_uri.empty()) {
+ if (xml_attr->name == "class") {
+ flat_elem->classIndex = util::HostToDevice16(attribute_index);
+ } else if (xml_attr->name == "style") {
+ flat_elem->styleIndex = util::HostToDevice16(attribute_index);
}
}
- attributeIndex++;
+ attribute_index++;
// Add the namespaceUri to the list of StringRefs to encode. Use null if
// the namespace
// is empty (doesn't exist).
- addString(xmlAttr->namespaceUri, kLowPriority, &flatAttr->ns,
- true /* treatEmptyStringAsNull */);
+ AddString(xml_attr->namespace_uri, kLowPriority, &flat_attr->ns,
+ true /* treat_empty_string_as_null */);
- flatAttr->rawValue.index = util::hostToDevice32(-1);
+ flat_attr->rawValue.index = util::HostToDevice32(-1);
- if (!xmlAttr->compiledAttribute ||
- !xmlAttr->compiledAttribute.value().id) {
+ if (!xml_attr->compiled_attribute ||
+ !xml_attr->compiled_attribute.value().id) {
// The attribute has no associated ResourceID, so the string order
// doesn't matter.
- addString(xmlAttr->name, kLowPriority, &flatAttr->name);
+ AddString(xml_attr->name, kLowPriority, &flat_attr->name);
} else {
// Attribute names are stored without packages, but we use
// their StringPool index to lookup their resource IDs.
@@ -252,99 +255,106 @@
// pools that we later combine.
//
// Lookup the StringPool for this package and make the reference there.
- const xml::AaptAttribute& aaptAttr = xmlAttr->compiledAttribute.value();
+ const xml::AaptAttribute& aapt_attr =
+ xml_attr->compiled_attribute.value();
- StringPool::Ref nameRef =
- mPackagePools[aaptAttr.id.value().packageId()].makeRef(
- xmlAttr->name, StringPool::Context(aaptAttr.id.value().id));
+ StringPool::Ref name_ref =
+ package_pools[aapt_attr.id.value().package_id()].MakeRef(
+ xml_attr->name, StringPool::Context(aapt_attr.id.value().id));
// Add it to the list of strings to flatten.
- addString(nameRef, &flatAttr->name);
+ AddString(name_ref, &flat_attr->name);
}
- if (mOptions.keepRawValues || !xmlAttr->compiledValue) {
+ if (options_.keep_raw_values || !xml_attr->compiled_value) {
// Keep raw values if the value is not compiled or
// if we're building a static library (need symbols).
- addString(xmlAttr->value, kLowPriority, &flatAttr->rawValue);
+ AddString(xml_attr->value, kLowPriority, &flat_attr->rawValue);
}
- if (xmlAttr->compiledValue) {
- bool result = xmlAttr->compiledValue->flatten(&flatAttr->typedValue);
- assert(result);
+ if (xml_attr->compiled_value) {
+ CHECK(xml_attr->compiled_value->Flatten(&flat_attr->typedValue));
} else {
// Flatten as a regular string type.
- flatAttr->typedValue.dataType = android::Res_value::TYPE_STRING;
- addString(xmlAttr->value, kLowPriority,
- (ResStringPool_ref*)&flatAttr->typedValue.data);
+ flat_attr->typedValue.dataType = android::Res_value::TYPE_STRING;
+ AddString(xml_attr->value, kLowPriority,
+ (ResStringPool_ref*)&flat_attr->typedValue.data);
}
- flatAttr->typedValue.size =
- util::hostToDevice16(sizeof(flatAttr->typedValue));
- flatAttr++;
+ flat_attr->typedValue.size =
+ util::HostToDevice16(sizeof(flat_attr->typedValue));
+ flat_attr++;
}
}
+
+ BigBuffer* buffer_;
+ XmlFlattenerOptions options_;
+
+ // Scratch vector to filter attributes. We avoid allocations
+ // making this a member.
+ std::vector<xml::Attribute*> filtered_attrs_;
};
} // namespace
-bool XmlFlattener::flatten(IAaptContext* context, xml::Node* node) {
- BigBuffer nodeBuffer(1024);
- XmlFlattenerVisitor visitor(&nodeBuffer, mOptions);
- node->accept(&visitor);
+bool XmlFlattener::Flatten(IAaptContext* context, xml::Node* node) {
+ BigBuffer node_buffer(1024);
+ XmlFlattenerVisitor visitor(&node_buffer, options_);
+ node->Accept(&visitor);
// Merge the package pools into the main pool.
- for (auto& packagePoolEntry : visitor.mPackagePools) {
- visitor.mPool.merge(std::move(packagePoolEntry.second));
+ for (auto& package_pool_entry : visitor.package_pools) {
+ visitor.pool.Merge(std::move(package_pool_entry.second));
}
// Sort the string pool so that attribute resource IDs show up first.
- visitor.mPool.sort(
+ visitor.pool.Sort(
[](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
return a.context.priority < b.context.priority;
});
// Now we flatten the string pool references into the correct places.
- for (const auto& refEntry : visitor.mStringRefs) {
- refEntry.dest->index = util::hostToDevice32(refEntry.ref.getIndex());
+ for (const auto& ref_entry : visitor.string_refs) {
+ ref_entry.dest->index = util::HostToDevice32(ref_entry.ref.index());
}
// Write the XML header.
- ChunkWriter xmlHeaderWriter(mBuffer);
- xmlHeaderWriter.startChunk<ResXMLTree_header>(RES_XML_TYPE);
+ ChunkWriter xml_header_writer(buffer_);
+ xml_header_writer.StartChunk<ResXMLTree_header>(RES_XML_TYPE);
// Flatten the StringPool.
- StringPool::flattenUtf8(mBuffer, visitor.mPool);
+ StringPool::FlattenUtf8(buffer_, visitor.pool);
{
// Write the array of resource IDs, indexed by StringPool order.
- ChunkWriter resIdMapWriter(mBuffer);
- resIdMapWriter.startChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
- for (const auto& str : visitor.mPool) {
+ ChunkWriter res_id_map_writer(buffer_);
+ res_id_map_writer.StartChunk<ResChunk_header>(RES_XML_RESOURCE_MAP_TYPE);
+ for (const auto& str : visitor.pool) {
ResourceId id = {str->context.priority};
- if (id.id == kLowPriority || !id.isValid()) {
+ if (id.id == kLowPriority || !id.is_valid()) {
// When we see the first non-resource ID,
// we're done.
break;
}
- *resIdMapWriter.nextBlock<uint32_t>() = id.id;
+ *res_id_map_writer.NextBlock<uint32_t>() = id.id;
}
- resIdMapWriter.finish();
+ res_id_map_writer.Finish();
}
// Move the nodeBuffer and append it to the out buffer.
- mBuffer->appendBuffer(std::move(nodeBuffer));
+ buffer_->AppendBuffer(std::move(node_buffer));
// Finish the xml header.
- xmlHeaderWriter.finish();
+ xml_header_writer.Finish();
return true;
}
-bool XmlFlattener::consume(IAaptContext* context, xml::XmlResource* resource) {
+bool XmlFlattener::Consume(IAaptContext* context, xml::XmlResource* resource) {
if (!resource->root) {
return false;
}
- return flatten(context, resource->root.get());
+ return Flatten(context, resource->root.get());
}
} // namespace aapt
diff --git a/tools/aapt2/flatten/XmlFlattener.h b/tools/aapt2/flatten/XmlFlattener.h
index d8d592b..f5129fd 100644
--- a/tools/aapt2/flatten/XmlFlattener.h
+++ b/tools/aapt2/flatten/XmlFlattener.h
@@ -17,6 +17,8 @@
#ifndef AAPT_FLATTEN_XMLFLATTENER_H
#define AAPT_FLATTEN_XMLFLATTENER_H
+#include "android-base/macros.h"
+
#include "process/IResourceTableConsumer.h"
#include "util/BigBuffer.h"
#include "xml/XmlDom.h"
@@ -27,26 +29,28 @@
/**
* Keep attribute raw string values along with typed values.
*/
- bool keepRawValues = false;
+ bool keep_raw_values = false;
/**
* If set, the max SDK level of attribute to flatten. All others are ignored.
*/
- Maybe<size_t> maxSdkLevel;
+ Maybe<size_t> max_sdk_level;
};
class XmlFlattener : public IXmlResourceConsumer {
public:
XmlFlattener(BigBuffer* buffer, XmlFlattenerOptions options)
- : mBuffer(buffer), mOptions(options) {}
+ : buffer_(buffer), options_(options) {}
- bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+ bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
private:
- BigBuffer* mBuffer;
- XmlFlattenerOptions mOptions;
+ DISALLOW_COPY_AND_ASSIGN(XmlFlattener);
- bool flatten(IAaptContext* context, xml::Node* node);
+ bool Flatten(IAaptContext* context, xml::Node* node);
+
+ BigBuffer* buffer_;
+ XmlFlattenerOptions options_;
};
} // namespace aapt
diff --git a/tools/aapt2/flatten/XmlFlattener_test.cpp b/tools/aapt2/flatten/XmlFlattener_test.cpp
index e0159cb..2c83bb3 100644
--- a/tools/aapt2/flatten/XmlFlattener_test.cpp
+++ b/tools/aapt2/flatten/XmlFlattener_test.cpp
@@ -15,61 +15,62 @@
*/
#include "flatten/XmlFlattener.h"
+
+#include "androidfw/ResourceTypes.h"
+
#include "link/Linkers.h"
#include "test/Test.h"
#include "util/BigBuffer.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-
namespace aapt {
class XmlFlattenerTest : public ::testing::Test {
public:
void SetUp() override {
- mContext =
+ context_ =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
- .addSymbolSource(
+ .SetCompilationPackage("com.app.test")
+ .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addSymbol("android:attr/id", ResourceId(0x010100d0),
- test::AttributeBuilder().build())
- .addSymbol("com.app.test:id/id", ResourceId(0x7f020000))
- .addSymbol("android:attr/paddingStart",
+ .AddSymbol("android:attr/id", ResourceId(0x010100d0),
+ test::AttributeBuilder().Build())
+ .AddSymbol("com.app.test:id/id", ResourceId(0x7f020000))
+ .AddSymbol("android:attr/paddingStart",
ResourceId(0x010103b3),
- test::AttributeBuilder().build())
- .addSymbol("android:attr/colorAccent",
+ test::AttributeBuilder().Build())
+ .AddSymbol("android:attr/colorAccent",
ResourceId(0x01010435),
- test::AttributeBuilder().build())
- .build())
- .build();
+ test::AttributeBuilder().Build())
+ .Build())
+ .Build();
}
- ::testing::AssertionResult flatten(xml::XmlResource* doc,
- android::ResXMLTree* outTree,
+ ::testing::AssertionResult Flatten(xml::XmlResource* doc,
+ android::ResXMLTree* out_tree,
const XmlFlattenerOptions& options = {}) {
using namespace android; // For NO_ERROR on windows because it is a macro.
BigBuffer buffer(1024);
XmlFlattener flattener(&buffer, options);
- if (!flattener.consume(mContext.get(), doc)) {
+ if (!flattener.Consume(context_.get(), doc)) {
return ::testing::AssertionFailure() << "failed to flatten XML Tree";
}
- std::unique_ptr<uint8_t[]> data = util::copy(buffer);
- if (outTree->setTo(data.get(), buffer.size(), true) != NO_ERROR) {
+ std::unique_ptr<uint8_t[]> data = util::Copy(buffer);
+ if (out_tree->setTo(data.get(), buffer.size(), true) != NO_ERROR) {
return ::testing::AssertionFailure() << "flattened XML is corrupt";
}
return ::testing::AssertionSuccess();
}
protected:
- std::unique_ptr<IAaptContext> mContext;
+ std::unique_ptr<IAaptContext> context_;
};
TEST_F(XmlFlattenerTest, FlattenXmlWithNoCompiledAttributes) {
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View xmlns:test="http://com.test"
attr="hey">
<Layout test:hello="hi" />
@@ -77,27 +78,27 @@
</View>)EOF");
android::ResXMLTree tree;
- ASSERT_TRUE(flatten(doc.get(), &tree));
+ ASSERT_TRUE(Flatten(doc.get(), &tree));
ASSERT_EQ(tree.next(), android::ResXMLTree::START_NAMESPACE);
size_t len;
- const char16_t* namespacePrefix = tree.getNamespacePrefix(&len);
- EXPECT_EQ(StringPiece16(namespacePrefix, len), u"test");
+ const char16_t* namespace_prefix = tree.getNamespacePrefix(&len);
+ EXPECT_EQ(StringPiece16(namespace_prefix, len), u"test");
- const char16_t* namespaceUri = tree.getNamespaceUri(&len);
- ASSERT_EQ(StringPiece16(namespaceUri, len), u"http://com.test");
+ const char16_t* namespace_uri = tree.getNamespaceUri(&len);
+ ASSERT_EQ(StringPiece16(namespace_uri, len), u"http://com.test");
ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
- const char16_t* tagName = tree.getElementName(&len);
- EXPECT_EQ(StringPiece16(tagName, len), u"View");
+ const char16_t* tag_name = tree.getElementName(&len);
+ EXPECT_EQ(StringPiece16(tag_name, len), u"View");
ASSERT_EQ(1u, tree.getAttributeCount());
ASSERT_EQ(tree.getAttributeNamespace(0, &len), nullptr);
- const char16_t* attrName = tree.getAttributeName(0, &len);
- EXPECT_EQ(StringPiece16(attrName, len), u"attr");
+ const char16_t* attr_name = tree.getAttributeName(0, &len);
+ EXPECT_EQ(StringPiece16(attr_name, len), u"attr");
EXPECT_EQ(0, tree.indexOfAttribute(nullptr, 0, u"attr",
StringPiece16(u"attr").size()));
@@ -105,22 +106,22 @@
ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
- tagName = tree.getElementName(&len);
- EXPECT_EQ(StringPiece16(tagName, len), u"Layout");
+ tag_name = tree.getElementName(&len);
+ EXPECT_EQ(StringPiece16(tag_name, len), u"Layout");
ASSERT_EQ(1u, tree.getAttributeCount());
- const char16_t* attrNamespace = tree.getAttributeNamespace(0, &len);
- EXPECT_EQ(StringPiece16(attrNamespace, len), u"http://com.test");
+ const char16_t* attr_namespace = tree.getAttributeNamespace(0, &len);
+ EXPECT_EQ(StringPiece16(attr_namespace, len), u"http://com.test");
- attrName = tree.getAttributeName(0, &len);
- EXPECT_EQ(StringPiece16(attrName, len), u"hello");
+ attr_name = tree.getAttributeName(0, &len);
+ EXPECT_EQ(StringPiece16(attr_name, len), u"hello");
ASSERT_EQ(tree.next(), android::ResXMLTree::END_TAG);
ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
- tagName = tree.getElementName(&len);
- EXPECT_EQ(StringPiece16(tagName, len), u"Layout");
+ tag_name = tree.getElementName(&len);
+ EXPECT_EQ(StringPiece16(tag_name, len), u"Layout");
ASSERT_EQ(0u, tree.getAttributeCount());
ASSERT_EQ(tree.next(), android::ResXMLTree::TEXT);
@@ -129,39 +130,39 @@
ASSERT_EQ(tree.next(), android::ResXMLTree::END_TAG);
ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
- tagName = tree.getElementName(&len);
- EXPECT_EQ(StringPiece16(tagName, len), u"Layout");
+ tag_name = tree.getElementName(&len);
+ EXPECT_EQ(StringPiece16(tag_name, len), u"Layout");
ASSERT_EQ(tree.next(), android::ResXMLTree::END_TAG);
ASSERT_EQ(tree.getElementNamespace(&len), nullptr);
- tagName = tree.getElementName(&len);
- EXPECT_EQ(StringPiece16(tagName, len), u"View");
+ tag_name = tree.getElementName(&len);
+ EXPECT_EQ(StringPiece16(tag_name, len), u"View");
ASSERT_EQ(tree.next(), android::ResXMLTree::END_NAMESPACE);
- namespacePrefix = tree.getNamespacePrefix(&len);
- EXPECT_EQ(StringPiece16(namespacePrefix, len), u"test");
+ namespace_prefix = tree.getNamespacePrefix(&len);
+ EXPECT_EQ(StringPiece16(namespace_prefix, len), u"test");
- namespaceUri = tree.getNamespaceUri(&len);
- ASSERT_EQ(StringPiece16(namespaceUri, len), u"http://com.test");
+ namespace_uri = tree.getNamespaceUri(&len);
+ ASSERT_EQ(StringPiece16(namespace_uri, len), u"http://com.test");
ASSERT_EQ(tree.next(), android::ResXMLTree::END_DOCUMENT);
}
TEST_F(XmlFlattenerTest, FlattenCompiledXmlAndStripSdk21) {
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:paddingStart="1dp"
android:colorAccent="#ffffff"/>)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
- ASSERT_TRUE(linker.getSdkLevels().count(17) == 1);
- ASSERT_TRUE(linker.getSdkLevels().count(21) == 1);
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
+ ASSERT_TRUE(linker.sdk_levels().count(17) == 1);
+ ASSERT_TRUE(linker.sdk_levels().count(21) == 1);
android::ResXMLTree tree;
XmlFlattenerOptions options;
- options.maxSdkLevel = 17;
- ASSERT_TRUE(flatten(doc.get(), &tree, options));
+ options.max_sdk_level = 17;
+ ASSERT_TRUE(Flatten(doc.get(), &tree, options));
while (tree.next() != android::ResXMLTree::START_TAG) {
ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
@@ -173,23 +174,23 @@
}
TEST_F(XmlFlattenerTest, FlattenCompiledXmlAndStripOnlyTools) {
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View xmlns:tools="http://schemas.android.com/tools"
xmlns:foo="http://schemas.android.com/foo"
foo:bar="Foo"
tools:ignore="MissingTranslation"/>)EOF");
android::ResXMLTree tree;
- ASSERT_TRUE(flatten(doc.get(), &tree));
+ ASSERT_TRUE(Flatten(doc.get(), &tree));
ASSERT_EQ(tree.next(), android::ResXMLTree::START_NAMESPACE);
size_t len;
- const char16_t* namespacePrefix = tree.getNamespacePrefix(&len);
- EXPECT_EQ(StringPiece16(namespacePrefix, len), u"foo");
+ const char16_t* namespace_prefix = tree.getNamespacePrefix(&len);
+ EXPECT_EQ(StringPiece16(namespace_prefix, len), u"foo");
- const char16_t* namespaceUri = tree.getNamespaceUri(&len);
- ASSERT_EQ(StringPiece16(namespaceUri, len),
+ const char16_t* namespace_uri = tree.getNamespaceUri(&len);
+ ASSERT_EQ(StringPiece16(namespace_uri, len),
u"http://schemas.android.com/foo");
ASSERT_EQ(tree.next(), android::ResXMLTree::START_TAG);
@@ -200,14 +201,14 @@
}
TEST_F(XmlFlattenerTest, AssignSpecialAttributeIndices) {
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@id/id"
class="str"
style="@id/id"/>)EOF");
android::ResXMLTree tree;
- ASSERT_TRUE(flatten(doc.get(), &tree));
+ ASSERT_TRUE(Flatten(doc.get(), &tree));
while (tree.next() != android::ResXMLTree::START_TAG) {
ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
@@ -225,10 +226,10 @@
*/
TEST_F(XmlFlattenerTest, NoNamespaceIsNotTheSameAsEmptyNamespace) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDom("<View package=\"android\"/>");
+ test::BuildXmlDom("<View package=\"android\"/>");
android::ResXMLTree tree;
- ASSERT_TRUE(flatten(doc.get(), &tree));
+ ASSERT_TRUE(Flatten(doc.get(), &tree));
while (tree.next() != android::ResXMLTree::START_TAG) {
ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
@@ -242,10 +243,10 @@
TEST_F(XmlFlattenerTest, EmptyStringValueInAttributeIsNotNull) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDom("<View package=\"\"/>");
+ test::BuildXmlDom("<View package=\"\"/>");
android::ResXMLTree tree;
- ASSERT_TRUE(flatten(doc.get(), &tree));
+ ASSERT_TRUE(Flatten(doc.get(), &tree));
while (tree.next() != android::ResXMLTree::START_TAG) {
ASSERT_NE(tree.getEventType(), android::ResXMLTree::BAD_DOCUMENT);
diff --git a/tools/aapt2/io/Data.h b/tools/aapt2/io/Data.h
index 0479228b..fdc044d 100644
--- a/tools/aapt2/io/Data.h
+++ b/tools/aapt2/io/Data.h
@@ -17,10 +17,11 @@
#ifndef AAPT_IO_DATA_H
#define AAPT_IO_DATA_H
-#include <android-base/macros.h>
-#include <utils/FileMap.h>
#include <memory>
+#include "android-base/macros.h"
+#include "utils/FileMap.h"
+
namespace aapt {
namespace io {
@@ -39,20 +40,20 @@
class DataSegment : public IData {
public:
explicit DataSegment(std::unique_ptr<IData> data, size_t offset, size_t len)
- : mData(std::move(data)), mOffset(offset), mLen(len) {}
+ : data_(std::move(data)), offset_(offset), len_(len) {}
const void* data() const override {
- return static_cast<const uint8_t*>(mData->data()) + mOffset;
+ return static_cast<const uint8_t*>(data_->data()) + offset_;
}
- size_t size() const override { return mLen; }
+ size_t size() const override { return len_; }
private:
DISALLOW_COPY_AND_ASSIGN(DataSegment);
- std::unique_ptr<IData> mData;
- size_t mOffset;
- size_t mLen;
+ std::unique_ptr<IData> data_;
+ size_t offset_;
+ size_t len_;
};
/**
@@ -63,14 +64,14 @@
class MmappedData : public IData {
public:
explicit MmappedData(android::FileMap&& map)
- : mMap(std::forward<android::FileMap>(map)) {}
+ : map_(std::forward<android::FileMap>(map)) {}
- const void* data() const override { return mMap.getDataPtr(); }
+ const void* data() const override { return map_.getDataPtr(); }
- size_t size() const override { return mMap.getDataLength(); }
+ size_t size() const override { return map_.getDataLength(); }
private:
- android::FileMap mMap;
+ android::FileMap map_;
};
/**
@@ -81,15 +82,15 @@
class MallocData : public IData {
public:
MallocData(std::unique_ptr<const uint8_t[]> data, size_t size)
- : mData(std::move(data)), mSize(size) {}
+ : data_(std::move(data)), size_(size) {}
- const void* data() const override { return mData.get(); }
+ const void* data() const override { return data_.get(); }
- size_t size() const override { return mSize; }
+ size_t size() const override { return size_; }
private:
- std::unique_ptr<const uint8_t[]> mData;
- size_t mSize;
+ std::unique_ptr<const uint8_t[]> data_;
+ size_t size_;
};
/**
diff --git a/tools/aapt2/io/File.cpp b/tools/aapt2/io/File.cpp
index 739c0d2..ee73728 100644
--- a/tools/aapt2/io/File.cpp
+++ b/tools/aapt2/io/File.cpp
@@ -21,23 +21,23 @@
namespace aapt {
namespace io {
-IFile* IFile::createFileSegment(size_t offset, size_t len) {
- FileSegment* fileSegment = new FileSegment(this, offset, len);
- mSegments.push_back(std::unique_ptr<IFile>(fileSegment));
- return fileSegment;
+IFile* IFile::CreateFileSegment(size_t offset, size_t len) {
+ FileSegment* file_segment = new FileSegment(this, offset, len);
+ segments_.push_back(std::unique_ptr<IFile>(file_segment));
+ return file_segment;
}
-std::unique_ptr<IData> FileSegment::openAsData() {
- std::unique_ptr<IData> data = mFile->openAsData();
- if (!data) {
- return {};
- }
-
- if (mOffset <= data->size() - mLen) {
- return util::make_unique<DataSegment>(std::move(data), mOffset, mLen);
- }
+std::unique_ptr<IData> FileSegment::OpenAsData() {
+ std::unique_ptr<IData> data = file_->OpenAsData();
+ if (!data) {
return {};
+ }
+
+ if (offset_ <= data->size() - len_) {
+ return util::make_unique<DataSegment>(std::move(data), offset_, len_);
+ }
+ return {};
}
-} // namespace io
-} // namespace aapt
+} // namespace io
+} // namespace aapt
diff --git a/tools/aapt2/io/File.h b/tools/aapt2/io/File.h
index 012f446..644f59f 100644
--- a/tools/aapt2/io/File.h
+++ b/tools/aapt2/io/File.h
@@ -17,15 +17,16 @@
#ifndef AAPT_IO_FILE_H
#define AAPT_IO_FILE_H
-#include "Source.h"
-#include "io/Data.h"
-#include "util/Util.h"
-
-#include <android-base/macros.h>
#include <list>
#include <memory>
#include <vector>
+#include "android-base/macros.h"
+
+#include "Source.h"
+#include "io/Data.h"
+#include "util/Util.h"
+
namespace aapt {
namespace io {
@@ -49,7 +50,7 @@
*
* Returns nullptr on failure.
*/
- virtual std::unique_ptr<IData> openAsData() = 0;
+ virtual std::unique_ptr<IData> OpenAsData() = 0;
/**
* Returns the source of this file. This is for presentation to the user and
@@ -58,9 +59,9 @@
* the files within
* a ZIP archive from the path to the containing ZIP archive.
*/
- virtual const Source& getSource() const = 0;
+ virtual const Source& GetSource() const = 0;
- IFile* createFileSegment(size_t offset, size_t len);
+ IFile* CreateFileSegment(size_t offset, size_t len);
private:
// Any segments created from this IFile need to be owned by this IFile, so
@@ -68,7 +69,7 @@
// in a list. This will never be read, so we prefer better insertion
// performance
// than cache locality, hence the list.
- std::list<std::unique_ptr<IFile>> mSegments;
+ std::list<std::unique_ptr<IFile>> segments_;
};
/**
@@ -78,26 +79,26 @@
class FileSegment : public IFile {
public:
explicit FileSegment(IFile* file, size_t offset, size_t len)
- : mFile(file), mOffset(offset), mLen(len) {}
+ : file_(file), offset_(offset), len_(len) {}
- std::unique_ptr<IData> openAsData() override;
+ std::unique_ptr<IData> OpenAsData() override;
- const Source& getSource() const override { return mFile->getSource(); }
+ const Source& GetSource() const override { return file_->GetSource(); }
private:
DISALLOW_COPY_AND_ASSIGN(FileSegment);
- IFile* mFile;
- size_t mOffset;
- size_t mLen;
+ IFile* file_;
+ size_t offset_;
+ size_t len_;
};
class IFileCollectionIterator {
public:
virtual ~IFileCollectionIterator() = default;
- virtual bool hasNext() = 0;
- virtual IFile* next() = 0;
+ virtual bool HasNext() = 0;
+ virtual IFile* Next() = 0;
};
/**
@@ -109,8 +110,8 @@
public:
virtual ~IFileCollection() = default;
- virtual IFile* findFile(const StringPiece& path) = 0;
- virtual std::unique_ptr<IFileCollectionIterator> iterator() = 0;
+ virtual IFile* FindFile(const StringPiece& path) = 0;
+ virtual std::unique_ptr<IFileCollectionIterator> Iterator() = 0;
};
} // namespace io
diff --git a/tools/aapt2/io/FileSystem.cpp b/tools/aapt2/io/FileSystem.cpp
index e758d8a4..828f34e 100644
--- a/tools/aapt2/io/FileSystem.cpp
+++ b/tools/aapt2/io/FileSystem.cpp
@@ -14,65 +14,62 @@
* limitations under the License.
*/
-#include "Source.h"
#include "io/FileSystem.h"
+
+#include "utils/FileMap.h"
+
+#include "Source.h"
#include "util/Files.h"
#include "util/Maybe.h"
#include "util/StringPiece.h"
#include "util/Util.h"
-#include <utils/FileMap.h>
-
namespace aapt {
namespace io {
-RegularFile::RegularFile(const Source& source) : mSource(source) {
-}
+RegularFile::RegularFile(const Source& source) : source_(source) {}
-std::unique_ptr<IData> RegularFile::openAsData() {
- android::FileMap map;
- if (Maybe<android::FileMap> map = file::mmapPath(mSource.path, nullptr)) {
- if (map.value().getDataPtr() && map.value().getDataLength() > 0) {
- return util::make_unique<MmappedData>(std::move(map.value()));
- }
- return util::make_unique<EmptyData>();
+std::unique_ptr<IData> RegularFile::OpenAsData() {
+ android::FileMap map;
+ if (Maybe<android::FileMap> map = file::MmapPath(source_.path, nullptr)) {
+ if (map.value().getDataPtr() && map.value().getDataLength() > 0) {
+ return util::make_unique<MmappedData>(std::move(map.value()));
}
- return {};
+ return util::make_unique<EmptyData>();
+ }
+ return {};
}
-const Source& RegularFile::getSource() const {
- return mSource;
+const Source& RegularFile::GetSource() const { return source_; }
+
+FileCollectionIterator::FileCollectionIterator(FileCollection* collection)
+ : current_(collection->files_.begin()), end_(collection->files_.end()) {}
+
+bool FileCollectionIterator::HasNext() { return current_ != end_; }
+
+IFile* FileCollectionIterator::Next() {
+ IFile* result = current_->second.get();
+ ++current_;
+ return result;
}
-FileCollectionIterator::FileCollectionIterator(FileCollection* collection) :
- mCurrent(collection->mFiles.begin()), mEnd(collection->mFiles.end()) {
+IFile* FileCollection::InsertFile(const StringPiece& path) {
+ return (files_[path.ToString()] =
+ util::make_unique<RegularFile>(Source(path)))
+ .get();
}
-bool FileCollectionIterator::hasNext() {
- return mCurrent != mEnd;
+IFile* FileCollection::FindFile(const StringPiece& path) {
+ auto iter = files_.find(path.ToString());
+ if (iter != files_.end()) {
+ return iter->second.get();
+ }
+ return nullptr;
}
-IFile* FileCollectionIterator::next() {
- IFile* result = mCurrent->second.get();
- ++mCurrent;
- return result;
+std::unique_ptr<IFileCollectionIterator> FileCollection::Iterator() {
+ return util::make_unique<FileCollectionIterator>(this);
}
-IFile* FileCollection::insertFile(const StringPiece& path) {
- return (mFiles[path.toString()] = util::make_unique<RegularFile>(Source(path))).get();
-}
-
-IFile* FileCollection::findFile(const StringPiece& path) {
- auto iter = mFiles.find(path.toString());
- if (iter != mFiles.end()) {
- return iter->second.get();
- }
- return nullptr;
-}
-
-std::unique_ptr<IFileCollectionIterator> FileCollection::iterator() {
- return util::make_unique<FileCollectionIterator>(this);
-}
-
-} // namespace io
-} // namespace aapt
+} // namespace io
+} // namespace aapt
diff --git a/tools/aapt2/io/FileSystem.h b/tools/aapt2/io/FileSystem.h
index 8584d48..84f851f 100644
--- a/tools/aapt2/io/FileSystem.h
+++ b/tools/aapt2/io/FileSystem.h
@@ -17,10 +17,10 @@
#ifndef AAPT_IO_FILESYSTEM_H
#define AAPT_IO_FILESYSTEM_H
-#include "io/File.h"
-
#include <map>
+#include "io/File.h"
+
namespace aapt {
namespace io {
@@ -31,11 +31,11 @@
public:
explicit RegularFile(const Source& source);
- std::unique_ptr<IData> openAsData() override;
- const Source& getSource() const override;
+ std::unique_ptr<IData> OpenAsData() override;
+ const Source& GetSource() const override;
private:
- Source mSource;
+ Source source_;
};
class FileCollection;
@@ -44,11 +44,11 @@
public:
explicit FileCollectionIterator(FileCollection* collection);
- bool hasNext() override;
- io::IFile* next() override;
+ bool HasNext() override;
+ io::IFile* Next() override;
private:
- std::map<std::string, std::unique_ptr<IFile>>::const_iterator mCurrent, mEnd;
+ std::map<std::string, std::unique_ptr<IFile>>::const_iterator current_, end_;
};
/**
@@ -59,13 +59,13 @@
/**
* Adds a file located at path. Returns the IFile representation of that file.
*/
- IFile* insertFile(const StringPiece& path);
- IFile* findFile(const StringPiece& path) override;
- std::unique_ptr<IFileCollectionIterator> iterator() override;
+ IFile* InsertFile(const StringPiece& path);
+ IFile* FindFile(const StringPiece& path) override;
+ std::unique_ptr<IFileCollectionIterator> Iterator() override;
private:
friend class FileCollectionIterator;
- std::map<std::string, std::unique_ptr<IFile>> mFiles;
+ std::map<std::string, std::unique_ptr<IFile>> files_;
};
} // namespace io
diff --git a/tools/aapt2/io/Io.cpp b/tools/aapt2/io/Io.cpp
index 963c21c..cab4b65 100644
--- a/tools/aapt2/io/Io.cpp
+++ b/tools/aapt2/io/Io.cpp
@@ -22,23 +22,23 @@
namespace aapt {
namespace io {
-bool copy(OutputStream* out, InputStream* in) {
- const void* inBuffer;
- int inLen;
- while (in->Next(&inBuffer, &inLen)) {
- void* outBuffer;
- int outLen;
- if (!out->Next(&outBuffer, &outLen)) {
- return !out->HadError();
- }
-
- const int bytesToCopy = std::min(inLen, outLen);
- memcpy(outBuffer, inBuffer, bytesToCopy);
- out->BackUp(outLen - bytesToCopy);
- in->BackUp(inLen - bytesToCopy);
+bool Copy(OutputStream* out, InputStream* in) {
+ const void* in_buffer;
+ int in_len;
+ while (in->Next(&in_buffer, &in_len)) {
+ void* out_buffer;
+ int out_len;
+ if (!out->Next(&out_buffer, &out_len)) {
+ return !out->HadError();
}
- return !in->HadError();
+
+ const int bytes_to_copy = std::min(in_len, out_len);
+ memcpy(out_buffer, in_buffer, bytes_to_copy);
+ out->BackUp(out_len - bytes_to_copy);
+ in->BackUp(in_len - bytes_to_copy);
+ }
+ return !in->HadError();
}
-} // namespace io
-} // namespace aapt
+} // namespace io
+} // namespace aapt
diff --git a/tools/aapt2/io/Io.h b/tools/aapt2/io/Io.h
index 49b9fc3..33cdc7b 100644
--- a/tools/aapt2/io/Io.h
+++ b/tools/aapt2/io/Io.h
@@ -17,9 +17,10 @@
#ifndef AAPT_IO_IO_H
#define AAPT_IO_IO_H
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <string>
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+
namespace aapt {
namespace io {
@@ -29,7 +30,7 @@
*
* The code style here matches the protobuf style.
*/
-class InputStream : public google::protobuf::io::ZeroCopyInputStream {
+class InputStream : public ::google::protobuf::io::ZeroCopyInputStream {
public:
virtual std::string GetError() const { return {}; }
@@ -42,7 +43,7 @@
*
* The code style here matches the protobuf style.
*/
-class OutputStream : public google::protobuf::io::ZeroCopyOutputStream {
+class OutputStream : public ::google::protobuf::io::ZeroCopyOutputStream {
public:
virtual std::string GetError() const { return {}; }
@@ -54,7 +55,7 @@
* If there was an error, check the individual streams' HadError/GetError
* methods.
*/
-bool copy(OutputStream* out, InputStream* in);
+bool Copy(OutputStream* out, InputStream* in);
} // namespace io
} // namespace aapt
diff --git a/tools/aapt2/io/ZipArchive.cpp b/tools/aapt2/io/ZipArchive.cpp
index b3e7a02..f4a128e 100644
--- a/tools/aapt2/io/ZipArchive.cpp
+++ b/tools/aapt2/io/ZipArchive.cpp
@@ -14,129 +14,128 @@
* limitations under the License.
*/
-#include "Source.h"
#include "io/ZipArchive.h"
-#include "util/Util.h"
-#include <utils/FileMap.h>
-#include <ziparchive/zip_archive.h>
+#include "utils/FileMap.h"
+#include "ziparchive/zip_archive.h"
+
+#include "Source.h"
+#include "util/Util.h"
namespace aapt {
namespace io {
-ZipFile::ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source) :
- mZipHandle(handle), mZipEntry(entry), mSource(source) {
-}
+ZipFile::ZipFile(ZipArchiveHandle handle, const ZipEntry& entry,
+ const Source& source)
+ : zip_handle_(handle), zip_entry_(entry), source_(source) {}
-std::unique_ptr<IData> ZipFile::openAsData() {
- if (mZipEntry.method == kCompressStored) {
- int fd = GetFileDescriptor(mZipHandle);
+std::unique_ptr<IData> ZipFile::OpenAsData() {
+ if (zip_entry_.method == kCompressStored) {
+ int fd = GetFileDescriptor(zip_handle_);
- android::FileMap fileMap;
- bool result = fileMap.create(nullptr, fd, mZipEntry.offset,
- mZipEntry.uncompressed_length, true);
- if (!result) {
- return {};
- }
- return util::make_unique<MmappedData>(std::move(fileMap));
-
- } else {
- std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(
- new uint8_t[mZipEntry.uncompressed_length]);
- int32_t result = ExtractToMemory(mZipHandle, &mZipEntry, data.get(),
- static_cast<uint32_t>(mZipEntry.uncompressed_length));
- if (result != 0) {
- return {};
- }
- return util::make_unique<MallocData>(std::move(data), mZipEntry.uncompressed_length);
+ android::FileMap file_map;
+ bool result = file_map.create(nullptr, fd, zip_entry_.offset,
+ zip_entry_.uncompressed_length, true);
+ if (!result) {
+ return {};
}
-}
+ return util::make_unique<MmappedData>(std::move(file_map));
-const Source& ZipFile::getSource() const {
- return mSource;
-}
-
-ZipFileCollectionIterator::ZipFileCollectionIterator(ZipFileCollection* collection) :
- mCurrent(collection->mFiles.begin()), mEnd(collection->mFiles.end()) {
-}
-
-bool ZipFileCollectionIterator::hasNext() {
- return mCurrent != mEnd;
-}
-
-IFile* ZipFileCollectionIterator::next() {
- IFile* result = mCurrent->second.get();
- ++mCurrent;
- return result;
-}
-
-ZipFileCollection::ZipFileCollection() : mHandle(nullptr) {
-}
-
-std::unique_ptr<ZipFileCollection> ZipFileCollection::create(const StringPiece& path,
- std::string* outError) {
- constexpr static const int32_t kEmptyArchive = -6;
-
- std::unique_ptr<ZipFileCollection> collection = std::unique_ptr<ZipFileCollection>(
- new ZipFileCollection());
-
- int32_t result = OpenArchive(path.data(), &collection->mHandle);
+ } else {
+ std::unique_ptr<uint8_t[]> data =
+ std::unique_ptr<uint8_t[]>(new uint8_t[zip_entry_.uncompressed_length]);
+ int32_t result =
+ ExtractToMemory(zip_handle_, &zip_entry_, data.get(),
+ static_cast<uint32_t>(zip_entry_.uncompressed_length));
if (result != 0) {
- // If a zip is empty, result will be an error code. This is fine and we should
- // return an empty ZipFileCollection.
- if (result == kEmptyArchive) {
- return collection;
- }
-
- if (outError) *outError = ErrorCodeString(result);
- return {};
+ return {};
}
-
- void* cookie = nullptr;
- result = StartIteration(collection->mHandle, &cookie, nullptr, nullptr);
- if (result != 0) {
- if (outError) *outError = ErrorCodeString(result);
- return {};
- }
-
- using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
- IterationEnder iterationEnder(cookie, EndIteration);
-
- ZipString zipEntryName;
- ZipEntry zipData;
- while ((result = Next(cookie, &zipData, &zipEntryName)) == 0) {
- std::string zipEntryPath = std::string(reinterpret_cast<const char*>(zipEntryName.name),
- zipEntryName.name_length);
- std::string nestedPath = path.toString() + "@" + zipEntryPath;
- collection->mFiles[zipEntryPath] = util::make_unique<ZipFile>(collection->mHandle,
- zipData,
- Source(nestedPath));
- }
-
- if (result != -1) {
- if (outError) *outError = ErrorCodeString(result);
- return {};
- }
- return collection;
+ return util::make_unique<MallocData>(std::move(data),
+ zip_entry_.uncompressed_length);
+ }
}
-IFile* ZipFileCollection::findFile(const StringPiece& path) {
- auto iter = mFiles.find(path.toString());
- if (iter != mFiles.end()) {
- return iter->second.get();
- }
- return nullptr;
+const Source& ZipFile::GetSource() const { return source_; }
+
+ZipFileCollectionIterator::ZipFileCollectionIterator(
+ ZipFileCollection* collection)
+ : current_(collection->files_.begin()), end_(collection->files_.end()) {}
+
+bool ZipFileCollectionIterator::HasNext() { return current_ != end_; }
+
+IFile* ZipFileCollectionIterator::Next() {
+ IFile* result = current_->second.get();
+ ++current_;
+ return result;
}
-std::unique_ptr<IFileCollectionIterator> ZipFileCollection::iterator() {
- return util::make_unique<ZipFileCollectionIterator>(this);
+ZipFileCollection::ZipFileCollection() : handle_(nullptr) {}
+
+std::unique_ptr<ZipFileCollection> ZipFileCollection::Create(
+ const StringPiece& path, std::string* out_error) {
+ constexpr static const int32_t kEmptyArchive = -6;
+
+ std::unique_ptr<ZipFileCollection> collection =
+ std::unique_ptr<ZipFileCollection>(new ZipFileCollection());
+
+ int32_t result = OpenArchive(path.data(), &collection->handle_);
+ if (result != 0) {
+ // If a zip is empty, result will be an error code. This is fine and we
+ // should
+ // return an empty ZipFileCollection.
+ if (result == kEmptyArchive) {
+ return collection;
+ }
+
+ if (out_error) *out_error = ErrorCodeString(result);
+ return {};
+ }
+
+ void* cookie = nullptr;
+ result = StartIteration(collection->handle_, &cookie, nullptr, nullptr);
+ if (result != 0) {
+ if (out_error) *out_error = ErrorCodeString(result);
+ return {};
+ }
+
+ using IterationEnder = std::unique_ptr<void, decltype(EndIteration)*>;
+ IterationEnder iteration_ender(cookie, EndIteration);
+
+ ZipString zip_entry_name;
+ ZipEntry zip_data;
+ while ((result = Next(cookie, &zip_data, &zip_entry_name)) == 0) {
+ std::string zip_entry_path =
+ std::string(reinterpret_cast<const char*>(zip_entry_name.name),
+ zip_entry_name.name_length);
+ std::string nested_path = path.ToString() + "@" + zip_entry_path;
+ collection->files_[zip_entry_path] = util::make_unique<ZipFile>(
+ collection->handle_, zip_data, Source(nested_path));
+ }
+
+ if (result != -1) {
+ if (out_error) *out_error = ErrorCodeString(result);
+ return {};
+ }
+ return collection;
+}
+
+IFile* ZipFileCollection::FindFile(const StringPiece& path) {
+ auto iter = files_.find(path.ToString());
+ if (iter != files_.end()) {
+ return iter->second.get();
+ }
+ return nullptr;
+}
+
+std::unique_ptr<IFileCollectionIterator> ZipFileCollection::Iterator() {
+ return util::make_unique<ZipFileCollectionIterator>(this);
}
ZipFileCollection::~ZipFileCollection() {
- if (mHandle) {
- CloseArchive(mHandle);
- }
+ if (handle_) {
+ CloseArchive(handle_);
+ }
}
-} // namespace io
-} // namespace aapt
+} // namespace io
+} // namespace aapt
diff --git a/tools/aapt2/io/ZipArchive.h b/tools/aapt2/io/ZipArchive.h
index e04525f..85ca1ae 100644
--- a/tools/aapt2/io/ZipArchive.h
+++ b/tools/aapt2/io/ZipArchive.h
@@ -17,12 +17,13 @@
#ifndef AAPT_IO_ZIPARCHIVE_H
#define AAPT_IO_ZIPARCHIVE_H
+#include "ziparchive/zip_archive.h"
+
+#include <map>
+
#include "io/File.h"
#include "util/StringPiece.h"
-#include <ziparchive/zip_archive.h>
-#include <map>
-
namespace aapt {
namespace io {
@@ -36,13 +37,13 @@
public:
ZipFile(ZipArchiveHandle handle, const ZipEntry& entry, const Source& source);
- std::unique_ptr<IData> openAsData() override;
- const Source& getSource() const override;
+ std::unique_ptr<IData> OpenAsData() override;
+ const Source& GetSource() const override;
private:
- ZipArchiveHandle mZipHandle;
- ZipEntry mZipEntry;
- Source mSource;
+ ZipArchiveHandle zip_handle_;
+ ZipEntry zip_entry_;
+ Source source_;
};
class ZipFileCollection;
@@ -51,11 +52,11 @@
public:
explicit ZipFileCollectionIterator(ZipFileCollection* collection);
- bool hasNext() override;
- io::IFile* next() override;
+ bool HasNext() override;
+ io::IFile* Next() override;
private:
- std::map<std::string, std::unique_ptr<IFile>>::const_iterator mCurrent, mEnd;
+ std::map<std::string, std::unique_ptr<IFile>>::const_iterator current_, end_;
};
/**
@@ -63,11 +64,11 @@
*/
class ZipFileCollection : public IFileCollection {
public:
- static std::unique_ptr<ZipFileCollection> create(const StringPiece& path,
+ static std::unique_ptr<ZipFileCollection> Create(const StringPiece& path,
std::string* outError);
- io::IFile* findFile(const StringPiece& path) override;
- std::unique_ptr<IFileCollectionIterator> iterator() override;
+ io::IFile* FindFile(const StringPiece& path) override;
+ std::unique_ptr<IFileCollectionIterator> Iterator() override;
~ZipFileCollection() override;
@@ -75,8 +76,8 @@
friend class ZipFileCollectionIterator;
ZipFileCollection();
- ZipArchiveHandle mHandle;
- std::map<std::string, std::unique_ptr<IFile>> mFiles;
+ ZipArchiveHandle handle_;
+ std::map<std::string, std::unique_ptr<IFile>> files_;
};
} // namespace io
diff --git a/tools/aapt2/java/AnnotationProcessor.cpp b/tools/aapt2/java/AnnotationProcessor.cpp
index 23ff8ab..2951e5c 100644
--- a/tools/aapt2/java/AnnotationProcessor.cpp
+++ b/tools/aapt2/java/AnnotationProcessor.cpp
@@ -15,69 +15,71 @@
*/
#include "java/AnnotationProcessor.h"
-#include "util/Util.h"
#include <algorithm>
+#include "util/Util.h"
+
namespace aapt {
-void AnnotationProcessor::appendCommentLine(std::string& comment) {
- static const std::string sDeprecated = "@deprecated";
- static const std::string sSystemApi = "@SystemApi";
+void AnnotationProcessor::AppendCommentLine(std::string& comment) {
+ static const std::string sDeprecated = "@deprecated";
+ static const std::string sSystemApi = "@SystemApi";
- if (comment.find(sDeprecated) != std::string::npos) {
- mAnnotationBitMask |= kDeprecated;
- }
+ if (comment.find(sDeprecated) != std::string::npos) {
+ annotation_bit_mask_ |= kDeprecated;
+ }
- std::string::size_type idx = comment.find(sSystemApi);
- if (idx != std::string::npos) {
- mAnnotationBitMask |= kSystemApi;
- comment.erase(comment.begin() + idx, comment.begin() + idx + sSystemApi.size());
- }
+ std::string::size_type idx = comment.find(sSystemApi);
+ if (idx != std::string::npos) {
+ annotation_bit_mask_ |= kSystemApi;
+ comment.erase(comment.begin() + idx,
+ comment.begin() + idx + sSystemApi.size());
+ }
- if (util::trimWhitespace(comment).empty()) {
- return;
- }
+ if (util::TrimWhitespace(comment).empty()) {
+ return;
+ }
- if (!mHasComments) {
- mHasComments = true;
- mComment << "/**";
- }
+ if (!has_comments_) {
+ has_comments_ = true;
+ comment_ << "/**";
+ }
- mComment << "\n * " << std::move(comment);
+ comment_ << "\n * " << std::move(comment);
}
-void AnnotationProcessor::appendComment(const StringPiece& comment) {
- // We need to process line by line to clean-up whitespace and append prefixes.
- for (StringPiece line : util::tokenize(comment, '\n')) {
- line = util::trimWhitespace(line);
- if (!line.empty()) {
- std::string lineCopy = line.toString();
- appendCommentLine(lineCopy);
- }
+void AnnotationProcessor::AppendComment(const StringPiece& comment) {
+ // We need to process line by line to clean-up whitespace and append prefixes.
+ for (StringPiece line : util::Tokenize(comment, '\n')) {
+ line = util::TrimWhitespace(line);
+ if (!line.empty()) {
+ std::string lineCopy = line.ToString();
+ AppendCommentLine(lineCopy);
}
+ }
}
-void AnnotationProcessor::appendNewLine() {
- mComment << "\n *";
+void AnnotationProcessor::AppendNewLine() { comment_ << "\n *"; }
+
+void AnnotationProcessor::WriteToStream(std::ostream* out,
+ const StringPiece& prefix) const {
+ if (has_comments_) {
+ std::string result = comment_.str();
+ for (StringPiece line : util::Tokenize(result, '\n')) {
+ *out << prefix << line << "\n";
+ }
+ *out << prefix << " */"
+ << "\n";
+ }
+
+ if (annotation_bit_mask_ & kDeprecated) {
+ *out << prefix << "@Deprecated\n";
+ }
+
+ if (annotation_bit_mask_ & kSystemApi) {
+ *out << prefix << "@android.annotation.SystemApi\n";
+ }
}
-void AnnotationProcessor::writeToStream(std::ostream* out, const StringPiece& prefix) const {
- if (mHasComments) {
- std::string result = mComment.str();
- for (StringPiece line : util::tokenize(result, '\n')) {
- *out << prefix << line << "\n";
- }
- *out << prefix << " */" << "\n";
- }
-
- if (mAnnotationBitMask & kDeprecated) {
- *out << prefix << "@Deprecated\n";
- }
-
- if (mAnnotationBitMask & kSystemApi) {
- *out << prefix << "@android.annotation.SystemApi\n";
- }
-}
-
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/java/AnnotationProcessor.h b/tools/aapt2/java/AnnotationProcessor.h
index 5419608..666a7f3 100644
--- a/tools/aapt2/java/AnnotationProcessor.h
+++ b/tools/aapt2/java/AnnotationProcessor.h
@@ -17,11 +17,11 @@
#ifndef AAPT_JAVA_ANNOTATIONPROCESSOR_H
#define AAPT_JAVA_ANNOTATIONPROCESSOR_H
-#include "util/StringPiece.h"
-
#include <sstream>
#include <string>
+#include "util/StringPiece.h"
+
namespace aapt {
/**
@@ -58,15 +58,15 @@
* configurations,
* we need to collect all the comments.
*/
- void appendComment(const StringPiece& comment);
+ void AppendComment(const StringPiece& comment);
- void appendNewLine();
+ void AppendNewLine();
/**
* Writes the comments and annotations to the stream, with the given prefix
* before each line.
*/
- void writeToStream(std::ostream* out, const StringPiece& prefix) const;
+ void WriteToStream(std::ostream* out, const StringPiece& prefix) const;
private:
enum : uint32_t {
@@ -74,12 +74,12 @@
kSystemApi = 0x02,
};
- std::stringstream mComment;
+ std::stringstream comment_;
std::stringstream mAnnotations;
- bool mHasComments = false;
- uint32_t mAnnotationBitMask = 0;
+ bool has_comments_ = false;
+ uint32_t annotation_bit_mask_ = 0;
- void appendCommentLine(std::string& line);
+ void AppendCommentLine(std::string& line);
};
} // namespace aapt
diff --git a/tools/aapt2/java/AnnotationProcessor_test.cpp b/tools/aapt2/java/AnnotationProcessor_test.cpp
index 5a39add..3e43c42 100644
--- a/tools/aapt2/java/AnnotationProcessor_test.cpp
+++ b/tools/aapt2/java/AnnotationProcessor_test.cpp
@@ -15,38 +15,39 @@
*/
#include "java/AnnotationProcessor.h"
+
#include "test/Test.h"
namespace aapt {
TEST(AnnotationProcessorTest, EmitsDeprecated) {
- const char* comment = "Some comment, and it should contain a marker word, "
- "something that marks this resource as nor needed. "
- "{@deprecated That's the marker! }";
+ const char* comment =
+ "Some comment, and it should contain a marker word, "
+ "something that marks this resource as nor needed. "
+ "{@deprecated That's the marker! }";
- AnnotationProcessor processor;
- processor.appendComment(comment);
+ AnnotationProcessor processor;
+ processor.AppendComment(comment);
- std::stringstream result;
- processor.writeToStream(&result, "");
- std::string annotations = result.str();
+ std::stringstream result;
+ processor.WriteToStream(&result, "");
+ std::string annotations = result.str();
- EXPECT_NE(std::string::npos, annotations.find("@Deprecated"));
+ EXPECT_NE(std::string::npos, annotations.find("@Deprecated"));
}
TEST(AnnotationProcessorTest, EmitsSystemApiAnnotationAndRemovesFromComment) {
- AnnotationProcessor processor;
- processor.appendComment("@SystemApi This is a system API");
+ AnnotationProcessor processor;
+ processor.AppendComment("@SystemApi This is a system API");
- std::stringstream result;
- processor.writeToStream(&result, "");
- std::string annotations = result.str();
+ std::stringstream result;
+ processor.WriteToStream(&result, "");
+ std::string annotations = result.str();
- EXPECT_NE(std::string::npos, annotations.find("@android.annotation.SystemApi"));
- EXPECT_EQ(std::string::npos, annotations.find("@SystemApi"));
- EXPECT_NE(std::string::npos, annotations.find("This is a system API"));
+ EXPECT_NE(std::string::npos,
+ annotations.find("@android.annotation.SystemApi"));
+ EXPECT_EQ(std::string::npos, annotations.find("@SystemApi"));
+ EXPECT_NE(std::string::npos, annotations.find("This is a system API"));
}
-} // namespace aapt
-
-
+} // namespace aapt
diff --git a/tools/aapt2/java/ClassDefinition.cpp b/tools/aapt2/java/ClassDefinition.cpp
index 08f2c8b..f1f1f92 100644
--- a/tools/aapt2/java/ClassDefinition.cpp
+++ b/tools/aapt2/java/ClassDefinition.cpp
@@ -15,61 +15,59 @@
*/
#include "java/ClassDefinition.h"
-#include "util/StringPiece.h"
-#include <ostream>
+#include "util/StringPiece.h"
namespace aapt {
bool ClassDefinition::empty() const {
- for (const std::unique_ptr<ClassMember>& member : mMembers) {
- if (!member->empty()) {
- return false;
- }
+ for (const std::unique_ptr<ClassMember>& member : members_) {
+ if (!member->empty()) {
+ return false;
}
- return true;
+ }
+ return true;
}
-void ClassDefinition::writeToStream(const StringPiece& prefix, bool final,
+void ClassDefinition::WriteToStream(const StringPiece& prefix, bool final,
std::ostream* out) const {
- if (mMembers.empty() && !mCreateIfEmpty) {
- return;
- }
+ if (members_.empty() && !create_if_empty_) {
+ return;
+ }
- ClassMember::writeToStream(prefix, final, out);
+ ClassMember::WriteToStream(prefix, final, out);
- *out << prefix << "public ";
- if (mQualifier == ClassQualifier::Static) {
- *out << "static ";
- }
- *out << "final class " << mName << " {\n";
+ *out << prefix << "public ";
+ if (qualifier_ == ClassQualifier::Static) {
+ *out << "static ";
+ }
+ *out << "final class " << name_ << " {\n";
- std::string newPrefix = prefix.toString();
- newPrefix.append(kIndent);
+ std::string new_prefix = prefix.ToString();
+ new_prefix.append(kIndent);
- for (const std::unique_ptr<ClassMember>& member : mMembers) {
- member->writeToStream(newPrefix, final, out);
- *out << "\n";
- }
+ for (const std::unique_ptr<ClassMember>& member : members_) {
+ member->WriteToStream(new_prefix, final, out);
+ *out << "\n";
+ }
- *out << prefix << "}";
+ *out << prefix << "}";
}
constexpr static const char* sWarningHeader =
- "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n"
- " *\n"
- " * This class was automatically generated by the\n"
- " * aapt tool from the resource data it found. It\n"
- " * should not be modified by hand.\n"
- " */\n\n";
+ "/* AUTO-GENERATED FILE. DO NOT MODIFY.\n"
+ " *\n"
+ " * This class was automatically generated by the\n"
+ " * aapt tool from the resource data it found. It\n"
+ " * should not be modified by hand.\n"
+ " */\n\n";
-bool ClassDefinition::writeJavaFile(const ClassDefinition* def,
- const StringPiece& package,
- bool final,
+bool ClassDefinition::WriteJavaFile(const ClassDefinition* def,
+ const StringPiece& package, bool final,
std::ostream* out) {
- *out << sWarningHeader << "package " << package << ";\n\n";
- def->writeToStream("", final, out);
- return bool(*out);
+ *out << sWarningHeader << "package " << package << ";\n\n";
+ def->WriteToStream("", final, out);
+ return bool(*out);
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/java/ClassDefinition.h b/tools/aapt2/java/ClassDefinition.h
index bd7e7b2..d8b61d9 100644
--- a/tools/aapt2/java/ClassDefinition.h
+++ b/tools/aapt2/java/ClassDefinition.h
@@ -17,15 +17,16 @@
#ifndef AAPT_JAVA_CLASSDEFINITION_H
#define AAPT_JAVA_CLASSDEFINITION_H
+#include <ostream>
+#include <string>
+
+#include "android-base/macros.h"
+
#include "Resource.h"
#include "java/AnnotationProcessor.h"
#include "util/StringPiece.h"
#include "util/Util.h"
-#include <android-base/macros.h>
-#include <sstream>
-#include <string>
-
namespace aapt {
// The number of attributes to emit per line in a Styleable array.
@@ -36,38 +37,38 @@
public:
virtual ~ClassMember() = default;
- AnnotationProcessor* getCommentBuilder() { return &mProcessor; }
+ AnnotationProcessor* GetCommentBuilder() { return &processor_; }
virtual bool empty() const = 0;
- virtual void writeToStream(const StringPiece& prefix, bool final,
+ virtual void WriteToStream(const StringPiece& prefix, bool final,
std::ostream* out) const {
- mProcessor.writeToStream(out, prefix);
+ processor_.WriteToStream(out, prefix);
}
private:
- AnnotationProcessor mProcessor;
+ AnnotationProcessor processor_;
};
template <typename T>
class PrimitiveMember : public ClassMember {
public:
PrimitiveMember(const StringPiece& name, const T& val)
- : mName(name.toString()), mVal(val) {}
+ : name_(name.ToString()), val_(val) {}
bool empty() const override { return false; }
- void writeToStream(const StringPiece& prefix, bool final,
+ void WriteToStream(const StringPiece& prefix, bool final,
std::ostream* out) const override {
- ClassMember::writeToStream(prefix, final, out);
+ ClassMember::WriteToStream(prefix, final, out);
*out << prefix << "public static " << (final ? "final " : "") << "int "
- << mName << "=" << mVal << ";";
+ << name_ << "=" << val_ << ";";
}
private:
- std::string mName;
- T mVal;
+ std::string name_;
+ T val_;
DISALLOW_COPY_AND_ASSIGN(PrimitiveMember);
};
@@ -79,21 +80,21 @@
class PrimitiveMember<std::string> : public ClassMember {
public:
PrimitiveMember(const StringPiece& name, const std::string& val)
- : mName(name.toString()), mVal(val) {}
+ : name_(name.ToString()), val_(val) {}
bool empty() const override { return false; }
- void writeToStream(const StringPiece& prefix, bool final,
+ void WriteToStream(const StringPiece& prefix, bool final,
std::ostream* out) const override {
- ClassMember::writeToStream(prefix, final, out);
+ ClassMember::WriteToStream(prefix, final, out);
*out << prefix << "public static " << (final ? "final " : "") << "String "
- << mName << "=\"" << mVal << "\";";
+ << name_ << "=\"" << val_ << "\";";
}
private:
- std::string mName;
- std::string mVal;
+ std::string name_;
+ std::string val_;
DISALLOW_COPY_AND_ASSIGN(PrimitiveMember);
};
@@ -106,20 +107,20 @@
class PrimitiveArrayMember : public ClassMember {
public:
explicit PrimitiveArrayMember(const StringPiece& name)
- : mName(name.toString()) {}
+ : name_(name.ToString()) {}
- void addElement(const T& val) { mElements.push_back(val); }
+ void AddElement(const T& val) { elements_.push_back(val); }
bool empty() const override { return false; }
- void writeToStream(const StringPiece& prefix, bool final,
+ void WriteToStream(const StringPiece& prefix, bool final,
std::ostream* out) const override {
- ClassMember::writeToStream(prefix, final, out);
+ ClassMember::WriteToStream(prefix, final, out);
- *out << prefix << "public static final int[] " << mName << "={";
+ *out << prefix << "public static final int[] " << name_ << "={";
- const auto begin = mElements.begin();
- const auto end = mElements.end();
+ const auto begin = elements_.begin();
+ const auto end = elements_.end();
for (auto current = begin; current != end; ++current) {
if (std::distance(begin, current) % kAttribsPerLine == 0) {
*out << "\n" << prefix << kIndent << kIndent;
@@ -134,8 +135,8 @@
}
private:
- std::string mName;
- std::vector<T> mElements;
+ std::string name_;
+ std::vector<T> elements_;
DISALLOW_COPY_AND_ASSIGN(PrimitiveArrayMember);
};
@@ -146,29 +147,29 @@
class ClassDefinition : public ClassMember {
public:
- static bool writeJavaFile(const ClassDefinition* def,
+ static bool WriteJavaFile(const ClassDefinition* def,
const StringPiece& package, bool final,
std::ostream* out);
ClassDefinition(const StringPiece& name, ClassQualifier qualifier,
bool createIfEmpty)
- : mName(name.toString()),
- mQualifier(qualifier),
- mCreateIfEmpty(createIfEmpty) {}
+ : name_(name.ToString()),
+ qualifier_(qualifier),
+ create_if_empty_(createIfEmpty) {}
- void addMember(std::unique_ptr<ClassMember> member) {
- mMembers.push_back(std::move(member));
+ void AddMember(std::unique_ptr<ClassMember> member) {
+ members_.push_back(std::move(member));
}
bool empty() const override;
- void writeToStream(const StringPiece& prefix, bool final,
+ void WriteToStream(const StringPiece& prefix, bool final,
std::ostream* out) const override;
private:
- std::string mName;
- ClassQualifier mQualifier;
- bool mCreateIfEmpty;
- std::vector<std::unique_ptr<ClassMember>> mMembers;
+ std::string name_;
+ ClassQualifier qualifier_;
+ bool create_if_empty_;
+ std::vector<std::unique_ptr<ClassMember>> members_;
DISALLOW_COPY_AND_ASSIGN(ClassDefinition);
};
diff --git a/tools/aapt2/java/JavaClassGenerator.cpp b/tools/aapt2/java/JavaClassGenerator.cpp
index fbaefb1..6e7c7078 100644
--- a/tools/aapt2/java/JavaClassGenerator.cpp
+++ b/tools/aapt2/java/JavaClassGenerator.cpp
@@ -14,16 +14,7 @@
* limitations under the License.
*/
-#include "NameMangler.h"
-#include "Resource.h"
-#include "ResourceTable.h"
-#include "ResourceValues.h"
-#include "ValueVisitor.h"
-#include "java/AnnotationProcessor.h"
-#include "java/ClassDefinition.h"
#include "java/JavaClassGenerator.h"
-#include "process/SymbolTable.h"
-#include "util/StringPiece.h"
#include <algorithm>
#include <ostream>
@@ -31,42 +22,49 @@
#include <sstream>
#include <tuple>
+#include "android-base/logging.h"
+
+#include "NameMangler.h"
+#include "Resource.h"
+#include "ResourceTable.h"
+#include "ResourceValues.h"
+#include "ValueVisitor.h"
+#include "java/AnnotationProcessor.h"
+#include "java/ClassDefinition.h"
+#include "process/SymbolTable.h"
+#include "util/StringPiece.h"
+
namespace aapt {
-JavaClassGenerator::JavaClassGenerator(IAaptContext* context, ResourceTable* table,
- const JavaClassGeneratorOptions& options) :
- mContext(context), mTable(table), mOptions(options) {
-}
-
static const std::set<StringPiece> sJavaIdentifiers = {
- "abstract", "assert", "boolean", "break", "byte",
- "case", "catch", "char", "class", "const", "continue",
- "default", "do", "double", "else", "enum", "extends",
- "final", "finally", "float", "for", "goto", "if",
- "implements", "import", "instanceof", "int", "interface",
- "long", "native", "new", "package", "private", "protected",
- "public", "return", "short", "static", "strictfp", "super",
- "switch", "synchronized", "this", "throw", "throws",
- "transient", "try", "void", "volatile", "while", "true",
- "false", "null"
-};
+ "abstract", "assert", "boolean", "break", "byte",
+ "case", "catch", "char", "class", "const",
+ "continue", "default", "do", "double", "else",
+ "enum", "extends", "final", "finally", "float",
+ "for", "goto", "if", "implements", "import",
+ "instanceof", "int", "interface", "long", "native",
+ "new", "package", "private", "protected", "public",
+ "return", "short", "static", "strictfp", "super",
+ "switch", "synchronized", "this", "throw", "throws",
+ "transient", "try", "void", "volatile", "while",
+ "true", "false", "null"};
-static bool isValidSymbol(const StringPiece& symbol) {
- return sJavaIdentifiers.find(symbol) == sJavaIdentifiers.end();
+static bool IsValidSymbol(const StringPiece& symbol) {
+ return sJavaIdentifiers.find(symbol) == sJavaIdentifiers.end();
}
/*
* Java symbols can not contain . or -, but those are valid in a resource name.
* Replace those with '_'.
*/
-static std::string transform(const StringPiece& symbol) {
- std::string output = symbol.toString();
- for (char& c : output) {
- if (c == '.' || c == '-') {
- c = '_';
- }
+static std::string Transform(const StringPiece& symbol) {
+ std::string output = symbol.ToString();
+ for (char& c : output) {
+ if (c == '.' || c == '-') {
+ c = '_';
}
- return output;
+ }
+ return output;
}
/**
@@ -80,475 +78,519 @@
* Foo_android_bar
* Foo_bar
*/
-static std::string transformNestedAttr(const ResourceNameRef& attrName,
- const std::string& styleableClassName,
- const StringPiece& packageNameToGenerate) {
- std::string output = styleableClassName;
+static std::string TransformNestedAttr(
+ const ResourceNameRef& attr_name, const std::string& styleable_class_name,
+ const StringPiece& package_name_to_generate) {
+ std::string output = styleable_class_name;
- // We may reference IDs from other packages, so prefix the entry name with
- // the package.
- if (!attrName.package.empty() && packageNameToGenerate != attrName.package) {
- output += "_" + transform(attrName.package);
- }
- output += "_" + transform(attrName.entry);
- return output;
+ // We may reference IDs from other packages, so prefix the entry name with
+ // the package.
+ if (!attr_name.package.empty() &&
+ package_name_to_generate != attr_name.package) {
+ output += "_" + Transform(attr_name.package);
+ }
+ output += "_" + Transform(attr_name.entry);
+ return output;
}
-static void addAttributeFormatDoc(AnnotationProcessor* processor, Attribute* attr) {
- const uint32_t typeMask = attr->typeMask;
- if (typeMask & android::ResTable_map::TYPE_REFERENCE) {
- processor->appendComment(
- "<p>May be a reference to another resource, in the form\n"
- "\"<code>@[+][<i>package</i>:]<i>type</i>/<i>name</i></code>\" or a theme\n"
- "attribute in the form\n"
- "\"<code>?[<i>package</i>:]<i>type</i>/<i>name</i></code>\".");
+static void AddAttributeFormatDoc(AnnotationProcessor* processor,
+ Attribute* attr) {
+ const uint32_t type_mask = attr->type_mask;
+ if (type_mask & android::ResTable_map::TYPE_REFERENCE) {
+ processor->AppendComment(
+ "<p>May be a reference to another resource, in the form\n"
+ "\"<code>@[+][<i>package</i>:]<i>type</i>/<i>name</i></code>\" or a "
+ "theme\n"
+ "attribute in the form\n"
+ "\"<code>?[<i>package</i>:]<i>type</i>/<i>name</i></code>\".");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_STRING) {
+ processor->AppendComment(
+ "<p>May be a string value, using '\\\\;' to escape characters such as\n"
+ "'\\\\n' or '\\\\uxxxx' for a unicode character;");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_INTEGER) {
+ processor->AppendComment(
+ "<p>May be an integer value, such as \"<code>100</code>\".");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_BOOLEAN) {
+ processor->AppendComment(
+ "<p>May be a boolean value, such as \"<code>true</code>\" or\n"
+ "\"<code>false</code>\".");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_COLOR) {
+ processor->AppendComment(
+ "<p>May be a color value, in the form of "
+ "\"<code>#<i>rgb</i></code>\",\n"
+ "\"<code>#<i>argb</i></code>\", \"<code>#<i>rrggbb</i></code\", or \n"
+ "\"<code>#<i>aarrggbb</i></code>\".");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_FLOAT) {
+ processor->AppendComment(
+ "<p>May be a floating point value, such as \"<code>1.2</code>\".");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_DIMENSION) {
+ processor->AppendComment(
+ "<p>May be a dimension value, which is a floating point number "
+ "appended with a\n"
+ "unit such as \"<code>14.5sp</code>\".\n"
+ "Available units are: px (pixels), dp (density-independent pixels),\n"
+ "sp (scaled pixels based on preferred font size), in (inches), and\n"
+ "mm (millimeters).");
+ }
+
+ if (type_mask & android::ResTable_map::TYPE_FRACTION) {
+ processor->AppendComment(
+ "<p>May be a fractional value, which is a floating point number "
+ "appended with\n"
+ "either % or %p, such as \"<code>14.5%</code>\".\n"
+ "The % suffix always means a percentage of the base size;\n"
+ "the optional %p suffix provides a size relative to some parent "
+ "container.");
+ }
+
+ if (type_mask &
+ (android::ResTable_map::TYPE_FLAGS | android::ResTable_map::TYPE_ENUM)) {
+ if (type_mask & android::ResTable_map::TYPE_FLAGS) {
+ processor->AppendComment(
+ "<p>Must be one or more (separated by '|') of the following "
+ "constant values.</p>");
+ } else {
+ processor->AppendComment(
+ "<p>Must be one of the following constant values.</p>");
}
- if (typeMask & android::ResTable_map::TYPE_STRING) {
- processor->appendComment(
- "<p>May be a string value, using '\\\\;' to escape characters such as\n"
- "'\\\\n' or '\\\\uxxxx' for a unicode character;");
+ processor->AppendComment(
+ "<table>\n<colgroup align=\"left\" />\n"
+ "<colgroup align=\"left\" />\n"
+ "<colgroup align=\"left\" />\n"
+ "<tr><th>Constant</th><th>Value</th><th>Description</th></tr>\n");
+ for (const Attribute::Symbol& symbol : attr->symbols) {
+ std::stringstream line;
+ line << "<tr><td>" << symbol.symbol.name.value().entry << "</td>"
+ << "<td>" << std::hex << symbol.value << std::dec << "</td>"
+ << "<td>" << util::TrimWhitespace(symbol.symbol.GetComment())
+ << "</td></tr>";
+ processor->AppendComment(line.str());
}
-
- if (typeMask & android::ResTable_map::TYPE_INTEGER) {
- processor->appendComment("<p>May be an integer value, such as \"<code>100</code>\".");
- }
-
- if (typeMask & android::ResTable_map::TYPE_BOOLEAN) {
- processor->appendComment(
- "<p>May be a boolean value, such as \"<code>true</code>\" or\n"
- "\"<code>false</code>\".");
- }
-
- if (typeMask & android::ResTable_map::TYPE_COLOR) {
- processor->appendComment(
- "<p>May be a color value, in the form of \"<code>#<i>rgb</i></code>\",\n"
- "\"<code>#<i>argb</i></code>\", \"<code>#<i>rrggbb</i></code\", or \n"
- "\"<code>#<i>aarrggbb</i></code>\".");
- }
-
- if (typeMask & android::ResTable_map::TYPE_FLOAT) {
- processor->appendComment(
- "<p>May be a floating point value, such as \"<code>1.2</code>\".");
- }
-
- if (typeMask & android::ResTable_map::TYPE_DIMENSION) {
- processor->appendComment(
- "<p>May be a dimension value, which is a floating point number appended with a\n"
- "unit such as \"<code>14.5sp</code>\".\n"
- "Available units are: px (pixels), dp (density-independent pixels),\n"
- "sp (scaled pixels based on preferred font size), in (inches), and\n"
- "mm (millimeters).");
- }
-
- if (typeMask & android::ResTable_map::TYPE_FRACTION) {
- processor->appendComment(
- "<p>May be a fractional value, which is a floating point number appended with\n"
- "either % or %p, such as \"<code>14.5%</code>\".\n"
- "The % suffix always means a percentage of the base size;\n"
- "the optional %p suffix provides a size relative to some parent container.");
- }
-
- if (typeMask & (android::ResTable_map::TYPE_FLAGS | android::ResTable_map::TYPE_ENUM)) {
- if (typeMask & android::ResTable_map::TYPE_FLAGS) {
- processor->appendComment(
- "<p>Must be one or more (separated by '|') of the following "
- "constant values.</p>");
- } else {
- processor->appendComment("<p>Must be one of the following constant values.</p>");
- }
-
- processor->appendComment("<table>\n<colgroup align=\"left\" />\n"
- "<colgroup align=\"left\" />\n"
- "<colgroup align=\"left\" />\n"
- "<tr><th>Constant</th><th>Value</th><th>Description</th></tr>\n");
- for (const Attribute::Symbol& symbol : attr->symbols) {
- std::stringstream line;
- line << "<tr><td>" << symbol.symbol.name.value().entry << "</td>"
- << "<td>" << std::hex << symbol.value << std::dec << "</td>"
- << "<td>" << util::trimWhitespace(symbol.symbol.getComment()) << "</td></tr>";
- processor->appendComment(line.str());
- }
- processor->appendComment("</table>");
- }
+ processor->AppendComment("</table>");
+ }
}
-bool JavaClassGenerator::skipSymbol(SymbolState state) {
- switch (mOptions.types) {
+JavaClassGenerator::JavaClassGenerator(IAaptContext* context,
+ ResourceTable* table,
+ const JavaClassGeneratorOptions& options)
+ : context_(context), table_(table), options_(options) {}
+
+bool JavaClassGenerator::SkipSymbol(SymbolState state) {
+ switch (options_.types) {
case JavaClassGeneratorOptions::SymbolTypes::kAll:
- return false;
+ return false;
case JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate:
- return state == SymbolState::kUndefined;
+ return state == SymbolState::kUndefined;
case JavaClassGeneratorOptions::SymbolTypes::kPublic:
- return state != SymbolState::kPublic;
- }
- return true;
+ return state != SymbolState::kPublic;
+ }
+ return true;
}
struct StyleableAttr {
- const Reference* attrRef;
- std::string fieldName;
- std::unique_ptr<SymbolTable::Symbol> symbol;
+ const Reference* attr_ref;
+ std::string field_name;
+ std::unique_ptr<SymbolTable::Symbol> symbol;
};
-static bool lessStyleableAttr(const StyleableAttr& lhs, const StyleableAttr& rhs) {
- const ResourceId lhsId = lhs.attrRef->id ? lhs.attrRef->id.value() : ResourceId(0);
- const ResourceId rhsId = rhs.attrRef->id ? rhs.attrRef->id.value() : ResourceId(0);
- if (lhsId < rhsId) {
- return true;
- } else if (lhsId > rhsId) {
- return false;
+static bool less_styleable_attr(const StyleableAttr& lhs,
+ const StyleableAttr& rhs) {
+ const ResourceId lhs_id =
+ lhs.attr_ref->id ? lhs.attr_ref->id.value() : ResourceId(0);
+ const ResourceId rhs_id =
+ rhs.attr_ref->id ? rhs.attr_ref->id.value() : ResourceId(0);
+ if (lhs_id < rhs_id) {
+ return true;
+ } else if (lhs_id > rhs_id) {
+ return false;
+ } else {
+ return lhs.attr_ref->name.value() < rhs.attr_ref->name.value();
+ }
+}
+
+void JavaClassGenerator::AddMembersToStyleableClass(
+ const StringPiece& package_name_to_generate, const std::string& entry_name,
+ const Styleable* styleable, ClassDefinition* out_styleable_class_def) {
+ const std::string class_name = Transform(entry_name);
+
+ std::unique_ptr<ResourceArrayMember> styleable_array_def =
+ util::make_unique<ResourceArrayMember>(class_name);
+
+ // This must be sorted by resource ID.
+ std::vector<StyleableAttr> sorted_attributes;
+ sorted_attributes.reserve(styleable->entries.size());
+ for (const auto& attr : styleable->entries) {
+ // If we are not encoding final attributes, the styleable entry may have no
+ // ID if we are building a static library.
+ CHECK(!options_.use_final || attr.id) << "no ID set for Styleable entry";
+ CHECK(bool(attr.name)) << "no name set for Styleable entry";
+
+ // We will need the unmangled, transformed name in the comments and the
+ // field,
+ // so create it once and cache it in this StyleableAttr data structure.
+ StyleableAttr styleable_attr = {};
+ styleable_attr.attr_ref = &attr;
+ styleable_attr.field_name = TransformNestedAttr(
+ attr.name.value(), class_name, package_name_to_generate);
+
+ Reference mangled_reference;
+ mangled_reference.id = attr.id;
+ mangled_reference.name = attr.name;
+ if (mangled_reference.name.value().package.empty()) {
+ mangled_reference.name.value().package =
+ context_->GetCompilationPackage();
+ }
+
+ if (Maybe<ResourceName> mangled_name =
+ context_->GetNameMangler()->MangleName(
+ mangled_reference.name.value())) {
+ mangled_reference.name = mangled_name;
+ }
+
+ // Look up the symbol so that we can write out in the comments what are
+ // possible
+ // legal values for this attribute.
+ const SymbolTable::Symbol* symbol =
+ context_->GetExternalSymbols()->FindByReference(mangled_reference);
+ if (symbol && symbol->attribute) {
+ // Copy the symbol data structure because the returned instance can be
+ // destroyed.
+ styleable_attr.symbol = util::make_unique<SymbolTable::Symbol>(*symbol);
+ }
+ sorted_attributes.push_back(std::move(styleable_attr));
+ }
+
+ // Sort the attributes by ID.
+ std::sort(sorted_attributes.begin(), sorted_attributes.end(),
+ less_styleable_attr);
+
+ const size_t attr_count = sorted_attributes.size();
+ if (attr_count > 0) {
+ // Build the comment string for the Styleable. It includes details about the
+ // child attributes.
+ std::stringstream styleable_comment;
+ if (!styleable->GetComment().empty()) {
+ styleable_comment << styleable->GetComment() << "\n";
} else {
- return lhs.attrRef->name.value() < rhs.attrRef->name.value();
+ styleable_comment << "Attributes that can be used with a " << class_name
+ << ".\n";
}
+
+ styleable_comment << "<p>Includes the following attributes:</p>\n"
+ "<table>\n"
+ "<colgroup align=\"left\" />\n"
+ "<colgroup align=\"left\" />\n"
+ "<tr><th>Attribute</th><th>Description</th></tr>\n";
+
+ for (const StyleableAttr& entry : sorted_attributes) {
+ if (!entry.symbol) {
+ continue;
+ }
+
+ if (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
+ !entry.symbol->is_public) {
+ // Don't write entries for non-public attributes.
+ continue;
+ }
+
+ StringPiece attr_comment_line = entry.symbol->attribute->GetComment();
+ if (attr_comment_line.contains("@removed")) {
+ // Removed attributes are public but hidden from the documentation, so
+ // don't emit
+ // them as part of the class documentation.
+ continue;
+ }
+
+ const ResourceName& attr_name = entry.attr_ref->name.value();
+ styleable_comment << "<tr><td>";
+ styleable_comment << "<code>{@link #" << entry.field_name << " "
+ << (!attr_name.package.empty()
+ ? attr_name.package
+ : context_->GetCompilationPackage())
+ << ":" << attr_name.entry << "}</code>";
+ styleable_comment << "</td>";
+
+ styleable_comment << "<td>";
+
+ // Only use the comment up until the first '.'. This is to stay compatible
+ // with
+ // the way old AAPT did it (presumably to keep it short and to avoid
+ // including
+ // annotations like @hide which would affect this Styleable).
+ auto iter =
+ std::find(attr_comment_line.begin(), attr_comment_line.end(), u'.');
+ if (iter != attr_comment_line.end()) {
+ attr_comment_line =
+ attr_comment_line.substr(0, (iter - attr_comment_line.begin()) + 1);
+ }
+ styleable_comment << attr_comment_line << "</td></tr>\n";
+ }
+ styleable_comment << "</table>\n";
+
+ for (const StyleableAttr& entry : sorted_attributes) {
+ if (!entry.symbol) {
+ continue;
+ }
+
+ if (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
+ !entry.symbol->is_public) {
+ // Don't write entries for non-public attributes.
+ continue;
+ }
+ styleable_comment << "@see #" << entry.field_name << "\n";
+ }
+
+ styleable_array_def->GetCommentBuilder()->AppendComment(
+ styleable_comment.str());
+ }
+
+ // Add the ResourceIds to the array member.
+ for (const StyleableAttr& styleable_attr : sorted_attributes) {
+ styleable_array_def->AddElement(styleable_attr.attr_ref->id
+ ? styleable_attr.attr_ref->id.value()
+ : ResourceId(0));
+ }
+
+ // Add the Styleable array to the Styleable class.
+ out_styleable_class_def->AddMember(std::move(styleable_array_def));
+
+ // Now we emit the indices into the array.
+ for (size_t i = 0; i < attr_count; i++) {
+ const StyleableAttr& styleable_attr = sorted_attributes[i];
+
+ if (!styleable_attr.symbol) {
+ continue;
+ }
+
+ if (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
+ !styleable_attr.symbol->is_public) {
+ // Don't write entries for non-public attributes.
+ continue;
+ }
+
+ StringPiece comment = styleable_attr.attr_ref->GetComment();
+ if (styleable_attr.symbol->attribute && comment.empty()) {
+ comment = styleable_attr.symbol->attribute->GetComment();
+ }
+
+ if (comment.contains("@removed")) {
+ // Removed attributes are public but hidden from the documentation, so
+ // don't emit them
+ // as part of the class documentation.
+ continue;
+ }
+
+ const ResourceName& attr_name = styleable_attr.attr_ref->name.value();
+
+ StringPiece package_name = attr_name.package;
+ if (package_name.empty()) {
+ package_name = context_->GetCompilationPackage();
+ }
+
+ std::unique_ptr<IntMember> index_member = util::make_unique<IntMember>(
+ sorted_attributes[i].field_name, static_cast<uint32_t>(i));
+
+ AnnotationProcessor* attr_processor = index_member->GetCommentBuilder();
+
+ if (!comment.empty()) {
+ attr_processor->AppendComment("<p>\n@attr description");
+ attr_processor->AppendComment(comment);
+ } else {
+ std::stringstream default_comment;
+ default_comment << "<p>This symbol is the offset where the "
+ << "{@link " << package_name << ".R.attr#"
+ << Transform(attr_name.entry) << "}\n"
+ << "attribute's value can be found in the "
+ << "{@link #" << class_name << "} array.";
+ attr_processor->AppendComment(default_comment.str());
+ }
+
+ attr_processor->AppendNewLine();
+
+ AddAttributeFormatDoc(attr_processor,
+ styleable_attr.symbol->attribute.get());
+ attr_processor->AppendNewLine();
+
+ std::stringstream doclava_name;
+ doclava_name << "@attr name " << package_name << ":" << attr_name.entry;
+
+ attr_processor->AppendComment(doclava_name.str());
+
+ out_styleable_class_def->AddMember(std::move(index_member));
+ }
}
-void JavaClassGenerator::addMembersToStyleableClass(const StringPiece& packageNameToGenerate,
- const std::string& entryName,
- const Styleable* styleable,
- ClassDefinition* outStyleableClassDef) {
- const std::string className = transform(entryName);
-
- std::unique_ptr<ResourceArrayMember> styleableArrayDef =
- util::make_unique<ResourceArrayMember>(className);
-
- // This must be sorted by resource ID.
- std::vector<StyleableAttr> sortedAttributes;
- sortedAttributes.reserve(styleable->entries.size());
- for (const auto& attr : styleable->entries) {
- // If we are not encoding final attributes, the styleable entry may have no ID
- // if we are building a static library.
- assert((!mOptions.useFinal || attr.id) && "no ID set for Styleable entry");
- assert(attr.name && "no name set for Styleable entry");
-
- // We will need the unmangled, transformed name in the comments and the field,
- // so create it once and cache it in this StyleableAttr data structure.
- StyleableAttr styleableAttr = {};
- styleableAttr.attrRef = &attr;
- styleableAttr.fieldName = transformNestedAttr(attr.name.value(), className,
- packageNameToGenerate);
-
- Reference mangledReference;
- mangledReference.id = attr.id;
- mangledReference.name = attr.name;
- if (mangledReference.name.value().package.empty()) {
- mangledReference.name.value().package = mContext->getCompilationPackage();
- }
-
- if (Maybe<ResourceName> mangledName =
- mContext->getNameMangler()->mangleName(mangledReference.name.value())) {
- mangledReference.name = mangledName;
- }
-
- // Look up the symbol so that we can write out in the comments what are possible
- // legal values for this attribute.
- const SymbolTable::Symbol* symbol = mContext->getExternalSymbols()->findByReference(
- mangledReference);
- if (symbol && symbol->attribute) {
- // Copy the symbol data structure because the returned instance can be destroyed.
- styleableAttr.symbol = util::make_unique<SymbolTable::Symbol>(*symbol);
- }
- sortedAttributes.push_back(std::move(styleableAttr));
+bool JavaClassGenerator::AddMembersToTypeClass(
+ const StringPiece& package_name_to_generate,
+ const ResourceTablePackage* package, const ResourceTableType* type,
+ ClassDefinition* out_type_class_def) {
+ for (const auto& entry : type->entries) {
+ if (SkipSymbol(entry->symbol_status.state)) {
+ continue;
}
- // Sort the attributes by ID.
- std::sort(sortedAttributes.begin(), sortedAttributes.end(), lessStyleableAttr);
-
- const size_t attrCount = sortedAttributes.size();
- if (attrCount > 0) {
- // Build the comment string for the Styleable. It includes details about the
- // child attributes.
- std::stringstream styleableComment;
- if (!styleable->getComment().empty()) {
- styleableComment << styleable->getComment() << "\n";
- } else {
- styleableComment << "Attributes that can be used with a " << className << ".\n";
- }
-
- styleableComment <<
- "<p>Includes the following attributes:</p>\n"
- "<table>\n"
- "<colgroup align=\"left\" />\n"
- "<colgroup align=\"left\" />\n"
- "<tr><th>Attribute</th><th>Description</th></tr>\n";
-
- for (const StyleableAttr& entry : sortedAttributes) {
- if (!entry.symbol) {
- continue;
- }
-
- if (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
- !entry.symbol->isPublic) {
- // Don't write entries for non-public attributes.
- continue;
- }
-
- StringPiece attrCommentLine = entry.symbol->attribute->getComment();
- if (attrCommentLine.contains("@removed")) {
- // Removed attributes are public but hidden from the documentation, so don't emit
- // them as part of the class documentation.
- continue;
- }
-
- const ResourceName& attrName = entry.attrRef->name.value();
- styleableComment << "<tr><td>";
- styleableComment << "<code>{@link #"
- << entry.fieldName << " "
- << (!attrName.package.empty()
- ? attrName.package : mContext->getCompilationPackage())
- << ":" << attrName.entry
- << "}</code>";
- styleableComment << "</td>";
-
- styleableComment << "<td>";
-
- // Only use the comment up until the first '.'. This is to stay compatible with
- // the way old AAPT did it (presumably to keep it short and to avoid including
- // annotations like @hide which would affect this Styleable).
- auto iter = std::find(attrCommentLine.begin(), attrCommentLine.end(), u'.');
- if (iter != attrCommentLine.end()) {
- attrCommentLine = attrCommentLine.substr(
- 0, (iter - attrCommentLine.begin()) + 1);
- }
- styleableComment << attrCommentLine << "</td></tr>\n";
- }
- styleableComment << "</table>\n";
-
- for (const StyleableAttr& entry : sortedAttributes) {
- if (!entry.symbol) {
- continue;
- }
-
- if (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
- !entry.symbol->isPublic) {
- // Don't write entries for non-public attributes.
- continue;
- }
- styleableComment << "@see #" << entry.fieldName << "\n";
- }
-
- styleableArrayDef->getCommentBuilder()->appendComment(styleableComment.str());
+ ResourceId id;
+ if (package->id && type->id && entry->id) {
+ id = ResourceId(package->id.value(), type->id.value(), entry->id.value());
}
- // Add the ResourceIds to the array member.
- for (const StyleableAttr& styleableAttr : sortedAttributes) {
- styleableArrayDef->addElement(
- styleableAttr.attrRef->id ? styleableAttr.attrRef->id.value() : ResourceId(0));
+ std::string unmangled_package;
+ std::string unmangled_name = entry->name;
+ if (NameMangler::Unmangle(&unmangled_name, &unmangled_package)) {
+ // The entry name was mangled, and we successfully unmangled it.
+ // Check that we want to emit this symbol.
+ if (package->name != unmangled_package) {
+ // Skip the entry if it doesn't belong to the package we're writing.
+ continue;
+ }
+ } else if (package_name_to_generate != package->name) {
+ // We are processing a mangled package name,
+ // but this is a non-mangled resource.
+ continue;
}
- // Add the Styleable array to the Styleable class.
- outStyleableClassDef->addMember(std::move(styleableArrayDef));
-
- // Now we emit the indices into the array.
- for (size_t i = 0; i < attrCount; i++) {
- const StyleableAttr& styleableAttr = sortedAttributes[i];
-
- if (!styleableAttr.symbol) {
- continue;
- }
-
- if (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic &&
- !styleableAttr.symbol->isPublic) {
- // Don't write entries for non-public attributes.
- continue;
- }
-
- StringPiece comment = styleableAttr.attrRef->getComment();
- if (styleableAttr.symbol->attribute && comment.empty()) {
- comment = styleableAttr.symbol->attribute->getComment();
- }
-
- if (comment.contains("@removed")) {
- // Removed attributes are public but hidden from the documentation, so don't emit them
- // as part of the class documentation.
- continue;
- }
-
- const ResourceName& attrName = styleableAttr.attrRef->name.value();
-
- StringPiece packageName = attrName.package;
- if (packageName.empty()) {
- packageName = mContext->getCompilationPackage();
- }
-
- std::unique_ptr<IntMember> indexMember = util::make_unique<IntMember>(
- sortedAttributes[i].fieldName, static_cast<uint32_t>(i));
-
- AnnotationProcessor* attrProcessor = indexMember->getCommentBuilder();
-
- if (!comment.empty()) {
- attrProcessor->appendComment("<p>\n@attr description");
- attrProcessor->appendComment(comment);
- } else {
- std::stringstream defaultComment;
- defaultComment
- << "<p>This symbol is the offset where the "
- << "{@link " << packageName << ".R.attr#" << transform(attrName.entry) << "}\n"
- << "attribute's value can be found in the "
- << "{@link #" << className << "} array.";
- attrProcessor->appendComment(defaultComment.str());
- }
-
- attrProcessor->appendNewLine();
-
- addAttributeFormatDoc(attrProcessor, styleableAttr.symbol->attribute.get());
- attrProcessor->appendNewLine();
-
- std::stringstream doclavaName;
- doclavaName << "@attr name " << packageName << ":" << attrName.entry;;
- attrProcessor->appendComment(doclavaName.str());
-
- outStyleableClassDef->addMember(std::move(indexMember));
+ if (!IsValidSymbol(unmangled_name)) {
+ ResourceNameRef resource_name(package_name_to_generate, type->type,
+ unmangled_name);
+ std::stringstream err;
+ err << "invalid symbol name '" << resource_name << "'";
+ error_ = err.str();
+ return false;
}
+
+ if (type->type == ResourceType::kStyleable) {
+ CHECK(!entry->values.empty());
+
+ const Styleable* styleable =
+ static_cast<const Styleable*>(entry->values.front()->value.get());
+
+ // Comments are handled within this method.
+ AddMembersToStyleableClass(package_name_to_generate, unmangled_name,
+ styleable, out_type_class_def);
+ } else {
+ std::unique_ptr<ResourceMember> resource_member =
+ util::make_unique<ResourceMember>(Transform(unmangled_name), id);
+
+ // Build the comments and annotations for this entry.
+ AnnotationProcessor* processor = resource_member->GetCommentBuilder();
+
+ // Add the comments from any <public> tags.
+ if (entry->symbol_status.state != SymbolState::kUndefined) {
+ processor->AppendComment(entry->symbol_status.comment);
+ }
+
+ // Add the comments from all configurations of this entry.
+ for (const auto& config_value : entry->values) {
+ processor->AppendComment(config_value->value->GetComment());
+ }
+
+ // If this is an Attribute, append the format Javadoc.
+ if (!entry->values.empty()) {
+ if (Attribute* attr =
+ ValueCast<Attribute>(entry->values.front()->value.get())) {
+ // We list out the available values for the given attribute.
+ AddAttributeFormatDoc(processor, attr);
+ }
+ }
+
+ out_type_class_def->AddMember(std::move(resource_member));
+ }
+ }
+ return true;
}
-bool JavaClassGenerator::addMembersToTypeClass(const StringPiece& packageNameToGenerate,
- const ResourceTablePackage* package,
- const ResourceTableType* type,
- ClassDefinition* outTypeClassDef) {
-
- for (const auto& entry : type->entries) {
- if (skipSymbol(entry->symbolStatus.state)) {
- continue;
- }
-
- ResourceId id;
- if (package->id && type->id && entry->id) {
- id = ResourceId(package->id.value(), type->id.value(), entry->id.value());
- }
-
- std::string unmangledPackage;
- std::string unmangledName = entry->name;
- if (NameMangler::unmangle(&unmangledName, &unmangledPackage)) {
- // The entry name was mangled, and we successfully unmangled it.
- // Check that we want to emit this symbol.
- if (package->name != unmangledPackage) {
- // Skip the entry if it doesn't belong to the package we're writing.
- continue;
- }
- } else if (packageNameToGenerate != package->name) {
- // We are processing a mangled package name,
- // but this is a non-mangled resource.
- continue;
- }
-
- if (!isValidSymbol(unmangledName)) {
- ResourceNameRef resourceName(packageNameToGenerate, type->type, unmangledName);
- std::stringstream err;
- err << "invalid symbol name '" << resourceName << "'";
- mError = err.str();
- return false;
- }
-
- if (type->type == ResourceType::kStyleable) {
- assert(!entry->values.empty());
-
- const Styleable* styleable = static_cast<const Styleable*>(
- entry->values.front()->value.get());
-
- // Comments are handled within this method.
- addMembersToStyleableClass(packageNameToGenerate, unmangledName, styleable,
- outTypeClassDef);
- } else {
- std::unique_ptr<ResourceMember> resourceMember =
- util::make_unique<ResourceMember>(transform(unmangledName), id);
-
- // Build the comments and annotations for this entry.
- AnnotationProcessor* processor = resourceMember->getCommentBuilder();
-
- // Add the comments from any <public> tags.
- if (entry->symbolStatus.state != SymbolState::kUndefined) {
- processor->appendComment(entry->symbolStatus.comment);
- }
-
- // Add the comments from all configurations of this entry.
- for (const auto& configValue : entry->values) {
- processor->appendComment(configValue->value->getComment());
- }
-
- // If this is an Attribute, append the format Javadoc.
- if (!entry->values.empty()) {
- if (Attribute* attr = valueCast<Attribute>(entry->values.front()->value.get())) {
- // We list out the available values for the given attribute.
- addAttributeFormatDoc(processor, attr);
- }
- }
-
- outTypeClassDef->addMember(std::move(resourceMember));
- }
- }
- return true;
+bool JavaClassGenerator::Generate(const StringPiece& package_name_to_generate,
+ std::ostream* out) {
+ return Generate(package_name_to_generate, package_name_to_generate, out);
}
-bool JavaClassGenerator::generate(const StringPiece& packageNameToGenerate, std::ostream* out) {
- return generate(packageNameToGenerate, packageNameToGenerate, out);
+static void AppendJavaDocAnnotations(
+ const std::vector<std::string>& annotations,
+ AnnotationProcessor* processor) {
+ for (const std::string& annotation : annotations) {
+ std::string proper_annotation = "@";
+ proper_annotation += annotation;
+ processor->AppendComment(proper_annotation);
+ }
}
-static void appendJavaDocAnnotations(const std::vector<std::string>& annotations,
- AnnotationProcessor* processor) {
- for (const std::string& annotation : annotations) {
- std::string properAnnotation = "@";
- properAnnotation += annotation;
- processor->appendComment(properAnnotation);
- }
-}
+bool JavaClassGenerator::Generate(const StringPiece& package_name_to_generate,
+ const StringPiece& out_package_name,
+ std::ostream* out) {
+ ClassDefinition r_class("R", ClassQualifier::None, true);
-bool JavaClassGenerator::generate(const StringPiece& packageNameToGenerate,
- const StringPiece& outPackageName, std::ostream* out) {
+ for (const auto& package : table_->packages) {
+ for (const auto& type : package->types) {
+ if (type->type == ResourceType::kAttrPrivate) {
+ continue;
+ }
- ClassDefinition rClass("R", ClassQualifier::None, true);
+ const bool force_creation_if_empty =
+ (options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic);
- for (const auto& package : mTable->packages) {
- for (const auto& type : package->types) {
- if (type->type == ResourceType::kAttrPrivate) {
- continue;
- }
+ std::unique_ptr<ClassDefinition> class_def =
+ util::make_unique<ClassDefinition>(ToString(type->type),
+ ClassQualifier::Static,
+ force_creation_if_empty);
- const bool forceCreationIfEmpty =
- (mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic);
-
- std::unique_ptr<ClassDefinition> classDef = util::make_unique<ClassDefinition>(
- toString(type->type), ClassQualifier::Static, forceCreationIfEmpty);
-
- bool result = addMembersToTypeClass(packageNameToGenerate, package.get(), type.get(),
- classDef.get());
- if (!result) {
- return false;
- }
-
- if (type->type == ResourceType::kAttr) {
- // Also include private attributes in this same class.
- ResourceTableType* privType = package->findType(ResourceType::kAttrPrivate);
- if (privType) {
- result = addMembersToTypeClass(packageNameToGenerate, package.get(), privType,
- classDef.get());
- if (!result) {
- return false;
- }
- }
- }
-
- if (type->type == ResourceType::kStyleable &&
- mOptions.types == JavaClassGeneratorOptions::SymbolTypes::kPublic) {
- // When generating a public R class, we don't want Styleable to be part of the API.
- // It is only emitted for documentation purposes.
- classDef->getCommentBuilder()->appendComment("@doconly");
- }
-
- appendJavaDocAnnotations(mOptions.javadocAnnotations, classDef->getCommentBuilder());
-
- rClass.addMember(std::move(classDef));
- }
- }
-
- appendJavaDocAnnotations(mOptions.javadocAnnotations, rClass.getCommentBuilder());
-
- if (!ClassDefinition::writeJavaFile(&rClass, outPackageName, mOptions.useFinal, out)) {
+ bool result = AddMembersToTypeClass(
+ package_name_to_generate, package.get(), type.get(), class_def.get());
+ if (!result) {
return false;
- }
+ }
- out->flush();
- return true;
+ if (type->type == ResourceType::kAttr) {
+ // Also include private attributes in this same class.
+ ResourceTableType* priv_type =
+ package->FindType(ResourceType::kAttrPrivate);
+ if (priv_type) {
+ result =
+ AddMembersToTypeClass(package_name_to_generate, package.get(),
+ priv_type, class_def.get());
+ if (!result) {
+ return false;
+ }
+ }
+ }
+
+ if (type->type == ResourceType::kStyleable &&
+ options_.types == JavaClassGeneratorOptions::SymbolTypes::kPublic) {
+ // When generating a public R class, we don't want Styleable to be part
+ // of the API.
+ // It is only emitted for documentation purposes.
+ class_def->GetCommentBuilder()->AppendComment("@doconly");
+ }
+
+ AppendJavaDocAnnotations(options_.javadoc_annotations,
+ class_def->GetCommentBuilder());
+
+ r_class.AddMember(std::move(class_def));
+ }
+ }
+
+ AppendJavaDocAnnotations(options_.javadoc_annotations,
+ r_class.GetCommentBuilder());
+
+ if (!ClassDefinition::WriteJavaFile(&r_class, out_package_name,
+ options_.use_final, out)) {
+ return false;
+ }
+
+ out->flush();
+ return true;
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/java/JavaClassGenerator.h b/tools/aapt2/java/JavaClassGenerator.h
index 2fdf268..190e73b 100644
--- a/tools/aapt2/java/JavaClassGenerator.h
+++ b/tools/aapt2/java/JavaClassGenerator.h
@@ -17,14 +17,14 @@
#ifndef AAPT_JAVA_CLASS_GENERATOR_H
#define AAPT_JAVA_CLASS_GENERATOR_H
+#include <ostream>
+#include <string>
+
#include "ResourceTable.h"
#include "ResourceValues.h"
#include "process/IResourceTableConsumer.h"
#include "util/StringPiece.h"
-#include <ostream>
-#include <string>
-
namespace aapt {
class AnnotationProcessor;
@@ -35,7 +35,7 @@
* Specifies whether to use the 'final' modifier
* on resource entries. Default is true.
*/
- bool useFinal = true;
+ bool use_final = true;
enum class SymbolTypes {
kAll,
@@ -49,7 +49,7 @@
* A list of JavaDoc annotations to add to the comments of all generated
* classes.
*/
- std::vector<std::string> javadocAnnotations;
+ std::vector<std::string> javadoc_annotations;
};
/*
@@ -69,34 +69,34 @@
* We need to generate these symbols in a separate file.
* Returns true on success.
*/
- bool generate(const StringPiece& packageNameToGenerate, std::ostream* out);
+ bool Generate(const StringPiece& packageNameToGenerate, std::ostream* out);
- bool generate(const StringPiece& packageNameToGenerate,
+ bool Generate(const StringPiece& packageNameToGenerate,
const StringPiece& outputPackageName, std::ostream* out);
const std::string& getError() const;
private:
- bool addMembersToTypeClass(const StringPiece& packageNameToGenerate,
+ bool AddMembersToTypeClass(const StringPiece& packageNameToGenerate,
const ResourceTablePackage* package,
const ResourceTableType* type,
ClassDefinition* outTypeClassDef);
- void addMembersToStyleableClass(const StringPiece& packageNameToGenerate,
+ void AddMembersToStyleableClass(const StringPiece& packageNameToGenerate,
const std::string& entryName,
const Styleable* styleable,
ClassDefinition* outStyleableClassDef);
- bool skipSymbol(SymbolState state);
+ bool SkipSymbol(SymbolState state);
- IAaptContext* mContext;
- ResourceTable* mTable;
- JavaClassGeneratorOptions mOptions;
- std::string mError;
+ IAaptContext* context_;
+ ResourceTable* table_;
+ JavaClassGeneratorOptions options_;
+ std::string error_;
};
inline const std::string& JavaClassGenerator::getError() const {
- return mError;
+ return error_;
}
} // namespace aapt
diff --git a/tools/aapt2/java/JavaClassGenerator_test.cpp b/tools/aapt2/java/JavaClassGenerator_test.cpp
index ed7c6bd..3d3d24e 100644
--- a/tools/aapt2/java/JavaClassGenerator_test.cpp
+++ b/tools/aapt2/java/JavaClassGenerator_test.cpp
@@ -15,154 +15,181 @@
*/
#include "java/JavaClassGenerator.h"
-#include "test/Test.h"
-#include "util/Util.h"
#include <sstream>
#include <string>
+#include "test/Test.h"
+#include "util/Util.h"
+
namespace aapt {
TEST(JavaClassGeneratorTest, FailWhenEntryIsJavaKeyword) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addSimple("android:id/class", ResourceId(0x01020000))
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddSimple("android:id/class", ResourceId(0x01020000))
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGenerator generator(context.get(), table.get(), {});
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGenerator generator(context.get(), table.get(), {});
- std::stringstream out;
- EXPECT_FALSE(generator.generate("android", &out));
+ std::stringstream out;
+ EXPECT_FALSE(generator.Generate("android", &out));
}
TEST(JavaClassGeneratorTest, TransformInvalidJavaIdentifierCharacter) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addSimple("android:id/hey-man", ResourceId(0x01020000))
- .addValue("android:attr/cool.attr", ResourceId(0x01010000),
- test::AttributeBuilder(false).build())
- .addValue("android:styleable/hey.dude", ResourceId(0x01030000),
- test::StyleableBuilder()
- .addItem("android:attr/cool.attr", ResourceId(0x01010000))
- .build())
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddSimple("android:id/hey-man", ResourceId(0x01020000))
+ .AddValue("android:attr/cool.attr", ResourceId(0x01010000),
+ test::AttributeBuilder(false).Build())
+ .AddValue(
+ "android:styleable/hey.dude", ResourceId(0x01030000),
+ test::StyleableBuilder()
+ .AddItem("android:attr/cool.attr", ResourceId(0x01010000))
+ .Build())
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGenerator generator(context.get(), table.get(), {});
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGenerator generator(context.get(), table.get(), {});
- std::stringstream out;
- EXPECT_TRUE(generator.generate("android", &out));
+ std::stringstream out;
+ EXPECT_TRUE(generator.Generate("android", &out));
- std::string output = out.str();
+ std::string output = out.str();
- EXPECT_NE(std::string::npos,
- output.find("public static final int hey_man=0x01020000;"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int hey_man=0x01020000;"));
- EXPECT_NE(std::string::npos,
- output.find("public static final int[] hey_dude={"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int[] hey_dude={"));
- EXPECT_NE(std::string::npos,
- output.find("public static final int hey_dude_cool_attr=0;"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int hey_dude_cool_attr=0;"));
}
TEST(JavaClassGeneratorTest, CorrectPackageNameIsUsed) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addSimple("android:id/one", ResourceId(0x01020000))
- .addSimple("android:id/com.foo$two", ResourceId(0x01020001))
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddSimple("android:id/one", ResourceId(0x01020000))
+ .AddSimple("android:id/com.foo$two", ResourceId(0x01020001))
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGenerator generator(context.get(), table.get(), {});
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", "com.android.internal", &out));
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGenerator generator(context.get(), table.get(), {});
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", "com.android.internal", &out));
- std::string output = out.str();
- EXPECT_NE(std::string::npos, output.find("package com.android.internal;"));
- EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
- EXPECT_EQ(std::string::npos, output.find("two"));
- EXPECT_EQ(std::string::npos, output.find("com_foo$two"));
+ std::string output = out.str();
+ EXPECT_NE(std::string::npos, output.find("package com.android.internal;"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int one=0x01020000;"));
+ EXPECT_EQ(std::string::npos, output.find("two"));
+ EXPECT_EQ(std::string::npos, output.find("com_foo$two"));
}
TEST(JavaClassGeneratorTest, AttrPrivateIsWrittenAsAttr) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addSimple("android:attr/two", ResourceId(0x01010001))
- .addSimple("android:^attr-private/one", ResourceId(0x01010000))
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddSimple("android:attr/two", ResourceId(0x01010001))
+ .AddSimple("android:^attr-private/one", ResourceId(0x01010000))
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGenerator generator(context.get(), table.get(), {});
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGenerator generator(context.get(), table.get(), {});
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
- std::string output = out.str();
- EXPECT_NE(std::string::npos, output.find("public static final class attr"));
- EXPECT_EQ(std::string::npos, output.find("public static final class ^attr-private"));
+ std::string output = out.str();
+ EXPECT_NE(std::string::npos, output.find("public static final class attr"));
+ EXPECT_EQ(std::string::npos,
+ output.find("public static final class ^attr-private"));
}
TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
- StdErrDiagnostics diag;
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addSimple("android:id/one", ResourceId(0x01020000))
- .addSimple("android:id/two", ResourceId(0x01020001))
- .addSimple("android:id/three", ResourceId(0x01020002))
- .setSymbolState("android:id/one", ResourceId(0x01020000), SymbolState::kPublic)
- .setSymbolState("android:id/two", ResourceId(0x01020001), SymbolState::kPrivate)
- .build();
+ StdErrDiagnostics diag;
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddSimple("android:id/one", ResourceId(0x01020000))
+ .AddSimple("android:id/two", ResourceId(0x01020001))
+ .AddSimple("android:id/three", ResourceId(0x01020002))
+ .SetSymbolState("android:id/one", ResourceId(0x01020000),
+ SymbolState::kPublic)
+ .SetSymbolState("android:id/two", ResourceId(0x01020001),
+ SymbolState::kPrivate)
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
- JavaClassGeneratorOptions options;
- options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
- {
- JavaClassGenerator generator(context.get(), table.get(), options);
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
- std::string output = out.str();
- EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
- EXPECT_EQ(std::string::npos, output.find("two"));
- EXPECT_EQ(std::string::npos, output.find("three"));
- }
+ JavaClassGeneratorOptions options;
+ options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
+ {
+ JavaClassGenerator generator(context.get(), table.get(), options);
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
+ std::string output = out.str();
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int one=0x01020000;"));
+ EXPECT_EQ(std::string::npos, output.find("two"));
+ EXPECT_EQ(std::string::npos, output.find("three"));
+ }
- options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
- {
- JavaClassGenerator generator(context.get(), table.get(), options);
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
- std::string output = out.str();
- EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
- EXPECT_NE(std::string::npos, output.find("public static final int two=0x01020001;"));
- EXPECT_EQ(std::string::npos, output.find("three"));
- }
+ options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
+ {
+ JavaClassGenerator generator(context.get(), table.get(), options);
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
+ std::string output = out.str();
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int one=0x01020000;"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int two=0x01020001;"));
+ EXPECT_EQ(std::string::npos, output.find("three"));
+ }
- options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
- {
- JavaClassGenerator generator(context.get(), table.get(), options);
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
- std::string output = out.str();
- EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
- EXPECT_NE(std::string::npos, output.find("public static final int two=0x01020001;"));
- EXPECT_NE(std::string::npos, output.find("public static final int three=0x01020002;"));
- }
+ options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
+ {
+ JavaClassGenerator generator(context.get(), table.get(), options);
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
+ std::string output = out.str();
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int one=0x01020000;"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int two=0x01020001;"));
+ EXPECT_NE(std::string::npos,
+ output.find("public static final int three=0x01020002;"));
+ }
}
/*
@@ -172,12 +199,15 @@
ResourceId{ 0x01, 0x02, 0x0000 }));
ResourceTable table;
table.setPackage(u"com.lib");
- ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test" }, {},
- Source{ "lib.xml", 33 }, util::make_unique<Id>()));
+ ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test"
+}, {},
+ Source{ "lib.xml", 33 },
+util::make_unique<Id>()));
ASSERT_TRUE(mTable->merge(std::move(table)));
Linker linker(mTable,
- std::make_shared<MockResolver>(mTable, std::map<ResourceName, ResourceId>()),
+ std::make_shared<MockResolver>(mTable, std::map<ResourceName,
+ResourceId>()),
{});
ASSERT_TRUE(linker.linkAndValidate());
@@ -197,126 +227,139 @@
}*/
TEST(JavaClassGeneratorTest, EmitOtherPackagesAttributesInStyleable) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .setPackageId("com.lib", 0x02)
- .addValue("android:attr/bar", ResourceId(0x01010000),
- test::AttributeBuilder(false).build())
- .addValue("com.lib:attr/bar", ResourceId(0x02010000),
- test::AttributeBuilder(false).build())
- .addValue("android:styleable/foo", ResourceId(0x01030000),
- test::StyleableBuilder()
- .addItem("android:attr/bar", ResourceId(0x01010000))
- .addItem("com.lib:attr/bar", ResourceId(0x02010000))
- .build())
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .SetPackageId("com.lib", 0x02)
+ .AddValue("android:attr/bar", ResourceId(0x01010000),
+ test::AttributeBuilder(false).Build())
+ .AddValue("com.lib:attr/bar", ResourceId(0x02010000),
+ test::AttributeBuilder(false).Build())
+ .AddValue("android:styleable/foo", ResourceId(0x01030000),
+ test::StyleableBuilder()
+ .AddItem("android:attr/bar", ResourceId(0x01010000))
+ .AddItem("com.lib:attr/bar", ResourceId(0x02010000))
+ .Build())
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGenerator generator(context.get(), table.get(), {});
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGenerator generator(context.get(), table.get(), {});
- std::stringstream out;
- EXPECT_TRUE(generator.generate("android", &out));
+ std::stringstream out;
+ EXPECT_TRUE(generator.Generate("android", &out));
- std::string output = out.str();
- EXPECT_NE(std::string::npos, output.find("int foo_bar="));
- EXPECT_NE(std::string::npos, output.find("int foo_com_lib_bar="));
+ std::string output = out.str();
+ EXPECT_NE(std::string::npos, output.find("int foo_bar="));
+ EXPECT_NE(std::string::npos, output.find("int foo_com_lib_bar="));
}
TEST(JavaClassGeneratorTest, CommentsForSimpleResourcesArePresent) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addSimple("android:id/foo", ResourceId(0x01010000))
- .build();
- test::getValue<Id>(table.get(), "android:id/foo")
- ->setComment(std::string("This is a comment\n@deprecated"));
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddSimple("android:id/foo", ResourceId(0x01010000))
+ .Build();
+ test::GetValue<Id>(table.get(), "android:id/foo")
+ ->SetComment(std::string("This is a comment\n@deprecated"));
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGenerator generator(context.get(), table.get(), {});
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
- std::string actual = out.str();
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGenerator generator(context.get(), table.get(), {});
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
+ std::string actual = out.str();
- const char* expectedText =
-R"EOF(/**
+ const char* expectedText =
+ R"EOF(/**
* This is a comment
* @deprecated
*/
@Deprecated
public static final int foo=0x01010000;)EOF";
- EXPECT_NE(std::string::npos, actual.find(expectedText));
+ EXPECT_NE(std::string::npos, actual.find(expectedText));
}
-TEST(JavaClassGeneratorTest, CommentsForEnumAndFlagAttributesArePresent) {
+TEST(JavaClassGeneratorTest, CommentsForEnumAndFlagAttributesArePresent) {}
-}
+TEST(JavaClassGeneratorTest,
+ CommentsForStyleablesAndNestedAttributesArePresent) {
+ Attribute attr(false);
+ attr.SetComment(StringPiece("This is an attribute"));
-TEST(JavaClassGeneratorTest, CommentsForStyleablesAndNestedAttributesArePresent) {
- Attribute attr(false);
- attr.setComment(StringPiece("This is an attribute"));
+ Styleable styleable;
+ styleable.entries.push_back(
+ Reference(test::ParseNameOrDie("android:attr/one")));
+ styleable.SetComment(StringPiece("This is a styleable"));
- Styleable styleable;
- styleable.entries.push_back(Reference(test::parseNameOrDie("android:attr/one")));
- styleable.setComment(StringPiece("This is a styleable"));
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddValue("android:attr/one", util::make_unique<Attribute>(attr))
+ .AddValue("android:styleable/Container",
+ std::unique_ptr<Styleable>(styleable.Clone(nullptr)))
+ .Build();
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addValue("android:attr/one", util::make_unique<Attribute>(attr))
- .addValue("android:styleable/Container",
- std::unique_ptr<Styleable>(styleable.clone(nullptr)))
- .build();
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGeneratorOptions options;
+ options.use_final = false;
+ JavaClassGenerator generator(context.get(), table.get(), options);
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
+ std::string actual = out.str();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGeneratorOptions options;
- options.useFinal = false;
- JavaClassGenerator generator(context.get(), table.get(), options);
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
- std::string actual = out.str();
-
- EXPECT_NE(std::string::npos, actual.find("attr name android:one"));
- EXPECT_NE(std::string::npos, actual.find("attr description"));
- EXPECT_NE(std::string::npos, actual.find(attr.getComment().data()));
- EXPECT_NE(std::string::npos, actual.find(styleable.getComment().data()));
+ EXPECT_NE(std::string::npos, actual.find("attr name android:one"));
+ EXPECT_NE(std::string::npos, actual.find("attr description"));
+ EXPECT_NE(std::string::npos, actual.find(attr.GetComment().data()));
+ EXPECT_NE(std::string::npos, actual.find(styleable.GetComment().data()));
}
TEST(JavaClassGeneratorTest, CommentsForRemovedAttributesAreNotPresentInClass) {
- Attribute attr(false);
- attr.setComment(StringPiece("removed"));
+ Attribute attr(false);
+ attr.SetComment(StringPiece("removed"));
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("android", 0x01)
- .addValue("android:attr/one", util::make_unique<Attribute>(attr))
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("android", 0x01)
+ .AddValue("android:attr/one", util::make_unique<Attribute>(attr))
+ .Build();
- std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
- .setNameManglerPolicy(NameManglerPolicy{ "android" })
- .build();
- JavaClassGeneratorOptions options;
- options.useFinal = false;
- JavaClassGenerator generator(context.get(), table.get(), options);
- std::stringstream out;
- ASSERT_TRUE(generator.generate("android", &out));
- std::string actual = out.str();
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder()
+ .AddSymbolSource(
+ util::make_unique<ResourceTableSymbolSource>(table.get()))
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .Build();
+ JavaClassGeneratorOptions options;
+ options.use_final = false;
+ JavaClassGenerator generator(context.get(), table.get(), options);
+ std::stringstream out;
+ ASSERT_TRUE(generator.Generate("android", &out));
+ std::string actual = out.str();
- EXPECT_EQ(std::string::npos, actual.find("@attr name android:one"));
- EXPECT_EQ(std::string::npos, actual.find("@attr description"));
+ EXPECT_EQ(std::string::npos, actual.find("@attr name android:one"));
+ EXPECT_EQ(std::string::npos, actual.find("@attr description"));
- // We should find @removed only in the attribute javadoc and not anywhere else (i.e. the class
- // javadoc).
- const size_t pos = actual.find("removed");
- EXPECT_NE(std::string::npos, pos);
- EXPECT_EQ(std::string::npos, actual.find("removed", pos + 1));
+ // We should find @removed only in the attribute javadoc and not anywhere else
+ // (i.e. the class
+ // javadoc).
+ const size_t pos = actual.find("removed");
+ EXPECT_NE(std::string::npos, pos);
+ EXPECT_EQ(std::string::npos, actual.find("removed", pos + 1));
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/java/ManifestClassGenerator.cpp b/tools/aapt2/java/ManifestClassGenerator.cpp
index 5ff11b1..db84f29 100644
--- a/tools/aapt2/java/ManifestClassGenerator.cpp
+++ b/tools/aapt2/java/ManifestClassGenerator.cpp
@@ -14,111 +14,120 @@
* limitations under the License.
*/
-#include "Source.h"
-#include "java/AnnotationProcessor.h"
-#include "java/ClassDefinition.h"
#include "java/ManifestClassGenerator.h"
-#include "util/Maybe.h"
-#include "xml/XmlDom.h"
#include <algorithm>
+#include "Source.h"
+#include "java/AnnotationProcessor.h"
+#include "java/ClassDefinition.h"
+#include "util/Maybe.h"
+#include "xml/XmlDom.h"
+
namespace aapt {
-static Maybe<StringPiece> extractJavaIdentifier(IDiagnostics* diag, const Source& source,
+static Maybe<StringPiece> ExtractJavaIdentifier(IDiagnostics* diag,
+ const Source& source,
const StringPiece& value) {
- const StringPiece sep = ".";
- auto iter = std::find_end(value.begin(), value.end(), sep.begin(), sep.end());
+ const StringPiece sep = ".";
+ auto iter = std::find_end(value.begin(), value.end(), sep.begin(), sep.end());
- StringPiece result;
- if (iter != value.end()) {
- result.assign(iter + sep.size(), value.end() - (iter + sep.size()));
- } else {
- result = value;
- }
+ StringPiece result;
+ if (iter != value.end()) {
+ result.assign(iter + sep.size(), value.end() - (iter + sep.size()));
+ } else {
+ result = value;
+ }
- if (result.empty()) {
- diag->error(DiagMessage(source) << "empty symbol");
- return {};
- }
+ if (result.empty()) {
+ diag->Error(DiagMessage(source) << "empty symbol");
+ return {};
+ }
- iter = util::findNonAlphaNumericAndNotInSet(result, "_");
- if (iter != result.end()) {
- diag->error(DiagMessage(source)
- << "invalid character '" << StringPiece(iter, 1)
- << "' in '" << result << "'");
- return {};
- }
+ iter = util::FindNonAlphaNumericAndNotInSet(result, "_");
+ if (iter != result.end()) {
+ diag->Error(DiagMessage(source) << "invalid character '"
+ << StringPiece(iter, 1) << "' in '"
+ << result << "'");
+ return {};
+ }
- if (*result.begin() >= '0' && *result.begin() <= '9') {
- diag->error(DiagMessage(source) << "symbol can not start with a digit");
- return {};
- }
+ if (*result.begin() >= '0' && *result.begin() <= '9') {
+ diag->Error(DiagMessage(source) << "symbol can not start with a digit");
+ return {};
+ }
- return result;
+ return result;
}
-static bool writeSymbol(const Source& source, IDiagnostics* diag, xml::Element* el,
- ClassDefinition* classDef) {
- xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "name");
- if (!attr) {
- diag->error(DiagMessage(source) << "<" << el->name << "> must define 'android:name'");
- return false;
- }
+static bool WriteSymbol(const Source& source, IDiagnostics* diag,
+ xml::Element* el, ClassDefinition* class_def) {
+ xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name");
+ if (!attr) {
+ diag->Error(DiagMessage(source) << "<" << el->name
+ << "> must define 'android:name'");
+ return false;
+ }
- Maybe<StringPiece> result = extractJavaIdentifier(diag, source.withLine(el->lineNumber),
- attr->value);
- if (!result) {
- return false;
- }
+ Maybe<StringPiece> result = ExtractJavaIdentifier(
+ diag, source.WithLine(el->line_number), attr->value);
+ if (!result) {
+ return false;
+ }
- std::unique_ptr<StringMember> stringMember = util::make_unique<StringMember>(
- result.value(), attr->value);
- stringMember->getCommentBuilder()->appendComment(el->comment);
+ std::unique_ptr<StringMember> string_member =
+ util::make_unique<StringMember>(result.value(), attr->value);
+ string_member->GetCommentBuilder()->AppendComment(el->comment);
- classDef->addMember(std::move(stringMember));
- return true;
+ class_def->AddMember(std::move(string_member));
+ return true;
}
-std::unique_ptr<ClassDefinition> generateManifestClass(IDiagnostics* diag, xml::XmlResource* res) {
- xml::Element* el = xml::findRootElement(res->root.get());
- if (!el) {
- diag->error(DiagMessage(res->file.source) << "no root tag defined");
- return {};
+std::unique_ptr<ClassDefinition> GenerateManifestClass(IDiagnostics* diag,
+ xml::XmlResource* res) {
+ xml::Element* el = xml::FindRootElement(res->root.get());
+ if (!el) {
+ diag->Error(DiagMessage(res->file.source) << "no root tag defined");
+ return {};
+ }
+
+ if (el->name != "manifest" && !el->namespace_uri.empty()) {
+ diag->Error(DiagMessage(res->file.source)
+ << "no <manifest> root tag defined");
+ return {};
+ }
+
+ std::unique_ptr<ClassDefinition> permission_class =
+ util::make_unique<ClassDefinition>("permission", ClassQualifier::Static,
+ false);
+ std::unique_ptr<ClassDefinition> permission_group_class =
+ util::make_unique<ClassDefinition>("permission_group",
+ ClassQualifier::Static, false);
+
+ bool error = false;
+ std::vector<xml::Element*> children = el->GetChildElements();
+ for (xml::Element* child_el : children) {
+ if (child_el->namespace_uri.empty()) {
+ if (child_el->name == "permission") {
+ error |= !WriteSymbol(res->file.source, diag, child_el,
+ permission_class.get());
+ } else if (child_el->name == "permission-group") {
+ error |= !WriteSymbol(res->file.source, diag, child_el,
+ permission_group_class.get());
+ }
}
+ }
- if (el->name != "manifest" && !el->namespaceUri.empty()) {
- diag->error(DiagMessage(res->file.source) << "no <manifest> root tag defined");
- return {};
- }
+ if (error) {
+ return {};
+ }
- std::unique_ptr<ClassDefinition> permissionClass =
- util::make_unique<ClassDefinition>("permission", ClassQualifier::Static, false);
- std::unique_ptr<ClassDefinition> permissionGroupClass =
- util::make_unique<ClassDefinition>("permission_group", ClassQualifier::Static, false);
-
- bool error = false;
-
- std::vector<xml::Element*> children = el->getChildElements();
- for (xml::Element* childEl : children) {
- if (childEl->namespaceUri.empty()) {
- if (childEl->name == "permission") {
- error |= !writeSymbol(res->file.source, diag, childEl, permissionClass.get());
- } else if (childEl->name == "permission-group") {
- error |= !writeSymbol(res->file.source, diag, childEl, permissionGroupClass.get());
- }
- }
- }
-
- if (error) {
- return {};
- }
-
- std::unique_ptr<ClassDefinition> manifestClass =
- util::make_unique<ClassDefinition>("Manifest", ClassQualifier::None, false);
- manifestClass->addMember(std::move(permissionClass));
- manifestClass->addMember(std::move(permissionGroupClass));
- return manifestClass;
+ std::unique_ptr<ClassDefinition> manifest_class =
+ util::make_unique<ClassDefinition>("Manifest", ClassQualifier::None,
+ false);
+ manifest_class->AddMember(std::move(permission_class));
+ manifest_class->AddMember(std::move(permission_group_class));
+ return manifest_class;
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/java/ManifestClassGenerator.h b/tools/aapt2/java/ManifestClassGenerator.h
index 1817648..b12202a 100644
--- a/tools/aapt2/java/ManifestClassGenerator.h
+++ b/tools/aapt2/java/ManifestClassGenerator.h
@@ -19,14 +19,11 @@
#include "Diagnostics.h"
#include "java/ClassDefinition.h"
-#include "util/StringPiece.h"
#include "xml/XmlDom.h"
-#include <iostream>
-
namespace aapt {
-std::unique_ptr<ClassDefinition> generateManifestClass(IDiagnostics* diag,
+std::unique_ptr<ClassDefinition> GenerateManifestClass(IDiagnostics* diag,
xml::XmlResource* res);
} // namespace aapt
diff --git a/tools/aapt2/java/ManifestClassGenerator_test.cpp b/tools/aapt2/java/ManifestClassGenerator_test.cpp
index eecb544..5ebf508 100644
--- a/tools/aapt2/java/ManifestClassGenerator_test.cpp
+++ b/tools/aapt2/java/ManifestClassGenerator_test.cpp
@@ -15,30 +15,33 @@
*/
#include "java/ManifestClassGenerator.h"
+
#include "test/Test.h"
namespace aapt {
-static ::testing::AssertionResult getManifestClassText(IAaptContext* context, xml::XmlResource* res,
- std::string* outStr) {
- std::unique_ptr<ClassDefinition> manifestClass = generateManifestClass(
- context->getDiagnostics(), res);
- if (!manifestClass) {
- return ::testing::AssertionFailure() << "manifestClass == nullptr";
- }
+static ::testing::AssertionResult GetManifestClassText(IAaptContext* context,
+ xml::XmlResource* res,
+ std::string* out_str) {
+ std::unique_ptr<ClassDefinition> manifest_class =
+ GenerateManifestClass(context->GetDiagnostics(), res);
+ if (!manifest_class) {
+ return ::testing::AssertionFailure() << "manifest_class == nullptr";
+ }
- std::stringstream out;
- if (!manifestClass->writeJavaFile(manifestClass.get(), "android", true, &out)) {
- return ::testing::AssertionFailure() << "failed to write java file";
- }
+ std::stringstream out;
+ if (!manifest_class->WriteJavaFile(manifest_class.get(), "android", true,
+ &out)) {
+ return ::testing::AssertionFailure() << "failed to write java file";
+ }
- *outStr = out.str();
- return ::testing::AssertionSuccess();
+ *out_str = out.str();
+ return ::testing::AssertionSuccess();
}
TEST(ManifestClassGeneratorTest, NameIsProperlyGeneratedFromSymbol) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unique_ptr<xml::XmlResource> manifest = test::buildXmlDom(R"EOF(
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unique_ptr<xml::XmlResource> manifest = test::BuildXmlDom(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<permission android:name="android.permission.ACCESS_INTERNET" />
<permission android:name="android.DO_DANGEROUS_THINGS" />
@@ -46,46 +49,51 @@
<permission-group android:name="foo.bar.PERMISSION" />
</manifest>)EOF");
- std::string actual;
- ASSERT_TRUE(getManifestClassText(context.get(), manifest.get(), &actual));
+ std::string actual;
+ ASSERT_TRUE(GetManifestClassText(context.get(), manifest.get(), &actual));
- const size_t permissionClassPos = actual.find("public static final class permission {");
- const size_t permissionGroupClassPos =
- actual.find("public static final class permission_group {");
- ASSERT_NE(std::string::npos, permissionClassPos);
- ASSERT_NE(std::string::npos, permissionGroupClassPos);
+ const size_t permission_class_pos =
+ actual.find("public static final class permission {");
+ const size_t permission_croup_class_pos =
+ actual.find("public static final class permission_group {");
+ ASSERT_NE(std::string::npos, permission_class_pos);
+ ASSERT_NE(std::string::npos, permission_croup_class_pos);
- //
- // Make sure these permissions are in the permission class.
- //
+ //
+ // Make sure these permissions are in the permission class.
+ //
- size_t pos = actual.find("public static final String ACCESS_INTERNET="
- "\"android.permission.ACCESS_INTERNET\";");
- EXPECT_GT(pos, permissionClassPos);
- EXPECT_LT(pos, permissionGroupClassPos);
+ size_t pos = actual.find(
+ "public static final String ACCESS_INTERNET="
+ "\"android.permission.ACCESS_INTERNET\";");
+ EXPECT_GT(pos, permission_class_pos);
+ EXPECT_LT(pos, permission_croup_class_pos);
- pos = actual.find("public static final String DO_DANGEROUS_THINGS="
- "\"android.DO_DANGEROUS_THINGS\";");
- EXPECT_GT(pos, permissionClassPos);
- EXPECT_LT(pos, permissionGroupClassPos);
+ pos = actual.find(
+ "public static final String DO_DANGEROUS_THINGS="
+ "\"android.DO_DANGEROUS_THINGS\";");
+ EXPECT_GT(pos, permission_class_pos);
+ EXPECT_LT(pos, permission_croup_class_pos);
- pos = actual.find("public static final String HUH=\"com.test.sample.permission.HUH\";");
- EXPECT_GT(pos, permissionClassPos);
- EXPECT_LT(pos, permissionGroupClassPos);
+ pos = actual.find(
+ "public static final String HUH=\"com.test.sample.permission.HUH\";");
+ EXPECT_GT(pos, permission_class_pos);
+ EXPECT_LT(pos, permission_croup_class_pos);
- //
- // Make sure these permissions are in the permission_group class
- //
+ //
+ // Make sure these permissions are in the permission_group class
+ //
- pos = actual.find("public static final String PERMISSION="
- "\"foo.bar.PERMISSION\";");
- EXPECT_GT(pos, permissionGroupClassPos);
- EXPECT_LT(pos, std::string::npos);
+ pos = actual.find(
+ "public static final String PERMISSION="
+ "\"foo.bar.PERMISSION\";");
+ EXPECT_GT(pos, permission_croup_class_pos);
+ EXPECT_LT(pos, std::string::npos);
}
TEST(ManifestClassGeneratorTest, CommentsAndAnnotationsArePresent) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unique_ptr<xml::XmlResource> manifest = test::buildXmlDom(R"EOF(
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unique_ptr<xml::XmlResource> manifest = test::BuildXmlDom(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<!-- Required to access the internet.
Added in API 1. -->
@@ -98,36 +106,36 @@
<permission android:name="android.permission.SECRET" />
</manifest>)EOF");
- std::string actual;
- ASSERT_TRUE(getManifestClassText(context.get(), manifest.get(), &actual));
+ std::string actual;
+ ASSERT_TRUE(GetManifestClassText(context.get(), manifest.get(), &actual));
- const char* expectedAccessInternet =
-R"EOF( /**
+ const char* expected_access_internet =
+ R"EOF( /**
* Required to access the internet.
* Added in API 1.
*/
public static final String ACCESS_INTERNET="android.permission.ACCESS_INTERNET";)EOF";
- EXPECT_NE(std::string::npos, actual.find(expectedAccessInternet));
+ EXPECT_NE(std::string::npos, actual.find(expected_access_internet));
- const char* expectedPlayOutside =
-R"EOF( /**
+ const char* expected_play_outside =
+ R"EOF( /**
* @deprecated This permission is for playing outside.
*/
@Deprecated
public static final String PLAY_OUTSIDE="android.permission.PLAY_OUTSIDE";)EOF";
- EXPECT_NE(std::string::npos, actual.find(expectedPlayOutside));
+ EXPECT_NE(std::string::npos, actual.find(expected_play_outside));
- const char* expectedSecret =
-R"EOF( /**
+ const char* expected_secret =
+ R"EOF( /**
* This is a private permission for system only!
* @hide
*/
@android.annotation.SystemApi
public static final String SECRET="android.permission.SECRET";)EOF";
- EXPECT_NE(std::string::npos, actual.find(expectedSecret));
+ EXPECT_NE(std::string::npos, actual.find(expected_secret));
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/java/ProguardRules.cpp b/tools/aapt2/java/ProguardRules.cpp
index 902ec4c..624a559 100644
--- a/tools/aapt2/java/ProguardRules.cpp
+++ b/tools/aapt2/java/ProguardRules.cpp
@@ -15,254 +15,281 @@
*/
#include "java/ProguardRules.h"
-#include "util/Util.h"
-#include "xml/XmlDom.h"
#include <memory>
#include <string>
+#include "android-base/macros.h"
+
+#include "util/Util.h"
+#include "xml/XmlDom.h"
+
namespace aapt {
namespace proguard {
class BaseVisitor : public xml::Visitor {
-public:
- BaseVisitor(const Source& source, KeepSet* keepSet) : mSource(source), mKeepSet(keepSet) {
+ public:
+ BaseVisitor(const Source& source, KeepSet* keep_set)
+ : source_(source), keep_set_(keep_set) {}
+
+ virtual void Visit(xml::Text*) override{};
+
+ virtual void Visit(xml::Namespace* node) override {
+ for (const auto& child : node->children) {
+ child->Accept(this);
}
+ }
- virtual void visit(xml::Text*) override {};
-
- virtual void visit(xml::Namespace* node) override {
- for (const auto& child : node->children) {
- child->accept(this);
+ virtual void Visit(xml::Element* node) override {
+ if (!node->namespace_uri.empty()) {
+ Maybe<xml::ExtractedPackage> maybe_package =
+ xml::ExtractPackageFromNamespace(node->namespace_uri);
+ if (maybe_package) {
+ // This is a custom view, let's figure out the class name from this.
+ std::string package = maybe_package.value().package + "." + node->name;
+ if (util::IsJavaClassName(package)) {
+ AddClass(node->line_number, package);
}
+ }
+ } else if (util::IsJavaClassName(node->name)) {
+ AddClass(node->line_number, node->name);
}
- virtual void visit(xml::Element* node) override {
- if (!node->namespaceUri.empty()) {
- Maybe<xml::ExtractedPackage> maybePackage = xml::extractPackageFromNamespace(
- node->namespaceUri);
- if (maybePackage) {
- // This is a custom view, let's figure out the class name from this.
- std::string package = maybePackage.value().package + "." + node->name;
- if (util::isJavaClassName(package)) {
- addClass(node->lineNumber, package);
- }
- }
- } else if (util::isJavaClassName(node->name)) {
- addClass(node->lineNumber, node->name);
- }
-
- for (const auto& child: node->children) {
- child->accept(this);
- }
+ for (const auto& child : node->children) {
+ child->Accept(this);
}
+ }
-protected:
- void addClass(size_t lineNumber, const std::string& className) {
- mKeepSet->addClass(Source(mSource.path, lineNumber), className);
- }
+ protected:
+ void AddClass(size_t line_number, const std::string& class_name) {
+ keep_set_->AddClass(Source(source_.path, line_number), class_name);
+ }
- void addMethod(size_t lineNumber, const std::string& methodName) {
- mKeepSet->addMethod(Source(mSource.path, lineNumber), methodName);
- }
+ void AddMethod(size_t line_number, const std::string& method_name) {
+ keep_set_->AddMethod(Source(source_.path, line_number), method_name);
+ }
-private:
- Source mSource;
- KeepSet* mKeepSet;
+ private:
+ DISALLOW_COPY_AND_ASSIGN(BaseVisitor);
+
+ Source source_;
+ KeepSet* keep_set_;
};
-struct LayoutVisitor : public BaseVisitor {
- LayoutVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) {
+class LayoutVisitor : public BaseVisitor {
+ public:
+ LayoutVisitor(const Source& source, KeepSet* keep_set)
+ : BaseVisitor(source, keep_set) {}
+
+ virtual void Visit(xml::Element* node) override {
+ bool check_class = false;
+ bool check_name = false;
+ if (node->namespace_uri.empty()) {
+ check_class = node->name == "view" || node->name == "fragment";
+ } else if (node->namespace_uri == xml::kSchemaAndroid) {
+ check_name = node->name == "fragment";
}
- virtual void visit(xml::Element* node) override {
- bool checkClass = false;
- bool checkName = false;
- if (node->namespaceUri.empty()) {
- checkClass = node->name == "view" || node->name == "fragment";
- } else if (node->namespaceUri == xml::kSchemaAndroid) {
- checkName = node->name == "fragment";
- }
-
- for (const auto& attr : node->attributes) {
- if (checkClass && attr.namespaceUri.empty() && attr.name == "class" &&
- util::isJavaClassName(attr.value)) {
- addClass(node->lineNumber, attr.value);
- } else if (checkName && attr.namespaceUri == xml::kSchemaAndroid &&
- attr.name == "name" && util::isJavaClassName(attr.value)) {
- addClass(node->lineNumber, attr.value);
- } else if (attr.namespaceUri == xml::kSchemaAndroid && attr.name == "onClick") {
- addMethod(node->lineNumber, attr.value);
- }
- }
-
- BaseVisitor::visit(node);
+ for (const auto& attr : node->attributes) {
+ if (check_class && attr.namespace_uri.empty() && attr.name == "class" &&
+ util::IsJavaClassName(attr.value)) {
+ AddClass(node->line_number, attr.value);
+ } else if (check_name && attr.namespace_uri == xml::kSchemaAndroid &&
+ attr.name == "name" && util::IsJavaClassName(attr.value)) {
+ AddClass(node->line_number, attr.value);
+ } else if (attr.namespace_uri == xml::kSchemaAndroid &&
+ attr.name == "onClick") {
+ AddMethod(node->line_number, attr.value);
+ }
}
+
+ BaseVisitor::Visit(node);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(LayoutVisitor);
};
-struct XmlResourceVisitor : public BaseVisitor {
- XmlResourceVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) {
+class XmlResourceVisitor : public BaseVisitor {
+ public:
+ XmlResourceVisitor(const Source& source, KeepSet* keep_set)
+ : BaseVisitor(source, keep_set) {}
+
+ virtual void Visit(xml::Element* node) override {
+ bool check_fragment = false;
+ if (node->namespace_uri.empty()) {
+ check_fragment =
+ node->name == "PreferenceScreen" || node->name == "header";
}
- virtual void visit(xml::Element* node) override {
- bool checkFragment = false;
- if (node->namespaceUri.empty()) {
- checkFragment = node->name == "PreferenceScreen" || node->name == "header";
- }
-
- if (checkFragment) {
- xml::Attribute* attr = node->findAttribute(xml::kSchemaAndroid, "fragment");
- if (attr && util::isJavaClassName(attr->value)) {
- addClass(node->lineNumber, attr->value);
- }
- }
-
- BaseVisitor::visit(node);
+ if (check_fragment) {
+ xml::Attribute* attr =
+ node->FindAttribute(xml::kSchemaAndroid, "fragment");
+ if (attr && util::IsJavaClassName(attr->value)) {
+ AddClass(node->line_number, attr->value);
+ }
}
+
+ BaseVisitor::Visit(node);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlResourceVisitor);
};
-struct TransitionVisitor : public BaseVisitor {
- TransitionVisitor(const Source& source, KeepSet* keepSet) : BaseVisitor(source, keepSet) {
+class TransitionVisitor : public BaseVisitor {
+ public:
+ TransitionVisitor(const Source& source, KeepSet* keep_set)
+ : BaseVisitor(source, keep_set) {}
+
+ virtual void Visit(xml::Element* node) override {
+ bool check_class =
+ node->namespace_uri.empty() &&
+ (node->name == "transition" || node->name == "pathMotion");
+ if (check_class) {
+ xml::Attribute* attr = node->FindAttribute({}, "class");
+ if (attr && util::IsJavaClassName(attr->value)) {
+ AddClass(node->line_number, attr->value);
+ }
}
- virtual void visit(xml::Element* node) override {
- bool checkClass = node->namespaceUri.empty() &&
- (node->name == "transition" || node->name == "pathMotion");
- if (checkClass) {
- xml::Attribute* attr = node->findAttribute({}, "class");
- if (attr && util::isJavaClassName(attr->value)) {
- addClass(node->lineNumber, attr->value);
- }
- }
+ BaseVisitor::Visit(node);
+ }
- BaseVisitor::visit(node);
- }
+ private:
+ DISALLOW_COPY_AND_ASSIGN(TransitionVisitor);
};
-struct ManifestVisitor : public BaseVisitor {
- ManifestVisitor(const Source& source, KeepSet* keepSet, bool mainDexOnly)
- : BaseVisitor(source, keepSet), mMainDexOnly(mainDexOnly) {
- }
+class ManifestVisitor : public BaseVisitor {
+ public:
+ ManifestVisitor(const Source& source, KeepSet* keep_set, bool main_dex_only)
+ : BaseVisitor(source, keep_set), main_dex_only_(main_dex_only) {}
- virtual void visit(xml::Element* node) override {
- if (node->namespaceUri.empty()) {
- bool getName = false;
- if (node->name == "manifest") {
- xml::Attribute* attr = node->findAttribute({}, "package");
- if (attr) {
- mPackage = attr->value;
- }
- } else if (node->name == "application") {
- getName = true;
- xml::Attribute* attr = node->findAttribute(xml::kSchemaAndroid, "backupAgent");
- if (attr) {
- Maybe<std::string> result = util::getFullyQualifiedClassName(mPackage,
- attr->value);
- if (result) {
- addClass(node->lineNumber, result.value());
- }
- }
- if (mMainDexOnly) {
- xml::Attribute* defaultProcess = node->findAttribute(xml::kSchemaAndroid,
- "process");
- if (defaultProcess) {
- mDefaultProcess = defaultProcess->value;
- }
- }
- } else if (node->name == "activity" || node->name == "service" ||
- node->name == "receiver" || node->name == "provider") {
- getName = true;
-
- if (mMainDexOnly) {
- xml::Attribute* componentProcess = node->findAttribute(xml::kSchemaAndroid,
- "process");
-
- const std::string& process = componentProcess ? componentProcess->value
- : mDefaultProcess;
- getName = !process.empty() && process[0] != ':';
- }
- } else if (node-> name == "instrumentation") {
- getName = true;
- }
-
- if (getName) {
- xml::Attribute* attr = node->findAttribute(xml::kSchemaAndroid, "name");
- getName = attr != nullptr;
-
- if (getName) {
- Maybe<std::string> result = util::getFullyQualifiedClassName(mPackage,
- attr->value);
- if (result) {
- addClass(node->lineNumber, result.value());
- }
- }
- }
+ virtual void Visit(xml::Element* node) override {
+ if (node->namespace_uri.empty()) {
+ bool get_name = false;
+ if (node->name == "manifest") {
+ xml::Attribute* attr = node->FindAttribute({}, "package");
+ if (attr) {
+ package_ = attr->value;
}
- BaseVisitor::visit(node);
- }
+ } else if (node->name == "application") {
+ get_name = true;
+ xml::Attribute* attr =
+ node->FindAttribute(xml::kSchemaAndroid, "backupAgent");
+ if (attr) {
+ Maybe<std::string> result =
+ util::GetFullyQualifiedClassName(package_, attr->value);
+ if (result) {
+ AddClass(node->line_number, result.value());
+ }
+ }
+ if (main_dex_only_) {
+ xml::Attribute* default_process =
+ node->FindAttribute(xml::kSchemaAndroid, "process");
+ if (default_process) {
+ default_process_ = default_process->value;
+ }
+ }
+ } else if (node->name == "activity" || node->name == "service" ||
+ node->name == "receiver" || node->name == "provider") {
+ get_name = true;
-private:
- std::string mPackage;
- const bool mMainDexOnly;
- std::string mDefaultProcess;
+ if (main_dex_only_) {
+ xml::Attribute* component_process =
+ node->FindAttribute(xml::kSchemaAndroid, "process");
+
+ const std::string& process =
+ component_process ? component_process->value : default_process_;
+ get_name = !process.empty() && process[0] != ':';
+ }
+ } else if (node->name == "instrumentation") {
+ get_name = true;
+ }
+
+ if (get_name) {
+ xml::Attribute* attr = node->FindAttribute(xml::kSchemaAndroid, "name");
+ get_name = attr != nullptr;
+
+ if (get_name) {
+ Maybe<std::string> result =
+ util::GetFullyQualifiedClassName(package_, attr->value);
+ if (result) {
+ AddClass(node->line_number, result.value());
+ }
+ }
+ }
+ }
+ BaseVisitor::Visit(node);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ManifestVisitor);
+
+ std::string package_;
+ const bool main_dex_only_;
+ std::string default_process_;
};
-bool collectProguardRulesForManifest(const Source& source, xml::XmlResource* res,
- KeepSet* keepSet, bool mainDexOnly) {
- ManifestVisitor visitor(source, keepSet, mainDexOnly);
- if (res->root) {
- res->root->accept(&visitor);
- return true;
- }
+bool CollectProguardRulesForManifest(const Source& source,
+ xml::XmlResource* res, KeepSet* keep_set,
+ bool main_dex_only) {
+ ManifestVisitor visitor(source, keep_set, main_dex_only);
+ if (res->root) {
+ res->root->Accept(&visitor);
+ return true;
+ }
+ return false;
+}
+
+bool CollectProguardRules(const Source& source, xml::XmlResource* res,
+ KeepSet* keep_set) {
+ if (!res->root) {
return false;
+ }
+
+ switch (res->file.name.type) {
+ case ResourceType::kLayout: {
+ LayoutVisitor visitor(source, keep_set);
+ res->root->Accept(&visitor);
+ break;
+ }
+
+ case ResourceType::kXml: {
+ XmlResourceVisitor visitor(source, keep_set);
+ res->root->Accept(&visitor);
+ break;
+ }
+
+ case ResourceType::kTransition: {
+ TransitionVisitor visitor(source, keep_set);
+ res->root->Accept(&visitor);
+ break;
+ }
+
+ default:
+ break;
+ }
+ return true;
}
-bool collectProguardRules(const Source& source, xml::XmlResource* res, KeepSet* keepSet) {
- if (!res->root) {
- return false;
+bool WriteKeepSet(std::ostream* out, const KeepSet& keep_set) {
+ for (const auto& entry : keep_set.keep_set_) {
+ for (const Source& source : entry.second) {
+ *out << "# Referenced at " << source << "\n";
}
+ *out << "-keep class " << entry.first << " { <init>(...); }\n" << std::endl;
+ }
- switch (res->file.name.type) {
- case ResourceType::kLayout: {
- LayoutVisitor visitor(source, keepSet);
- res->root->accept(&visitor);
- break;
- }
-
- case ResourceType::kXml: {
- XmlResourceVisitor visitor(source, keepSet);
- res->root->accept(&visitor);
- break;
- }
-
- case ResourceType::kTransition: {
- TransitionVisitor visitor(source, keepSet);
- res->root->accept(&visitor);
- break;
- }
-
- default:
- break;
+ for (const auto& entry : keep_set.keep_method_set_) {
+ for (const Source& source : entry.second) {
+ *out << "# Referenced at " << source << "\n";
}
- return true;
+ *out << "-keepclassmembers class * { *** " << entry.first << "(...); }\n"
+ << std::endl;
+ }
+ return true;
}
-bool writeKeepSet(std::ostream* out, const KeepSet& keepSet) {
- for (const auto& entry : keepSet.mKeepSet) {
- for (const Source& source : entry.second) {
- *out << "# Referenced at " << source << "\n";
- }
- *out << "-keep class " << entry.first << " { <init>(...); }\n" << std::endl;
- }
-
- for (const auto& entry : keepSet.mKeepMethodSet) {
- for (const Source& source : entry.second) {
- *out << "# Referenced at " << source << "\n";
- }
- *out << "-keepclassmembers class * { *** " << entry.first << "(...); }\n" << std::endl;
- }
- return true;
-}
-
-} // namespace proguard
-} // namespace aapt
+} // namespace proguard
+} // namespace aapt
diff --git a/tools/aapt2/java/ProguardRules.h b/tools/aapt2/java/ProguardRules.h
index 7578ec2..3c349ba 100644
--- a/tools/aapt2/java/ProguardRules.h
+++ b/tools/aapt2/java/ProguardRules.h
@@ -17,42 +17,42 @@
#ifndef AAPT_PROGUARD_RULES_H
#define AAPT_PROGUARD_RULES_H
-#include "Resource.h"
-#include "Source.h"
-#include "xml/XmlDom.h"
-
#include <map>
#include <ostream>
#include <set>
#include <string>
+#include "Resource.h"
+#include "Source.h"
+#include "xml/XmlDom.h"
+
namespace aapt {
namespace proguard {
class KeepSet {
public:
- inline void addClass(const Source& source, const std::string& className) {
- mKeepSet[className].insert(source);
+ inline void AddClass(const Source& source, const std::string& class_name) {
+ keep_set_[class_name].insert(source);
}
- inline void addMethod(const Source& source, const std::string& methodName) {
- mKeepMethodSet[methodName].insert(source);
+ inline void AddMethod(const Source& source, const std::string& method_name) {
+ keep_method_set_[method_name].insert(source);
}
private:
- friend bool writeKeepSet(std::ostream* out, const KeepSet& keepSet);
+ friend bool WriteKeepSet(std::ostream* out, const KeepSet& keep_set);
- std::map<std::string, std::set<Source>> mKeepSet;
- std::map<std::string, std::set<Source>> mKeepMethodSet;
+ std::map<std::string, std::set<Source>> keep_set_;
+ std::map<std::string, std::set<Source>> keep_method_set_;
};
-bool collectProguardRulesForManifest(const Source& source,
- xml::XmlResource* res, KeepSet* keepSet,
- bool mainDexOnly = false);
-bool collectProguardRules(const Source& source, xml::XmlResource* res,
- KeepSet* keepSet);
+bool CollectProguardRulesForManifest(const Source& source,
+ xml::XmlResource* res, KeepSet* keep_set,
+ bool main_dex_only = false);
+bool CollectProguardRules(const Source& source, xml::XmlResource* res,
+ KeepSet* keep_set);
-bool writeKeepSet(std::ostream* out, const KeepSet& keepSet);
+bool WriteKeepSet(std::ostream* out, const KeepSet& keep_set);
} // namespace proguard
} // namespace aapt
diff --git a/tools/aapt2/jni/aapt2_jni.cpp b/tools/aapt2/jni/aapt2_jni.cpp
index dff77b9..211ada8 100644
--- a/tools/aapt2/jni/aapt2_jni.cpp
+++ b/tools/aapt2/jni/aapt2_jni.cpp
@@ -14,84 +14,81 @@
* limitations under the License.
*/
+#include "com_android_tools_aapt2_Aapt2.h"
+
#include <algorithm>
-#include <cassert>
#include <memory>
#include <utility>
#include <vector>
-#include <ScopedUtfChars.h>
+#include "android-base/logging.h"
+#include "nativehelper/ScopedUtfChars.h"
#include "util/Util.h"
-#include "com_android_tools_aapt2_Aapt2.h"
-
namespace aapt {
- extern int compile(const std::vector<StringPiece>& args);
- extern int link(const std::vector<StringPiece>& args);
+extern int Compile(const std::vector<StringPiece> &args);
+extern int Link(const std::vector<StringPiece> &args);
}
/*
* Converts a java List<String> into C++ vector<ScopedUtfChars>.
*/
static std::vector<ScopedUtfChars> list_to_utfchars(JNIEnv *env, jobject obj) {
- std::vector<ScopedUtfChars> converted;
+ std::vector<ScopedUtfChars> converted;
- // Call size() method on the list to know how many elements there are.
- jclass list_cls = env->GetObjectClass(obj);
- jmethodID size_method_id = env->GetMethodID(list_cls, "size", "()I");
- assert(size_method_id != 0);
- jint size = env->CallIntMethod(obj, size_method_id);
- assert(size >= 0);
+ // Call size() method on the list to know how many elements there are.
+ jclass list_cls = env->GetObjectClass(obj);
+ jmethodID size_method_id = env->GetMethodID(list_cls, "size", "()I");
+ CHECK(size_method_id != 0);
+ jint size = env->CallIntMethod(obj, size_method_id);
+ CHECK(size >= 0);
- // Now, iterate all strings in the list
- // (note: generic erasure means get() return an Object)
- jmethodID get_method_id = env->GetMethodID(list_cls, "get", "()Ljava/lang/Object;");
- for (jint i = 0; i < size; i++) {
- // Call get(i) to get the string in the ith position.
- jobject string_obj_uncast = env->CallObjectMethod(obj, get_method_id, i);
- assert(string_obj_uncast != nullptr);
- jstring string_obj = static_cast<jstring>(string_obj_uncast);
- converted.push_back(ScopedUtfChars(env, string_obj));
- }
+ // Now, iterate all strings in the list
+ // (note: generic erasure means get() return an Object)
+ jmethodID get_method_id =
+ env->GetMethodID(list_cls, "get", "()Ljava/lang/Object;");
+ for (jint i = 0; i < size; i++) {
+ // Call get(i) to get the string in the ith position.
+ jobject string_obj_uncast = env->CallObjectMethod(obj, get_method_id, i);
+ CHECK(string_obj_uncast != nullptr);
+ jstring string_obj = static_cast<jstring>(string_obj_uncast);
+ converted.push_back(ScopedUtfChars(env, string_obj));
+ }
- return converted;
+ return converted;
}
/*
* Extracts all StringPiece from the ScopedUtfChars instances.
- *
+ *
* The returned pieces can only be used while the original ones have not been
* destroyed.
*/
static std::vector<aapt::StringPiece> extract_pieces(
- const std::vector<ScopedUtfChars> &strings) {
- std::vector<aapt::StringPiece> pieces;
-
- std::for_each(
- strings.begin(),
- strings.end(),
- [&pieces](const ScopedUtfChars &p) {
- pieces.push_back(p.c_str());
- });
-
- return pieces;
+ const std::vector<ScopedUtfChars> &strings) {
+ std::vector<aapt::StringPiece> pieces;
+
+ std::for_each(
+ strings.begin(), strings.end(),
+ [&pieces](const ScopedUtfChars &p) { pieces.push_back(p.c_str()); });
+
+ return pieces;
}
JNIEXPORT void JNICALL Java_com_android_tools_aapt2_Aapt2_nativeCompile(
- JNIEnv *env,
- jclass aapt_obj,
- jobject arguments_obj) {
- std::vector<ScopedUtfChars> compile_args_jni = list_to_utfchars(env, arguments_obj);
- std::vector<aapt::StringPiece> compile_args = extract_pieces(compile_args_jni);
- aapt::compile(compile_args);
+ JNIEnv *env, jclass aapt_obj, jobject arguments_obj) {
+ std::vector<ScopedUtfChars> compile_args_jni =
+ list_to_utfchars(env, arguments_obj);
+ std::vector<aapt::StringPiece> compile_args =
+ extract_pieces(compile_args_jni);
+ aapt::Compile(compile_args);
}
JNIEXPORT void JNICALL Java_com_android_tools_aapt2_Aapt2_nativeLink(
- JNIEnv *env,
- jclass aapt_obj,
- jobject arguments_obj) {
- std::vector<ScopedUtfChars> link_args_jni = list_to_utfchars(env, arguments_obj);
- std::vector<aapt::StringPiece> link_args = extract_pieces(link_args_jni);
- aapt::link(link_args);
+ JNIEnv *env, jclass aapt_obj, jobject arguments_obj) {
+ std::vector<ScopedUtfChars> link_args_jni =
+ list_to_utfchars(env, arguments_obj);
+ std::vector<aapt::StringPiece> link_args = extract_pieces(link_args_jni);
+ aapt::Link(link_args);
}
diff --git a/tools/aapt2/link/AutoVersioner.cpp b/tools/aapt2/link/AutoVersioner.cpp
index 5ba9819..77471ea 100644
--- a/tools/aapt2/link/AutoVersioner.cpp
+++ b/tools/aapt2/link/AutoVersioner.cpp
@@ -14,34 +14,36 @@
* limitations under the License.
*/
+#include "link/Linkers.h"
+
+#include <algorithm>
+
+#include "android-base/logging.h"
+
#include "ConfigDescription.h"
#include "ResourceTable.h"
#include "SdkConstants.h"
#include "ValueVisitor.h"
-#include "link/Linkers.h"
-
-#include <algorithm>
-#include <cassert>
namespace aapt {
-bool shouldGenerateVersionedResource(const ResourceEntry* entry,
+bool ShouldGenerateVersionedResource(const ResourceEntry* entry,
const ConfigDescription& config,
- const int sdkVersionToGenerate) {
+ const int sdk_version_to_generate) {
// We assume the caller is trying to generate a version greater than the
// current configuration.
- assert(sdkVersionToGenerate > config.sdkVersion);
+ CHECK(sdk_version_to_generate > config.sdkVersion);
- const auto endIter = entry->values.end();
+ const auto end_iter = entry->values.end();
auto iter = entry->values.begin();
- for (; iter != endIter; ++iter) {
+ for (; iter != end_iter; ++iter) {
if ((*iter)->config == config) {
break;
}
}
// The source config came from this list, so it should be here.
- assert(iter != entry->values.end());
+ CHECK(iter != entry->values.end());
++iter;
// The next configuration either only varies in sdkVersion, or it is
@@ -53,12 +55,12 @@
// than other
// qualifiers, so we need to iterate through the entire list to be sure there
// are no higher sdk level versions of this resource.
- ConfigDescription tempConfig(config);
- for (; iter != endIter; ++iter) {
- tempConfig.sdkVersion = (*iter)->config.sdkVersion;
- if (tempConfig == (*iter)->config) {
+ ConfigDescription temp_config(config);
+ for (; iter != end_iter; ++iter) {
+ temp_config.sdkVersion = (*iter)->config.sdkVersion;
+ if (temp_config == (*iter)->config) {
// The two configs are the same, check the sdk version.
- return sdkVersionToGenerate < (*iter)->config.sdkVersion;
+ return sdk_version_to_generate < (*iter)->config.sdkVersion;
}
}
@@ -66,7 +68,7 @@
return true;
}
-bool AutoVersioner::consume(IAaptContext* context, ResourceTable* table) {
+bool AutoVersioner::Consume(IAaptContext* context, ResourceTable* table) {
for (auto& package : table->packages) {
for (auto& type : package->types) {
if (type->type != ResourceType::kStyle) {
@@ -75,36 +77,37 @@
for (auto& entry : type->entries) {
for (size_t i = 0; i < entry->values.size(); i++) {
- ResourceConfigValue* configValue = entry->values[i].get();
- if (configValue->config.sdkVersion >= SDK_LOLLIPOP_MR1) {
+ ResourceConfigValue* config_value = entry->values[i].get();
+ if (config_value->config.sdkVersion >= SDK_LOLLIPOP_MR1) {
// If this configuration is only used on L-MR1 then we don't need
// to do anything since we use private attributes since that
// version.
continue;
}
- if (Style* style = valueCast<Style>(configValue->value.get())) {
- Maybe<size_t> minSdkStripped;
+ if (Style* style = ValueCast<Style>(config_value->value.get())) {
+ Maybe<size_t> min_sdk_stripped;
std::vector<Style::Entry> stripped;
auto iter = style->entries.begin();
while (iter != style->entries.end()) {
- assert(iter->key.id && "IDs must be assigned and linked");
+ CHECK(bool(iter->key.id)) << "IDs must be assigned and linked";
// Find the SDK level that is higher than the configuration
// allows.
- const size_t sdkLevel =
- findAttributeSdkLevel(iter->key.id.value());
- if (sdkLevel >
- std::max<size_t>(configValue->config.sdkVersion, 1)) {
+ const size_t sdk_level =
+ FindAttributeSdkLevel(iter->key.id.value());
+ if (sdk_level >
+ std::max<size_t>(config_value->config.sdkVersion, 1)) {
// Record that we are about to strip this.
stripped.emplace_back(std::move(*iter));
// We use the smallest SDK level to generate the new style.
- if (minSdkStripped) {
- minSdkStripped = std::min(minSdkStripped.value(), sdkLevel);
+ if (min_sdk_stripped) {
+ min_sdk_stripped =
+ std::min(min_sdk_stripped.value(), sdk_level);
} else {
- minSdkStripped = sdkLevel;
+ min_sdk_stripped = sdk_level;
}
// Erase this from this style.
@@ -114,31 +117,31 @@
++iter;
}
- if (minSdkStripped && !stripped.empty()) {
+ if (min_sdk_stripped && !stripped.empty()) {
// We found attributes from a higher SDK level. Check that
// there is no other defined resource for the version we want to
// generate.
- if (shouldGenerateVersionedResource(entry.get(),
- configValue->config,
- minSdkStripped.value())) {
+ if (ShouldGenerateVersionedResource(entry.get(),
+ config_value->config,
+ min_sdk_stripped.value())) {
// Let's create a new Style for this versioned resource.
- ConfigDescription newConfig(configValue->config);
- newConfig.sdkVersion = minSdkStripped.value();
+ ConfigDescription new_config(config_value->config);
+ new_config.sdkVersion = min_sdk_stripped.value();
- std::unique_ptr<Style> newStyle(
- style->clone(&table->stringPool));
- newStyle->setComment(style->getComment());
- newStyle->setSource(style->getSource());
+ std::unique_ptr<Style> new_style(
+ style->Clone(&table->string_pool));
+ new_style->SetComment(style->GetComment());
+ new_style->SetSource(style->GetSource());
// Move the previously stripped attributes into this style.
- newStyle->entries.insert(
- newStyle->entries.end(),
+ new_style->entries.insert(
+ new_style->entries.end(),
std::make_move_iterator(stripped.begin()),
std::make_move_iterator(stripped.end()));
// Insert the new Resource into the correct place.
- entry->findOrCreateValue(newConfig, {})->value =
- std::move(newStyle);
+ entry->FindOrCreateValue(new_config, {})->value =
+ std::move(new_style);
}
}
}
diff --git a/tools/aapt2/link/AutoVersioner_test.cpp b/tools/aapt2/link/AutoVersioner_test.cpp
index 04bf9cd..755af0a 100644
--- a/tools/aapt2/link/AutoVersioner_test.cpp
+++ b/tools/aapt2/link/AutoVersioner_test.cpp
@@ -14,121 +14,124 @@
* limitations under the License.
*/
-#include "ConfigDescription.h"
#include "link/Linkers.h"
+
+#include "ConfigDescription.h"
#include "test/Test.h"
namespace aapt {
TEST(AutoVersionerTest, GenerateVersionedResources) {
- const ConfigDescription defaultConfig = {};
- const ConfigDescription landConfig = test::parseConfigOrDie("land");
- const ConfigDescription sw600dpLandConfig =
- test::parseConfigOrDie("sw600dp-land");
+ const ConfigDescription land_config = test::ParseConfigOrDie("land");
+ const ConfigDescription sw600dp_land_config =
+ test::ParseConfigOrDie("sw600dp-land");
ResourceEntry entry("foo");
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(
+ ConfigDescription::DefaultConfig(), ""));
entry.values.push_back(
- util::make_unique<ResourceConfigValue>(defaultConfig, ""));
+ util::make_unique<ResourceConfigValue>(land_config, ""));
entry.values.push_back(
- util::make_unique<ResourceConfigValue>(landConfig, ""));
- entry.values.push_back(
- util::make_unique<ResourceConfigValue>(sw600dpLandConfig, ""));
+ util::make_unique<ResourceConfigValue>(sw600dp_land_config, ""));
- EXPECT_TRUE(shouldGenerateVersionedResource(&entry, defaultConfig, 17));
- EXPECT_TRUE(shouldGenerateVersionedResource(&entry, landConfig, 17));
+ EXPECT_TRUE(ShouldGenerateVersionedResource(
+ &entry, ConfigDescription::DefaultConfig(), 17));
+ EXPECT_TRUE(ShouldGenerateVersionedResource(&entry, land_config, 17));
}
TEST(AutoVersionerTest, GenerateVersionedResourceWhenHigherVersionExists) {
- const ConfigDescription defaultConfig = {};
- const ConfigDescription sw600dpV13Config =
- test::parseConfigOrDie("sw600dp-v13");
- const ConfigDescription v21Config = test::parseConfigOrDie("v21");
+ const ConfigDescription sw600dp_v13_config =
+ test::ParseConfigOrDie("sw600dp-v13");
+ const ConfigDescription v21_config = test::ParseConfigOrDie("v21");
ResourceEntry entry("foo");
+ entry.values.push_back(util::make_unique<ResourceConfigValue>(
+ ConfigDescription::DefaultConfig(), ""));
entry.values.push_back(
- util::make_unique<ResourceConfigValue>(defaultConfig, ""));
+ util::make_unique<ResourceConfigValue>(sw600dp_v13_config, ""));
entry.values.push_back(
- util::make_unique<ResourceConfigValue>(sw600dpV13Config, ""));
- entry.values.push_back(util::make_unique<ResourceConfigValue>(v21Config, ""));
+ util::make_unique<ResourceConfigValue>(v21_config, ""));
- EXPECT_TRUE(shouldGenerateVersionedResource(&entry, defaultConfig, 17));
- EXPECT_FALSE(shouldGenerateVersionedResource(&entry, defaultConfig, 22));
+ EXPECT_TRUE(ShouldGenerateVersionedResource(
+ &entry, ConfigDescription::DefaultConfig(), 17));
+ EXPECT_FALSE(ShouldGenerateVersionedResource(
+ &entry, ConfigDescription::DefaultConfig(), 22));
}
TEST(AutoVersionerTest, VersionStylesForTable) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("app", 0x7f)
- .addValue(
- "app:style/Foo", test::parseConfigOrDie("v4"),
+ .SetPackageId("app", 0x7f)
+ .AddValue(
+ "app:style/Foo", test::ParseConfigOrDie("v4"),
ResourceId(0x7f020000),
test::StyleBuilder()
- .addItem("android:attr/onClick", ResourceId(0x0101026f),
+ .AddItem("android:attr/onClick", ResourceId(0x0101026f),
util::make_unique<Id>())
- .addItem("android:attr/paddingStart", ResourceId(0x010103b3),
+ .AddItem("android:attr/paddingStart", ResourceId(0x010103b3),
util::make_unique<Id>())
- .addItem("android:attr/requiresSmallestWidthDp",
+ .AddItem("android:attr/requiresSmallestWidthDp",
ResourceId(0x01010364), util::make_unique<Id>())
- .addItem("android:attr/colorAccent", ResourceId(0x01010435),
+ .AddItem("android:attr/colorAccent", ResourceId(0x01010435),
util::make_unique<Id>())
- .build())
- .addValue(
- "app:style/Foo", test::parseConfigOrDie("v21"),
+ .Build())
+ .AddValue(
+ "app:style/Foo", test::ParseConfigOrDie("v21"),
ResourceId(0x7f020000),
test::StyleBuilder()
- .addItem("android:attr/paddingEnd", ResourceId(0x010103b4),
+ .AddItem("android:attr/paddingEnd", ResourceId(0x010103b4),
util::make_unique<Id>())
- .build())
- .build();
+ .Build())
+ .Build();
std::unique_ptr<IAaptContext> context = test::ContextBuilder()
- .setCompilationPackage("app")
- .setPackageId(0x7f)
- .build();
+ .SetCompilationPackage("app")
+ .SetPackageId(0x7f)
+ .Build();
AutoVersioner versioner;
- ASSERT_TRUE(versioner.consume(context.get(), table.get()));
+ ASSERT_TRUE(versioner.Consume(context.get(), table.get()));
- Style* style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
- test::parseConfigOrDie("v4"));
+ Style* style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+ test::ParseConfigOrDie("v4"));
ASSERT_NE(style, nullptr);
ASSERT_EQ(style->entries.size(), 1u);
AAPT_ASSERT_TRUE(style->entries.front().key.name);
EXPECT_EQ(style->entries.front().key.name.value(),
- test::parseNameOrDie("android:attr/onClick"));
+ test::ParseNameOrDie("android:attr/onClick"));
- style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
- test::parseConfigOrDie("v13"));
+ style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+ test::ParseConfigOrDie("v13"));
ASSERT_NE(style, nullptr);
ASSERT_EQ(style->entries.size(), 2u);
AAPT_ASSERT_TRUE(style->entries[0].key.name);
EXPECT_EQ(style->entries[0].key.name.value(),
- test::parseNameOrDie("android:attr/onClick"));
+ test::ParseNameOrDie("android:attr/onClick"));
AAPT_ASSERT_TRUE(style->entries[1].key.name);
EXPECT_EQ(style->entries[1].key.name.value(),
- test::parseNameOrDie("android:attr/requiresSmallestWidthDp"));
+ test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
- style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
- test::parseConfigOrDie("v17"));
+ style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+ test::ParseConfigOrDie("v17"));
ASSERT_NE(style, nullptr);
ASSERT_EQ(style->entries.size(), 3u);
AAPT_ASSERT_TRUE(style->entries[0].key.name);
EXPECT_EQ(style->entries[0].key.name.value(),
- test::parseNameOrDie("android:attr/onClick"));
+ test::ParseNameOrDie("android:attr/onClick"));
AAPT_ASSERT_TRUE(style->entries[1].key.name);
EXPECT_EQ(style->entries[1].key.name.value(),
- test::parseNameOrDie("android:attr/requiresSmallestWidthDp"));
+ test::ParseNameOrDie("android:attr/requiresSmallestWidthDp"));
AAPT_ASSERT_TRUE(style->entries[2].key.name);
EXPECT_EQ(style->entries[2].key.name.value(),
- test::parseNameOrDie("android:attr/paddingStart"));
+ test::ParseNameOrDie("android:attr/paddingStart"));
- style = test::getValueForConfig<Style>(table.get(), "app:style/Foo",
- test::parseConfigOrDie("v21"));
+ style = test::GetValueForConfig<Style>(table.get(), "app:style/Foo",
+ test::ParseConfigOrDie("v21"));
ASSERT_NE(style, nullptr);
ASSERT_EQ(style->entries.size(), 1u);
AAPT_ASSERT_TRUE(style->entries.front().key.name);
EXPECT_EQ(style->entries.front().key.name.value(),
- test::parseNameOrDie("android:attr/paddingEnd"));
+ test::ParseNameOrDie("android:attr/paddingEnd"));
}
} // namespace aapt
diff --git a/tools/aapt2/link/Link.cpp b/tools/aapt2/link/Link.cpp
index 6dd34e3..717978ea 100644
--- a/tools/aapt2/link/Link.cpp
+++ b/tools/aapt2/link/Link.cpp
@@ -14,6 +14,17 @@
* limitations under the License.
*/
+#include <sys/stat.h>
+
+#include <fstream>
+#include <queue>
+#include <unordered_map>
+#include <vector>
+
+#include "android-base/errors.h"
+#include "android-base/file.h"
+#include "google/protobuf/io/coded_stream.h"
+
#include "AppInfo.h"
#include "Debug.h"
#include "Flags.h"
@@ -32,7 +43,6 @@
#include "java/ProguardRules.h"
#include "link/Linkers.h"
#include "link/ManifestFixer.h"
-#include "link/ProductFilter.h"
#include "link/ReferenceLinker.h"
#include "link/TableMerger.h"
#include "process/IResourceTableConsumer.h"
@@ -44,179 +54,179 @@
#include "util/StringPiece.h"
#include "xml/XmlDom.h"
-#include <android-base/file.h>
-#include <google/protobuf/io/coded_stream.h>
-
-#include <sys/stat.h>
-#include <fstream>
-#include <queue>
-#include <unordered_map>
-#include <vector>
-
-using google::protobuf::io::CopyingOutputStreamAdaptor;
+using ::google::protobuf::io::CopyingOutputStreamAdaptor;
namespace aapt {
struct LinkOptions {
- std::string outputPath;
- std::string manifestPath;
- std::vector<std::string> includePaths;
- std::vector<std::string> overlayFiles;
+ std::string output_path;
+ std::string manifest_path;
+ std::vector<std::string> include_paths;
+ std::vector<std::string> overlay_files;
+ bool output_to_directory = false;
+ bool auto_add_overlay = false;
// Java/Proguard options.
- Maybe<std::string> generateJavaClassPath;
- Maybe<std::string> customJavaPackage;
- std::set<std::string> extraJavaPackages;
- Maybe<std::string> generateProguardRulesPath;
- Maybe<std::string> generateMainDexProguardRulesPath;
+ Maybe<std::string> generate_java_class_path;
+ Maybe<std::string> custom_java_package;
+ std::set<std::string> extra_java_packages;
+ Maybe<std::string> generate_proguard_rules_path;
+ Maybe<std::string> generate_main_dex_proguard_rules_path;
+ bool generate_non_final_ids = false;
+ std::vector<std::string> javadoc_annotations;
+ Maybe<std::string> private_symbols;
- bool noAutoVersion = false;
- bool noVersionVectors = false;
- bool noResourceDeduping = false;
- bool staticLib = false;
- bool noStaticLibPackages = false;
- bool generateNonFinalIds = false;
- std::vector<std::string> javadocAnnotations;
- bool outputToDirectory = false;
- bool noXmlNamespaces = false;
- bool autoAddOverlay = false;
- bool doNotCompressAnything = false;
- std::unordered_set<std::string> extensionsToNotCompress;
- Maybe<std::string> privateSymbols;
- ManifestFixerOptions manifestFixerOptions;
+ // Optimizations/features.
+ bool no_auto_version = false;
+ bool no_version_vectors = false;
+ bool no_resource_deduping = false;
+ bool no_xml_namespaces = false;
+ bool do_not_compress_anything = false;
+ std::unordered_set<std::string> extensions_to_not_compress;
+
+ // Static lib options.
+ bool static_lib = false;
+ bool no_static_lib_packages = false;
+
+ // AndroidManifest.xml massaging options.
+ ManifestFixerOptions manifest_fixer_options;
+
+ // Products to use/filter on.
std::unordered_set<std::string> products;
// Split APK options.
- TableSplitterOptions tableSplitterOptions;
- std::vector<SplitConstraints> splitConstraints;
- std::vector<std::string> splitPaths;
+ TableSplitterOptions table_splitter_options;
+ std::vector<SplitConstraints> split_constraints;
+ std::vector<std::string> split_paths;
// Stable ID options.
- std::unordered_map<ResourceName, ResourceId> stableIdMap;
- Maybe<std::string> resourceIdMapPath;
+ std::unordered_map<ResourceName, ResourceId> stable_id_map;
+ Maybe<std::string> resource_id_map_path;
};
class LinkContext : public IAaptContext {
public:
- LinkContext() : mNameMangler({}) {}
+ LinkContext() : name_mangler_({}) {}
- IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+ IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
- NameMangler* getNameMangler() override { return &mNameMangler; }
+ NameMangler* GetNameMangler() override { return &name_mangler_; }
- void setNameManglerPolicy(const NameManglerPolicy& policy) {
- mNameMangler = NameMangler(policy);
+ void SetNameManglerPolicy(const NameManglerPolicy& policy) {
+ name_mangler_ = NameMangler(policy);
}
- const std::string& getCompilationPackage() override {
- return mCompilationPackage;
+ const std::string& GetCompilationPackage() override {
+ return compilation_package_;
}
- void setCompilationPackage(const StringPiece& packageName) {
- mCompilationPackage = packageName.toString();
+ void SetCompilationPackage(const StringPiece& package_name) {
+ compilation_package_ = package_name.ToString();
}
- uint8_t getPackageId() override { return mPackageId; }
+ uint8_t GetPackageId() override { return package_id_; }
- void setPackageId(uint8_t id) { mPackageId = id; }
+ void SetPackageId(uint8_t id) { package_id_ = id; }
- SymbolTable* getExternalSymbols() override { return &mSymbols; }
+ SymbolTable* GetExternalSymbols() override { return &symbols_; }
- bool verbose() override { return mVerbose; }
+ bool IsVerbose() override { return verbose_; }
- void setVerbose(bool val) { mVerbose = val; }
+ void SetVerbose(bool val) { verbose_ = val; }
- int getMinSdkVersion() override { return mMinSdkVersion; }
+ int GetMinSdkVersion() override { return min_sdk_version_; }
- void setMinSdkVersion(int minSdk) { mMinSdkVersion = minSdk; }
+ void SetMinSdkVersion(int minSdk) { min_sdk_version_ = minSdk; }
private:
- StdErrDiagnostics mDiagnostics;
- NameMangler mNameMangler;
- std::string mCompilationPackage;
- uint8_t mPackageId = 0x0;
- SymbolTable mSymbols;
- bool mVerbose = false;
- int mMinSdkVersion = 0;
+ DISALLOW_COPY_AND_ASSIGN(LinkContext);
+
+ StdErrDiagnostics diagnostics_;
+ NameMangler name_mangler_;
+ std::string compilation_package_;
+ uint8_t package_id_ = 0x0;
+ SymbolTable symbols_;
+ bool verbose_ = false;
+ int min_sdk_version_ = 0;
};
-static bool copyFileToArchive(io::IFile* file, const std::string& outPath,
- uint32_t compressionFlags, IArchiveWriter* writer,
- IAaptContext* context) {
- std::unique_ptr<io::IData> data = file->openAsData();
+static bool CopyFileToArchive(io::IFile* file, const std::string& out_path,
+ uint32_t compression_flags,
+ IArchiveWriter* writer, IAaptContext* context) {
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- context->getDiagnostics()->error(DiagMessage(file->getSource())
+ context->GetDiagnostics()->Error(DiagMessage(file->GetSource())
<< "failed to open file");
return false;
}
const uint8_t* buffer = reinterpret_cast<const uint8_t*>(data->data());
- const size_t bufferSize = data->size();
+ const size_t buffer_size = data->size();
- if (context->verbose()) {
- context->getDiagnostics()->note(DiagMessage() << "writing " << outPath
+ if (context->IsVerbose()) {
+ context->GetDiagnostics()->Note(DiagMessage() << "writing " << out_path
<< " to archive");
}
- if (writer->startEntry(outPath, compressionFlags)) {
- if (writer->writeEntry(buffer, bufferSize)) {
- if (writer->finishEntry()) {
+ if (writer->StartEntry(out_path, compression_flags)) {
+ if (writer->WriteEntry(buffer, buffer_size)) {
+ if (writer->FinishEntry()) {
return true;
}
}
}
- context->getDiagnostics()->error(DiagMessage() << "failed to write file "
- << outPath);
+ context->GetDiagnostics()->Error(DiagMessage() << "failed to write file "
+ << out_path);
return false;
}
-static bool flattenXml(xml::XmlResource* xmlRes, const StringPiece& path,
- Maybe<size_t> maxSdkLevel, bool keepRawValues,
+static bool FlattenXml(xml::XmlResource* xml_res, const StringPiece& path,
+ Maybe<size_t> max_sdk_level, bool keep_raw_values,
IArchiveWriter* writer, IAaptContext* context) {
BigBuffer buffer(1024);
XmlFlattenerOptions options = {};
- options.keepRawValues = keepRawValues;
- options.maxSdkLevel = maxSdkLevel;
+ options.keep_raw_values = keep_raw_values;
+ options.max_sdk_level = max_sdk_level;
XmlFlattener flattener(&buffer, options);
- if (!flattener.consume(context, xmlRes)) {
+ if (!flattener.Consume(context, xml_res)) {
return false;
}
- if (context->verbose()) {
+ if (context->IsVerbose()) {
DiagMessage msg;
msg << "writing " << path << " to archive";
- if (maxSdkLevel) {
- msg << " maxSdkLevel=" << maxSdkLevel.value()
- << " keepRawValues=" << keepRawValues;
+ if (max_sdk_level) {
+ msg << " maxSdkLevel=" << max_sdk_level.value()
+ << " keepRawValues=" << keep_raw_values;
}
- context->getDiagnostics()->note(msg);
+ context->GetDiagnostics()->Note(msg);
}
- if (writer->startEntry(path, ArchiveEntry::kCompress)) {
- if (writer->writeEntry(buffer)) {
- if (writer->finishEntry()) {
+ if (writer->StartEntry(path, ArchiveEntry::kCompress)) {
+ if (writer->WriteEntry(buffer)) {
+ if (writer->FinishEntry()) {
return true;
}
}
}
- context->getDiagnostics()->error(DiagMessage() << "failed to write " << path
+ context->GetDiagnostics()->Error(DiagMessage() << "failed to write " << path
<< " to archive");
return false;
}
-static std::unique_ptr<ResourceTable> loadTableFromPb(const Source& source,
+static std::unique_ptr<ResourceTable> LoadTableFromPb(const Source& source,
const void* data,
size_t len,
IDiagnostics* diag) {
- pb::ResourceTable pbTable;
- if (!pbTable.ParseFromArray(data, len)) {
- diag->error(DiagMessage(source) << "invalid compiled table");
+ pb::ResourceTable pb_table;
+ if (!pb_table.ParseFromArray(data, len)) {
+ diag->Error(DiagMessage(source) << "invalid compiled table");
return {};
}
std::unique_ptr<ResourceTable> table =
- deserializeTableFromPb(pbTable, source, diag);
+ DeserializeTableFromPb(pb_table, source, diag);
if (!table) {
return {};
}
@@ -226,33 +236,33 @@
/**
* Inflates an XML file from the source path.
*/
-static std::unique_ptr<xml::XmlResource> loadXml(const std::string& path,
+static std::unique_ptr<xml::XmlResource> LoadXml(const std::string& path,
IDiagnostics* diag) {
std::ifstream fin(path, std::ifstream::binary);
if (!fin) {
- diag->error(DiagMessage(path) << strerror(errno));
+ diag->Error(DiagMessage(path) << strerror(errno));
return {};
}
- return xml::inflate(&fin, diag, Source(path));
+ return xml::Inflate(&fin, diag, Source(path));
}
struct ResourceFileFlattenerOptions {
- bool noAutoVersion = false;
- bool noVersionVectors = false;
- bool noXmlNamespaces = false;
- bool keepRawValues = false;
- bool doNotCompressAnything = false;
- bool updateProguardSpec = false;
- std::unordered_set<std::string> extensionsToNotCompress;
+ bool no_auto_version = false;
+ bool no_version_vectors = false;
+ bool no_xml_namespaces = false;
+ bool keep_raw_values = false;
+ bool do_not_compress_anything = false;
+ bool update_proguard_spec = false;
+ std::unordered_set<std::string> extensions_to_not_compress;
};
class ResourceFileFlattener {
public:
ResourceFileFlattener(const ResourceFileFlattenerOptions& options,
- IAaptContext* context, proguard::KeepSet* keepSet)
- : mOptions(options), mContext(context), mKeepSet(keepSet) {}
+ IAaptContext* context, proguard::KeepSet* keep_set)
+ : options_(options), context_(context), keep_set_(keep_set) {}
- bool flatten(ResourceTable* table, IArchiveWriter* archiveWriter);
+ bool Flatten(ResourceTable* table, IArchiveWriter* archive_writer);
private:
struct FileOperation {
@@ -262,118 +272,119 @@
const ResourceEntry* entry;
// The file to copy as-is.
- io::IFile* fileToCopy;
+ io::IFile* file_to_copy;
// The XML to process and flatten.
- std::unique_ptr<xml::XmlResource> xmlToFlatten;
+ std::unique_ptr<xml::XmlResource> xml_to_flatten;
// The destination to write this file to.
- std::string dstPath;
- bool skipVersion = false;
+ std::string dst_path;
+ bool skip_version = false;
};
- uint32_t getCompressionFlags(const StringPiece& str);
+ uint32_t GetCompressionFlags(const StringPiece& str);
- bool linkAndVersionXmlFile(ResourceTable* table, FileOperation* fileOp,
- std::queue<FileOperation>* outFileOpQueue);
+ bool LinkAndVersionXmlFile(ResourceTable* table, FileOperation* file_op,
+ std::queue<FileOperation>* out_file_op_queue);
- ResourceFileFlattenerOptions mOptions;
- IAaptContext* mContext;
- proguard::KeepSet* mKeepSet;
+ ResourceFileFlattenerOptions options_;
+ IAaptContext* context_;
+ proguard::KeepSet* keep_set_;
};
-uint32_t ResourceFileFlattener::getCompressionFlags(const StringPiece& str) {
- if (mOptions.doNotCompressAnything) {
+uint32_t ResourceFileFlattener::GetCompressionFlags(const StringPiece& str) {
+ if (options_.do_not_compress_anything) {
return 0;
}
- for (const std::string& extension : mOptions.extensionsToNotCompress) {
- if (util::stringEndsWith(str, extension)) {
+ for (const std::string& extension : options_.extensions_to_not_compress) {
+ if (util::EndsWith(str, extension)) {
return 0;
}
}
return ArchiveEntry::kCompress;
}
-bool ResourceFileFlattener::linkAndVersionXmlFile(
- ResourceTable* table, FileOperation* fileOp,
- std::queue<FileOperation>* outFileOpQueue) {
- xml::XmlResource* doc = fileOp->xmlToFlatten.get();
+bool ResourceFileFlattener::LinkAndVersionXmlFile(
+ ResourceTable* table, FileOperation* file_op,
+ std::queue<FileOperation>* out_file_op_queue) {
+ xml::XmlResource* doc = file_op->xml_to_flatten.get();
const Source& src = doc->file.source;
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(DiagMessage() << "linking " << src.path);
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(DiagMessage() << "linking " << src.path);
}
- XmlReferenceLinker xmlLinker;
- if (!xmlLinker.consume(mContext, doc)) {
+ XmlReferenceLinker xml_linker;
+ if (!xml_linker.Consume(context_, doc)) {
return false;
}
- if (mOptions.updateProguardSpec &&
- !proguard::collectProguardRules(src, doc, mKeepSet)) {
+ if (options_.update_proguard_spec &&
+ !proguard::CollectProguardRules(src, doc, keep_set_)) {
return false;
}
- if (mOptions.noXmlNamespaces) {
- XmlNamespaceRemover namespaceRemover;
- if (!namespaceRemover.consume(mContext, doc)) {
+ if (options_.no_xml_namespaces) {
+ XmlNamespaceRemover namespace_remover;
+ if (!namespace_remover.Consume(context_, doc)) {
return false;
}
}
- if (!mOptions.noAutoVersion) {
- if (mOptions.noVersionVectors) {
+ if (!options_.no_auto_version) {
+ if (options_.no_version_vectors) {
// Skip this if it is a vector or animated-vector.
- xml::Element* el = xml::findRootElement(doc);
- if (el && el->namespaceUri.empty()) {
+ xml::Element* el = xml::FindRootElement(doc);
+ if (el && el->namespace_uri.empty()) {
if (el->name == "vector" || el->name == "animated-vector") {
// We are NOT going to version this file.
- fileOp->skipVersion = true;
+ file_op->skip_version = true;
return true;
}
}
}
- const ConfigDescription& config = fileOp->config;
+ const ConfigDescription& config = file_op->config;
// Find the first SDK level used that is higher than this defined config and
// not superseded by a lower or equal SDK level resource.
- const int minSdkVersion = mContext->getMinSdkVersion();
- for (int sdkLevel : xmlLinker.getSdkLevels()) {
- if (sdkLevel > minSdkVersion && sdkLevel > config.sdkVersion) {
- if (!shouldGenerateVersionedResource(fileOp->entry, config, sdkLevel)) {
+ const int min_sdk_version = context_->GetMinSdkVersion();
+ for (int sdk_level : xml_linker.sdk_levels()) {
+ if (sdk_level > min_sdk_version && sdk_level > config.sdkVersion) {
+ if (!ShouldGenerateVersionedResource(file_op->entry, config,
+ sdk_level)) {
// If we shouldn't generate a versioned resource, stop checking.
break;
}
- ResourceFile versionedFileDesc = doc->file;
- versionedFileDesc.config.sdkVersion = (uint16_t)sdkLevel;
+ ResourceFile versioned_file_desc = doc->file;
+ versioned_file_desc.config.sdkVersion = (uint16_t)sdk_level;
- FileOperation newFileOp;
- newFileOp.xmlToFlatten = util::make_unique<xml::XmlResource>(
- versionedFileDesc, doc->root->clone());
- newFileOp.config = versionedFileDesc.config;
- newFileOp.entry = fileOp->entry;
- newFileOp.dstPath = ResourceUtils::buildResourceFileName(
- versionedFileDesc, mContext->getNameMangler());
+ FileOperation new_file_op;
+ new_file_op.xml_to_flatten = util::make_unique<xml::XmlResource>(
+ versioned_file_desc, doc->root->Clone());
+ new_file_op.config = versioned_file_desc.config;
+ new_file_op.entry = file_op->entry;
+ new_file_op.dst_path = ResourceUtils::BuildResourceFileName(
+ versioned_file_desc, context_->GetNameMangler());
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(
- DiagMessage(versionedFileDesc.source)
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(
+ DiagMessage(versioned_file_desc.source)
<< "auto-versioning resource from config '" << config << "' -> '"
- << versionedFileDesc.config << "'");
+ << versioned_file_desc.config << "'");
}
- bool added = table->addFileReferenceAllowMangled(
- versionedFileDesc.name, versionedFileDesc.config,
- versionedFileDesc.source, newFileOp.dstPath, nullptr,
- mContext->getDiagnostics());
+ bool added = table->AddFileReferenceAllowMangled(
+ versioned_file_desc.name, versioned_file_desc.config,
+ versioned_file_desc.source, new_file_op.dst_path, nullptr,
+ context_->GetDiagnostics());
if (!added) {
return false;
}
- outFileOpQueue->push(std::move(newFileOp));
+ out_file_op_queue->push(std::move(new_file_op));
break;
}
}
@@ -386,100 +397,96 @@
* will
* corrupt the iteration order.
*/
-bool ResourceFileFlattener::flatten(ResourceTable* table,
- IArchiveWriter* archiveWriter) {
+bool ResourceFileFlattener::Flatten(ResourceTable* table,
+ IArchiveWriter* archive_writer) {
bool error = false;
std::map<std::pair<ConfigDescription, StringPiece>, FileOperation>
- configSortedFiles;
+ config_sorted_files;
for (auto& pkg : table->packages) {
for (auto& type : pkg->types) {
// Sort by config and name, so that we get better locality in the zip
// file.
- configSortedFiles.clear();
- std::queue<FileOperation> fileOperations;
+ config_sorted_files.clear();
+ std::queue<FileOperation> file_operations;
// Populate the queue with all files in the ResourceTable.
for (auto& entry : type->entries) {
- for (auto& configValue : entry->values) {
- FileReference* fileRef =
- valueCast<FileReference>(configValue->value.get());
- if (!fileRef) {
+ for (auto& config_value : entry->values) {
+ FileReference* file_ref =
+ ValueCast<FileReference>(config_value->value.get());
+ if (!file_ref) {
continue;
}
- io::IFile* file = fileRef->file;
+ io::IFile* file = file_ref->file;
if (!file) {
- mContext->getDiagnostics()->error(DiagMessage(fileRef->getSource())
+ context_->GetDiagnostics()->Error(DiagMessage(file_ref->GetSource())
<< "file not found");
return false;
}
- FileOperation fileOp;
- fileOp.entry = entry.get();
- fileOp.dstPath = *fileRef->path;
- fileOp.config = configValue->config;
+ FileOperation file_op;
+ file_op.entry = entry.get();
+ file_op.dst_path = *file_ref->path;
+ file_op.config = config_value->config;
- const StringPiece srcPath = file->getSource().path;
+ const StringPiece src_path = file->GetSource().path;
if (type->type != ResourceType::kRaw &&
- (util::stringEndsWith(srcPath, ".xml.flat") ||
- util::stringEndsWith(srcPath, ".xml"))) {
- std::unique_ptr<io::IData> data = file->openAsData();
+ (util::EndsWith(src_path, ".xml.flat") ||
+ util::EndsWith(src_path, ".xml"))) {
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- mContext->getDiagnostics()->error(DiagMessage(file->getSource())
+ context_->GetDiagnostics()->Error(DiagMessage(file->GetSource())
<< "failed to open file");
return false;
}
- fileOp.xmlToFlatten =
- xml::inflate(data->data(), data->size(),
- mContext->getDiagnostics(), file->getSource());
+ file_op.xml_to_flatten =
+ xml::Inflate(data->data(), data->size(),
+ context_->GetDiagnostics(), file->GetSource());
- if (!fileOp.xmlToFlatten) {
+ if (!file_op.xml_to_flatten) {
return false;
}
- fileOp.xmlToFlatten->file.config = configValue->config;
- fileOp.xmlToFlatten->file.source = fileRef->getSource();
- fileOp.xmlToFlatten->file.name =
+ file_op.xml_to_flatten->file.config = config_value->config;
+ file_op.xml_to_flatten->file.source = file_ref->GetSource();
+ file_op.xml_to_flatten->file.name =
ResourceName(pkg->name, type->type, entry->name);
// Enqueue the XML files to be processed.
- fileOperations.push(std::move(fileOp));
+ file_operations.push(std::move(file_op));
} else {
- fileOp.fileToCopy = file;
+ file_op.file_to_copy = file;
// NOTE(adamlesinski): Explicitly construct a StringPiece here, or
- // else
- // we end up copying the string in the std::make_pair() method, then
- // creating a StringPiece from the copy, which would cause us to end
- // up
- // referencing garbage in the map.
- const StringPiece entryName(entry->name);
- configSortedFiles[std::make_pair(configValue->config, entryName)] =
- std::move(fileOp);
+ // else we end up copying the string in the std::make_pair() method,
+ // then creating a StringPiece from the copy, which would cause us
+ // to end up referencing garbage in the map.
+ const StringPiece entry_name(entry->name);
+ config_sorted_files[std::make_pair(
+ config_value->config, entry_name)] = std::move(file_op);
}
}
}
// Now process the XML queue
- for (; !fileOperations.empty(); fileOperations.pop()) {
- FileOperation& fileOp = fileOperations.front();
+ for (; !file_operations.empty(); file_operations.pop()) {
+ FileOperation& file_op = file_operations.front();
- if (!linkAndVersionXmlFile(table, &fileOp, &fileOperations)) {
+ if (!LinkAndVersionXmlFile(table, &file_op, &file_operations)) {
error = true;
continue;
}
// NOTE(adamlesinski): Explicitly construct a StringPiece here, or else
// we end up copying the string in the std::make_pair() method, then
- // creating
- // a StringPiece from the copy, which would cause us to end up
- // referencing
- // garbage in the map.
- const StringPiece entryName(fileOp.entry->name);
- configSortedFiles[std::make_pair(fileOp.config, entryName)] =
- std::move(fileOp);
+ // creating a StringPiece from the copy, which would cause us to end up
+ // referencing garbage in the map.
+ const StringPiece entry_name(file_op.entry->name);
+ config_sorted_files[std::make_pair(file_op.config, entry_name)] =
+ std::move(file_op);
}
if (error) {
@@ -487,28 +494,28 @@
}
// Now flatten the sorted values.
- for (auto& mapEntry : configSortedFiles) {
- const ConfigDescription& config = mapEntry.first.first;
- const FileOperation& fileOp = mapEntry.second;
+ for (auto& map_entry : config_sorted_files) {
+ const ConfigDescription& config = map_entry.first.first;
+ const FileOperation& file_op = map_entry.second;
- if (fileOp.xmlToFlatten) {
- Maybe<size_t> maxSdkLevel;
- if (!mOptions.noAutoVersion && !fileOp.skipVersion) {
- maxSdkLevel =
+ if (file_op.xml_to_flatten) {
+ Maybe<size_t> max_sdk_level;
+ if (!options_.no_auto_version && !file_op.skip_version) {
+ max_sdk_level =
std::max<size_t>(std::max<size_t>(config.sdkVersion, 1u),
- mContext->getMinSdkVersion());
+ context_->GetMinSdkVersion());
}
- bool result =
- flattenXml(fileOp.xmlToFlatten.get(), fileOp.dstPath, maxSdkLevel,
- mOptions.keepRawValues, archiveWriter, mContext);
+ bool result = FlattenXml(
+ file_op.xml_to_flatten.get(), file_op.dst_path, max_sdk_level,
+ options_.keep_raw_values, archive_writer, context_);
if (!result) {
error = true;
}
} else {
- bool result = copyFileToArchive(fileOp.fileToCopy, fileOp.dstPath,
- getCompressionFlags(fileOp.dstPath),
- archiveWriter, mContext);
+ bool result = CopyFileToArchive(
+ file_op.file_to_copy, file_op.dst_path,
+ GetCompressionFlags(file_op.dst_path), archive_writer, context_);
if (!result) {
error = true;
}
@@ -519,136 +526,136 @@
return !error;
}
-static bool writeStableIdMapToPath(
+static bool WriteStableIdMapToPath(
IDiagnostics* diag,
- const std::unordered_map<ResourceName, ResourceId>& idMap,
- const std::string& idMapPath) {
- std::ofstream fout(idMapPath, std::ofstream::binary);
+ const std::unordered_map<ResourceName, ResourceId>& id_map,
+ const std::string& id_map_path) {
+ std::ofstream fout(id_map_path, std::ofstream::binary);
if (!fout) {
- diag->error(DiagMessage(idMapPath) << strerror(errno));
+ diag->Error(DiagMessage(id_map_path) << strerror(errno));
return false;
}
- for (const auto& entry : idMap) {
+ for (const auto& entry : id_map) {
const ResourceName& name = entry.first;
const ResourceId& id = entry.second;
fout << name << " = " << id << "\n";
}
if (!fout) {
- diag->error(DiagMessage(idMapPath) << "failed writing to file: "
- << strerror(errno));
+ diag->Error(DiagMessage(id_map_path)
+ << "failed writing to file: "
+ << android::base::SystemErrorCodeToString(errno));
return false;
}
return true;
}
-static bool loadStableIdMap(
+static bool LoadStableIdMap(
IDiagnostics* diag, const std::string& path,
- std::unordered_map<ResourceName, ResourceId>* outIdMap) {
+ std::unordered_map<ResourceName, ResourceId>* out_id_map) {
std::string content;
if (!android::base::ReadFileToString(path, &content)) {
- diag->error(DiagMessage(path) << "failed reading stable ID file");
+ diag->Error(DiagMessage(path) << "failed reading stable ID file");
return false;
}
- outIdMap->clear();
- size_t lineNo = 0;
- for (StringPiece line : util::tokenize(content, '\n')) {
- lineNo++;
- line = util::trimWhitespace(line);
+ out_id_map->clear();
+ size_t line_no = 0;
+ for (StringPiece line : util::Tokenize(content, '\n')) {
+ line_no++;
+ line = util::TrimWhitespace(line);
if (line.empty()) {
continue;
}
auto iter = std::find(line.begin(), line.end(), '=');
if (iter == line.end()) {
- diag->error(DiagMessage(Source(path, lineNo)) << "missing '='");
+ diag->Error(DiagMessage(Source(path, line_no)) << "missing '='");
return false;
}
ResourceNameRef name;
- StringPiece resNameStr =
- util::trimWhitespace(line.substr(0, std::distance(line.begin(), iter)));
- if (!ResourceUtils::parseResourceName(resNameStr, &name)) {
- diag->error(DiagMessage(Source(path, lineNo)) << "invalid resource name '"
- << resNameStr << "'");
+ StringPiece res_name_str =
+ util::TrimWhitespace(line.substr(0, std::distance(line.begin(), iter)));
+ if (!ResourceUtils::ParseResourceName(res_name_str, &name)) {
+ diag->Error(DiagMessage(Source(path, line_no))
+ << "invalid resource name '" << res_name_str << "'");
return false;
}
- const size_t resIdStartIdx = std::distance(line.begin(), iter) + 1;
- const size_t resIdStrLen = line.size() - resIdStartIdx;
- StringPiece resIdStr =
- util::trimWhitespace(line.substr(resIdStartIdx, resIdStrLen));
+ const size_t res_id_start_idx = std::distance(line.begin(), iter) + 1;
+ const size_t res_id_str_len = line.size() - res_id_start_idx;
+ StringPiece res_id_str =
+ util::TrimWhitespace(line.substr(res_id_start_idx, res_id_str_len));
- Maybe<ResourceId> maybeId = ResourceUtils::parseResourceId(resIdStr);
- if (!maybeId) {
- diag->error(DiagMessage(Source(path, lineNo)) << "invalid resource ID '"
- << resIdStr << "'");
+ Maybe<ResourceId> maybe_id = ResourceUtils::ParseResourceId(res_id_str);
+ if (!maybe_id) {
+ diag->Error(DiagMessage(Source(path, line_no)) << "invalid resource ID '"
+ << res_id_str << "'");
return false;
}
- (*outIdMap)[name.toResourceName()] = maybeId.value();
+ (*out_id_map)[name.ToResourceName()] = maybe_id.value();
}
return true;
}
-static bool parseSplitParameter(const StringPiece& arg, IDiagnostics* diag,
- std::string* outPath,
- SplitConstraints* outSplit) {
- std::vector<std::string> parts = util::split(arg, ':');
+static bool ParseSplitParameter(const StringPiece& arg, IDiagnostics* diag,
+ std::string* out_path,
+ SplitConstraints* out_split) {
+ std::vector<std::string> parts = util::Split(arg, ':');
if (parts.size() != 2) {
- diag->error(DiagMessage() << "invalid split parameter '" << arg << "'");
- diag->note(
+ diag->Error(DiagMessage() << "invalid split parameter '" << arg << "'");
+ diag->Note(
DiagMessage()
<< "should be --split path/to/output.apk:<config>[,<config>...]");
return false;
}
- *outPath = parts[0];
+ *out_path = parts[0];
std::vector<ConfigDescription> configs;
- for (const StringPiece& configStr : util::tokenize(parts[1], ',')) {
+ for (const StringPiece& config_str : util::Tokenize(parts[1], ',')) {
configs.push_back({});
- if (!ConfigDescription::parse(configStr, &configs.back())) {
- diag->error(DiagMessage() << "invalid config '" << configStr
+ if (!ConfigDescription::Parse(config_str, &configs.back())) {
+ diag->Error(DiagMessage() << "invalid config '" << config_str
<< "' in split parameter '" << arg << "'");
return false;
}
}
- outSplit->configs.insert(configs.begin(), configs.end());
+ out_split->configs.insert(configs.begin(), configs.end());
return true;
}
class LinkCommand {
public:
LinkCommand(LinkContext* context, const LinkOptions& options)
- : mOptions(options),
- mContext(context),
- mFinalTable(),
- mFileCollection(util::make_unique<io::FileCollection>()) {}
+ : options_(options),
+ context_(context),
+ final_table_(),
+ file_collection_(util::make_unique<io::FileCollection>()) {}
/**
* Creates a SymbolTable that loads symbols from the various APKs and caches
- * the
- * results for faster lookup.
+ * the results for faster lookup.
*/
- bool loadSymbolsFromIncludePaths() {
- std::unique_ptr<AssetManagerSymbolSource> assetSource =
+ bool LoadSymbolsFromIncludePaths() {
+ std::unique_ptr<AssetManagerSymbolSource> asset_source =
util::make_unique<AssetManagerSymbolSource>();
- for (const std::string& path : mOptions.includePaths) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(DiagMessage(path)
+ for (const std::string& path : options_.include_paths) {
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(DiagMessage(path)
<< "loading include path");
}
// First try to load the file as a static lib.
- std::string errorStr;
- std::unique_ptr<ResourceTable> staticInclude =
- loadStaticLibrary(path, &errorStr);
- if (staticInclude) {
- if (!mOptions.staticLib) {
+ std::string error_str;
+ std::unique_ptr<ResourceTable> static_include =
+ LoadStaticLibrary(path, &error_str);
+ if (static_include) {
+ if (!options_.static_lib) {
// Can't include static libraries when not building a static library.
- mContext->getDiagnostics()->error(
+ context_->GetDiagnostics()->Error(
DiagMessage(path)
<< "can't include static library when building app");
return false;
@@ -657,92 +664,92 @@
// If we are using --no-static-lib-packages, we need to rename the
// package of this
// table to our compilation package.
- if (mOptions.noStaticLibPackages) {
+ if (options_.no_static_lib_packages) {
if (ResourceTablePackage* pkg =
- staticInclude->findPackageById(0x7f)) {
- pkg->name = mContext->getCompilationPackage();
+ static_include->FindPackageById(0x7f)) {
+ pkg->name = context_->GetCompilationPackage();
}
}
- mContext->getExternalSymbols()->appendSource(
- util::make_unique<ResourceTableSymbolSource>(staticInclude.get()));
+ context_->GetExternalSymbols()->AppendSource(
+ util::make_unique<ResourceTableSymbolSource>(static_include.get()));
- mStaticTableIncludes.push_back(std::move(staticInclude));
+ static_table_includes_.push_back(std::move(static_include));
- } else if (!errorStr.empty()) {
+ } else if (!error_str.empty()) {
// We had an error with reading, so fail.
- mContext->getDiagnostics()->error(DiagMessage(path) << errorStr);
+ context_->GetDiagnostics()->Error(DiagMessage(path) << error_str);
return false;
}
- if (!assetSource->addAssetPath(path)) {
- mContext->getDiagnostics()->error(DiagMessage(path)
+ if (!asset_source->AddAssetPath(path)) {
+ context_->GetDiagnostics()->Error(DiagMessage(path)
<< "failed to load include path");
return false;
}
}
- mContext->getExternalSymbols()->appendSource(std::move(assetSource));
+ context_->GetExternalSymbols()->AppendSource(std::move(asset_source));
return true;
}
- Maybe<AppInfo> extractAppInfoFromManifest(xml::XmlResource* xmlRes,
+ Maybe<AppInfo> ExtractAppInfoFromManifest(xml::XmlResource* xml_res,
IDiagnostics* diag) {
// Make sure the first element is <manifest> with package attribute.
- if (xml::Element* manifestEl = xml::findRootElement(xmlRes->root.get())) {
- AppInfo appInfo;
+ if (xml::Element* manifest_el = xml::FindRootElement(xml_res->root.get())) {
+ AppInfo app_info;
- if (!manifestEl->namespaceUri.empty() || manifestEl->name != "manifest") {
- diag->error(DiagMessage(xmlRes->file.source)
+ if (!manifest_el->namespace_uri.empty() ||
+ manifest_el->name != "manifest") {
+ diag->Error(DiagMessage(xml_res->file.source)
<< "root tag must be <manifest>");
return {};
}
- xml::Attribute* packageAttr = manifestEl->findAttribute({}, "package");
- if (!packageAttr) {
- diag->error(DiagMessage(xmlRes->file.source)
+ xml::Attribute* package_attr = manifest_el->FindAttribute({}, "package");
+ if (!package_attr) {
+ diag->Error(DiagMessage(xml_res->file.source)
<< "<manifest> must have a 'package' attribute");
return {};
}
- appInfo.package = packageAttr->value;
+ app_info.package = package_attr->value;
- if (xml::Attribute* versionCodeAttr =
- manifestEl->findAttribute(xml::kSchemaAndroid, "versionCode")) {
- Maybe<uint32_t> maybeCode =
- ResourceUtils::parseInt(versionCodeAttr->value);
- if (!maybeCode) {
- diag->error(
- DiagMessage(xmlRes->file.source.withLine(manifestEl->lineNumber))
- << "invalid android:versionCode '" << versionCodeAttr->value
- << "'");
+ if (xml::Attribute* version_code_attr =
+ manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode")) {
+ Maybe<uint32_t> maybe_code =
+ ResourceUtils::ParseInt(version_code_attr->value);
+ if (!maybe_code) {
+ diag->Error(DiagMessage(xml_res->file.source.WithLine(
+ manifest_el->line_number))
+ << "invalid android:versionCode '"
+ << version_code_attr->value << "'");
return {};
}
- appInfo.versionCode = maybeCode.value();
+ app_info.version_code = maybe_code.value();
}
- if (xml::Attribute* revisionCodeAttr =
- manifestEl->findAttribute(xml::kSchemaAndroid, "revisionCode")) {
- Maybe<uint32_t> maybeCode =
- ResourceUtils::parseInt(revisionCodeAttr->value);
- if (!maybeCode) {
- diag->error(
- DiagMessage(xmlRes->file.source.withLine(manifestEl->lineNumber))
- << "invalid android:revisionCode '" << revisionCodeAttr->value
- << "'");
+ if (xml::Attribute* revision_code_attr =
+ manifest_el->FindAttribute(xml::kSchemaAndroid, "revisionCode")) {
+ Maybe<uint32_t> maybe_code =
+ ResourceUtils::ParseInt(revision_code_attr->value);
+ if (!maybe_code) {
+ diag->Error(DiagMessage(xml_res->file.source.WithLine(
+ manifest_el->line_number))
+ << "invalid android:revisionCode '"
+ << revision_code_attr->value << "'");
return {};
}
- appInfo.revisionCode = maybeCode.value();
+ app_info.revision_code = maybe_code.value();
}
- if (xml::Element* usesSdkEl = manifestEl->findChild({}, "uses-sdk")) {
- if (xml::Attribute* minSdk = usesSdkEl->findAttribute(
+ if (xml::Element* uses_sdk_el = manifest_el->FindChild({}, "uses-sdk")) {
+ if (xml::Attribute* min_sdk = uses_sdk_el->FindAttribute(
xml::kSchemaAndroid, "minSdkVersion")) {
- appInfo.minSdkVersion = minSdk->value;
+ app_info.min_sdk_version = min_sdk->value;
}
}
-
- return appInfo;
+ return app_info;
}
return {};
}
@@ -751,38 +758,36 @@
* Precondition: ResourceTable doesn't have any IDs assigned yet, nor is it
* linked.
* Postcondition: ResourceTable has only one package left. All others are
- * stripped, or there
- * is an error and false is returned.
+ * stripped, or there is an error and false is returned.
*/
- bool verifyNoExternalPackages() {
- auto isExtPackageFunc =
+ bool VerifyNoExternalPackages() {
+ auto is_ext_package_func =
[&](const std::unique_ptr<ResourceTablePackage>& pkg) -> bool {
- return mContext->getCompilationPackage() != pkg->name || !pkg->id ||
- pkg->id.value() != mContext->getPackageId();
+ return context_->GetCompilationPackage() != pkg->name || !pkg->id ||
+ pkg->id.value() != context_->GetPackageId();
};
bool error = false;
- for (const auto& package : mFinalTable.packages) {
- if (isExtPackageFunc(package)) {
+ for (const auto& package : final_table_.packages) {
+ if (is_ext_package_func(package)) {
// We have a package that is not related to the one we're building!
for (const auto& type : package->types) {
for (const auto& entry : type->entries) {
- ResourceNameRef resName(package->name, type->type, entry->name);
+ ResourceNameRef res_name(package->name, type->type, entry->name);
- for (const auto& configValue : entry->values) {
+ for (const auto& config_value : entry->values) {
// Special case the occurrence of an ID that is being generated
- // for the
- // 'android' package. This is due to legacy reasons.
- if (valueCast<Id>(configValue->value.get()) &&
+ // for the 'android' package. This is due to legacy reasons.
+ if (ValueCast<Id>(config_value->value.get()) &&
package->name == "android") {
- mContext->getDiagnostics()->warn(
- DiagMessage(configValue->value->getSource())
- << "generated id '" << resName << "' for external package '"
- << package->name << "'");
+ context_->GetDiagnostics()->Warn(
+ DiagMessage(config_value->value->GetSource())
+ << "generated id '" << res_name
+ << "' for external package '" << package->name << "'");
} else {
- mContext->getDiagnostics()->error(
- DiagMessage(configValue->value->getSource())
- << "defined resource '" << resName
+ context_->GetDiagnostics()->Error(
+ DiagMessage(config_value->value->GetSource())
+ << "defined resource '" << res_name
<< "' for external package '" << package->name << "'");
error = true;
}
@@ -792,21 +797,21 @@
}
}
- auto newEndIter =
- std::remove_if(mFinalTable.packages.begin(), mFinalTable.packages.end(),
- isExtPackageFunc);
- mFinalTable.packages.erase(newEndIter, mFinalTable.packages.end());
+ auto new_end_iter =
+ std::remove_if(final_table_.packages.begin(),
+ final_table_.packages.end(), is_ext_package_func);
+ final_table_.packages.erase(new_end_iter, final_table_.packages.end());
return !error;
}
/**
* Returns true if no IDs have been set, false otherwise.
*/
- bool verifyNoIdsSet() {
- for (const auto& package : mFinalTable.packages) {
+ bool VerifyNoIdsSet() {
+ for (const auto& package : final_table_.packages) {
for (const auto& type : package->types) {
if (type->id) {
- mContext->getDiagnostics()->error(
+ context_->GetDiagnostics()->Error(
DiagMessage() << "type " << type->type << " has ID " << std::hex
<< (int)type->id.value() << std::dec
<< " assigned");
@@ -815,9 +820,9 @@
for (const auto& entry : type->entries) {
if (entry->id) {
- ResourceNameRef resName(package->name, type->type, entry->name);
- mContext->getDiagnostics()->error(
- DiagMessage() << "entry " << resName << " has ID " << std::hex
+ ResourceNameRef res_name(package->name, type->type, entry->name);
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "entry " << res_name << " has ID " << std::hex
<< (int)entry->id.value() << std::dec
<< " assigned");
return false;
@@ -828,265 +833,261 @@
return true;
}
- std::unique_ptr<IArchiveWriter> makeArchiveWriter(const StringPiece& out) {
- if (mOptions.outputToDirectory) {
- return createDirectoryArchiveWriter(mContext->getDiagnostics(), out);
+ std::unique_ptr<IArchiveWriter> MakeArchiveWriter(const StringPiece& out) {
+ if (options_.output_to_directory) {
+ return CreateDirectoryArchiveWriter(context_->GetDiagnostics(), out);
} else {
- return createZipFileArchiveWriter(mContext->getDiagnostics(), out);
+ return CreateZipFileArchiveWriter(context_->GetDiagnostics(), out);
}
}
- bool flattenTable(ResourceTable* table, IArchiveWriter* writer) {
+ bool FlattenTable(ResourceTable* table, IArchiveWriter* writer) {
BigBuffer buffer(1024);
TableFlattener flattener(&buffer);
- if (!flattener.consume(mContext, table)) {
+ if (!flattener.Consume(context_, table)) {
return false;
}
- if (writer->startEntry("resources.arsc", ArchiveEntry::kAlign)) {
- if (writer->writeEntry(buffer)) {
- if (writer->finishEntry()) {
+ if (writer->StartEntry("resources.arsc", ArchiveEntry::kAlign)) {
+ if (writer->WriteEntry(buffer)) {
+ if (writer->FinishEntry()) {
return true;
}
}
}
- mContext->getDiagnostics()->error(
+ context_->GetDiagnostics()->Error(
DiagMessage() << "failed to write resources.arsc to archive");
return false;
}
- bool flattenTableToPb(ResourceTable* table, IArchiveWriter* writer) {
+ bool FlattenTableToPb(ResourceTable* table, IArchiveWriter* writer) {
// Create the file/zip entry.
- if (!writer->startEntry("resources.arsc.flat", 0)) {
- mContext->getDiagnostics()->error(DiagMessage() << "failed to open");
+ if (!writer->StartEntry("resources.arsc.flat", 0)) {
+ context_->GetDiagnostics()->Error(DiagMessage() << "failed to open");
return false;
}
// Make sure CopyingOutputStreamAdaptor is deleted before we call
- // writer->finishEntry().
+ // writer->FinishEntry().
{
// Wrap our IArchiveWriter with an adaptor that implements the
- // ZeroCopyOutputStream
- // interface.
+ // ZeroCopyOutputStream interface.
CopyingOutputStreamAdaptor adaptor(writer);
- std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(table);
- if (!pbTable->SerializeToZeroCopyStream(&adaptor)) {
- mContext->getDiagnostics()->error(DiagMessage() << "failed to write");
+ std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table);
+ if (!pb_table->SerializeToZeroCopyStream(&adaptor)) {
+ context_->GetDiagnostics()->Error(DiagMessage() << "failed to write");
return false;
}
}
- if (!writer->finishEntry()) {
- mContext->getDiagnostics()->error(DiagMessage()
+ if (!writer->FinishEntry()) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed to finish entry");
return false;
}
return true;
}
- bool writeJavaFile(ResourceTable* table,
- const StringPiece& packageNameToGenerate,
- const StringPiece& outPackage,
- const JavaClassGeneratorOptions& javaOptions) {
- if (!mOptions.generateJavaClassPath) {
+ bool WriteJavaFile(ResourceTable* table,
+ const StringPiece& package_name_to_generate,
+ const StringPiece& out_package,
+ const JavaClassGeneratorOptions& java_options) {
+ if (!options_.generate_java_class_path) {
return true;
}
- std::string outPath = mOptions.generateJavaClassPath.value();
- file::appendPath(&outPath, file::packageToPath(outPackage));
- if (!file::mkdirs(outPath)) {
- mContext->getDiagnostics()->error(
- DiagMessage() << "failed to create directory '" << outPath << "'");
+ std::string out_path = options_.generate_java_class_path.value();
+ file::AppendPath(&out_path, file::PackageToPath(out_package));
+ if (!file::mkdirs(out_path)) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed to create directory '" << out_path << "'");
return false;
}
- file::appendPath(&outPath, "R.java");
+ file::AppendPath(&out_path, "R.java");
- std::ofstream fout(outPath, std::ofstream::binary);
+ std::ofstream fout(out_path, std::ofstream::binary);
if (!fout) {
- mContext->getDiagnostics()->error(DiagMessage()
- << "failed writing to '" << outPath
- << "': " << strerror(errno));
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed writing to '" << out_path << "': "
+ << android::base::SystemErrorCodeToString(errno));
return false;
}
- JavaClassGenerator generator(mContext, table, javaOptions);
- if (!generator.generate(packageNameToGenerate, outPackage, &fout)) {
- mContext->getDiagnostics()->error(DiagMessage(outPath)
+ JavaClassGenerator generator(context_, table, java_options);
+ if (!generator.Generate(package_name_to_generate, out_package, &fout)) {
+ context_->GetDiagnostics()->Error(DiagMessage(out_path)
<< generator.getError());
return false;
}
if (!fout) {
- mContext->getDiagnostics()->error(DiagMessage()
- << "failed writing to '" << outPath
- << "': " << strerror(errno));
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed writing to '" << out_path << "': "
+ << android::base::SystemErrorCodeToString(errno));
}
return true;
}
- bool writeManifestJavaFile(xml::XmlResource* manifestXml) {
- if (!mOptions.generateJavaClassPath) {
+ bool WriteManifestJavaFile(xml::XmlResource* manifest_xml) {
+ if (!options_.generate_java_class_path) {
return true;
}
- std::unique_ptr<ClassDefinition> manifestClass =
- generateManifestClass(mContext->getDiagnostics(), manifestXml);
+ std::unique_ptr<ClassDefinition> manifest_class =
+ GenerateManifestClass(context_->GetDiagnostics(), manifest_xml);
- if (!manifestClass) {
+ if (!manifest_class) {
// Something bad happened, but we already logged it, so exit.
return false;
}
- if (manifestClass->empty()) {
+ if (manifest_class->empty()) {
// Empty Manifest class, no need to generate it.
return true;
}
// Add any JavaDoc annotations to the generated class.
- for (const std::string& annotation : mOptions.javadocAnnotations) {
- std::string properAnnotation = "@";
- properAnnotation += annotation;
- manifestClass->getCommentBuilder()->appendComment(properAnnotation);
+ for (const std::string& annotation : options_.javadoc_annotations) {
+ std::string proper_annotation = "@";
+ proper_annotation += annotation;
+ manifest_class->GetCommentBuilder()->AppendComment(proper_annotation);
}
- const std::string& packageUtf8 = mContext->getCompilationPackage();
+ const std::string& package_utf8 = context_->GetCompilationPackage();
- std::string outPath = mOptions.generateJavaClassPath.value();
- file::appendPath(&outPath, file::packageToPath(packageUtf8));
+ std::string out_path = options_.generate_java_class_path.value();
+ file::AppendPath(&out_path, file::PackageToPath(package_utf8));
- if (!file::mkdirs(outPath)) {
- mContext->getDiagnostics()->error(
- DiagMessage() << "failed to create directory '" << outPath << "'");
+ if (!file::mkdirs(out_path)) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed to create directory '" << out_path << "'");
return false;
}
- file::appendPath(&outPath, "Manifest.java");
+ file::AppendPath(&out_path, "Manifest.java");
- std::ofstream fout(outPath, std::ofstream::binary);
+ std::ofstream fout(out_path, std::ofstream::binary);
if (!fout) {
- mContext->getDiagnostics()->error(DiagMessage()
- << "failed writing to '" << outPath
- << "': " << strerror(errno));
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed writing to '" << out_path << "': "
+ << android::base::SystemErrorCodeToString(errno));
return false;
}
- if (!ClassDefinition::writeJavaFile(manifestClass.get(), packageUtf8, true,
- &fout)) {
- mContext->getDiagnostics()->error(DiagMessage()
- << "failed writing to '" << outPath
- << "': " << strerror(errno));
+ if (!ClassDefinition::WriteJavaFile(manifest_class.get(), package_utf8,
+ true, &fout)) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed writing to '" << out_path << "': "
+ << android::base::SystemErrorCodeToString(errno));
return false;
}
return true;
}
- bool writeProguardFile(const Maybe<std::string>& out,
- const proguard::KeepSet& keepSet) {
+ bool WriteProguardFile(const Maybe<std::string>& out,
+ const proguard::KeepSet& keep_set) {
if (!out) {
return true;
}
- const std::string& outPath = out.value();
- std::ofstream fout(outPath, std::ofstream::binary);
+ const std::string& out_path = out.value();
+ std::ofstream fout(out_path, std::ofstream::binary);
if (!fout) {
- mContext->getDiagnostics()->error(DiagMessage()
- << "failed to open '" << outPath
- << "': " << strerror(errno));
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed to open '" << out_path << "': "
+ << android::base::SystemErrorCodeToString(errno));
return false;
}
- proguard::writeKeepSet(&fout, keepSet);
+ proguard::WriteKeepSet(&fout, keep_set);
if (!fout) {
- mContext->getDiagnostics()->error(DiagMessage()
- << "failed writing to '" << outPath
- << "': " << strerror(errno));
+ context_->GetDiagnostics()->Error(
+ DiagMessage() << "failed writing to '" << out_path << "': "
+ << android::base::SystemErrorCodeToString(errno));
return false;
}
return true;
}
- std::unique_ptr<ResourceTable> loadStaticLibrary(const std::string& input,
- std::string* outError) {
+ std::unique_ptr<ResourceTable> LoadStaticLibrary(const std::string& input,
+ std::string* out_error) {
std::unique_ptr<io::ZipFileCollection> collection =
- io::ZipFileCollection::create(input, outError);
+ io::ZipFileCollection::Create(input, out_error);
if (!collection) {
return {};
}
- return loadTablePbFromCollection(collection.get());
+ return LoadTablePbFromCollection(collection.get());
}
- std::unique_ptr<ResourceTable> loadTablePbFromCollection(
+ std::unique_ptr<ResourceTable> LoadTablePbFromCollection(
io::IFileCollection* collection) {
- io::IFile* file = collection->findFile("resources.arsc.flat");
+ io::IFile* file = collection->FindFile("resources.arsc.flat");
if (!file) {
return {};
}
- std::unique_ptr<io::IData> data = file->openAsData();
- return loadTableFromPb(file->getSource(), data->data(), data->size(),
- mContext->getDiagnostics());
+ std::unique_ptr<io::IData> data = file->OpenAsData();
+ return LoadTableFromPb(file->GetSource(), data->data(), data->size(),
+ context_->GetDiagnostics());
}
- bool mergeStaticLibrary(const std::string& input, bool override) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(DiagMessage()
+ bool MergeStaticLibrary(const std::string& input, bool override) {
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(DiagMessage()
<< "merging static library " << input);
}
- std::string errorStr;
+ std::string error_str;
std::unique_ptr<io::ZipFileCollection> collection =
- io::ZipFileCollection::create(input, &errorStr);
+ io::ZipFileCollection::Create(input, &error_str);
if (!collection) {
- mContext->getDiagnostics()->error(DiagMessage(input) << errorStr);
+ context_->GetDiagnostics()->Error(DiagMessage(input) << error_str);
return false;
}
std::unique_ptr<ResourceTable> table =
- loadTablePbFromCollection(collection.get());
+ LoadTablePbFromCollection(collection.get());
if (!table) {
- mContext->getDiagnostics()->error(DiagMessage(input)
+ context_->GetDiagnostics()->Error(DiagMessage(input)
<< "invalid static library");
return false;
}
- ResourceTablePackage* pkg = table->findPackageById(0x7f);
+ ResourceTablePackage* pkg = table->FindPackageById(0x7f);
if (!pkg) {
- mContext->getDiagnostics()->error(DiagMessage(input)
+ context_->GetDiagnostics()->Error(DiagMessage(input)
<< "static library has no package");
return false;
}
bool result;
- if (mOptions.noStaticLibPackages) {
+ if (options_.no_static_lib_packages) {
// Merge all resources as if they were in the compilation package. This is
- // the old
- // behaviour of aapt.
+ // the old behavior of aapt.
// Add the package to the set of --extra-packages so we emit an R.java for
- // each
- // library package.
+ // each library package.
if (!pkg->name.empty()) {
- mOptions.extraJavaPackages.insert(pkg->name);
+ options_.extra_java_packages.insert(pkg->name);
}
pkg->name = "";
if (override) {
- result = mTableMerger->mergeOverlay(Source(input), table.get(),
- collection.get());
+ result = table_merger_->MergeOverlay(Source(input), table.get(),
+ collection.get());
} else {
result =
- mTableMerger->merge(Source(input), table.get(), collection.get());
+ table_merger_->Merge(Source(input), table.get(), collection.get());
}
} else {
// This is the proper way to merge libraries, where the package name is
- // preserved
- // and resource names are mangled.
- result = mTableMerger->mergeAndMangle(Source(input), pkg->name,
- table.get(), collection.get());
+ // preserved and resource names are mangled.
+ result = table_merger_->MergeAndMangle(Source(input), pkg->name,
+ table.get(), collection.get());
}
if (!result) {
@@ -1094,52 +1095,52 @@
}
// Make sure to move the collection into the set of IFileCollections.
- mCollections.push_back(std::move(collection));
+ collections_.push_back(std::move(collection));
return true;
}
- bool mergeResourceTable(io::IFile* file, bool override) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(
- DiagMessage() << "merging resource table " << file->getSource());
+ bool MergeResourceTable(io::IFile* file, bool override) {
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(
+ DiagMessage() << "merging resource table " << file->GetSource());
}
- std::unique_ptr<io::IData> data = file->openAsData();
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- mContext->getDiagnostics()->error(DiagMessage(file->getSource())
+ context_->GetDiagnostics()->Error(DiagMessage(file->GetSource())
<< "failed to open file");
return false;
}
std::unique_ptr<ResourceTable> table =
- loadTableFromPb(file->getSource(), data->data(), data->size(),
- mContext->getDiagnostics());
+ LoadTableFromPb(file->GetSource(), data->data(), data->size(),
+ context_->GetDiagnostics());
if (!table) {
return false;
}
bool result = false;
if (override) {
- result = mTableMerger->mergeOverlay(file->getSource(), table.get());
+ result = table_merger_->MergeOverlay(file->GetSource(), table.get());
} else {
- result = mTableMerger->merge(file->getSource(), table.get());
+ result = table_merger_->Merge(file->GetSource(), table.get());
}
return result;
}
- bool mergeCompiledFile(io::IFile* file, ResourceFile* fileDesc,
+ bool MergeCompiledFile(io::IFile* file, ResourceFile* file_desc,
bool override) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(
- DiagMessage() << "merging '" << fileDesc->name
- << "' from compiled file " << file->getSource());
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(
+ DiagMessage() << "merging '" << file_desc->name
+ << "' from compiled file " << file->GetSource());
}
bool result = false;
if (override) {
- result = mTableMerger->mergeFileOverlay(*fileDesc, file);
+ result = table_merger_->MergeFileOverlay(*file_desc, file);
} else {
- result = mTableMerger->mergeFile(*fileDesc, file);
+ result = table_merger_->MergeFile(*file_desc, file);
}
if (!result) {
@@ -1147,24 +1148,24 @@
}
// Add the exports of this file to the table.
- for (SourcedResourceName& exportedSymbol : fileDesc->exportedSymbols) {
- if (exportedSymbol.name.package.empty()) {
- exportedSymbol.name.package = mContext->getCompilationPackage();
+ for (SourcedResourceName& exported_symbol : file_desc->exported_symbols) {
+ if (exported_symbol.name.package.empty()) {
+ exported_symbol.name.package = context_->GetCompilationPackage();
}
- ResourceNameRef resName = exportedSymbol.name;
+ ResourceNameRef res_name = exported_symbol.name;
- Maybe<ResourceName> mangledName =
- mContext->getNameMangler()->mangleName(exportedSymbol.name);
- if (mangledName) {
- resName = mangledName.value();
+ Maybe<ResourceName> mangled_name =
+ context_->GetNameMangler()->MangleName(exported_symbol.name);
+ if (mangled_name) {
+ res_name = mangled_name.value();
}
std::unique_ptr<Id> id = util::make_unique<Id>();
- id->setSource(fileDesc->source.withLine(exportedSymbol.line));
- bool result = mFinalTable.addResourceAllowMangled(
- resName, ConfigDescription::defaultConfig(), std::string(),
- std::move(id), mContext->getDiagnostics());
+ id->SetSource(file_desc->source.WithLine(exported_symbol.line));
+ bool result = final_table_.AddResourceAllowMangled(
+ res_name, ConfigDescription::DefaultConfig(), std::string(),
+ std::move(id), context_->GetDiagnostics());
if (!result) {
return false;
}
@@ -1176,35 +1177,34 @@
* Takes a path to load as a ZIP file and merges the files within into the
* master ResourceTable.
* If override is true, conflicting resources are allowed to override each
- * other, in order of
- * last seen.
+ * other, in order of last seen.
*
* An io::IFileCollection is created from the ZIP file and added to the set of
* io::IFileCollections that are open.
*/
- bool mergeArchive(const std::string& input, bool override) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(DiagMessage() << "merging archive "
+ bool MergeArchive(const std::string& input, bool override) {
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(DiagMessage() << "merging archive "
<< input);
}
- std::string errorStr;
+ std::string error_str;
std::unique_ptr<io::ZipFileCollection> collection =
- io::ZipFileCollection::create(input, &errorStr);
+ io::ZipFileCollection::Create(input, &error_str);
if (!collection) {
- mContext->getDiagnostics()->error(DiagMessage(input) << errorStr);
+ context_->GetDiagnostics()->Error(DiagMessage(input) << error_str);
return false;
}
bool error = false;
- for (auto iter = collection->iterator(); iter->hasNext();) {
- if (!mergeFile(iter->next(), override)) {
+ for (auto iter = collection->Iterator(); iter->HasNext();) {
+ if (!MergeFile(iter->Next(), override)) {
error = true;
}
}
// Make sure to move the collection into the set of IFileCollections.
- mCollections.push_back(std::move(collection));
+ collections_.push_back(std::move(collection));
return !error;
}
@@ -1220,18 +1220,16 @@
*
* Otherwise the files is processed on its own.
*/
- bool mergePath(const std::string& path, bool override) {
- if (util::stringEndsWith(path, ".flata") ||
- util::stringEndsWith(path, ".jar") ||
- util::stringEndsWith(path, ".jack") ||
- util::stringEndsWith(path, ".zip")) {
- return mergeArchive(path, override);
- } else if (util::stringEndsWith(path, ".apk")) {
- return mergeStaticLibrary(path, override);
+ bool MergePath(const std::string& path, bool override) {
+ if (util::EndsWith(path, ".flata") || util::EndsWith(path, ".jar") ||
+ util::EndsWith(path, ".jack") || util::EndsWith(path, ".zip")) {
+ return MergeArchive(path, override);
+ } else if (util::EndsWith(path, ".apk")) {
+ return MergeStaticLibrary(path, override);
}
- io::IFile* file = mFileCollection->insertFile(path);
- return mergeFile(file, override);
+ io::IFile* file = file_collection_->InsertFile(path);
+ return MergeFile(file, override);
}
/**
@@ -1250,63 +1248,63 @@
* coming from a zip,
* where we could have other files like classes.dex.
*/
- bool mergeFile(io::IFile* file, bool override) {
- const Source& src = file->getSource();
- if (util::stringEndsWith(src.path, ".arsc.flat")) {
- return mergeResourceTable(file, override);
+ bool MergeFile(io::IFile* file, bool override) {
+ const Source& src = file->GetSource();
+ if (util::EndsWith(src.path, ".arsc.flat")) {
+ return MergeResourceTable(file, override);
- } else if (util::stringEndsWith(src.path, ".flat")) {
+ } else if (util::EndsWith(src.path, ".flat")) {
// Try opening the file and looking for an Export header.
- std::unique_ptr<io::IData> data = file->openAsData();
+ std::unique_ptr<io::IData> data = file->OpenAsData();
if (!data) {
- mContext->getDiagnostics()->error(DiagMessage(src) << "failed to open");
+ context_->GetDiagnostics()->Error(DiagMessage(src) << "failed to open");
return false;
}
- CompiledFileInputStream inputStream(data->data(), data->size());
- uint32_t numFiles = 0;
- if (!inputStream.ReadLittleEndian32(&numFiles)) {
- mContext->getDiagnostics()->error(DiagMessage(src)
+ CompiledFileInputStream input_stream(data->data(), data->size());
+ uint32_t num_files = 0;
+ if (!input_stream.ReadLittleEndian32(&num_files)) {
+ context_->GetDiagnostics()->Error(DiagMessage(src)
<< "failed read num files");
return false;
}
- for (uint32_t i = 0; i < numFiles; i++) {
- pb::CompiledFile compiledFile;
- if (!inputStream.ReadCompiledFile(&compiledFile)) {
- mContext->getDiagnostics()->error(
+ for (uint32_t i = 0; i < num_files; i++) {
+ pb::CompiledFile compiled_file;
+ if (!input_stream.ReadCompiledFile(&compiled_file)) {
+ context_->GetDiagnostics()->Error(
DiagMessage(src) << "failed to read compiled file header");
return false;
}
uint64_t offset, len;
- if (!inputStream.ReadDataMetaData(&offset, &len)) {
- mContext->getDiagnostics()->error(DiagMessage(src)
+ if (!input_stream.ReadDataMetaData(&offset, &len)) {
+ context_->GetDiagnostics()->Error(DiagMessage(src)
<< "failed to read data meta data");
return false;
}
- std::unique_ptr<ResourceFile> resourceFile =
- deserializeCompiledFileFromPb(compiledFile, file->getSource(),
- mContext->getDiagnostics());
- if (!resourceFile) {
+ std::unique_ptr<ResourceFile> resource_file =
+ DeserializeCompiledFileFromPb(compiled_file, file->GetSource(),
+ context_->GetDiagnostics());
+ if (!resource_file) {
return false;
}
- if (!mergeCompiledFile(file->createFileSegment(offset, len),
- resourceFile.get(), override)) {
+ if (!MergeCompiledFile(file->CreateFileSegment(offset, len),
+ resource_file.get(), override)) {
return false;
}
}
return true;
- } else if (util::stringEndsWith(src.path, ".xml") ||
- util::stringEndsWith(src.path, ".png")) {
+ } else if (util::EndsWith(src.path, ".xml") ||
+ util::EndsWith(src.path, ".png")) {
// Since AAPT compiles these file types and appends .flat to them, seeing
// their raw extensions is a sign that they weren't compiled.
- const StringPiece fileType =
- util::stringEndsWith(src.path, ".xml") ? "XML" : "PNG";
- mContext->getDiagnostics()->error(DiagMessage(src)
- << "uncompiled " << fileType
+ const StringPiece file_type =
+ util::EndsWith(src.path, ".xml") ? "XML" : "PNG";
+ context_->GetDiagnostics()->Error(DiagMessage(src)
+ << "uncompiled " << file_type
<< " file passed as argument. Must be "
"compiled first into .flat file.");
return false;
@@ -1318,95 +1316,95 @@
return true;
}
- std::unique_ptr<xml::XmlResource> generateSplitManifest(
- const AppInfo& appInfo, const SplitConstraints& constraints) {
+ std::unique_ptr<xml::XmlResource> GenerateSplitManifest(
+ const AppInfo& app_info, const SplitConstraints& constraints) {
std::unique_ptr<xml::XmlResource> doc =
util::make_unique<xml::XmlResource>();
- std::unique_ptr<xml::Namespace> namespaceAndroid =
+ std::unique_ptr<xml::Namespace> namespace_android =
util::make_unique<xml::Namespace>();
- namespaceAndroid->namespaceUri = xml::kSchemaAndroid;
- namespaceAndroid->namespacePrefix = "android";
+ namespace_android->namespace_uri = xml::kSchemaAndroid;
+ namespace_android->namespace_prefix = "android";
- std::unique_ptr<xml::Element> manifestEl =
+ std::unique_ptr<xml::Element> manifest_el =
util::make_unique<xml::Element>();
- manifestEl->name = "manifest";
- manifestEl->attributes.push_back(
- xml::Attribute{"", "package", appInfo.package});
+ manifest_el->name = "manifest";
+ manifest_el->attributes.push_back(
+ xml::Attribute{"", "package", app_info.package});
- if (appInfo.versionCode) {
- manifestEl->attributes.push_back(
+ if (app_info.version_code) {
+ manifest_el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "versionCode",
- std::to_string(appInfo.versionCode.value())});
+ std::to_string(app_info.version_code.value())});
}
- if (appInfo.revisionCode) {
- manifestEl->attributes.push_back(
+ if (app_info.revision_code) {
+ manifest_el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "revisionCode",
- std::to_string(appInfo.revisionCode.value())});
+ std::to_string(app_info.revision_code.value())});
}
- std::stringstream splitName;
- splitName << "config." << util::joiner(constraints.configs, "_");
+ std::stringstream split_name;
+ split_name << "config." << util::Joiner(constraints.configs, "_");
- manifestEl->attributes.push_back(
- xml::Attribute{"", "split", splitName.str()});
+ manifest_el->attributes.push_back(
+ xml::Attribute{"", "split", split_name.str()});
- std::unique_ptr<xml::Element> applicationEl =
+ std::unique_ptr<xml::Element> application_el =
util::make_unique<xml::Element>();
- applicationEl->name = "application";
- applicationEl->attributes.push_back(
+ application_el->name = "application";
+ application_el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "hasCode", "false"});
- manifestEl->addChild(std::move(applicationEl));
- namespaceAndroid->addChild(std::move(manifestEl));
- doc->root = std::move(namespaceAndroid);
+ manifest_el->AddChild(std::move(application_el));
+ namespace_android->AddChild(std::move(manifest_el));
+ doc->root = std::move(namespace_android);
return doc;
}
/**
* Writes the AndroidManifest, ResourceTable, and all XML files referenced by
- * the ResourceTable
- * to the IArchiveWriter.
+ * the ResourceTable to the IArchiveWriter.
*/
- bool writeApk(IArchiveWriter* writer, proguard::KeepSet* keepSet,
+ bool WriteApk(IArchiveWriter* writer, proguard::KeepSet* keep_set,
xml::XmlResource* manifest, ResourceTable* table) {
- const bool keepRawValues = mOptions.staticLib;
- bool result = flattenXml(manifest, "AndroidManifest.xml", {}, keepRawValues,
- writer, mContext);
+ const bool keep_raw_values = options_.static_lib;
+ bool result = FlattenXml(manifest, "AndroidManifest.xml", {},
+ keep_raw_values, writer, context_);
if (!result) {
return false;
}
- ResourceFileFlattenerOptions fileFlattenerOptions;
- fileFlattenerOptions.keepRawValues = keepRawValues;
- fileFlattenerOptions.doNotCompressAnything = mOptions.doNotCompressAnything;
- fileFlattenerOptions.extensionsToNotCompress =
- mOptions.extensionsToNotCompress;
- fileFlattenerOptions.noAutoVersion = mOptions.noAutoVersion;
- fileFlattenerOptions.noVersionVectors = mOptions.noVersionVectors;
- fileFlattenerOptions.noXmlNamespaces = mOptions.noXmlNamespaces;
- fileFlattenerOptions.updateProguardSpec =
- static_cast<bool>(mOptions.generateProguardRulesPath);
+ ResourceFileFlattenerOptions file_flattener_options;
+ file_flattener_options.keep_raw_values = keep_raw_values;
+ file_flattener_options.do_not_compress_anything =
+ options_.do_not_compress_anything;
+ file_flattener_options.extensions_to_not_compress =
+ options_.extensions_to_not_compress;
+ file_flattener_options.no_auto_version = options_.no_auto_version;
+ file_flattener_options.no_version_vectors = options_.no_version_vectors;
+ file_flattener_options.no_xml_namespaces = options_.no_xml_namespaces;
+ file_flattener_options.update_proguard_spec =
+ static_cast<bool>(options_.generate_proguard_rules_path);
- ResourceFileFlattener fileFlattener(fileFlattenerOptions, mContext,
- keepSet);
+ ResourceFileFlattener file_flattener(file_flattener_options, context_,
+ keep_set);
- if (!fileFlattener.flatten(table, writer)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ if (!file_flattener.Flatten(table, writer)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed linking file resources");
return false;
}
- if (mOptions.staticLib) {
- if (!flattenTableToPb(table, writer)) {
- mContext->getDiagnostics()->error(
+ if (options_.static_lib) {
+ if (!FlattenTableToPb(table, writer)) {
+ context_->GetDiagnostics()->Error(
DiagMessage() << "failed to write resources.arsc.flat");
return false;
}
} else {
- if (!flattenTable(table, writer)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ if (!FlattenTable(table, writer)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed to write resources.arsc");
return false;
}
@@ -1414,118 +1412,118 @@
return true;
}
- int run(const std::vector<std::string>& inputFiles) {
+ int Run(const std::vector<std::string>& input_files) {
// Load the AndroidManifest.xml
- std::unique_ptr<xml::XmlResource> manifestXml =
- loadXml(mOptions.manifestPath, mContext->getDiagnostics());
- if (!manifestXml) {
+ std::unique_ptr<xml::XmlResource> manifest_xml =
+ LoadXml(options_.manifest_path, context_->GetDiagnostics());
+ if (!manifest_xml) {
return 1;
}
// First extract the Package name without modifying it (via
// --rename-manifest-package).
- if (Maybe<AppInfo> maybeAppInfo = extractAppInfoFromManifest(
- manifestXml.get(), mContext->getDiagnostics())) {
- const AppInfo& appInfo = maybeAppInfo.value();
- mContext->setCompilationPackage(appInfo.package);
+ if (Maybe<AppInfo> maybe_app_info = ExtractAppInfoFromManifest(
+ manifest_xml.get(), context_->GetDiagnostics())) {
+ const AppInfo& app_info = maybe_app_info.value();
+ context_->SetCompilationPackage(app_info.package);
}
- ManifestFixer manifestFixer(mOptions.manifestFixerOptions);
- if (!manifestFixer.consume(mContext, manifestXml.get())) {
+ ManifestFixer manifest_fixer(options_.manifest_fixer_options);
+ if (!manifest_fixer.Consume(context_, manifest_xml.get())) {
return 1;
}
- Maybe<AppInfo> maybeAppInfo = extractAppInfoFromManifest(
- manifestXml.get(), mContext->getDiagnostics());
- if (!maybeAppInfo) {
+ Maybe<AppInfo> maybe_app_info = ExtractAppInfoFromManifest(
+ manifest_xml.get(), context_->GetDiagnostics());
+ if (!maybe_app_info) {
return 1;
}
- const AppInfo& appInfo = maybeAppInfo.value();
- if (appInfo.minSdkVersion) {
- if (Maybe<int> maybeMinSdkVersion =
- ResourceUtils::parseSdkVersion(appInfo.minSdkVersion.value())) {
- mContext->setMinSdkVersion(maybeMinSdkVersion.value());
+ const AppInfo& app_info = maybe_app_info.value();
+ if (app_info.min_sdk_version) {
+ if (Maybe<int> maybe_min_sdk_version = ResourceUtils::ParseSdkVersion(
+ app_info.min_sdk_version.value())) {
+ context_->SetMinSdkVersion(maybe_min_sdk_version.value());
}
}
- mContext->setNameManglerPolicy(
- NameManglerPolicy{mContext->getCompilationPackage()});
- if (mContext->getCompilationPackage() == "android") {
- mContext->setPackageId(0x01);
+ context_->SetNameManglerPolicy(
+ NameManglerPolicy{context_->GetCompilationPackage()});
+ if (context_->GetCompilationPackage() == "android") {
+ context_->SetPackageId(0x01);
} else {
- mContext->setPackageId(0x7f);
+ context_->SetPackageId(0x7f);
}
- if (!loadSymbolsFromIncludePaths()) {
+ if (!LoadSymbolsFromIncludePaths()) {
return 1;
}
- TableMergerOptions tableMergerOptions;
- tableMergerOptions.autoAddOverlay = mOptions.autoAddOverlay;
- mTableMerger = util::make_unique<TableMerger>(mContext, &mFinalTable,
- tableMergerOptions);
+ TableMergerOptions table_merger_options;
+ table_merger_options.auto_add_overlay = options_.auto_add_overlay;
+ table_merger_ = util::make_unique<TableMerger>(context_, &final_table_,
+ table_merger_options);
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(DiagMessage()
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(DiagMessage()
<< "linking package '"
- << mContext->getCompilationPackage()
+ << context_->GetCompilationPackage()
<< "' with package ID " << std::hex
- << (int)mContext->getPackageId());
+ << (int)context_->GetPackageId());
}
- for (const std::string& input : inputFiles) {
- if (!mergePath(input, false)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ for (const std::string& input : input_files) {
+ if (!MergePath(input, false)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed parsing input");
return 1;
}
}
- for (const std::string& input : mOptions.overlayFiles) {
- if (!mergePath(input, true)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ for (const std::string& input : options_.overlay_files) {
+ if (!MergePath(input, true)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed parsing overlays");
return 1;
}
}
- if (!verifyNoExternalPackages()) {
+ if (!VerifyNoExternalPackages()) {
return 1;
}
- if (!mOptions.staticLib) {
+ if (!options_.static_lib) {
PrivateAttributeMover mover;
- if (!mover.consume(mContext, &mFinalTable)) {
- mContext->getDiagnostics()->error(
+ if (!mover.Consume(context_, &final_table_)) {
+ context_->GetDiagnostics()->Error(
DiagMessage() << "failed moving private attributes");
return 1;
}
// Assign IDs if we are building a regular app.
- IdAssigner idAssigner(&mOptions.stableIdMap);
- if (!idAssigner.consume(mContext, &mFinalTable)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ IdAssigner id_assigner(&options_.stable_id_map);
+ if (!id_assigner.Consume(context_, &final_table_)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed assigning IDs");
return 1;
}
// Now grab each ID and emit it as a file.
- if (mOptions.resourceIdMapPath) {
- for (auto& package : mFinalTable.packages) {
+ if (options_.resource_id_map_path) {
+ for (auto& package : final_table_.packages) {
for (auto& type : package->types) {
for (auto& entry : type->entries) {
ResourceName name(package->name, type->type, entry->name);
// The IDs are guaranteed to exist.
- mOptions.stableIdMap[std::move(name)] = ResourceId(
+ options_.stable_id_map[std::move(name)] = ResourceId(
package->id.value(), type->id.value(), entry->id.value());
}
}
}
- if (!writeStableIdMapToPath(mContext->getDiagnostics(),
- mOptions.stableIdMap,
- mOptions.resourceIdMapPath.value())) {
+ if (!WriteStableIdMapToPath(context_->GetDiagnostics(),
+ options_.stable_id_map,
+ options_.resource_id_map_path.value())) {
return 1;
}
}
@@ -1533,80 +1531,80 @@
// Static libs are merged with other apps, and ID collisions are bad, so
// verify that
// no IDs have been set.
- if (!verifyNoIdsSet()) {
+ if (!VerifyNoIdsSet()) {
return 1;
}
}
// Add the names to mangle based on our source merge earlier.
- mContext->setNameManglerPolicy(NameManglerPolicy{
- mContext->getCompilationPackage(), mTableMerger->getMergedPackages()});
+ context_->SetNameManglerPolicy(NameManglerPolicy{
+ context_->GetCompilationPackage(), table_merger_->merged_packages()});
// Add our table to the symbol table.
- mContext->getExternalSymbols()->prependSource(
- util::make_unique<ResourceTableSymbolSource>(&mFinalTable));
+ context_->GetExternalSymbols()->PrependSource(
+ util::make_unique<ResourceTableSymbolSource>(&final_table_));
ReferenceLinker linker;
- if (!linker.consume(mContext, &mFinalTable)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ if (!linker.Consume(context_, &final_table_)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed linking references");
return 1;
}
- if (mOptions.staticLib) {
- if (!mOptions.products.empty()) {
- mContext->getDiagnostics()
- ->warn(DiagMessage()
+ if (options_.static_lib) {
+ if (!options_.products.empty()) {
+ context_->GetDiagnostics()
+ ->Warn(DiagMessage()
<< "can't select products when building static library");
}
} else {
- ProductFilter productFilter(mOptions.products);
- if (!productFilter.consume(mContext, &mFinalTable)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ ProductFilter product_filter(options_.products);
+ if (!product_filter.Consume(context_, &final_table_)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed stripping products");
return 1;
}
}
- if (!mOptions.noAutoVersion) {
+ if (!options_.no_auto_version) {
AutoVersioner versioner;
- if (!versioner.consume(mContext, &mFinalTable)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ if (!versioner.Consume(context_, &final_table_)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed versioning styles");
return 1;
}
}
- if (!mOptions.staticLib && mContext->getMinSdkVersion() > 0) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(
+ if (!options_.static_lib && context_->GetMinSdkVersion() > 0) {
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(
DiagMessage() << "collapsing resource versions for minimum SDK "
- << mContext->getMinSdkVersion());
+ << context_->GetMinSdkVersion());
}
VersionCollapser collapser;
- if (!collapser.consume(mContext, &mFinalTable)) {
+ if (!collapser.Consume(context_, &final_table_)) {
return 1;
}
}
- if (!mOptions.noResourceDeduping) {
+ if (!options_.no_resource_deduping) {
ResourceDeduper deduper;
- if (!deduper.consume(mContext, &mFinalTable)) {
- mContext->getDiagnostics()->error(DiagMessage()
+ if (!deduper.Consume(context_, &final_table_)) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed deduping resources");
return 1;
}
}
- proguard::KeepSet proguardKeepSet;
- proguard::KeepSet proguardMainDexKeepSet;
+ proguard::KeepSet proguard_keep_set;
+ proguard::KeepSet proguard_main_dex_keep_set;
- if (mOptions.staticLib) {
- if (mOptions.tableSplitterOptions.configFilter != nullptr ||
- mOptions.tableSplitterOptions.preferredDensity) {
- mContext->getDiagnostics()
- ->warn(DiagMessage()
+ if (options_.static_lib) {
+ if (options_.table_splitter_options.config_filter != nullptr ||
+ options_.table_splitter_options.preferred_density) {
+ context_->GetDiagnostics()
+ ->Warn(DiagMessage()
<< "can't strip resources when building static library");
}
} else {
@@ -1615,73 +1613,73 @@
// than or equal to the minSdk. Otherwise the resources that have had
// their SDK version
// stripped due to minSdk won't ever match.
- std::vector<SplitConstraints> adjustedConstraintsList;
- adjustedConstraintsList.reserve(mOptions.splitConstraints.size());
- for (const SplitConstraints& constraints : mOptions.splitConstraints) {
- SplitConstraints adjustedConstraints;
+ std::vector<SplitConstraints> adjusted_constraints_list;
+ adjusted_constraints_list.reserve(options_.split_constraints.size());
+ for (const SplitConstraints& constraints : options_.split_constraints) {
+ SplitConstraints adjusted_constraints;
for (const ConfigDescription& config : constraints.configs) {
- if (config.sdkVersion <= mContext->getMinSdkVersion()) {
- adjustedConstraints.configs.insert(config.copyWithoutSdkVersion());
+ if (config.sdkVersion <= context_->GetMinSdkVersion()) {
+ adjusted_constraints.configs.insert(config.CopyWithoutSdkVersion());
} else {
- adjustedConstraints.configs.insert(config);
+ adjusted_constraints.configs.insert(config);
}
}
- adjustedConstraintsList.push_back(std::move(adjustedConstraints));
+ adjusted_constraints_list.push_back(std::move(adjusted_constraints));
}
- TableSplitter tableSplitter(adjustedConstraintsList,
- mOptions.tableSplitterOptions);
- if (!tableSplitter.verifySplitConstraints(mContext)) {
+ TableSplitter table_splitter(adjusted_constraints_list,
+ options_.table_splitter_options);
+ if (!table_splitter.VerifySplitConstraints(context_)) {
return 1;
}
- tableSplitter.splitTable(&mFinalTable);
+ table_splitter.SplitTable(&final_table_);
// Now we need to write out the Split APKs.
- auto pathIter = mOptions.splitPaths.begin();
- auto splitConstraintsIter = adjustedConstraintsList.begin();
- for (std::unique_ptr<ResourceTable>& splitTable :
- tableSplitter.getSplits()) {
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(
- DiagMessage(*pathIter)
+ auto path_iter = options_.split_paths.begin();
+ auto split_constraints_iter = adjusted_constraints_list.begin();
+ for (std::unique_ptr<ResourceTable>& split_table :
+ table_splitter.splits()) {
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(
+ DiagMessage(*path_iter)
<< "generating split with configurations '"
- << util::joiner(splitConstraintsIter->configs, ", ") << "'");
+ << util::Joiner(split_constraints_iter->configs, ", ") << "'");
}
- std::unique_ptr<IArchiveWriter> archiveWriter =
- makeArchiveWriter(*pathIter);
- if (!archiveWriter) {
- mContext->getDiagnostics()->error(DiagMessage()
+ std::unique_ptr<IArchiveWriter> archive_writer =
+ MakeArchiveWriter(*path_iter);
+ if (!archive_writer) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed to create archive");
return 1;
}
// Generate an AndroidManifest.xml for each split.
- std::unique_ptr<xml::XmlResource> splitManifest =
- generateSplitManifest(appInfo, *splitConstraintsIter);
+ std::unique_ptr<xml::XmlResource> split_manifest =
+ GenerateSplitManifest(app_info, *split_constraints_iter);
XmlReferenceLinker linker;
- if (!linker.consume(mContext, splitManifest.get())) {
- mContext->getDiagnostics()->error(
+ if (!linker.Consume(context_, split_manifest.get())) {
+ context_->GetDiagnostics()->Error(
DiagMessage() << "failed to create Split AndroidManifest.xml");
return 1;
}
- if (!writeApk(archiveWriter.get(), &proguardKeepSet,
- splitManifest.get(), splitTable.get())) {
+ if (!WriteApk(archive_writer.get(), &proguard_keep_set,
+ split_manifest.get(), split_table.get())) {
return 1;
}
- ++pathIter;
- ++splitConstraintsIter;
+ ++path_iter;
+ ++split_constraints_iter;
}
}
// Start writing the base APK.
- std::unique_ptr<IArchiveWriter> archiveWriter =
- makeArchiveWriter(mOptions.outputPath);
- if (!archiveWriter) {
- mContext->getDiagnostics()->error(DiagMessage()
+ std::unique_ptr<IArchiveWriter> archive_writer =
+ MakeArchiveWriter(options_.output_path);
+ if (!archive_writer) {
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed to create archive");
return 1;
}
@@ -1692,35 +1690,35 @@
// from the name
// (aka, which package the AndroidManifest.xml is coming from).
// So we give it a package name so it can see local resources.
- manifestXml->file.name.package = mContext->getCompilationPackage();
+ manifest_xml->file.name.package = context_->GetCompilationPackage();
- XmlReferenceLinker manifestLinker;
- if (manifestLinker.consume(mContext, manifestXml.get())) {
- if (mOptions.generateProguardRulesPath &&
- !proguard::collectProguardRulesForManifest(
- Source(mOptions.manifestPath), manifestXml.get(),
- &proguardKeepSet)) {
+ XmlReferenceLinker manifest_linker;
+ if (manifest_linker.Consume(context_, manifest_xml.get())) {
+ if (options_.generate_proguard_rules_path &&
+ !proguard::CollectProguardRulesForManifest(
+ Source(options_.manifest_path), manifest_xml.get(),
+ &proguard_keep_set)) {
error = true;
}
- if (mOptions.generateMainDexProguardRulesPath &&
- !proguard::collectProguardRulesForManifest(
- Source(mOptions.manifestPath), manifestXml.get(),
- &proguardMainDexKeepSet, true)) {
+ if (options_.generate_main_dex_proguard_rules_path &&
+ !proguard::CollectProguardRulesForManifest(
+ Source(options_.manifest_path), manifest_xml.get(),
+ &proguard_main_dex_keep_set, true)) {
error = true;
}
- if (mOptions.generateJavaClassPath) {
- if (!writeManifestJavaFile(manifestXml.get())) {
+ if (options_.generate_java_class_path) {
+ if (!WriteManifestJavaFile(manifest_xml.get())) {
error = true;
}
}
- if (mOptions.noXmlNamespaces) {
+ if (options_.no_xml_namespaces) {
// PackageParser will fail if URIs are removed from
// AndroidManifest.xml.
- XmlNamespaceRemover namespaceRemover(true /* keepUris */);
- if (!namespaceRemover.consume(mContext, manifestXml.get())) {
+ XmlNamespaceRemover namespace_remover(true /* keepUris */);
+ if (!namespace_remover.Consume(context_, manifest_xml.get())) {
error = true;
}
}
@@ -1730,382 +1728,385 @@
}
if (error) {
- mContext->getDiagnostics()->error(DiagMessage()
+ context_->GetDiagnostics()->Error(DiagMessage()
<< "failed processing manifest");
return 1;
}
- if (!writeApk(archiveWriter.get(), &proguardKeepSet, manifestXml.get(),
- &mFinalTable)) {
+ if (!WriteApk(archive_writer.get(), &proguard_keep_set, manifest_xml.get(),
+ &final_table_)) {
return 1;
}
- if (mOptions.generateJavaClassPath) {
+ if (options_.generate_java_class_path) {
JavaClassGeneratorOptions options;
options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
- options.javadocAnnotations = mOptions.javadocAnnotations;
+ options.javadoc_annotations = options_.javadoc_annotations;
- if (mOptions.staticLib || mOptions.generateNonFinalIds) {
- options.useFinal = false;
+ if (options_.static_lib || options_.generate_non_final_ids) {
+ options.use_final = false;
}
- const StringPiece actualPackage = mContext->getCompilationPackage();
- StringPiece outputPackage = mContext->getCompilationPackage();
- if (mOptions.customJavaPackage) {
+ const StringPiece actual_package = context_->GetCompilationPackage();
+ StringPiece output_package = context_->GetCompilationPackage();
+ if (options_.custom_java_package) {
// Override the output java package to the custom one.
- outputPackage = mOptions.customJavaPackage.value();
+ output_package = options_.custom_java_package.value();
}
- if (mOptions.privateSymbols) {
+ if (options_.private_symbols) {
// If we defined a private symbols package, we only emit Public symbols
// to the original package, and private and public symbols to the
// private package.
options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
- if (!writeJavaFile(&mFinalTable, mContext->getCompilationPackage(),
- outputPackage, options)) {
+ if (!WriteJavaFile(&final_table_, context_->GetCompilationPackage(),
+ output_package, options)) {
return 1;
}
options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
- outputPackage = mOptions.privateSymbols.value();
+ output_package = options_.private_symbols.value();
}
- if (!writeJavaFile(&mFinalTable, actualPackage, outputPackage, options)) {
+ if (!WriteJavaFile(&final_table_, actual_package, output_package,
+ options)) {
return 1;
}
- for (const std::string& extraPackage : mOptions.extraJavaPackages) {
- if (!writeJavaFile(&mFinalTable, actualPackage, extraPackage,
+ for (const std::string& extra_package : options_.extra_java_packages) {
+ if (!WriteJavaFile(&final_table_, actual_package, extra_package,
options)) {
return 1;
}
}
}
- if (!writeProguardFile(mOptions.generateProguardRulesPath,
- proguardKeepSet)) {
+ if (!WriteProguardFile(options_.generate_proguard_rules_path,
+ proguard_keep_set)) {
return 1;
}
- if (!writeProguardFile(mOptions.generateMainDexProguardRulesPath,
- proguardMainDexKeepSet)) {
+ if (!WriteProguardFile(options_.generate_main_dex_proguard_rules_path,
+ proguard_main_dex_keep_set)) {
return 1;
}
- if (mContext->verbose()) {
- DebugPrintTableOptions debugPrintTableOptions;
- debugPrintTableOptions.showSources = true;
- Debug::printTable(&mFinalTable, debugPrintTableOptions);
+ if (context_->IsVerbose()) {
+ DebugPrintTableOptions debug_print_table_options;
+ debug_print_table_options.show_sources = true;
+ Debug::PrintTable(&final_table_, debug_print_table_options);
}
return 0;
}
private:
- LinkOptions mOptions;
- LinkContext* mContext;
- ResourceTable mFinalTable;
+ LinkOptions options_;
+ LinkContext* context_;
+ ResourceTable final_table_;
- std::unique_ptr<TableMerger> mTableMerger;
+ std::unique_ptr<TableMerger> table_merger_;
// A pointer to the FileCollection representing the filesystem (not archives).
- std::unique_ptr<io::FileCollection> mFileCollection;
+ std::unique_ptr<io::FileCollection> file_collection_;
// A vector of IFileCollections. This is mainly here to keep ownership of the
// collections.
- std::vector<std::unique_ptr<io::IFileCollection>> mCollections;
+ std::vector<std::unique_ptr<io::IFileCollection>> collections_;
// A vector of ResourceTables. This is here to retain ownership, so that the
// SymbolTable
// can use these.
- std::vector<std::unique_ptr<ResourceTable>> mStaticTableIncludes;
+ std::vector<std::unique_ptr<ResourceTable>> static_table_includes_;
};
-int link(const std::vector<StringPiece>& args) {
+int Link(const std::vector<StringPiece>& args) {
LinkContext context;
LinkOptions options;
- std::vector<std::string> overlayArgList;
- std::vector<std::string> extraJavaPackages;
+ std::vector<std::string> overlay_arg_list;
+ std::vector<std::string> extra_java_packages;
Maybe<std::string> configs;
- Maybe<std::string> preferredDensity;
- Maybe<std::string> productList;
- bool legacyXFlag = false;
- bool requireLocalization = false;
+ Maybe<std::string> preferred_density;
+ Maybe<std::string> product_list;
+ bool legacy_x_flag = false;
+ bool require_localization = false;
bool verbose = false;
- Maybe<std::string> stableIdFilePath;
- std::vector<std::string> splitArgs;
+ Maybe<std::string> stable_id_file_path;
+ std::vector<std::string> split_args;
Flags flags =
Flags()
- .requiredFlag("-o", "Output path", &options.outputPath)
- .requiredFlag("--manifest", "Path to the Android manifest to build",
- &options.manifestPath)
- .optionalFlagList("-I", "Adds an Android APK to link against",
- &options.includePaths)
- .optionalFlagList(
+ .RequiredFlag("-o", "Output path", &options.output_path)
+ .RequiredFlag("--manifest", "Path to the Android manifest to build",
+ &options.manifest_path)
+ .OptionalFlagList("-I", "Adds an Android APK to link against",
+ &options.include_paths)
+ .OptionalFlagList(
"-R",
"Compilation unit to link, using `overlay` semantics.\n"
"The last conflicting resource given takes precedence.",
- &overlayArgList)
- .optionalFlag("--java", "Directory in which to generate R.java",
- &options.generateJavaClassPath)
- .optionalFlag("--proguard",
+ &overlay_arg_list)
+ .OptionalFlag("--java", "Directory in which to generate R.java",
+ &options.generate_java_class_path)
+ .OptionalFlag("--proguard",
"Output file for generated Proguard rules",
- &options.generateProguardRulesPath)
- .optionalFlag(
+ &options.generate_proguard_rules_path)
+ .OptionalFlag(
"--proguard-main-dex",
"Output file for generated Proguard rules for the main dex",
- &options.generateMainDexProguardRulesPath)
- .optionalSwitch("--no-auto-version",
+ &options.generate_main_dex_proguard_rules_path)
+ .OptionalSwitch("--no-auto-version",
"Disables automatic style and layout SDK versioning",
- &options.noAutoVersion)
- .optionalSwitch("--no-version-vectors",
+ &options.no_auto_version)
+ .OptionalSwitch("--no-version-vectors",
"Disables automatic versioning of vector drawables. "
"Use this only\n"
"when building with vector drawable support library",
- &options.noVersionVectors)
- .optionalSwitch("--no-resource-deduping",
+ &options.no_version_vectors)
+ .OptionalSwitch("--no-resource-deduping",
"Disables automatic deduping of resources with\n"
"identical values across compatible configurations.",
- &options.noResourceDeduping)
- .optionalSwitch(
+ &options.no_resource_deduping)
+ .OptionalSwitch(
"-x",
"Legacy flag that specifies to use the package identifier 0x01",
- &legacyXFlag)
- .optionalSwitch("-z",
+ &legacy_x_flag)
+ .OptionalSwitch("-z",
"Require localization of strings marked 'suggested'",
- &requireLocalization)
- .optionalFlag(
+ &require_localization)
+ .OptionalFlag(
"-c",
"Comma separated list of configurations to include. The default\n"
"is all configurations",
&configs)
- .optionalFlag(
+ .OptionalFlag(
"--preferred-density",
"Selects the closest matching density and strips out all others.",
- &preferredDensity)
- .optionalFlag("--product",
+ &preferred_density)
+ .OptionalFlag("--product",
"Comma separated list of product names to keep",
- &productList)
- .optionalSwitch("--output-to-dir",
+ &product_list)
+ .OptionalSwitch("--output-to-dir",
"Outputs the APK contents to a directory specified "
"by -o",
- &options.outputToDirectory)
- .optionalSwitch("--no-xml-namespaces",
+ &options.output_to_directory)
+ .OptionalSwitch("--no-xml-namespaces",
"Removes XML namespace prefix and URI "
"information from AndroidManifest.xml\nand XML "
"binaries in res/*.",
- &options.noXmlNamespaces)
- .optionalFlag("--min-sdk-version",
+ &options.no_xml_namespaces)
+ .OptionalFlag("--min-sdk-version",
"Default minimum SDK version to use for "
"AndroidManifest.xml",
- &options.manifestFixerOptions.minSdkVersionDefault)
- .optionalFlag("--target-sdk-version",
- "Default target SDK version to use for "
- "AndroidManifest.xml",
- &options.manifestFixerOptions.targetSdkVersionDefault)
- .optionalFlag("--version-code",
+ &options.manifest_fixer_options.min_sdk_version_default)
+ .OptionalFlag(
+ "--target-sdk-version",
+ "Default target SDK version to use for "
+ "AndroidManifest.xml",
+ &options.manifest_fixer_options.target_sdk_version_default)
+ .OptionalFlag("--version-code",
"Version code (integer) to inject into the "
"AndroidManifest.xml if none is present",
- &options.manifestFixerOptions.versionCodeDefault)
- .optionalFlag("--version-name",
+ &options.manifest_fixer_options.version_code_default)
+ .OptionalFlag("--version-name",
"Version name to inject into the AndroidManifest.xml "
"if none is present",
- &options.manifestFixerOptions.versionNameDefault)
- .optionalSwitch("--static-lib", "Generate a static Android library",
- &options.staticLib)
- .optionalSwitch("--no-static-lib-packages",
+ &options.manifest_fixer_options.version_name_default)
+ .OptionalSwitch("--static-lib", "Generate a static Android library",
+ &options.static_lib)
+ .OptionalSwitch("--no-static-lib-packages",
"Merge all library resources under the app's package",
- &options.noStaticLibPackages)
- .optionalSwitch("--non-final-ids",
+ &options.no_static_lib_packages)
+ .OptionalSwitch("--non-final-ids",
"Generates R.java without the final modifier.\n"
"This is implied when --static-lib is specified.",
- &options.generateNonFinalIds)
- .optionalFlag("--stable-ids",
+ &options.generate_non_final_ids)
+ .OptionalFlag("--stable-ids",
"File containing a list of name to ID mapping.",
- &stableIdFilePath)
- .optionalFlag(
+ &stable_id_file_path)
+ .OptionalFlag(
"--emit-ids",
"Emit a file at the given path with a list of name to ID\n"
"mappings, suitable for use with --stable-ids.",
- &options.resourceIdMapPath)
- .optionalFlag("--private-symbols",
+ &options.resource_id_map_path)
+ .OptionalFlag("--private-symbols",
"Package name to use when generating R.java for "
"private symbols.\n"
"If not specified, public and private symbols will use "
"the application's "
"package name",
- &options.privateSymbols)
- .optionalFlag("--custom-package",
+ &options.private_symbols)
+ .OptionalFlag("--custom-package",
"Custom Java package under which to generate R.java",
- &options.customJavaPackage)
- .optionalFlagList("--extra-packages",
+ &options.custom_java_package)
+ .OptionalFlagList("--extra-packages",
"Generate the same R.java but with different "
"package names",
- &extraJavaPackages)
- .optionalFlagList("--add-javadoc-annotation",
+ &extra_java_packages)
+ .OptionalFlagList("--add-javadoc-annotation",
"Adds a JavaDoc annotation to all "
"generated Java classes",
- &options.javadocAnnotations)
- .optionalSwitch("--auto-add-overlay",
+ &options.javadoc_annotations)
+ .OptionalSwitch("--auto-add-overlay",
"Allows the addition of new resources in "
"overlays without <add-resource> tags",
- &options.autoAddOverlay)
- .optionalFlag("--rename-manifest-package",
+ &options.auto_add_overlay)
+ .OptionalFlag("--rename-manifest-package",
"Renames the package in AndroidManifest.xml",
- &options.manifestFixerOptions.renameManifestPackage)
- .optionalFlag(
+ &options.manifest_fixer_options.rename_manifest_package)
+ .OptionalFlag(
"--rename-instrumentation-target-package",
"Changes the name of the target package for instrumentation. "
"Most useful "
"when used\nin conjunction with --rename-manifest-package",
- &options.manifestFixerOptions.renameInstrumentationTargetPackage)
- .optionalFlagList("-0", "File extensions not to compress",
- &options.extensionsToNotCompress)
- .optionalFlagList(
+ &options.manifest_fixer_options
+ .rename_instrumentation_target_package)
+ .OptionalFlagList("-0", "File extensions not to compress",
+ &options.extensions_to_not_compress)
+ .OptionalFlagList(
"--split",
"Split resources matching a set of configs out to a "
"Split APK.\nSyntax: path/to/output.apk:<config>[,<config>[...]]",
- &splitArgs)
- .optionalSwitch("-v", "Enables verbose logging", &verbose);
+ &split_args)
+ .OptionalSwitch("-v", "Enables verbose logging", &verbose);
- if (!flags.parse("aapt2 link", args, &std::cerr)) {
+ if (!flags.Parse("aapt2 link", args, &std::cerr)) {
return 1;
}
// Expand all argument-files passed into the command line. These start with
// '@'.
- std::vector<std::string> argList;
- for (const std::string& arg : flags.getArgs()) {
- if (util::stringStartsWith(arg, "@")) {
+ std::vector<std::string> arg_list;
+ for (const std::string& arg : flags.GetArgs()) {
+ if (util::StartsWith(arg, "@")) {
const std::string path = arg.substr(1, arg.size() - 1);
std::string error;
- if (!file::appendArgsFromFile(path, &argList, &error)) {
- context.getDiagnostics()->error(DiagMessage(path) << error);
+ if (!file::AppendArgsFromFile(path, &arg_list, &error)) {
+ context.GetDiagnostics()->Error(DiagMessage(path) << error);
return 1;
}
} else {
- argList.push_back(arg);
+ arg_list.push_back(arg);
}
}
// Expand all argument-files passed to -R.
- for (const std::string& arg : overlayArgList) {
- if (util::stringStartsWith(arg, "@")) {
+ for (const std::string& arg : overlay_arg_list) {
+ if (util::StartsWith(arg, "@")) {
const std::string path = arg.substr(1, arg.size() - 1);
std::string error;
- if (!file::appendArgsFromFile(path, &options.overlayFiles, &error)) {
- context.getDiagnostics()->error(DiagMessage(path) << error);
+ if (!file::AppendArgsFromFile(path, &options.overlay_files, &error)) {
+ context.GetDiagnostics()->Error(DiagMessage(path) << error);
return 1;
}
} else {
- options.overlayFiles.push_back(arg);
+ options.overlay_files.push_back(arg);
}
}
if (verbose) {
- context.setVerbose(verbose);
+ context.SetVerbose(verbose);
}
// Populate the set of extra packages for which to generate R.java.
- for (std::string& extraPackage : extraJavaPackages) {
+ for (std::string& extra_package : extra_java_packages) {
// A given package can actually be a colon separated list of packages.
- for (StringPiece package : util::split(extraPackage, ':')) {
- options.extraJavaPackages.insert(package.toString());
+ for (StringPiece package : util::Split(extra_package, ':')) {
+ options.extra_java_packages.insert(package.ToString());
}
}
- if (productList) {
- for (StringPiece product : util::tokenize(productList.value(), ',')) {
+ if (product_list) {
+ for (StringPiece product : util::Tokenize(product_list.value(), ',')) {
if (product != "" && product != "default") {
- options.products.insert(product.toString());
+ options.products.insert(product.ToString());
}
}
}
AxisConfigFilter filter;
if (configs) {
- for (const StringPiece& configStr : util::tokenize(configs.value(), ',')) {
+ for (const StringPiece& config_str : util::Tokenize(configs.value(), ',')) {
ConfigDescription config;
LocaleValue lv;
- if (lv.initFromFilterString(configStr)) {
- lv.writeTo(&config);
- } else if (!ConfigDescription::parse(configStr, &config)) {
- context.getDiagnostics()->error(DiagMessage() << "invalid config '"
- << configStr
+ if (lv.InitFromFilterString(config_str)) {
+ lv.WriteTo(&config);
+ } else if (!ConfigDescription::Parse(config_str, &config)) {
+ context.GetDiagnostics()->Error(DiagMessage() << "invalid config '"
+ << config_str
<< "' for -c option");
return 1;
}
if (config.density != 0) {
- context.getDiagnostics()->warn(DiagMessage() << "ignoring density '"
+ context.GetDiagnostics()->Warn(DiagMessage() << "ignoring density '"
<< config
<< "' for -c option");
} else {
- filter.addConfig(config);
+ filter.AddConfig(config);
}
}
- options.tableSplitterOptions.configFilter = &filter;
+ options.table_splitter_options.config_filter = &filter;
}
- if (preferredDensity) {
- ConfigDescription preferredDensityConfig;
- if (!ConfigDescription::parse(preferredDensity.value(),
- &preferredDensityConfig)) {
- context.getDiagnostics()->error(
- DiagMessage() << "invalid density '" << preferredDensity.value()
+ if (preferred_density) {
+ ConfigDescription preferred_density_config;
+ if (!ConfigDescription::Parse(preferred_density.value(),
+ &preferred_density_config)) {
+ context.GetDiagnostics()->Error(
+ DiagMessage() << "invalid density '" << preferred_density.value()
<< "' for --preferred-density option");
return 1;
}
// Clear the version that can be automatically added.
- preferredDensityConfig.sdkVersion = 0;
+ preferred_density_config.sdkVersion = 0;
- if (preferredDensityConfig.diff(ConfigDescription::defaultConfig()) !=
+ if (preferred_density_config.diff(ConfigDescription::DefaultConfig()) !=
ConfigDescription::CONFIG_DENSITY) {
- context.getDiagnostics()->error(
+ context.GetDiagnostics()->Error(
DiagMessage() << "invalid preferred density '"
- << preferredDensity.value() << "'. "
+ << preferred_density.value() << "'. "
<< "Preferred density must only be a density value");
return 1;
}
- options.tableSplitterOptions.preferredDensity =
- preferredDensityConfig.density;
+ options.table_splitter_options.preferred_density =
+ preferred_density_config.density;
}
- if (!options.staticLib && stableIdFilePath) {
- if (!loadStableIdMap(context.getDiagnostics(), stableIdFilePath.value(),
- &options.stableIdMap)) {
+ if (!options.static_lib && stable_id_file_path) {
+ if (!LoadStableIdMap(context.GetDiagnostics(), stable_id_file_path.value(),
+ &options.stable_id_map)) {
return 1;
}
}
// Populate some default no-compress extensions that are already compressed.
- options.extensionsToNotCompress.insert(
+ options.extensions_to_not_compress.insert(
{".jpg", ".jpeg", ".png", ".gif", ".wav", ".mp2", ".mp3", ".ogg",
".aac", ".mpg", ".mpeg", ".mid", ".midi", ".smf", ".jet", ".rtttl",
".imy", ".xmf", ".mp4", ".m4a", ".m4v", ".3gp", ".3gpp", ".3g2",
".3gpp2", ".amr", ".awb", ".wma", ".wmv", ".webm", ".mkv"});
// Parse the split parameters.
- for (const std::string& splitArg : splitArgs) {
- options.splitPaths.push_back({});
- options.splitConstraints.push_back({});
- if (!parseSplitParameter(splitArg, context.getDiagnostics(),
- &options.splitPaths.back(),
- &options.splitConstraints.back())) {
+ for (const std::string& split_arg : split_args) {
+ options.split_paths.push_back({});
+ options.split_constraints.push_back({});
+ if (!ParseSplitParameter(split_arg, context.GetDiagnostics(),
+ &options.split_paths.back(),
+ &options.split_constraints.back())) {
return 1;
}
}
// Turn off auto versioning for static-libs.
- if (options.staticLib) {
- options.noAutoVersion = true;
- options.noVersionVectors = true;
+ if (options.static_lib) {
+ options.no_auto_version = true;
+ options.no_version_vectors = true;
}
LinkCommand cmd(&context, options);
- return cmd.run(argList);
+ return cmd.Run(arg_list);
}
} // namespace aapt
diff --git a/tools/aapt2/link/Linkers.h b/tools/aapt2/link/Linkers.h
index f40c0e8..4687d2c 100644
--- a/tools/aapt2/link/Linkers.h
+++ b/tools/aapt2/link/Linkers.h
@@ -17,12 +17,15 @@
#ifndef AAPT_LINKER_LINKERS_H
#define AAPT_LINKER_LINKERS_H
+#include <set>
+#include <unordered_set>
+
+#include "android-base/macros.h"
+
#include "Resource.h"
#include "process/IResourceTableConsumer.h"
#include "xml/XmlDom.h"
-#include <set>
-
namespace aapt {
class ResourceTable;
@@ -31,8 +34,7 @@
/**
* Defines the location in which a value exists. This determines visibility of
- * other
- * package's private symbols.
+ * other package's private symbols.
*/
struct CallSite {
ResourceNameRef resource;
@@ -40,26 +42,30 @@
/**
* Determines whether a versioned resource should be created. If a versioned
- * resource already
- * exists, it takes precedence.
+ * resource already exists, it takes precedence.
*/
-bool shouldGenerateVersionedResource(const ResourceEntry* entry,
+bool ShouldGenerateVersionedResource(const ResourceEntry* entry,
const ConfigDescription& config,
- const int sdkVersionToGenerate);
+ const int sdk_version_to_generate);
class AutoVersioner : public IResourceTableConsumer {
public:
- bool consume(IAaptContext* context, ResourceTable* table) override;
-};
+ AutoVersioner() = default;
-class XmlAutoVersioner : public IXmlResourceConsumer {
- public:
- bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AutoVersioner);
};
class VersionCollapser : public IResourceTableConsumer {
public:
- bool consume(IAaptContext* context, ResourceTable* table) override;
+ VersionCollapser() = default;
+
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(VersionCollapser);
};
/**
@@ -67,7 +73,12 @@
*/
class ResourceDeduper : public IResourceTableConsumer {
public:
- bool consume(IAaptContext* context, ResourceTable* table) override;
+ ResourceDeduper() = default;
+
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ResourceDeduper);
};
/**
@@ -103,8 +114,46 @@
* conflict will never
* occur.
*/
-struct PrivateAttributeMover : public IResourceTableConsumer {
- bool consume(IAaptContext* context, ResourceTable* table) override;
+class PrivateAttributeMover : public IResourceTableConsumer {
+ public:
+ PrivateAttributeMover() = default;
+
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(PrivateAttributeMover);
+};
+
+class ResourceConfigValue;
+
+class ProductFilter : public IResourceTableConsumer {
+ public:
+ using ResourceConfigValueIter =
+ std::vector<std::unique_ptr<ResourceConfigValue>>::iterator;
+
+ explicit ProductFilter(std::unordered_set<std::string> products)
+ : products_(products) {}
+
+ ResourceConfigValueIter SelectProductToKeep(
+ const ResourceNameRef& name, const ResourceConfigValueIter begin,
+ const ResourceConfigValueIter end, IDiagnostics* diag);
+
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+ std::unordered_set<std::string> products_;
+
+ DISALLOW_COPY_AND_ASSIGN(ProductFilter);
+};
+
+class XmlAutoVersioner : public IXmlResourceConsumer {
+ public:
+ XmlAutoVersioner() = default;
+
+ bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlAutoVersioner);
};
/**
@@ -116,13 +165,16 @@
* XmlReferenceLinker.
*/
class XmlNamespaceRemover : public IXmlResourceConsumer {
- private:
- bool mKeepUris;
-
public:
- XmlNamespaceRemover(bool keepUris = false) : mKeepUris(keepUris){};
+ explicit XmlNamespaceRemover(bool keep_uris = false)
+ : keep_uris_(keep_uris){};
- bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+ bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlNamespaceRemover);
+
+ bool keep_uris_;
};
/**
@@ -131,18 +183,22 @@
* Once an XmlResource is processed by this linker, it is ready to be flattened.
*/
class XmlReferenceLinker : public IXmlResourceConsumer {
- private:
- std::set<int> mSdkLevelsFound;
-
public:
- bool consume(IAaptContext* context, xml::XmlResource* resource) override;
+ XmlReferenceLinker() = default;
+
+ bool Consume(IAaptContext* context, xml::XmlResource* resource) override;
/**
* Once the XmlResource has been consumed, this returns the various SDK levels
* in which
* framework attributes used within the XML document were defined.
*/
- inline const std::set<int>& getSdkLevels() const { return mSdkLevelsFound; }
+ inline const std::set<int>& sdk_levels() const { return sdk_levels_found_; }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlReferenceLinker);
+
+ std::set<int> sdk_levels_found_;
};
} // namespace aapt
diff --git a/tools/aapt2/link/ManifestFixer.cpp b/tools/aapt2/link/ManifestFixer.cpp
index 3c9298b..a418fc8 100644
--- a/tools/aapt2/link/ManifestFixer.cpp
+++ b/tools/aapt2/link/ManifestFixer.cpp
@@ -15,32 +15,36 @@
*/
#include "link/ManifestFixer.h"
+
+#include <unordered_set>
+
+#include "android-base/logging.h"
+
#include "ResourceUtils.h"
#include "util/Util.h"
#include "xml/XmlActionExecutor.h"
#include "xml/XmlDom.h"
-#include <unordered_set>
-
namespace aapt {
/**
* This is how PackageManager builds class names from AndroidManifest.xml
* entries.
*/
-static bool nameIsJavaClassName(xml::Element* el, xml::Attribute* attr,
+static bool NameIsJavaClassName(xml::Element* el, xml::Attribute* attr,
SourcePathDiagnostics* diag) {
// We allow unqualified class names (ie: .HelloActivity)
// Since we don't know the package name, we can just make a fake one here and
// the test will be identical as long as the real package name is valid too.
- Maybe<std::string> fullyQualifiedClassName =
- util::getFullyQualifiedClassName("a", attr->value);
+ Maybe<std::string> fully_qualified_class_name =
+ util::GetFullyQualifiedClassName("a", attr->value);
- StringPiece qualifiedClassName =
- fullyQualifiedClassName ? fullyQualifiedClassName.value() : attr->value;
+ StringPiece qualified_class_name = fully_qualified_class_name
+ ? fully_qualified_class_name.value()
+ : attr->value;
- if (!util::isJavaClassName(qualifiedClassName)) {
- diag->error(DiagMessage(el->lineNumber)
+ if (!util::IsJavaClassName(qualified_class_name)) {
+ diag->Error(DiagMessage(el->line_number)
<< "attribute 'android:name' in <" << el->name
<< "> tag must be a valid Java class name");
return false;
@@ -48,37 +52,37 @@
return true;
}
-static bool optionalNameIsJavaClassName(xml::Element* el,
+static bool OptionalNameIsJavaClassName(xml::Element* el,
SourcePathDiagnostics* diag) {
- if (xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "name")) {
- return nameIsJavaClassName(el, attr, diag);
+ if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name")) {
+ return NameIsJavaClassName(el, attr, diag);
}
return true;
}
-static bool requiredNameIsJavaClassName(xml::Element* el,
+static bool RequiredNameIsJavaClassName(xml::Element* el,
SourcePathDiagnostics* diag) {
- if (xml::Attribute* attr = el->findAttribute(xml::kSchemaAndroid, "name")) {
- return nameIsJavaClassName(el, attr, diag);
+ if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name")) {
+ return NameIsJavaClassName(el, attr, diag);
}
- diag->error(DiagMessage(el->lineNumber)
+ diag->Error(DiagMessage(el->line_number)
<< "<" << el->name << "> is missing attribute 'android:name'");
return false;
}
-static bool verifyManifest(xml::Element* el, SourcePathDiagnostics* diag) {
- xml::Attribute* attr = el->findAttribute({}, "package");
+static bool VerifyManifest(xml::Element* el, SourcePathDiagnostics* diag) {
+ xml::Attribute* attr = el->FindAttribute({}, "package");
if (!attr) {
- diag->error(DiagMessage(el->lineNumber)
+ diag->Error(DiagMessage(el->line_number)
<< "<manifest> tag is missing 'package' attribute");
return false;
- } else if (ResourceUtils::isReference(attr->value)) {
- diag->error(
- DiagMessage(el->lineNumber)
+ } else if (ResourceUtils::IsReference(attr->value)) {
+ diag->Error(
+ DiagMessage(el->line_number)
<< "attribute 'package' in <manifest> tag must not be a reference");
return false;
- } else if (!util::isJavaPackageName(attr->value)) {
- diag->error(DiagMessage(el->lineNumber)
+ } else if (!util::IsJavaPackageName(attr->value)) {
+ diag->Error(DiagMessage(el->line_number)
<< "attribute 'package' in <manifest> tag is not a valid Java "
"package name: '"
<< attr->value << "'");
@@ -89,242 +93,243 @@
/**
* The coreApp attribute in <manifest> is not a regular AAPT attribute, so type
- * checking on it
- * is manual.
+ * checking on it is manual.
*/
-static bool fixCoreAppAttribute(xml::Element* el, SourcePathDiagnostics* diag) {
- if (xml::Attribute* attr = el->findAttribute("", "coreApp")) {
+static bool FixCoreAppAttribute(xml::Element* el, SourcePathDiagnostics* diag) {
+ if (xml::Attribute* attr = el->FindAttribute("", "coreApp")) {
std::unique_ptr<BinaryPrimitive> result =
- ResourceUtils::tryParseBool(attr->value);
+ ResourceUtils::TryParseBool(attr->value);
if (!result) {
- diag->error(DiagMessage(el->lineNumber)
+ diag->Error(DiagMessage(el->line_number)
<< "attribute coreApp must be a boolean");
return false;
}
- attr->compiledValue = std::move(result);
+ attr->compiled_value = std::move(result);
}
return true;
}
-bool ManifestFixer::buildRules(xml::XmlActionExecutor* executor,
+bool ManifestFixer::BuildRules(xml::XmlActionExecutor* executor,
IDiagnostics* diag) {
// First verify some options.
- if (mOptions.renameManifestPackage) {
- if (!util::isJavaPackageName(mOptions.renameManifestPackage.value())) {
- diag->error(DiagMessage() << "invalid manifest package override '"
- << mOptions.renameManifestPackage.value()
+ if (options_.rename_manifest_package) {
+ if (!util::IsJavaPackageName(options_.rename_manifest_package.value())) {
+ diag->Error(DiagMessage() << "invalid manifest package override '"
+ << options_.rename_manifest_package.value()
<< "'");
return false;
}
}
- if (mOptions.renameInstrumentationTargetPackage) {
- if (!util::isJavaPackageName(
- mOptions.renameInstrumentationTargetPackage.value())) {
- diag->error(DiagMessage()
+ if (options_.rename_instrumentation_target_package) {
+ if (!util::IsJavaPackageName(
+ options_.rename_instrumentation_target_package.value())) {
+ diag->Error(DiagMessage()
<< "invalid instrumentation target package override '"
- << mOptions.renameInstrumentationTargetPackage.value()
+ << options_.rename_instrumentation_target_package.value()
<< "'");
return false;
}
}
// Common intent-filter actions.
- xml::XmlNodeAction intentFilterAction;
- intentFilterAction["action"];
- intentFilterAction["category"];
- intentFilterAction["data"];
+ xml::XmlNodeAction intent_filter_action;
+ intent_filter_action["action"];
+ intent_filter_action["category"];
+ intent_filter_action["data"];
// Common meta-data actions.
- xml::XmlNodeAction metaDataAction;
+ xml::XmlNodeAction meta_data_action;
// Manifest actions.
- xml::XmlNodeAction& manifestAction = (*executor)["manifest"];
- manifestAction.action(verifyManifest);
- manifestAction.action(fixCoreAppAttribute);
- manifestAction.action([&](xml::Element* el) -> bool {
- if (mOptions.versionNameDefault) {
- if (el->findAttribute(xml::kSchemaAndroid, "versionName") == nullptr) {
+ xml::XmlNodeAction& manifest_action = (*executor)["manifest"];
+ manifest_action.Action(VerifyManifest);
+ manifest_action.Action(FixCoreAppAttribute);
+ manifest_action.Action([&](xml::Element* el) -> bool {
+ if (options_.version_name_default) {
+ if (el->FindAttribute(xml::kSchemaAndroid, "versionName") == nullptr) {
el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "versionName",
- mOptions.versionNameDefault.value()});
+ options_.version_name_default.value()});
}
}
- if (mOptions.versionCodeDefault) {
- if (el->findAttribute(xml::kSchemaAndroid, "versionCode") == nullptr) {
+ if (options_.version_code_default) {
+ if (el->FindAttribute(xml::kSchemaAndroid, "versionCode") == nullptr) {
el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "versionCode",
- mOptions.versionCodeDefault.value()});
+ options_.version_code_default.value()});
}
}
return true;
});
// Meta tags.
- manifestAction["eat-comment"];
+ manifest_action["eat-comment"];
// Uses-sdk actions.
- manifestAction["uses-sdk"].action([&](xml::Element* el) -> bool {
- if (mOptions.minSdkVersionDefault &&
- el->findAttribute(xml::kSchemaAndroid, "minSdkVersion") == nullptr) {
+ manifest_action["uses-sdk"].Action([&](xml::Element* el) -> bool {
+ if (options_.min_sdk_version_default &&
+ el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion") == nullptr) {
// There was no minSdkVersion defined and we have a default to assign.
el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "minSdkVersion",
- mOptions.minSdkVersionDefault.value()});
+ options_.min_sdk_version_default.value()});
}
- if (mOptions.targetSdkVersionDefault &&
- el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion") == nullptr) {
+ if (options_.target_sdk_version_default &&
+ el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion") == nullptr) {
// There was no targetSdkVersion defined and we have a default to assign.
el->attributes.push_back(
xml::Attribute{xml::kSchemaAndroid, "targetSdkVersion",
- mOptions.targetSdkVersionDefault.value()});
+ options_.target_sdk_version_default.value()});
}
return true;
});
// Instrumentation actions.
- manifestAction["instrumentation"].action([&](xml::Element* el) -> bool {
- if (!mOptions.renameInstrumentationTargetPackage) {
+ manifest_action["instrumentation"].Action([&](xml::Element* el) -> bool {
+ if (!options_.rename_instrumentation_target_package) {
return true;
}
if (xml::Attribute* attr =
- el->findAttribute(xml::kSchemaAndroid, "targetPackage")) {
- attr->value = mOptions.renameInstrumentationTargetPackage.value();
+ el->FindAttribute(xml::kSchemaAndroid, "targetPackage")) {
+ attr->value = options_.rename_instrumentation_target_package.value();
}
return true;
});
- manifestAction["original-package"];
- manifestAction["protected-broadcast"];
- manifestAction["uses-permission"];
- manifestAction["permission"];
- manifestAction["permission-tree"];
- manifestAction["permission-group"];
+ manifest_action["original-package"];
+ manifest_action["protected-broadcast"];
+ manifest_action["uses-permission"];
+ manifest_action["permission"];
+ manifest_action["permission-tree"];
+ manifest_action["permission-group"];
- manifestAction["uses-configuration"];
- manifestAction["uses-feature"];
- manifestAction["supports-screens"];
+ manifest_action["uses-configuration"];
+ manifest_action["uses-feature"];
+ manifest_action["supports-screens"];
- manifestAction["compatible-screens"];
- manifestAction["compatible-screens"]["screen"];
+ manifest_action["compatible-screens"];
+ manifest_action["compatible-screens"]["screen"];
- manifestAction["supports-gl-texture"];
+ manifest_action["supports-gl-texture"];
// Application actions.
- xml::XmlNodeAction& applicationAction = manifestAction["application"];
- applicationAction.action(optionalNameIsJavaClassName);
+ xml::XmlNodeAction& application_action = manifest_action["application"];
+ application_action.Action(OptionalNameIsJavaClassName);
// Uses library actions.
- applicationAction["uses-library"];
+ application_action["uses-library"];
// Meta-data.
- applicationAction["meta-data"] = metaDataAction;
+ application_action["meta-data"] = meta_data_action;
// Activity actions.
- applicationAction["activity"].action(requiredNameIsJavaClassName);
- applicationAction["activity"]["intent-filter"] = intentFilterAction;
- applicationAction["activity"]["meta-data"] = metaDataAction;
+ application_action["activity"].Action(RequiredNameIsJavaClassName);
+ application_action["activity"]["intent-filter"] = intent_filter_action;
+ application_action["activity"]["meta-data"] = meta_data_action;
// Activity alias actions.
- applicationAction["activity-alias"]["intent-filter"] = intentFilterAction;
- applicationAction["activity-alias"]["meta-data"] = metaDataAction;
+ application_action["activity-alias"]["intent-filter"] = intent_filter_action;
+ application_action["activity-alias"]["meta-data"] = meta_data_action;
// Service actions.
- applicationAction["service"].action(requiredNameIsJavaClassName);
- applicationAction["service"]["intent-filter"] = intentFilterAction;
- applicationAction["service"]["meta-data"] = metaDataAction;
+ application_action["service"].Action(RequiredNameIsJavaClassName);
+ application_action["service"]["intent-filter"] = intent_filter_action;
+ application_action["service"]["meta-data"] = meta_data_action;
// Receiver actions.
- applicationAction["receiver"].action(requiredNameIsJavaClassName);
- applicationAction["receiver"]["intent-filter"] = intentFilterAction;
- applicationAction["receiver"]["meta-data"] = metaDataAction;
+ application_action["receiver"].Action(RequiredNameIsJavaClassName);
+ application_action["receiver"]["intent-filter"] = intent_filter_action;
+ application_action["receiver"]["meta-data"] = meta_data_action;
// Provider actions.
- applicationAction["provider"].action(requiredNameIsJavaClassName);
- applicationAction["provider"]["intent-filter"] = intentFilterAction;
- applicationAction["provider"]["meta-data"] = metaDataAction;
- applicationAction["provider"]["grant-uri-permissions"];
- applicationAction["provider"]["path-permissions"];
+ application_action["provider"].Action(RequiredNameIsJavaClassName);
+ application_action["provider"]["intent-filter"] = intent_filter_action;
+ application_action["provider"]["meta-data"] = meta_data_action;
+ application_action["provider"]["grant-uri-permissions"];
+ application_action["provider"]["path-permissions"];
return true;
}
class FullyQualifiedClassNameVisitor : public xml::Visitor {
public:
- using xml::Visitor::visit;
+ using xml::Visitor::Visit;
explicit FullyQualifiedClassNameVisitor(const StringPiece& package)
- : mPackage(package) {}
+ : package_(package) {}
- void visit(xml::Element* el) override {
+ void Visit(xml::Element* el) override {
for (xml::Attribute& attr : el->attributes) {
- if (attr.namespaceUri == xml::kSchemaAndroid &&
- mClassAttributes.find(attr.name) != mClassAttributes.end()) {
- if (Maybe<std::string> newValue =
- util::getFullyQualifiedClassName(mPackage, attr.value)) {
- attr.value = std::move(newValue.value());
+ if (attr.namespace_uri == xml::kSchemaAndroid &&
+ class_attributes_.find(attr.name) != class_attributes_.end()) {
+ if (Maybe<std::string> new_value =
+ util::GetFullyQualifiedClassName(package_, attr.value)) {
+ attr.value = std::move(new_value.value());
}
}
}
// Super implementation to iterate over the children.
- xml::Visitor::visit(el);
+ xml::Visitor::Visit(el);
}
private:
- StringPiece mPackage;
- std::unordered_set<StringPiece> mClassAttributes = {"name"};
+ StringPiece package_;
+ std::unordered_set<StringPiece> class_attributes_ = {"name"};
};
-static bool renameManifestPackage(const StringPiece& packageOverride,
- xml::Element* manifestEl) {
- xml::Attribute* attr = manifestEl->findAttribute({}, "package");
+static bool RenameManifestPackage(const StringPiece& package_override,
+ xml::Element* manifest_el) {
+ xml::Attribute* attr = manifest_el->FindAttribute({}, "package");
// We've already verified that the manifest element is present, with a package
// name specified.
- assert(attr);
+ CHECK(attr != nullptr);
- std::string originalPackage = std::move(attr->value);
- attr->value = packageOverride.toString();
+ std::string original_package = std::move(attr->value);
+ attr->value = package_override.ToString();
- FullyQualifiedClassNameVisitor visitor(originalPackage);
- manifestEl->accept(&visitor);
+ FullyQualifiedClassNameVisitor visitor(original_package);
+ manifest_el->Accept(&visitor);
return true;
}
-bool ManifestFixer::consume(IAaptContext* context, xml::XmlResource* doc) {
- xml::Element* root = xml::findRootElement(doc->root.get());
- if (!root || !root->namespaceUri.empty() || root->name != "manifest") {
- context->getDiagnostics()->error(DiagMessage(doc->file.source)
+bool ManifestFixer::Consume(IAaptContext* context, xml::XmlResource* doc) {
+ xml::Element* root = xml::FindRootElement(doc->root.get());
+ if (!root || !root->namespace_uri.empty() || root->name != "manifest") {
+ context->GetDiagnostics()->Error(DiagMessage(doc->file.source)
<< "root tag must be <manifest>");
return false;
}
- if ((mOptions.minSdkVersionDefault || mOptions.targetSdkVersionDefault) &&
- root->findChild({}, "uses-sdk") == nullptr) {
+ if ((options_.min_sdk_version_default ||
+ options_.target_sdk_version_default) &&
+ root->FindChild({}, "uses-sdk") == nullptr) {
// Auto insert a <uses-sdk> element.
- std::unique_ptr<xml::Element> usesSdk = util::make_unique<xml::Element>();
- usesSdk->name = "uses-sdk";
- root->addChild(std::move(usesSdk));
+ std::unique_ptr<xml::Element> uses_sdk = util::make_unique<xml::Element>();
+ uses_sdk->name = "uses-sdk";
+ root->AddChild(std::move(uses_sdk));
}
xml::XmlActionExecutor executor;
- if (!buildRules(&executor, context->getDiagnostics())) {
+ if (!BuildRules(&executor, context->GetDiagnostics())) {
return false;
}
- if (!executor.execute(xml::XmlActionExecutorPolicy::Whitelist,
- context->getDiagnostics(), doc)) {
+ if (!executor.Execute(xml::XmlActionExecutorPolicy::kWhitelist,
+ context->GetDiagnostics(), doc)) {
return false;
}
- if (mOptions.renameManifestPackage) {
+ if (options_.rename_manifest_package) {
// Rename manifest package outside of the XmlActionExecutor.
// We need to extract the old package name and FullyQualify all class names.
- if (!renameManifestPackage(mOptions.renameManifestPackage.value(), root)) {
+ if (!RenameManifestPackage(options_.rename_manifest_package.value(),
+ root)) {
return false;
}
}
diff --git a/tools/aapt2/link/ManifestFixer.h b/tools/aapt2/link/ManifestFixer.h
index c3a114b..470f65e 100644
--- a/tools/aapt2/link/ManifestFixer.h
+++ b/tools/aapt2/link/ManifestFixer.h
@@ -17,22 +17,24 @@
#ifndef AAPT_LINK_MANIFESTFIXER_H
#define AAPT_LINK_MANIFESTFIXER_H
+#include <string>
+
+#include "android-base/macros.h"
+
#include "process/IResourceTableConsumer.h"
#include "util/Maybe.h"
#include "xml/XmlActionExecutor.h"
#include "xml/XmlDom.h"
-#include <string>
-
namespace aapt {
struct ManifestFixerOptions {
- Maybe<std::string> minSdkVersionDefault;
- Maybe<std::string> targetSdkVersionDefault;
- Maybe<std::string> renameManifestPackage;
- Maybe<std::string> renameInstrumentationTargetPackage;
- Maybe<std::string> versionNameDefault;
- Maybe<std::string> versionCodeDefault;
+ Maybe<std::string> min_sdk_version_default;
+ Maybe<std::string> target_sdk_version_default;
+ Maybe<std::string> rename_manifest_package;
+ Maybe<std::string> rename_instrumentation_target_package;
+ Maybe<std::string> version_name_default;
+ Maybe<std::string> version_code_default;
};
/**
@@ -42,14 +44,16 @@
class ManifestFixer : public IXmlResourceConsumer {
public:
explicit ManifestFixer(const ManifestFixerOptions& options)
- : mOptions(options) {}
+ : options_(options) {}
- bool consume(IAaptContext* context, xml::XmlResource* doc) override;
+ bool Consume(IAaptContext* context, xml::XmlResource* doc) override;
private:
- bool buildRules(xml::XmlActionExecutor* executor, IDiagnostics* diag);
+ DISALLOW_COPY_AND_ASSIGN(ManifestFixer);
- ManifestFixerOptions mOptions;
+ bool BuildRules(xml::XmlActionExecutor* executor, IDiagnostics* diag);
+
+ ManifestFixerOptions options_;
};
} // namespace aapt
diff --git a/tools/aapt2/link/ManifestFixer_test.cpp b/tools/aapt2/link/ManifestFixer_test.cpp
index dc78d98..0e29ba6 100644
--- a/tools/aapt2/link/ManifestFixer_test.cpp
+++ b/tools/aapt2/link/ManifestFixer_test.cpp
@@ -15,10 +15,8 @@
*/
#include "link/ManifestFixer.h"
-#include "test/Builders.h"
-#include "test/Context.h"
-#include <gtest/gtest.h>
+#include "test/Test.h"
namespace aapt {
@@ -28,42 +26,42 @@
void SetUp() override {
mContext =
test::ContextBuilder()
- .setCompilationPackage("android")
- .setPackageId(0x01)
- .setNameManglerPolicy(NameManglerPolicy{"android"})
- .addSymbolSource(
+ .SetCompilationPackage("android")
+ .SetPackageId(0x01)
+ .SetNameManglerPolicy(NameManglerPolicy{"android"})
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addSymbol(
+ .AddSymbol(
"android:attr/package", ResourceId(0x01010000),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_STRING)
- .build())
- .addSymbol(
+ .SetTypeMask(android::ResTable_map::TYPE_STRING)
+ .Build())
+ .AddSymbol(
"android:attr/minSdkVersion", ResourceId(0x01010001),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_STRING |
+ .SetTypeMask(android::ResTable_map::TYPE_STRING |
android::ResTable_map::TYPE_INTEGER)
- .build())
- .addSymbol(
+ .Build())
+ .AddSymbol(
"android:attr/targetSdkVersion", ResourceId(0x01010002),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_STRING |
+ .SetTypeMask(android::ResTable_map::TYPE_STRING |
android::ResTable_map::TYPE_INTEGER)
- .build())
- .addSymbol("android:string/str", ResourceId(0x01060000))
- .build())
- .build();
+ .Build())
+ .AddSymbol("android:string/str", ResourceId(0x01060000))
+ .Build())
+ .Build();
}
- std::unique_ptr<xml::XmlResource> verify(const StringPiece& str) {
- return verifyWithOptions(str, {});
+ std::unique_ptr<xml::XmlResource> Verify(const StringPiece& str) {
+ return VerifyWithOptions(str, {});
}
- std::unique_ptr<xml::XmlResource> verifyWithOptions(
+ std::unique_ptr<xml::XmlResource> VerifyWithOptions(
const StringPiece& str, const ManifestFixerOptions& options) {
- std::unique_ptr<xml::XmlResource> doc = test::buildXmlDom(str);
+ std::unique_ptr<xml::XmlResource> doc = test::BuildXmlDom(str);
ManifestFixer fixer(options);
- if (fixer.consume(mContext.get(), doc.get())) {
+ if (fixer.Consume(mContext.get(), doc.get())) {
return doc;
}
return {};
@@ -71,28 +69,28 @@
};
TEST_F(ManifestFixerTest, EnsureManifestIsRootTag) {
- EXPECT_EQ(nullptr, verify("<other-tag />"));
- EXPECT_EQ(nullptr, verify("<ns:manifest xmlns:ns=\"com\" />"));
- EXPECT_NE(nullptr, verify("<manifest package=\"android\"></manifest>"));
+ EXPECT_EQ(nullptr, Verify("<other-tag />"));
+ EXPECT_EQ(nullptr, Verify("<ns:manifest xmlns:ns=\"com\" />"));
+ EXPECT_NE(nullptr, Verify("<manifest package=\"android\"></manifest>"));
}
TEST_F(ManifestFixerTest, EnsureManifestHasPackage) {
- EXPECT_NE(nullptr, verify("<manifest package=\"android\" />"));
- EXPECT_NE(nullptr, verify("<manifest package=\"com.android\" />"));
- EXPECT_NE(nullptr, verify("<manifest package=\"com.android.google\" />"));
+ EXPECT_NE(nullptr, Verify("<manifest package=\"android\" />"));
+ EXPECT_NE(nullptr, Verify("<manifest package=\"com.android\" />"));
+ EXPECT_NE(nullptr, Verify("<manifest package=\"com.android.google\" />"));
EXPECT_EQ(nullptr,
- verify("<manifest package=\"com.android.google.Class$1\" />"));
- EXPECT_EQ(nullptr, verify("<manifest "
+ Verify("<manifest package=\"com.android.google.Class$1\" />"));
+ EXPECT_EQ(nullptr, Verify("<manifest "
"xmlns:android=\"http://schemas.android.com/apk/"
"res/android\" "
"android:package=\"com.android\" />"));
- EXPECT_EQ(nullptr, verify("<manifest package=\"@string/str\" />"));
+ EXPECT_EQ(nullptr, Verify("<manifest package=\"@string/str\" />"));
}
TEST_F(ManifestFixerTest, UseDefaultSdkVersionsIfNonePresent) {
ManifestFixerOptions options = {std::string("8"), std::string("22")};
- std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android">
<uses-sdk android:minSdkVersion="7" android:targetSdkVersion="21" />
@@ -103,18 +101,18 @@
xml::Element* el;
xml::Attribute* attr;
- el = xml::findRootElement(doc.get());
+ el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
- el = el->findChild({}, "uses-sdk");
+ el = el->FindChild({}, "uses-sdk");
ASSERT_NE(nullptr, el);
- attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("7", attr->value);
- attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("21", attr->value);
- doc = verifyWithOptions(R"EOF(
+ doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android">
<uses-sdk android:targetSdkVersion="21" />
@@ -122,18 +120,18 @@
options);
ASSERT_NE(nullptr, doc);
- el = xml::findRootElement(doc.get());
+ el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
- el = el->findChild({}, "uses-sdk");
+ el = el->FindChild({}, "uses-sdk");
ASSERT_NE(nullptr, el);
- attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("8", attr->value);
- attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("21", attr->value);
- doc = verifyWithOptions(R"EOF(
+ doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android">
<uses-sdk />
@@ -141,40 +139,40 @@
options);
ASSERT_NE(nullptr, doc);
- el = xml::findRootElement(doc.get());
+ el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
- el = el->findChild({}, "uses-sdk");
+ el = el->FindChild({}, "uses-sdk");
ASSERT_NE(nullptr, el);
- attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("8", attr->value);
- attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("22", attr->value);
- doc = verifyWithOptions(R"EOF(
+ doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android" />)EOF",
options);
ASSERT_NE(nullptr, doc);
- el = xml::findRootElement(doc.get());
+ el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
- el = el->findChild({}, "uses-sdk");
+ el = el->FindChild({}, "uses-sdk");
ASSERT_NE(nullptr, el);
- attr = el->findAttribute(xml::kSchemaAndroid, "minSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("8", attr->value);
- attr = el->findAttribute(xml::kSchemaAndroid, "targetSdkVersion");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion");
ASSERT_NE(nullptr, attr);
EXPECT_EQ("22", attr->value);
}
TEST_F(ManifestFixerTest, RenameManifestPackageAndFullyQualifyClasses) {
ManifestFixerOptions options;
- options.renameManifestPackage = std::string("com.android");
+ options.rename_manifest_package = std::string("com.android");
- std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android">
<application android:name=".MainApplication" text="hello">
@@ -185,38 +183,38 @@
options);
ASSERT_NE(nullptr, doc);
- xml::Element* manifestEl = xml::findRootElement(doc.get());
+ xml::Element* manifestEl = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, manifestEl);
xml::Attribute* attr = nullptr;
- attr = manifestEl->findAttribute({}, "package");
+ attr = manifestEl->FindAttribute({}, "package");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(std::string("com.android"), attr->value);
- xml::Element* applicationEl = manifestEl->findChild({}, "application");
+ xml::Element* applicationEl = manifestEl->FindChild({}, "application");
ASSERT_NE(nullptr, applicationEl);
- attr = applicationEl->findAttribute(xml::kSchemaAndroid, "name");
+ attr = applicationEl->FindAttribute(xml::kSchemaAndroid, "name");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(std::string("android.MainApplication"), attr->value);
- attr = applicationEl->findAttribute({}, "text");
+ attr = applicationEl->FindAttribute({}, "text");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(std::string("hello"), attr->value);
xml::Element* el;
- el = applicationEl->findChild({}, "activity");
+ el = applicationEl->FindChild({}, "activity");
ASSERT_NE(nullptr, el);
- attr = el->findAttribute(xml::kSchemaAndroid, "name");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "name");
ASSERT_NE(nullptr, el);
EXPECT_EQ(std::string("android.activity.Start"), attr->value);
- el = applicationEl->findChild({}, "receiver");
+ el = applicationEl->FindChild({}, "receiver");
ASSERT_NE(nullptr, el);
- attr = el->findAttribute(xml::kSchemaAndroid, "name");
+ attr = el->FindAttribute(xml::kSchemaAndroid, "name");
ASSERT_NE(nullptr, el);
EXPECT_EQ(std::string("com.google.android.Receiver"), attr->value);
}
@@ -224,9 +222,9 @@
TEST_F(ManifestFixerTest,
RenameManifestInstrumentationPackageAndFullyQualifyTarget) {
ManifestFixerOptions options;
- options.renameInstrumentationTargetPackage = std::string("com.android");
+ options.rename_instrumentation_target_package = std::string("com.android");
- std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android">
<instrumentation android:targetPackage="android" />
@@ -234,63 +232,63 @@
options);
ASSERT_NE(nullptr, doc);
- xml::Element* manifestEl = xml::findRootElement(doc.get());
- ASSERT_NE(nullptr, manifestEl);
+ xml::Element* manifest_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(nullptr, manifest_el);
- xml::Element* instrumentationEl =
- manifestEl->findChild({}, "instrumentation");
- ASSERT_NE(nullptr, instrumentationEl);
+ xml::Element* instrumentation_el =
+ manifest_el->FindChild({}, "instrumentation");
+ ASSERT_NE(nullptr, instrumentation_el);
xml::Attribute* attr =
- instrumentationEl->findAttribute(xml::kSchemaAndroid, "targetPackage");
+ instrumentation_el->FindAttribute(xml::kSchemaAndroid, "targetPackage");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(std::string("com.android"), attr->value);
}
TEST_F(ManifestFixerTest, UseDefaultVersionNameAndCode) {
ManifestFixerOptions options;
- options.versionNameDefault = std::string("Beta");
- options.versionCodeDefault = std::string("0x10000000");
+ options.version_name_default = std::string("Beta");
+ options.version_code_default = std::string("0x10000000");
- std::unique_ptr<xml::XmlResource> doc = verifyWithOptions(R"EOF(
+ std::unique_ptr<xml::XmlResource> doc = VerifyWithOptions(R"EOF(
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="android" />)EOF",
options);
ASSERT_NE(nullptr, doc);
- xml::Element* manifestEl = xml::findRootElement(doc.get());
- ASSERT_NE(nullptr, manifestEl);
+ xml::Element* manifest_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(nullptr, manifest_el);
xml::Attribute* attr =
- manifestEl->findAttribute(xml::kSchemaAndroid, "versionName");
+ manifest_el->FindAttribute(xml::kSchemaAndroid, "versionName");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(std::string("Beta"), attr->value);
- attr = manifestEl->findAttribute(xml::kSchemaAndroid, "versionCode");
+ attr = manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode");
ASSERT_NE(nullptr, attr);
EXPECT_EQ(std::string("0x10000000"), attr->value);
}
TEST_F(ManifestFixerTest, EnsureManifestAttributesAreTyped) {
EXPECT_EQ(nullptr,
- verify("<manifest package=\"android\" coreApp=\"hello\" />"));
+ Verify("<manifest package=\"android\" coreApp=\"hello\" />"));
EXPECT_EQ(nullptr,
- verify("<manifest package=\"android\" coreApp=\"1dp\" />"));
+ Verify("<manifest package=\"android\" coreApp=\"1dp\" />"));
std::unique_ptr<xml::XmlResource> doc =
- verify("<manifest package=\"android\" coreApp=\"true\" />");
+ Verify("<manifest package=\"android\" coreApp=\"true\" />");
ASSERT_NE(nullptr, doc);
- xml::Element* el = xml::findRootElement(doc.get());
+ xml::Element* el = xml::FindRootElement(doc.get());
ASSERT_NE(nullptr, el);
EXPECT_EQ("manifest", el->name);
- xml::Attribute* attr = el->findAttribute("", "coreApp");
+ xml::Attribute* attr = el->FindAttribute("", "coreApp");
ASSERT_NE(nullptr, attr);
- EXPECT_NE(nullptr, attr->compiledValue);
- EXPECT_NE(nullptr, valueCast<BinaryPrimitive>(attr->compiledValue.get()));
+ EXPECT_NE(nullptr, attr->compiled_value);
+ EXPECT_NE(nullptr, ValueCast<BinaryPrimitive>(attr->compiled_value.get()));
}
} // namespace aapt
diff --git a/tools/aapt2/link/PrivateAttributeMover.cpp b/tools/aapt2/link/PrivateAttributeMover.cpp
index 174b41f..cc07a6e 100644
--- a/tools/aapt2/link/PrivateAttributeMover.cpp
+++ b/tools/aapt2/link/PrivateAttributeMover.cpp
@@ -14,27 +14,30 @@
* limitations under the License.
*/
-#include "ResourceTable.h"
#include "link/Linkers.h"
#include <algorithm>
#include <iterator>
+#include "android-base/logging.h"
+
+#include "ResourceTable.h"
+
namespace aapt {
template <typename InputContainer, typename OutputIterator, typename Predicate>
-OutputIterator moveIf(InputContainer& inputContainer, OutputIterator result,
- Predicate pred) {
- const auto last = inputContainer.end();
- auto newEnd =
- std::find_if(inputContainer.begin(), inputContainer.end(), pred);
- if (newEnd == last) {
+OutputIterator move_if(InputContainer& input_container, OutputIterator result,
+ Predicate pred) {
+ const auto last = input_container.end();
+ auto new_end =
+ std::find_if(input_container.begin(), input_container.end(), pred);
+ if (new_end == last) {
return result;
}
- *result = std::move(*newEnd);
+ *result = std::move(*new_end);
- auto first = newEnd;
+ auto first = new_end;
++first;
for (; first != last; ++first) {
@@ -44,39 +47,38 @@
++result;
} else {
// We want to keep this guy, but we will need to move it up the list to
- // replace
- // missing items.
- *newEnd = std::move(*first);
- ++newEnd;
+ // replace missing items.
+ *new_end = std::move(*first);
+ ++new_end;
}
}
- inputContainer.erase(newEnd, last);
+ input_container.erase(new_end, last);
return result;
}
-bool PrivateAttributeMover::consume(IAaptContext* context,
+bool PrivateAttributeMover::Consume(IAaptContext* context,
ResourceTable* table) {
for (auto& package : table->packages) {
- ResourceTableType* type = package->findType(ResourceType::kAttr);
+ ResourceTableType* type = package->FindType(ResourceType::kAttr);
if (!type) {
continue;
}
- if (type->symbolStatus.state != SymbolState::kPublic) {
+ if (type->symbol_status.state != SymbolState::kPublic) {
// No public attributes, so we can safely leave these private attributes
// where they are.
return true;
}
- ResourceTableType* privAttrType =
- package->findOrCreateType(ResourceType::kAttrPrivate);
- assert(privAttrType->entries.empty());
+ ResourceTableType* priv_attr_type =
+ package->FindOrCreateType(ResourceType::kAttrPrivate);
+ CHECK(priv_attr_type->entries.empty());
- moveIf(type->entries, std::back_inserter(privAttrType->entries),
- [](const std::unique_ptr<ResourceEntry>& entry) -> bool {
- return entry->symbolStatus.state != SymbolState::kPublic;
- });
+ move_if(type->entries, std::back_inserter(priv_attr_type->entries),
+ [](const std::unique_ptr<ResourceEntry>& entry) -> bool {
+ return entry->symbol_status.state != SymbolState::kPublic;
+ });
break;
}
return true;
diff --git a/tools/aapt2/link/PrivateAttributeMover_test.cpp b/tools/aapt2/link/PrivateAttributeMover_test.cpp
index a7a1013..90c4922 100644
--- a/tools/aapt2/link/PrivateAttributeMover_test.cpp
+++ b/tools/aapt2/link/PrivateAttributeMover_test.cpp
@@ -15,64 +15,65 @@
*/
#include "link/Linkers.h"
+
#include "test/Test.h"
namespace aapt {
TEST(PrivateAttributeMoverTest, MovePrivateAttributes) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addSimple("android:attr/publicA")
- .addSimple("android:attr/privateA")
- .addSimple("android:attr/publicB")
- .addSimple("android:attr/privateB")
- .setSymbolState("android:attr/publicA", ResourceId(0x01010000),
+ .AddSimple("android:attr/publicA")
+ .AddSimple("android:attr/privateA")
+ .AddSimple("android:attr/publicB")
+ .AddSimple("android:attr/privateB")
+ .SetSymbolState("android:attr/publicA", ResourceId(0x01010000),
SymbolState::kPublic)
- .setSymbolState("android:attr/publicB", ResourceId(0x01010000),
+ .SetSymbolState("android:attr/publicB", ResourceId(0x01010000),
SymbolState::kPublic)
- .build();
+ .Build();
PrivateAttributeMover mover;
- ASSERT_TRUE(mover.consume(context.get(), table.get()));
+ ASSERT_TRUE(mover.Consume(context.get(), table.get()));
- ResourceTablePackage* package = table->findPackage("android");
+ ResourceTablePackage* package = table->FindPackage("android");
ASSERT_NE(package, nullptr);
- ResourceTableType* type = package->findType(ResourceType::kAttr);
+ ResourceTableType* type = package->FindType(ResourceType::kAttr);
ASSERT_NE(type, nullptr);
ASSERT_EQ(type->entries.size(), 2u);
- EXPECT_NE(type->findEntry("publicA"), nullptr);
- EXPECT_NE(type->findEntry("publicB"), nullptr);
+ EXPECT_NE(type->FindEntry("publicA"), nullptr);
+ EXPECT_NE(type->FindEntry("publicB"), nullptr);
- type = package->findType(ResourceType::kAttrPrivate);
+ type = package->FindType(ResourceType::kAttrPrivate);
ASSERT_NE(type, nullptr);
ASSERT_EQ(type->entries.size(), 2u);
- EXPECT_NE(type->findEntry("privateA"), nullptr);
- EXPECT_NE(type->findEntry("privateB"), nullptr);
+ EXPECT_NE(type->FindEntry("privateA"), nullptr);
+ EXPECT_NE(type->FindEntry("privateB"), nullptr);
}
TEST(PrivateAttributeMoverTest,
LeavePrivateAttributesWhenNoPublicAttributesDefined) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addSimple("android:attr/privateA")
- .addSimple("android:attr/privateB")
- .build();
+ .AddSimple("android:attr/privateA")
+ .AddSimple("android:attr/privateB")
+ .Build();
PrivateAttributeMover mover;
- ASSERT_TRUE(mover.consume(context.get(), table.get()));
+ ASSERT_TRUE(mover.Consume(context.get(), table.get()));
- ResourceTablePackage* package = table->findPackage("android");
+ ResourceTablePackage* package = table->FindPackage("android");
ASSERT_NE(package, nullptr);
- ResourceTableType* type = package->findType(ResourceType::kAttr);
+ ResourceTableType* type = package->FindType(ResourceType::kAttr);
ASSERT_NE(type, nullptr);
ASSERT_EQ(type->entries.size(), 2u);
- type = package->findType(ResourceType::kAttrPrivate);
+ type = package->FindType(ResourceType::kAttrPrivate);
ASSERT_EQ(type, nullptr);
}
diff --git a/tools/aapt2/link/ProductFilter.cpp b/tools/aapt2/link/ProductFilter.cpp
index d59b682..c1a95ee 100644
--- a/tools/aapt2/link/ProductFilter.cpp
+++ b/tools/aapt2/link/ProductFilter.cpp
@@ -14,103 +14,106 @@
* limitations under the License.
*/
-#include "link/ProductFilter.h"
+#include "link/Linkers.h"
+
+#include "ResourceTable.h"
namespace aapt {
-ProductFilter::ResourceConfigValueIter ProductFilter::selectProductToKeep(
+ProductFilter::ResourceConfigValueIter ProductFilter::SelectProductToKeep(
const ResourceNameRef& name, const ResourceConfigValueIter begin,
const ResourceConfigValueIter end, IDiagnostics* diag) {
- ResourceConfigValueIter defaultProductIter = end;
- ResourceConfigValueIter selectedProductIter = end;
+ ResourceConfigValueIter default_product_iter = end;
+ ResourceConfigValueIter selected_product_iter = end;
for (ResourceConfigValueIter iter = begin; iter != end; ++iter) {
- ResourceConfigValue* configValue = iter->get();
- if (mProducts.find(configValue->product) != mProducts.end()) {
- if (selectedProductIter != end) {
+ ResourceConfigValue* config_value = iter->get();
+ if (products_.find(config_value->product) != products_.end()) {
+ if (selected_product_iter != end) {
// We have two possible values for this product!
- diag->error(DiagMessage(configValue->value->getSource())
- << "selection of product '" << configValue->product
+ diag->Error(DiagMessage(config_value->value->GetSource())
+ << "selection of product '" << config_value->product
<< "' for resource " << name << " is ambiguous");
- ResourceConfigValue* previouslySelectedConfigValue =
- selectedProductIter->get();
- diag->note(
- DiagMessage(previouslySelectedConfigValue->value->getSource())
- << "product '" << previouslySelectedConfigValue->product
+ ResourceConfigValue* previously_selected_config_value =
+ selected_product_iter->get();
+ diag->Note(
+ DiagMessage(previously_selected_config_value->value->GetSource())
+ << "product '" << previously_selected_config_value->product
<< "' is also a candidate");
return end;
}
// Select this product.
- selectedProductIter = iter;
+ selected_product_iter = iter;
}
- if (configValue->product.empty() || configValue->product == "default") {
- if (defaultProductIter != end) {
+ if (config_value->product.empty() || config_value->product == "default") {
+ if (default_product_iter != end) {
// We have two possible default values.
- diag->error(DiagMessage(configValue->value->getSource())
+ diag->Error(DiagMessage(config_value->value->GetSource())
<< "multiple default products defined for resource "
<< name);
- ResourceConfigValue* previouslyDefaultConfigValue =
- defaultProductIter->get();
- diag->note(DiagMessage(previouslyDefaultConfigValue->value->getSource())
- << "default product also defined here");
+ ResourceConfigValue* previously_default_config_value =
+ default_product_iter->get();
+ diag->Note(
+ DiagMessage(previously_default_config_value->value->GetSource())
+ << "default product also defined here");
return end;
}
// Mark the default.
- defaultProductIter = iter;
+ default_product_iter = iter;
}
}
- if (defaultProductIter == end) {
- diag->error(DiagMessage() << "no default product defined for resource "
+ if (default_product_iter == end) {
+ diag->Error(DiagMessage() << "no default product defined for resource "
<< name);
return end;
}
- if (selectedProductIter == end) {
- selectedProductIter = defaultProductIter;
+ if (selected_product_iter == end) {
+ selected_product_iter = default_product_iter;
}
- return selectedProductIter;
+ return selected_product_iter;
}
-bool ProductFilter::consume(IAaptContext* context, ResourceTable* table) {
+bool ProductFilter::Consume(IAaptContext* context, ResourceTable* table) {
bool error = false;
for (auto& pkg : table->packages) {
for (auto& type : pkg->types) {
for (auto& entry : type->entries) {
- std::vector<std::unique_ptr<ResourceConfigValue>> newValues;
+ std::vector<std::unique_ptr<ResourceConfigValue>> new_values;
ResourceConfigValueIter iter = entry->values.begin();
- ResourceConfigValueIter startRangeIter = iter;
+ ResourceConfigValueIter start_range_iter = iter;
while (iter != entry->values.end()) {
++iter;
if (iter == entry->values.end() ||
- (*iter)->config != (*startRangeIter)->config) {
+ (*iter)->config != (*start_range_iter)->config) {
// End of the array, or we saw a different config,
// so this must be the end of a range of products.
// Select the product to keep from the set of products defined.
ResourceNameRef name(pkg->name, type->type, entry->name);
- auto valueToKeep = selectProductToKeep(name, startRangeIter, iter,
- context->getDiagnostics());
- if (valueToKeep == iter) {
+ auto value_to_keep = SelectProductToKeep(
+ name, start_range_iter, iter, context->GetDiagnostics());
+ if (value_to_keep == iter) {
// An error occurred, we could not pick a product.
error = true;
} else {
// We selected a product to keep. Move it to the new array.
- newValues.push_back(std::move(*valueToKeep));
+ new_values.push_back(std::move(*value_to_keep));
}
// Start the next range of products.
- startRangeIter = iter;
+ start_range_iter = iter;
}
}
// Now move the new values in to place.
- entry->values = std::move(newValues);
+ entry->values = std::move(new_values);
}
}
}
diff --git a/tools/aapt2/link/ProductFilter.h b/tools/aapt2/link/ProductFilter.h
deleted file mode 100644
index cc8b8c2..0000000
--- a/tools/aapt2/link/ProductFilter.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2016 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_LINK_PRODUCTFILTER_H
-#define AAPT_LINK_PRODUCTFILTER_H
-
-#include "ResourceTable.h"
-#include "process/IResourceTableConsumer.h"
-
-#include <android-base/macros.h>
-#include <unordered_set>
-
-namespace aapt {
-
-class ProductFilter {
- public:
- using ResourceConfigValueIter =
- std::vector<std::unique_ptr<ResourceConfigValue>>::iterator;
-
- explicit ProductFilter(std::unordered_set<std::string> products)
- : mProducts(products) {}
-
- ResourceConfigValueIter selectProductToKeep(
- const ResourceNameRef& name, const ResourceConfigValueIter begin,
- const ResourceConfigValueIter end, IDiagnostics* diag);
-
- bool consume(IAaptContext* context, ResourceTable* table);
-
- private:
- std::unordered_set<std::string> mProducts;
-
- DISALLOW_COPY_AND_ASSIGN(ProductFilter);
-};
-
-} // namespace aapt
-
-#endif /* AAPT_LINK_PRODUCTFILTER_H */
diff --git a/tools/aapt2/link/ProductFilter_test.cpp b/tools/aapt2/link/ProductFilter_test.cpp
index 7f78f8b..379ad26 100644
--- a/tools/aapt2/link/ProductFilter_test.cpp
+++ b/tools/aapt2/link/ProductFilter_test.cpp
@@ -14,116 +14,117 @@
* limitations under the License.
*/
-#include "link/ProductFilter.h"
+#include "link/Linkers.h"
+
#include "test/Test.h"
namespace aapt {
TEST(ProductFilterTest, SelectTwoProducts) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
- const ConfigDescription land = test::parseConfigOrDie("land");
- const ConfigDescription port = test::parseConfigOrDie("port");
+ const ConfigDescription land = test::ParseConfigOrDie("land");
+ const ConfigDescription port = test::ParseConfigOrDie("port");
ResourceTable table;
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"), land, "",
- test::ValueBuilder<Id>().setSource(Source("land/default.xml")).build(),
- context->getDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"), land, "tablet",
- test::ValueBuilder<Id>().setSource(Source("land/tablet.xml")).build(),
- context->getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"), land, "",
+ test::ValueBuilder<Id>().SetSource(Source("land/default.xml")).Build(),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"), land, "tablet",
+ test::ValueBuilder<Id>().SetSource(Source("land/tablet.xml")).Build(),
+ context->GetDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"), port, "",
- test::ValueBuilder<Id>().setSource(Source("port/default.xml")).build(),
- context->getDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"), port, "tablet",
- test::ValueBuilder<Id>().setSource(Source("port/tablet.xml")).build(),
- context->getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"), port, "",
+ test::ValueBuilder<Id>().SetSource(Source("port/default.xml")).Build(),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"), port, "tablet",
+ test::ValueBuilder<Id>().SetSource(Source("port/tablet.xml")).Build(),
+ context->GetDiagnostics()));
ProductFilter filter({"tablet"});
- ASSERT_TRUE(filter.consume(context.get(), &table));
+ ASSERT_TRUE(filter.Consume(context.get(), &table));
- EXPECT_EQ(nullptr, test::getValueForConfigAndProduct<Id>(
+ EXPECT_EQ(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/one", land, ""));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/one", land, "tablet"));
- EXPECT_EQ(nullptr, test::getValueForConfigAndProduct<Id>(
+ EXPECT_EQ(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/one", port, ""));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/one", port, "tablet"));
}
TEST(ProductFilterTest, SelectDefaultProduct) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
ResourceTable table;
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "",
- test::ValueBuilder<Id>().setSource(Source("default.xml")).build(),
- context->getDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "tablet",
- test::ValueBuilder<Id>().setSource(Source("tablet.xml")).build(),
- context->getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "",
+ test::ValueBuilder<Id>().SetSource(Source("default.xml")).Build(),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "tablet",
+ test::ValueBuilder<Id>().SetSource(Source("tablet.xml")).Build(),
+ context->GetDiagnostics()));
ProductFilter filter({});
- ASSERT_TRUE(filter.consume(context.get(), &table));
+ ASSERT_TRUE(filter.Consume(context.get(), &table));
- EXPECT_NE(nullptr, test::getValueForConfigAndProduct<Id>(
+ EXPECT_NE(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/one",
- ConfigDescription::defaultConfig(), ""));
- EXPECT_EQ(nullptr, test::getValueForConfigAndProduct<Id>(
+ ConfigDescription::DefaultConfig(), ""));
+ EXPECT_EQ(nullptr, test::GetValueForConfigAndProduct<Id>(
&table, "android:string/one",
- ConfigDescription::defaultConfig(), "tablet"));
+ ConfigDescription::DefaultConfig(), "tablet"));
}
TEST(ProductFilterTest, FailOnAmbiguousProduct) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
ResourceTable table;
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "",
- test::ValueBuilder<Id>().setSource(Source("default.xml")).build(),
- context->getDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "tablet",
- test::ValueBuilder<Id>().setSource(Source("tablet.xml")).build(),
- context->getDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "no-sdcard",
- test::ValueBuilder<Id>().setSource(Source("no-sdcard.xml")).build(),
- context->getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "",
+ test::ValueBuilder<Id>().SetSource(Source("default.xml")).Build(),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "tablet",
+ test::ValueBuilder<Id>().SetSource(Source("tablet.xml")).Build(),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "no-sdcard",
+ test::ValueBuilder<Id>().SetSource(Source("no-sdcard.xml")).Build(),
+ context->GetDiagnostics()));
ProductFilter filter({"tablet", "no-sdcard"});
- ASSERT_FALSE(filter.consume(context.get(), &table));
+ ASSERT_FALSE(filter.Consume(context.get(), &table));
}
TEST(ProductFilterTest, FailOnMultipleDefaults) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
ResourceTable table;
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "",
- test::ValueBuilder<Id>().setSource(Source(".xml")).build(),
- context->getDiagnostics()));
- ASSERT_TRUE(table.addResource(
- test::parseNameOrDie("android:string/one"),
- ConfigDescription::defaultConfig(), "default",
- test::ValueBuilder<Id>().setSource(Source("default.xml")).build(),
- context->getDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "",
+ test::ValueBuilder<Id>().SetSource(Source(".xml")).Build(),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(
+ test::ParseNameOrDie("android:string/one"),
+ ConfigDescription::DefaultConfig(), "default",
+ test::ValueBuilder<Id>().SetSource(Source("default.xml")).Build(),
+ context->GetDiagnostics()));
ProductFilter filter({});
- ASSERT_FALSE(filter.consume(context.get(), &table));
+ ASSERT_FALSE(filter.Consume(context.get(), &table));
}
} // namespace aapt
diff --git a/tools/aapt2/link/ReferenceLinker.cpp b/tools/aapt2/link/ReferenceLinker.cpp
index 7fe0956..be787b2 100644
--- a/tools/aapt2/link/ReferenceLinker.cpp
+++ b/tools/aapt2/link/ReferenceLinker.cpp
@@ -14,7 +14,11 @@
* limitations under the License.
*/
-#include "ReferenceLinker.h"
+#include "link/ReferenceLinker.h"
+
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
#include "Diagnostics.h"
#include "ResourceTable.h"
#include "ResourceUtils.h"
@@ -26,9 +30,6 @@
#include "util/Util.h"
#include "xml/XmlUtil.h"
-#include <androidfw/ResourceTypes.h>
-#include <cassert>
-
namespace aapt {
namespace {
@@ -46,21 +47,21 @@
*/
class ReferenceLinkerVisitor : public ValueVisitor {
public:
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
ReferenceLinkerVisitor(IAaptContext* context, SymbolTable* symbols,
- StringPool* stringPool, xml::IPackageDeclStack* decl,
- CallSite* callSite)
- : mContext(context),
- mSymbols(symbols),
- mPackageDecls(decl),
- mStringPool(stringPool),
- mCallSite(callSite) {}
+ StringPool* string_pool, xml::IPackageDeclStack* decl,
+ CallSite* callsite)
+ : context_(context),
+ symbols_(symbols),
+ package_decls_(decl),
+ string_pool_(string_pool),
+ callsite_(callsite) {}
- void visit(Reference* ref) override {
- if (!ReferenceLinker::linkReference(ref, mContext, mSymbols, mPackageDecls,
- mCallSite)) {
- mError = true;
+ void Visit(Reference* ref) override {
+ if (!ReferenceLinker::LinkReference(ref, context_, symbols_, package_decls_,
+ callsite_)) {
+ error_ = true;
}
}
@@ -72,13 +73,13 @@
* lookup the attributes to find out which types are allowed for the
* attributes' values.
*/
- void visit(Style* style) override {
+ void Visit(Style* style) override {
if (style->parent) {
- visit(&style->parent.value());
+ Visit(&style->parent.value());
}
for (Style::Entry& entry : style->entries) {
- std::string errStr;
+ std::string err_str;
// Transform the attribute reference so that it is using the fully
// qualified package
@@ -86,17 +87,17 @@
// resources if
// there was a '*' in the reference or if the package came from the
// private namespace.
- Reference transformedReference = entry.key;
- transformReferenceFromNamespace(mPackageDecls,
- mContext->getCompilationPackage(),
- &transformedReference);
+ Reference transformed_reference = entry.key;
+ TransformReferenceFromNamespace(package_decls_,
+ context_->GetCompilationPackage(),
+ &transformed_reference);
// Find the attribute in the symbol table and check if it is visible from
// this callsite.
const SymbolTable::Symbol* symbol =
- ReferenceLinker::resolveAttributeCheckVisibility(
- transformedReference, mContext->getNameMangler(), mSymbols,
- mCallSite, &errStr);
+ ReferenceLinker::ResolveAttributeCheckVisibility(
+ transformed_reference, context_->GetNameMangler(), symbols_,
+ callsite_, &err_str);
if (symbol) {
// Assign our style key the correct ID.
// The ID may not exist.
@@ -104,11 +105,11 @@
// Try to convert the value to a more specific, typed value based on the
// attribute it is set to.
- entry.value = parseValueWithAttribute(std::move(entry.value),
+ entry.value = ParseValueWithAttribute(std::move(entry.value),
symbol->attribute.get());
// Link/resolve the final value (mostly if it's a reference).
- entry.value->accept(this);
+ entry.value->Accept(this);
// Now verify that the type of this item is compatible with the
// attribute it
@@ -116,39 +117,34 @@
// check is
// fast and we avoid creating a DiagMessage when the match is
// successful.
- if (!symbol->attribute->matches(entry.value.get(), nullptr)) {
+ if (!symbol->attribute->Matches(entry.value.get(), nullptr)) {
// The actual type of this item is incompatible with the attribute.
- DiagMessage msg(entry.key.getSource());
+ DiagMessage msg(entry.key.GetSource());
// Call the matches method again, this time with a DiagMessage so we
// fill
// in the actual error message.
- symbol->attribute->matches(entry.value.get(), &msg);
- mContext->getDiagnostics()->error(msg);
- mError = true;
+ symbol->attribute->Matches(entry.value.get(), &msg);
+ context_->GetDiagnostics()->Error(msg);
+ error_ = true;
}
} else {
- DiagMessage msg(entry.key.getSource());
+ DiagMessage msg(entry.key.GetSource());
msg << "style attribute '";
- ReferenceLinker::writeResourceName(&msg, entry.key,
- transformedReference);
- msg << "' " << errStr;
- mContext->getDiagnostics()->error(msg);
- mError = true;
+ ReferenceLinker::WriteResourceName(&msg, entry.key,
+ transformed_reference);
+ msg << "' " << err_str;
+ context_->GetDiagnostics()->Error(msg);
+ error_ = true;
}
}
}
- bool hasError() { return mError; }
+ bool HasError() { return error_; }
private:
- IAaptContext* mContext;
- SymbolTable* mSymbols;
- xml::IPackageDeclStack* mPackageDecls;
- StringPool* mStringPool;
- CallSite* mCallSite;
- bool mError = false;
+ DISALLOW_COPY_AND_ASSIGN(ReferenceLinkerVisitor);
/**
* Transform a RawString value into a more specific, appropriate value, based
@@ -156,20 +152,20 @@
* Attribute. If a non RawString value is passed in, this is an identity
* transform.
*/
- std::unique_ptr<Item> parseValueWithAttribute(std::unique_ptr<Item> value,
+ std::unique_ptr<Item> ParseValueWithAttribute(std::unique_ptr<Item> value,
const Attribute* attr) {
- if (RawString* rawString = valueCast<RawString>(value.get())) {
+ if (RawString* raw_string = ValueCast<RawString>(value.get())) {
std::unique_ptr<Item> transformed =
- ResourceUtils::tryParseItemForAttribute(*rawString->value, attr);
+ ResourceUtils::TryParseItemForAttribute(*raw_string->value, attr);
// If we could not parse as any specific type, try a basic STRING.
if (!transformed &&
- (attr->typeMask & android::ResTable_map::TYPE_STRING)) {
- util::StringBuilder stringBuilder;
- stringBuilder.append(*rawString->value);
- if (stringBuilder) {
+ (attr->type_mask & android::ResTable_map::TYPE_STRING)) {
+ util::StringBuilder string_builder;
+ string_builder.Append(*raw_string->value);
+ if (string_builder) {
transformed = util::make_unique<String>(
- mStringPool->makeRef(stringBuilder.str()));
+ string_pool_->MakeRef(string_builder.ToString()));
}
}
@@ -179,6 +175,31 @@
};
return value;
}
+
+ IAaptContext* context_;
+ SymbolTable* symbols_;
+ xml::IPackageDeclStack* package_decls_;
+ StringPool* string_pool_;
+ CallSite* callsite_;
+ bool error_ = false;
+};
+
+class EmptyDeclStack : public xml::IPackageDeclStack {
+ public:
+ EmptyDeclStack() = default;
+
+ Maybe<xml::ExtractedPackage> TransformPackageAlias(
+ const StringPiece& alias,
+ const StringPiece& local_package) const override {
+ if (alias.empty()) {
+ return xml::ExtractedPackage{local_package.ToString(),
+ true /* private */};
+ }
+ return {};
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(EmptyDeclStack);
};
} // namespace
@@ -188,14 +209,14 @@
* requesting private access
* or if the callsite comes from the same package.
*/
-bool ReferenceLinker::isSymbolVisible(const SymbolTable::Symbol& symbol,
+bool ReferenceLinker::IsSymbolVisible(const SymbolTable::Symbol& symbol,
const Reference& ref,
- const CallSite& callSite) {
- if (!symbol.isPublic && !ref.privateReference) {
+ const CallSite& callsite) {
+ if (!symbol.is_public && !ref.private_reference) {
if (ref.name) {
- return callSite.resource.package == ref.name.value().package;
+ return callsite.resource.package == ref.name.value().package;
} else if (ref.id && symbol.id) {
- return ref.id.value().packageId() == symbol.id.value().packageId();
+ return ref.id.value().package_id() == symbol.id.value().package_id();
} else {
return false;
}
@@ -203,160 +224,144 @@
return true;
}
-const SymbolTable::Symbol* ReferenceLinker::resolveSymbol(
+const SymbolTable::Symbol* ReferenceLinker::ResolveSymbol(
const Reference& reference, NameMangler* mangler, SymbolTable* symbols) {
if (reference.name) {
- Maybe<ResourceName> mangled = mangler->mangleName(reference.name.value());
- return symbols->findByName(mangled ? mangled.value()
+ Maybe<ResourceName> mangled = mangler->MangleName(reference.name.value());
+ return symbols->FindByName(mangled ? mangled.value()
: reference.name.value());
} else if (reference.id) {
- return symbols->findById(reference.id.value());
+ return symbols->FindById(reference.id.value());
} else {
return nullptr;
}
}
-const SymbolTable::Symbol* ReferenceLinker::resolveSymbolCheckVisibility(
- const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
- CallSite* callSite, std::string* outError) {
+const SymbolTable::Symbol* ReferenceLinker::ResolveSymbolCheckVisibility(
+ const Reference& reference, NameMangler* name_mangler, SymbolTable* symbols,
+ CallSite* callsite, std::string* out_error) {
const SymbolTable::Symbol* symbol =
- resolveSymbol(reference, nameMangler, symbols);
+ ResolveSymbol(reference, name_mangler, symbols);
if (!symbol) {
- if (outError) *outError = "not found";
+ if (out_error) *out_error = "not found";
return nullptr;
}
- if (!isSymbolVisible(*symbol, reference, *callSite)) {
- if (outError) *outError = "is private";
+ if (!IsSymbolVisible(*symbol, reference, *callsite)) {
+ if (out_error) *out_error = "is private";
return nullptr;
}
return symbol;
}
-const SymbolTable::Symbol* ReferenceLinker::resolveAttributeCheckVisibility(
- const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
- CallSite* callSite, std::string* outError) {
- const SymbolTable::Symbol* symbol = resolveSymbolCheckVisibility(
- reference, nameMangler, symbols, callSite, outError);
+const SymbolTable::Symbol* ReferenceLinker::ResolveAttributeCheckVisibility(
+ const Reference& reference, NameMangler* name_mangler, SymbolTable* symbols,
+ CallSite* callsite, std::string* out_error) {
+ const SymbolTable::Symbol* symbol = ResolveSymbolCheckVisibility(
+ reference, name_mangler, symbols, callsite, out_error);
if (!symbol) {
return nullptr;
}
if (!symbol->attribute) {
- if (outError) *outError = "is not an attribute";
+ if (out_error) *out_error = "is not an attribute";
return nullptr;
}
return symbol;
}
-Maybe<xml::AaptAttribute> ReferenceLinker::compileXmlAttribute(
- const Reference& reference, NameMangler* nameMangler, SymbolTable* symbols,
- CallSite* callSite, std::string* outError) {
+Maybe<xml::AaptAttribute> ReferenceLinker::CompileXmlAttribute(
+ const Reference& reference, NameMangler* name_mangler, SymbolTable* symbols,
+ CallSite* callsite, std::string* out_error) {
const SymbolTable::Symbol* symbol =
- resolveSymbol(reference, nameMangler, symbols);
+ ResolveSymbol(reference, name_mangler, symbols);
if (!symbol) {
- if (outError) *outError = "not found";
+ if (out_error) *out_error = "not found";
return {};
}
if (!symbol->attribute) {
- if (outError) *outError = "is not an attribute";
+ if (out_error) *out_error = "is not an attribute";
return {};
}
return xml::AaptAttribute{symbol->id, *symbol->attribute};
}
-void ReferenceLinker::writeResourceName(DiagMessage* outMsg,
+void ReferenceLinker::WriteResourceName(DiagMessage* out_msg,
const Reference& orig,
const Reference& transformed) {
- assert(outMsg);
+ CHECK(out_msg != nullptr);
if (orig.name) {
- *outMsg << orig.name.value();
+ *out_msg << orig.name.value();
if (transformed.name.value() != orig.name.value()) {
- *outMsg << " (aka " << transformed.name.value() << ")";
+ *out_msg << " (aka " << transformed.name.value() << ")";
}
} else {
- *outMsg << orig.id.value();
+ *out_msg << orig.id.value();
}
}
-bool ReferenceLinker::linkReference(Reference* reference, IAaptContext* context,
+bool ReferenceLinker::LinkReference(Reference* reference, IAaptContext* context,
SymbolTable* symbols,
xml::IPackageDeclStack* decls,
- CallSite* callSite) {
- assert(reference);
- assert(reference->name || reference->id);
+ CallSite* callsite) {
+ CHECK(reference != nullptr);
+ CHECK(reference->name || reference->id);
- Reference transformedReference = *reference;
- transformReferenceFromNamespace(decls, context->getCompilationPackage(),
- &transformedReference);
+ Reference transformed_reference = *reference;
+ TransformReferenceFromNamespace(decls, context->GetCompilationPackage(),
+ &transformed_reference);
- std::string errStr;
- const SymbolTable::Symbol* s = resolveSymbolCheckVisibility(
- transformedReference, context->getNameMangler(), symbols, callSite,
- &errStr);
+ std::string err_str;
+ const SymbolTable::Symbol* s = ResolveSymbolCheckVisibility(
+ transformed_reference, context->GetNameMangler(), symbols, callsite,
+ &err_str);
if (s) {
// The ID may not exist. This is fine because of the possibility of building
- // against
- // libraries without assigned IDs.
+ // against libraries without assigned IDs.
// Ex: Linking against own resources when building a static library.
reference->id = s->id;
return true;
}
- DiagMessage errorMsg(reference->getSource());
- errorMsg << "resource ";
- writeResourceName(&errorMsg, *reference, transformedReference);
- errorMsg << " " << errStr;
- context->getDiagnostics()->error(errorMsg);
+ DiagMessage error_msg(reference->GetSource());
+ error_msg << "resource ";
+ WriteResourceName(&error_msg, *reference, transformed_reference);
+ error_msg << " " << err_str;
+ context->GetDiagnostics()->Error(error_msg);
return false;
}
-namespace {
-
-struct EmptyDeclStack : public xml::IPackageDeclStack {
- Maybe<xml::ExtractedPackage> transformPackageAlias(
- const StringPiece& alias,
- const StringPiece& localPackage) const override {
- if (alias.empty()) {
- return xml::ExtractedPackage{localPackage.toString(), true /* private */};
- }
- return {};
- }
-};
-
-} // namespace
-
-bool ReferenceLinker::consume(IAaptContext* context, ResourceTable* table) {
- EmptyDeclStack declStack;
+bool ReferenceLinker::Consume(IAaptContext* context, ResourceTable* table) {
+ EmptyDeclStack decl_stack;
bool error = false;
for (auto& package : table->packages) {
for (auto& type : package->types) {
for (auto& entry : type->entries) {
// Symbol state information may be lost if there is no value for the
// resource.
- if (entry->symbolStatus.state != SymbolState::kUndefined &&
+ if (entry->symbol_status.state != SymbolState::kUndefined &&
entry->values.empty()) {
- context->getDiagnostics()->error(
- DiagMessage(entry->symbolStatus.source)
+ context->GetDiagnostics()->Error(
+ DiagMessage(entry->symbol_status.source)
<< "no definition for declared symbol '"
<< ResourceNameRef(package->name, type->type, entry->name)
<< "'");
error = true;
}
- CallSite callSite = {
+ CallSite callsite = {
ResourceNameRef(package->name, type->type, entry->name)};
- ReferenceLinkerVisitor visitor(context, context->getExternalSymbols(),
- &table->stringPool, &declStack,
- &callSite);
+ ReferenceLinkerVisitor visitor(context, context->GetExternalSymbols(),
+ &table->string_pool, &decl_stack,
+ &callsite);
- for (auto& configValue : entry->values) {
- configValue->value->accept(&visitor);
+ for (auto& config_value : entry->values) {
+ config_value->value->Accept(&visitor);
}
- if (visitor.hasError()) {
+ if (visitor.HasError()) {
error = true;
}
}
diff --git a/tools/aapt2/link/ReferenceLinker.h b/tools/aapt2/link/ReferenceLinker.h
index 8f6604f..bdabf24 100644
--- a/tools/aapt2/link/ReferenceLinker.h
+++ b/tools/aapt2/link/ReferenceLinker.h
@@ -17,6 +17,8 @@
#ifndef AAPT_LINKER_REFERENCELINKER_H
#define AAPT_LINKER_REFERENCELINKER_H
+#include "android-base/macros.h"
+
#include "Resource.h"
#include "ResourceValues.h"
#include "ValueVisitor.h"
@@ -25,8 +27,6 @@
#include "process/SymbolTable.h"
#include "xml/XmlDom.h"
-#include <cassert>
-
namespace aapt {
/**
@@ -36,33 +36,33 @@
* Once the ResourceTable is processed by this linker, it is ready to be
* flattened.
*/
-struct ReferenceLinker : public IResourceTableConsumer {
+class ReferenceLinker : public IResourceTableConsumer {
+ public:
+ ReferenceLinker() = default;
+
/**
* Returns true if the symbol is visible by the reference and from the
* callsite.
*/
- static bool isSymbolVisible(const SymbolTable::Symbol& symbol,
- const Reference& ref, const CallSite& callSite);
+ static bool IsSymbolVisible(const SymbolTable::Symbol& symbol,
+ const Reference& ref, const CallSite& callsite);
/**
* Performs name mangling and looks up the resource in the symbol table.
- * Returns nullptr
- * if the symbol was not found.
+ * Returns nullptr if the symbol was not found.
*/
- static const SymbolTable::Symbol* resolveSymbol(const Reference& reference,
+ static const SymbolTable::Symbol* ResolveSymbol(const Reference& reference,
NameMangler* mangler,
SymbolTable* symbols);
/**
* Performs name mangling and looks up the resource in the symbol table. If
- * the symbol is
- * not visible by the reference at the callsite, nullptr is returned. outError
- * holds
- * the error message.
+ * the symbol is not visible by the reference at the callsite, nullptr is
+ * returned. out_error holds the error message.
*/
- static const SymbolTable::Symbol* resolveSymbolCheckVisibility(
- const Reference& reference, NameMangler* nameMangler,
- SymbolTable* symbols, CallSite* callSite, std::string* outError);
+ static const SymbolTable::Symbol* ResolveSymbolCheckVisibility(
+ const Reference& reference, NameMangler* name_mangler,
+ SymbolTable* symbols, CallSite* callsite, std::string* out_error);
/**
* Same as resolveSymbolCheckVisibility(), but also makes sure the symbol is
@@ -70,25 +70,24 @@
* That is, the return value will have a non-null value for
* ISymbolTable::Symbol::attribute.
*/
- static const SymbolTable::Symbol* resolveAttributeCheckVisibility(
- const Reference& reference, NameMangler* nameMangler,
- SymbolTable* symbols, CallSite* callSite, std::string* outError);
+ static const SymbolTable::Symbol* ResolveAttributeCheckVisibility(
+ const Reference& reference, NameMangler* name_mangler,
+ SymbolTable* symbols, CallSite* callsite, std::string* out_error);
/**
* Resolves the attribute reference and returns an xml::AaptAttribute if
* successful.
* If resolution fails, outError holds the error message.
*/
- static Maybe<xml::AaptAttribute> compileXmlAttribute(
- const Reference& reference, NameMangler* nameMangler,
- SymbolTable* symbols, CallSite* callSite, std::string* outError);
+ static Maybe<xml::AaptAttribute> CompileXmlAttribute(
+ const Reference& reference, NameMangler* name_mangler,
+ SymbolTable* symbols, CallSite* callsite, std::string* out_error);
/**
- * Writes the resource name to the DiagMessage, using the "orig_name (aka
- * <transformed_name>)"
- * syntax.
+ * Writes the resource name to the DiagMessage, using the
+ * "orig_name (aka <transformed_name>)" syntax.
*/
- static void writeResourceName(DiagMessage* outMsg, const Reference& orig,
+ static void WriteResourceName(DiagMessage* out_msg, const Reference& orig,
const Reference& transformed);
/**
@@ -100,14 +99,17 @@
* Returns false on failure, and an error message is logged to the
* IDiagnostics in the context.
*/
- static bool linkReference(Reference* reference, IAaptContext* context,
+ static bool LinkReference(Reference* reference, IAaptContext* context,
SymbolTable* symbols, xml::IPackageDeclStack* decls,
- CallSite* callSite);
+ CallSite* callsite);
/**
* Links all references in the ResourceTable.
*/
- bool consume(IAaptContext* context, ResourceTable* table) override;
+ bool Consume(IAaptContext* context, ResourceTable* table) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ReferenceLinker);
};
} // namespace aapt
diff --git a/tools/aapt2/link/ReferenceLinker_test.cpp b/tools/aapt2/link/ReferenceLinker_test.cpp
index 8aa3616..4ca36a9 100644
--- a/tools/aapt2/link/ReferenceLinker_test.cpp
+++ b/tools/aapt2/link/ReferenceLinker_test.cpp
@@ -15,6 +15,7 @@
*/
#include "link/ReferenceLinker.h"
+
#include "test/Test.h"
using android::ResTable_map;
@@ -24,46 +25,46 @@
TEST(ReferenceLinkerTest, LinkSimpleReferences) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addReference("com.app.test:string/foo", ResourceId(0x7f020000),
+ .SetPackageId("com.app.test", 0x7f)
+ .AddReference("com.app.test:string/foo", ResourceId(0x7f020000),
"com.app.test:string/bar")
// Test use of local reference (w/o package name).
- .addReference("com.app.test:string/bar", ResourceId(0x7f020001),
+ .AddReference("com.app.test:string/bar", ResourceId(0x7f020001),
"string/baz")
- .addReference("com.app.test:string/baz", ResourceId(0x7f020002),
+ .AddReference("com.app.test:string/baz", ResourceId(0x7f020002),
"android:string/ok")
- .build();
+ .Build();
std::unique_ptr<IAaptContext> context =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
- .addSymbolSource(
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+ .AddSymbolSource(
util::make_unique<ResourceTableSymbolSource>(table.get()))
- .addSymbolSource(
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addPublicSymbol("android:string/ok", ResourceId(0x01040034))
- .build())
- .build();
+ .AddPublicSymbol("android:string/ok", ResourceId(0x01040034))
+ .Build())
+ .Build();
ReferenceLinker linker;
- ASSERT_TRUE(linker.consume(context.get(), table.get()));
+ ASSERT_TRUE(linker.Consume(context.get(), table.get()));
Reference* ref =
- test::getValue<Reference>(table.get(), "com.app.test:string/foo");
+ test::GetValue<Reference>(table.get(), "com.app.test:string/foo");
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f020001));
- ref = test::getValue<Reference>(table.get(), "com.app.test:string/bar");
+ ref = test::GetValue<Reference>(table.get(), "com.app.test:string/bar");
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f020002));
- ref = test::getValue<Reference>(table.get(), "com.app.test:string/baz");
+ ref = test::GetValue<Reference>(table.get(), "com.app.test:string/baz");
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x01040034));
@@ -72,53 +73,53 @@
TEST(ReferenceLinkerTest, LinkStyleAttributes) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addValue("com.app.test:style/Theme",
+ .SetPackageId("com.app.test", 0x7f)
+ .AddValue("com.app.test:style/Theme",
test::StyleBuilder()
- .setParent("android:style/Theme.Material")
- .addItem("android:attr/foo",
- ResourceUtils::tryParseColor("#ff00ff"))
- .addItem("android:attr/bar", {} /* placeholder */)
- .build())
- .build();
+ .SetParent("android:style/Theme.Material")
+ .AddItem("android:attr/foo",
+ ResourceUtils::TryParseColor("#ff00ff"))
+ .AddItem("android:attr/bar", {} /* placeholder */)
+ .Build())
+ .Build();
{
// We need to fill in the value for the attribute android:attr/bar after we
// build the
// table, because we need access to the string pool.
Style* style =
- test::getValue<Style>(table.get(), "com.app.test:style/Theme");
+ test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
ASSERT_NE(style, nullptr);
style->entries.back().value =
- util::make_unique<RawString>(table->stringPool.makeRef("one|two"));
+ util::make_unique<RawString>(table->string_pool.MakeRef("one|two"));
}
std::unique_ptr<IAaptContext> context =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
- .addSymbolSource(
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addPublicSymbol("android:style/Theme.Material",
+ .AddPublicSymbol("android:style/Theme.Material",
ResourceId(0x01060000))
- .addPublicSymbol("android:attr/foo", ResourceId(0x01010001),
+ .AddPublicSymbol("android:attr/foo", ResourceId(0x01010001),
test::AttributeBuilder()
- .setTypeMask(ResTable_map::TYPE_COLOR)
- .build())
- .addPublicSymbol("android:attr/bar", ResourceId(0x01010002),
+ .SetTypeMask(ResTable_map::TYPE_COLOR)
+ .Build())
+ .AddPublicSymbol("android:attr/bar", ResourceId(0x01010002),
test::AttributeBuilder()
- .setTypeMask(ResTable_map::TYPE_FLAGS)
- .addItem("one", 0x01)
- .addItem("two", 0x02)
- .build())
- .build())
- .build();
+ .SetTypeMask(ResTable_map::TYPE_FLAGS)
+ .AddItem("one", 0x01)
+ .AddItem("two", 0x02)
+ .Build())
+ .Build())
+ .Build();
ReferenceLinker linker;
- ASSERT_TRUE(linker.consume(context.get(), table.get()));
+ ASSERT_TRUE(linker.Consume(context.get(), table.get()));
- Style* style = test::getValue<Style>(table.get(), "com.app.test:style/Theme");
+ Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
ASSERT_NE(style, nullptr);
AAPT_ASSERT_TRUE(style->parent);
AAPT_ASSERT_TRUE(style->parent.value().id);
@@ -128,44 +129,44 @@
AAPT_ASSERT_TRUE(style->entries[0].key.id);
EXPECT_EQ(style->entries[0].key.id.value(), ResourceId(0x01010001));
- ASSERT_NE(valueCast<BinaryPrimitive>(style->entries[0].value.get()), nullptr);
+ ASSERT_NE(ValueCast<BinaryPrimitive>(style->entries[0].value.get()), nullptr);
AAPT_ASSERT_TRUE(style->entries[1].key.id);
EXPECT_EQ(style->entries[1].key.id.value(), ResourceId(0x01010002));
- ASSERT_NE(valueCast<BinaryPrimitive>(style->entries[1].value.get()), nullptr);
+ ASSERT_NE(ValueCast<BinaryPrimitive>(style->entries[1].value.get()), nullptr);
}
TEST(ReferenceLinkerTest, LinkMangledReferencesAndAttributes) {
std::unique_ptr<IAaptContext> context =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .setNameManglerPolicy(
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .SetNameManglerPolicy(
NameManglerPolicy{"com.app.test", {"com.android.support"}})
- .addSymbolSource(
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addPublicSymbol("com.app.test:attr/com.android.support$foo",
+ .AddPublicSymbol("com.app.test:attr/com.android.support$foo",
ResourceId(0x7f010000),
test::AttributeBuilder()
- .setTypeMask(ResTable_map::TYPE_COLOR)
- .build())
- .build())
- .build();
+ .SetTypeMask(ResTable_map::TYPE_COLOR)
+ .Build())
+ .Build())
+ .Build();
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addValue("com.app.test:style/Theme", ResourceId(0x7f020000),
+ .SetPackageId("com.app.test", 0x7f)
+ .AddValue("com.app.test:style/Theme", ResourceId(0x7f020000),
test::StyleBuilder()
- .addItem("com.android.support:attr/foo",
- ResourceUtils::tryParseColor("#ff0000"))
- .build())
- .build();
+ .AddItem("com.android.support:attr/foo",
+ ResourceUtils::TryParseColor("#ff0000"))
+ .Build())
+ .Build();
ReferenceLinker linker;
- ASSERT_TRUE(linker.consume(context.get(), table.get()));
+ ASSERT_TRUE(linker.Consume(context.get(), table.get()));
- Style* style = test::getValue<Style>(table.get(), "com.app.test:style/Theme");
+ Style* style = test::GetValue<Style>(table.get(), "com.app.test:style/Theme");
ASSERT_NE(style, nullptr);
ASSERT_EQ(1u, style->entries.size());
AAPT_ASSERT_TRUE(style->entries.front().key.id);
@@ -175,85 +176,85 @@
TEST(ReferenceLinkerTest, FailToLinkPrivateSymbols) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addReference("com.app.test:string/foo", ResourceId(0x7f020000),
+ .SetPackageId("com.app.test", 0x7f)
+ .AddReference("com.app.test:string/foo", ResourceId(0x7f020000),
"android:string/hidden")
- .build();
+ .Build();
std::unique_ptr<IAaptContext> context =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
- .addSymbolSource(
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+ .AddSymbolSource(
util::make_unique<ResourceTableSymbolSource>(table.get()))
- .addSymbolSource(
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addSymbol("android:string/hidden", ResourceId(0x01040034))
- .build())
- .build();
+ .AddSymbol("android:string/hidden", ResourceId(0x01040034))
+ .Build())
+ .Build();
ReferenceLinker linker;
- ASSERT_FALSE(linker.consume(context.get(), table.get()));
+ ASSERT_FALSE(linker.Consume(context.get(), table.get()));
}
TEST(ReferenceLinkerTest, FailToLinkPrivateMangledSymbols) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addReference("com.app.test:string/foo", ResourceId(0x7f020000),
+ .SetPackageId("com.app.test", 0x7f)
+ .AddReference("com.app.test:string/foo", ResourceId(0x7f020000),
"com.app.lib:string/hidden")
- .build();
+ .Build();
std::unique_ptr<IAaptContext> context =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .setNameManglerPolicy(
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .SetNameManglerPolicy(
NameManglerPolicy{"com.app.test", {"com.app.lib"}})
- .addSymbolSource(
+ .AddSymbolSource(
util::make_unique<ResourceTableSymbolSource>(table.get()))
- .addSymbolSource(
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addSymbol("com.app.test:string/com.app.lib$hidden",
+ .AddSymbol("com.app.test:string/com.app.lib$hidden",
ResourceId(0x7f040034))
- .build())
+ .Build())
- .build();
+ .Build();
ReferenceLinker linker;
- ASSERT_FALSE(linker.consume(context.get(), table.get()));
+ ASSERT_FALSE(linker.Consume(context.get(), table.get()));
}
TEST(ReferenceLinkerTest, FailToLinkPrivateStyleAttributes) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .setPackageId("com.app.test", 0x7f)
- .addValue("com.app.test:style/Theme",
+ .SetPackageId("com.app.test", 0x7f)
+ .AddValue("com.app.test:style/Theme",
test::StyleBuilder()
- .addItem("android:attr/hidden",
- ResourceUtils::tryParseColor("#ff00ff"))
- .build())
- .build();
+ .AddItem("android:attr/hidden",
+ ResourceUtils::TryParseColor("#ff00ff"))
+ .Build())
+ .Build();
std::unique_ptr<IAaptContext> context =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setPackageId(0x7f)
- .setNameManglerPolicy(NameManglerPolicy{"com.app.test"})
- .addSymbolSource(
+ .SetCompilationPackage("com.app.test")
+ .SetPackageId(0x7f)
+ .SetNameManglerPolicy(NameManglerPolicy{"com.app.test"})
+ .AddSymbolSource(
util::make_unique<ResourceTableSymbolSource>(table.get()))
- .addSymbolSource(
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addSymbol("android:attr/hidden", ResourceId(0x01010001),
+ .AddSymbol("android:attr/hidden", ResourceId(0x01010001),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_COLOR)
- .build())
- .build())
- .build();
+ .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+ .Build())
+ .Build())
+ .Build();
ReferenceLinker linker;
- ASSERT_FALSE(linker.consume(context.get(), table.get()));
+ ASSERT_FALSE(linker.Consume(context.get(), table.get()));
}
} // namespace aapt
diff --git a/tools/aapt2/link/ResourceDeduper.cpp b/tools/aapt2/link/ResourceDeduper.cpp
index f565359..9431dce 100644
--- a/tools/aapt2/link/ResourceDeduper.cpp
+++ b/tools/aapt2/link/ResourceDeduper.cpp
@@ -14,12 +14,13 @@
* limitations under the License.
*/
-#include "DominatorTree.h"
-#include "ResourceTable.h"
#include "link/Linkers.h"
#include <algorithm>
+#include "DominatorTree.h"
+#include "ResourceTable.h"
+
namespace aapt {
namespace {
@@ -40,55 +41,57 @@
using Node = DominatorTree::Node;
explicit DominatedKeyValueRemover(IAaptContext* context, ResourceEntry* entry)
- : mContext(context), mEntry(entry) {}
+ : context_(context), entry_(entry) {}
- void visitConfig(Node* node) {
+ void VisitConfig(Node* node) {
Node* parent = node->parent();
if (!parent) {
return;
}
- ResourceConfigValue* nodeValue = node->value();
- ResourceConfigValue* parentValue = parent->value();
- if (!nodeValue || !parentValue) {
+ ResourceConfigValue* node_value = node->value();
+ ResourceConfigValue* parent_value = parent->value();
+ if (!node_value || !parent_value) {
return;
}
- if (!nodeValue->value->equals(parentValue->value.get())) {
+ if (!node_value->value->Equals(parent_value->value.get())) {
return;
}
// Compare compatible configs for this entry and ensure the values are
// equivalent.
- const ConfigDescription& nodeConfiguration = nodeValue->config;
- for (const auto& sibling : mEntry->values) {
+ const ConfigDescription& node_configuration = node_value->config;
+ for (const auto& sibling : entry_->values) {
if (!sibling->value) {
// Sibling was already removed.
continue;
}
- if (nodeConfiguration.isCompatibleWith(sibling->config) &&
- !nodeValue->value->equals(sibling->value.get())) {
+ if (node_configuration.IsCompatibleWith(sibling->config) &&
+ !node_value->value->Equals(sibling->value.get())) {
// The configurations are compatible, but the value is
// different, so we can't remove this value.
return;
}
}
- if (mContext->verbose()) {
- mContext->getDiagnostics()->note(
- DiagMessage(nodeValue->value->getSource())
+ if (context_->IsVerbose()) {
+ context_->GetDiagnostics()->Note(
+ DiagMessage(node_value->value->GetSource())
<< "removing dominated duplicate resource with name \""
- << mEntry->name << "\"");
+ << entry_->name << "\"");
}
- nodeValue->value = {};
+ node_value->value = {};
}
private:
- IAaptContext* mContext;
- ResourceEntry* mEntry;
+ DISALLOW_COPY_AND_ASSIGN(DominatedKeyValueRemover);
+
+ IAaptContext* context_;
+ ResourceEntry* entry_;
};
-static void dedupeEntry(IAaptContext* context, ResourceEntry* entry) {
+static void DedupeEntry(IAaptContext* context, ResourceEntry* entry) {
DominatorTree tree(entry->values);
DominatedKeyValueRemover remover(context, entry);
- tree.accept(&remover);
+ tree.Accept(&remover);
// Erase the values that were removed.
entry->values.erase(
@@ -102,15 +105,15 @@
} // namespace
-bool ResourceDeduper::consume(IAaptContext* context, ResourceTable* table) {
+bool ResourceDeduper::Consume(IAaptContext* context, ResourceTable* table) {
for (auto& package : table->packages) {
for (auto& type : package->types) {
for (auto& entry : type->entries) {
- dedupeEntry(context, entry.get());
+ DedupeEntry(context, entry.get());
}
}
}
return true;
}
-} // aapt
+} // namespace aapt
diff --git a/tools/aapt2/link/ResourceDeduper_test.cpp b/tools/aapt2/link/ResourceDeduper_test.cpp
index 7e2d476..d38059d 100644
--- a/tools/aapt2/link/ResourceDeduper_test.cpp
+++ b/tools/aapt2/link/ResourceDeduper_test.cpp
@@ -14,70 +14,74 @@
* limitations under the License.
*/
-#include "ResourceTable.h"
#include "link/Linkers.h"
+
+#include "ResourceTable.h"
#include "test/Test.h"
namespace aapt {
TEST(ResourceDeduperTest, SameValuesAreDeduped) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- const ConfigDescription defaultConfig = {};
- const ConfigDescription enConfig = test::parseConfigOrDie("en");
- const ConfigDescription enV21Config = test::parseConfigOrDie("en-v21");
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ const ConfigDescription default_config = {};
+ const ConfigDescription en_config = test::ParseConfigOrDie("en");
+ const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21");
// Chosen because this configuration is compatible with en.
- const ConfigDescription landConfig = test::parseConfigOrDie("land");
+ const ConfigDescription land_config = test::ParseConfigOrDie("land");
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addString("android:string/dedupe", ResourceId{}, defaultConfig,
+ .AddString("android:string/dedupe", ResourceId{}, default_config,
"dedupe")
- .addString("android:string/dedupe", ResourceId{}, enConfig, "dedupe")
- .addString("android:string/dedupe", ResourceId{}, landConfig,
+ .AddString("android:string/dedupe", ResourceId{}, en_config, "dedupe")
+ .AddString("android:string/dedupe", ResourceId{}, land_config,
"dedupe")
- .addString("android:string/dedupe2", ResourceId{}, defaultConfig,
+ .AddString("android:string/dedupe2", ResourceId{}, default_config,
"dedupe")
- .addString("android:string/dedupe2", ResourceId{}, enConfig, "dedupe")
- .addString("android:string/dedupe2", ResourceId{}, enV21Config,
+ .AddString("android:string/dedupe2", ResourceId{}, en_config,
+ "dedupe")
+ .AddString("android:string/dedupe2", ResourceId{}, en_v21_config,
"keep")
- .addString("android:string/dedupe2", ResourceId{}, landConfig,
+ .AddString("android:string/dedupe2", ResourceId{}, land_config,
"dedupe")
- .build();
+ .Build();
- ASSERT_TRUE(ResourceDeduper().consume(context.get(), table.get()));
- EXPECT_EQ(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/dedupe", enConfig));
- EXPECT_EQ(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/dedupe", landConfig));
- EXPECT_EQ(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/dedupe2", enConfig));
- EXPECT_NE(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/dedupe2", enV21Config));
+ ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get()));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/dedupe", en_config));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/dedupe", land_config));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/dedupe2", en_config));
+ EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/dedupe2", en_v21_config));
}
TEST(ResourceDeduperTest, DifferentValuesAreKept) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- const ConfigDescription defaultConfig = {};
- const ConfigDescription enConfig = test::parseConfigOrDie("en");
- const ConfigDescription enV21Config = test::parseConfigOrDie("en-v21");
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ const ConfigDescription default_config = {};
+ const ConfigDescription en_config = test::ParseConfigOrDie("en");
+ const ConfigDescription en_v21_config = test::ParseConfigOrDie("en-v21");
// Chosen because this configuration is compatible with en.
- const ConfigDescription landConfig = test::parseConfigOrDie("land");
+ const ConfigDescription land_config = test::ParseConfigOrDie("land");
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addString("android:string/keep", ResourceId{}, defaultConfig, "keep")
- .addString("android:string/keep", ResourceId{}, enConfig, "keep")
- .addString("android:string/keep", ResourceId{}, enV21Config, "keep2")
- .addString("android:string/keep", ResourceId{}, landConfig, "keep2")
- .build();
+ .AddString("android:string/keep", ResourceId{}, default_config,
+ "keep")
+ .AddString("android:string/keep", ResourceId{}, en_config, "keep")
+ .AddString("android:string/keep", ResourceId{}, en_v21_config,
+ "keep2")
+ .AddString("android:string/keep", ResourceId{}, land_config, "keep2")
+ .Build();
- ASSERT_TRUE(ResourceDeduper().consume(context.get(), table.get()));
- EXPECT_NE(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/keep", enConfig));
- EXPECT_NE(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/keep", enV21Config));
- EXPECT_NE(nullptr, test::getValueForConfig<String>(
- table.get(), "android:string/keep", landConfig));
+ ASSERT_TRUE(ResourceDeduper().Consume(context.get(), table.get()));
+ EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/keep", en_config));
+ EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/keep", en_v21_config));
+ EXPECT_NE(nullptr, test::GetValueForConfig<String>(
+ table.get(), "android:string/keep", land_config));
}
} // namespace aapt
diff --git a/tools/aapt2/link/TableMerger.cpp b/tools/aapt2/link/TableMerger.cpp
index adf83a4..d808da3 100644
--- a/tools/aapt2/link/TableMerger.cpp
+++ b/tools/aapt2/link/TableMerger.cpp
@@ -15,51 +15,52 @@
*/
#include "link/TableMerger.h"
+
+#include "android-base/logging.h"
+
#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
#include "ValueVisitor.h"
#include "util/Util.h"
-#include <cassert>
-
namespace aapt {
-TableMerger::TableMerger(IAaptContext* context, ResourceTable* outTable,
+TableMerger::TableMerger(IAaptContext* context, ResourceTable* out_table,
const TableMergerOptions& options)
- : mContext(context), mMasterTable(outTable), mOptions(options) {
+ : context_(context), master_table_(out_table), options_(options) {
// Create the desired package that all tables will be merged into.
- mMasterPackage = mMasterTable->createPackage(
- mContext->getCompilationPackage(), mContext->getPackageId());
- assert(mMasterPackage && "package name or ID already taken");
+ master_package_ = master_table_->CreatePackage(
+ context_->GetCompilationPackage(), context_->GetPackageId());
+ CHECK(master_package_ != nullptr) << "package name or ID already taken";
}
-bool TableMerger::merge(const Source& src, ResourceTable* table,
+bool TableMerger::Merge(const Source& src, ResourceTable* table,
io::IFileCollection* collection) {
- return mergeImpl(src, table, collection, false /* overlay */,
+ return MergeImpl(src, table, collection, false /* overlay */,
true /* allow new */);
}
-bool TableMerger::mergeOverlay(const Source& src, ResourceTable* table,
+bool TableMerger::MergeOverlay(const Source& src, ResourceTable* table,
io::IFileCollection* collection) {
- return mergeImpl(src, table, collection, true /* overlay */,
- mOptions.autoAddOverlay);
+ return MergeImpl(src, table, collection, true /* overlay */,
+ options_.auto_add_overlay);
}
/**
* This will merge packages with the same package name (or no package name).
*/
-bool TableMerger::mergeImpl(const Source& src, ResourceTable* table,
+bool TableMerger::MergeImpl(const Source& src, ResourceTable* table,
io::IFileCollection* collection, bool overlay,
- bool allowNew) {
- const uint8_t desiredPackageId = mContext->getPackageId();
+ bool allow_new) {
+ const uint8_t desired_package_id = context_->GetPackageId();
bool error = false;
for (auto& package : table->packages) {
// Warn of packages with an unrelated ID.
const Maybe<ResourceId>& id = package->id;
- if (id && id.value() != 0x0 && id.value() != desiredPackageId) {
- mContext->getDiagnostics()->warn(DiagMessage(src) << "ignoring package "
+ if (id && id.value() != 0x0 && id.value() != desired_package_id) {
+ context_->GetDiagnostics()->Warn(DiagMessage(src) << "ignoring package "
<< package->name);
continue;
}
@@ -70,22 +71,22 @@
// simply
// uses of the attribute or definitions.
if (package->name.empty() ||
- mContext->getCompilationPackage() == package->name) {
+ context_->GetCompilationPackage() == package->name) {
FileMergeCallback callback;
if (collection) {
callback = [&](const ResourceNameRef& name,
- const ConfigDescription& config, FileReference* newFile,
- FileReference* oldFile) -> bool {
+ const ConfigDescription& config, FileReference* new_file,
+ FileReference* old_file) -> bool {
// The old file's path points inside the APK, so we can use it as is.
- io::IFile* f = collection->findFile(*oldFile->path);
+ io::IFile* f = collection->FindFile(*old_file->path);
if (!f) {
- mContext->getDiagnostics()->error(DiagMessage(src)
- << "file '" << *oldFile->path
+ context_->GetDiagnostics()->Error(DiagMessage(src)
+ << "file '" << *old_file->path
<< "' not found");
return false;
}
- newFile->file = f;
+ new_file->file = f;
return true;
};
}
@@ -95,8 +96,8 @@
// mangled, then looked up at resolution time.
// Also, when linking, we convert references with no package name to use
// the compilation package name.
- error |= !doMerge(src, table, package.get(), false /* mangle */, overlay,
- allowNew, callback);
+ error |= !DoMerge(src, table, package.get(), false /* mangle */, overlay,
+ allow_new, callback);
}
}
return !error;
@@ -105,86 +106,87 @@
/**
* This will merge and mangle resources from a static library.
*/
-bool TableMerger::mergeAndMangle(const Source& src,
- const StringPiece& packageName,
+bool TableMerger::MergeAndMangle(const Source& src,
+ const StringPiece& package_name,
ResourceTable* table,
io::IFileCollection* collection) {
bool error = false;
for (auto& package : table->packages) {
// Warn of packages with an unrelated ID.
- if (packageName != package->name) {
- mContext->getDiagnostics()->warn(DiagMessage(src) << "ignoring package "
+ if (package_name != package->name) {
+ context_->GetDiagnostics()->Warn(DiagMessage(src) << "ignoring package "
<< package->name);
continue;
}
- bool mangle = packageName != mContext->getCompilationPackage();
- mMergedPackages.insert(package->name);
+ bool mangle = package_name != context_->GetCompilationPackage();
+ merged_packages_.insert(package->name);
- auto callback = [&](const ResourceNameRef& name,
- const ConfigDescription& config, FileReference* newFile,
- FileReference* oldFile) -> bool {
+ auto callback = [&](
+ const ResourceNameRef& name, const ConfigDescription& config,
+ FileReference* new_file, FileReference* old_file) -> bool {
// The old file's path points inside the APK, so we can use it as is.
- io::IFile* f = collection->findFile(*oldFile->path);
+ io::IFile* f = collection->FindFile(*old_file->path);
if (!f) {
- mContext->getDiagnostics()->error(
- DiagMessage(src) << "file '" << *oldFile->path << "' not found");
+ context_->GetDiagnostics()->Error(
+ DiagMessage(src) << "file '" << *old_file->path << "' not found");
return false;
}
- newFile->file = f;
+ new_file->file = f;
return true;
};
- error |= !doMerge(src, table, package.get(), mangle, false /* overlay */,
+ error |= !DoMerge(src, table, package.get(), mangle, false /* overlay */,
true /* allow new */, callback);
}
return !error;
}
-static bool mergeType(IAaptContext* context, const Source& src,
- ResourceTableType* dstType, ResourceTableType* srcType) {
- if (dstType->symbolStatus.state < srcType->symbolStatus.state) {
+static bool MergeType(IAaptContext* context, const Source& src,
+ ResourceTableType* dst_type,
+ ResourceTableType* src_type) {
+ if (dst_type->symbol_status.state < src_type->symbol_status.state) {
// The incoming type's visibility is stronger, so we should override
// the visibility.
- if (srcType->symbolStatus.state == SymbolState::kPublic) {
+ if (src_type->symbol_status.state == SymbolState::kPublic) {
// Only copy the ID if the source is public, or else the ID is
// meaningless.
- dstType->id = srcType->id;
+ dst_type->id = src_type->id;
}
- dstType->symbolStatus = std::move(srcType->symbolStatus);
- } else if (dstType->symbolStatus.state == SymbolState::kPublic &&
- srcType->symbolStatus.state == SymbolState::kPublic &&
- dstType->id && srcType->id &&
- dstType->id.value() != srcType->id.value()) {
+ dst_type->symbol_status = std::move(src_type->symbol_status);
+ } else if (dst_type->symbol_status.state == SymbolState::kPublic &&
+ src_type->symbol_status.state == SymbolState::kPublic &&
+ dst_type->id && src_type->id &&
+ dst_type->id.value() != src_type->id.value()) {
// Both types are public and have different IDs.
- context->getDiagnostics()->error(DiagMessage(src)
- << "cannot merge type '" << srcType->type
+ context->GetDiagnostics()->Error(DiagMessage(src)
+ << "cannot merge type '" << src_type->type
<< "': conflicting public IDs");
return false;
}
return true;
}
-static bool mergeEntry(IAaptContext* context, const Source& src,
- ResourceEntry* dstEntry, ResourceEntry* srcEntry) {
- if (dstEntry->symbolStatus.state < srcEntry->symbolStatus.state) {
+static bool MergeEntry(IAaptContext* context, const Source& src,
+ ResourceEntry* dst_entry, ResourceEntry* src_entry) {
+ if (dst_entry->symbol_status.state < src_entry->symbol_status.state) {
// The incoming type's visibility is stronger, so we should override
// the visibility.
- if (srcEntry->symbolStatus.state == SymbolState::kPublic) {
+ if (src_entry->symbol_status.state == SymbolState::kPublic) {
// Only copy the ID if the source is public, or else the ID is
// meaningless.
- dstEntry->id = srcEntry->id;
+ dst_entry->id = src_entry->id;
}
- dstEntry->symbolStatus = std::move(srcEntry->symbolStatus);
- } else if (srcEntry->symbolStatus.state == SymbolState::kPublic &&
- dstEntry->symbolStatus.state == SymbolState::kPublic &&
- dstEntry->id && srcEntry->id &&
- dstEntry->id.value() != srcEntry->id.value()) {
+ dst_entry->symbol_status = std::move(src_entry->symbol_status);
+ } else if (src_entry->symbol_status.state == SymbolState::kPublic &&
+ dst_entry->symbol_status.state == SymbolState::kPublic &&
+ dst_entry->id && src_entry->id &&
+ dst_entry->id.value() != src_entry->id.value()) {
// Both entries are public and have different IDs.
- context->getDiagnostics()->error(DiagMessage(src)
- << "cannot merge entry '" << srcEntry->name
- << "': conflicting public IDs");
+ context->GetDiagnostics()->Error(
+ DiagMessage(src) << "cannot merge entry '" << src_entry->name
+ << "': conflicting public IDs");
return false;
}
return true;
@@ -199,141 +201,145 @@
* and accumulate. If both values are Styleables, we just merge them into the
* existing value.
*/
-static ResourceTable::CollisionResult resolveMergeCollision(Value* existing,
+static ResourceTable::CollisionResult ResolveMergeCollision(Value* existing,
Value* incoming) {
- if (Styleable* existingStyleable = valueCast<Styleable>(existing)) {
- if (Styleable* incomingStyleable = valueCast<Styleable>(incoming)) {
+ if (Styleable* existing_styleable = ValueCast<Styleable>(existing)) {
+ if (Styleable* incoming_styleable = ValueCast<Styleable>(incoming)) {
// Styleables get merged.
- existingStyleable->mergeWith(incomingStyleable);
+ existing_styleable->MergeWith(incoming_styleable);
return ResourceTable::CollisionResult::kKeepOriginal;
}
}
// Delegate to the default handler.
- return ResourceTable::resolveValueCollision(existing, incoming);
+ return ResourceTable::ResolveValueCollision(existing, incoming);
}
-static ResourceTable::CollisionResult mergeConfigValue(
- IAaptContext* context, const ResourceNameRef& resName, const bool overlay,
- ResourceConfigValue* dstConfigValue, ResourceConfigValue* srcConfigValue) {
+static ResourceTable::CollisionResult MergeConfigValue(
+ IAaptContext* context, const ResourceNameRef& res_name, const bool overlay,
+ ResourceConfigValue* dst_config_value,
+ ResourceConfigValue* src_config_value) {
using CollisionResult = ResourceTable::CollisionResult;
- Value* dstValue = dstConfigValue->value.get();
- Value* srcValue = srcConfigValue->value.get();
+ Value* dst_value = dst_config_value->value.get();
+ Value* src_value = src_config_value->value.get();
- CollisionResult collisionResult;
+ CollisionResult collision_result;
if (overlay) {
- collisionResult = resolveMergeCollision(dstValue, srcValue);
+ collision_result = ResolveMergeCollision(dst_value, src_value);
} else {
- collisionResult = ResourceTable::resolveValueCollision(dstValue, srcValue);
+ collision_result =
+ ResourceTable::ResolveValueCollision(dst_value, src_value);
}
- if (collisionResult == CollisionResult::kConflict) {
+ if (collision_result == CollisionResult::kConflict) {
if (overlay) {
return CollisionResult::kTakeNew;
}
// Error!
- context->getDiagnostics()->error(
- DiagMessage(srcValue->getSource())
- << "resource '" << resName << "' has a conflicting value for "
- << "configuration (" << srcConfigValue->config << ")");
- context->getDiagnostics()->note(DiagMessage(dstValue->getSource())
+ context->GetDiagnostics()->Error(
+ DiagMessage(src_value->GetSource())
+ << "resource '" << res_name << "' has a conflicting value for "
+ << "configuration (" << src_config_value->config << ")");
+ context->GetDiagnostics()->Note(DiagMessage(dst_value->GetSource())
<< "originally defined here");
return CollisionResult::kConflict;
}
- return collisionResult;
+ return collision_result;
}
-bool TableMerger::doMerge(const Source& src, ResourceTable* srcTable,
- ResourceTablePackage* srcPackage,
- const bool manglePackage, const bool overlay,
- const bool allowNewResources,
+bool TableMerger::DoMerge(const Source& src, ResourceTable* src_table,
+ ResourceTablePackage* src_package,
+ const bool mangle_package, const bool overlay,
+ const bool allow_new_resources,
const FileMergeCallback& callback) {
bool error = false;
- for (auto& srcType : srcPackage->types) {
- ResourceTableType* dstType =
- mMasterPackage->findOrCreateType(srcType->type);
- if (!mergeType(mContext, src, dstType, srcType.get())) {
+ for (auto& src_type : src_package->types) {
+ ResourceTableType* dst_type =
+ master_package_->FindOrCreateType(src_type->type);
+ if (!MergeType(context_, src, dst_type, src_type.get())) {
error = true;
continue;
}
- for (auto& srcEntry : srcType->entries) {
- std::string entryName = srcEntry->name;
- if (manglePackage) {
- entryName = NameMangler::mangleEntry(srcPackage->name, srcEntry->name);
+ for (auto& src_entry : src_type->entries) {
+ std::string entry_name = src_entry->name;
+ if (mangle_package) {
+ entry_name =
+ NameMangler::MangleEntry(src_package->name, src_entry->name);
}
- ResourceEntry* dstEntry;
- if (allowNewResources) {
- dstEntry = dstType->findOrCreateEntry(entryName);
+ ResourceEntry* dst_entry;
+ if (allow_new_resources) {
+ dst_entry = dst_type->FindOrCreateEntry(entry_name);
} else {
- dstEntry = dstType->findEntry(entryName);
+ dst_entry = dst_type->FindEntry(entry_name);
}
- const ResourceNameRef resName(srcPackage->name, srcType->type,
- srcEntry->name);
+ const ResourceNameRef res_name(src_package->name, src_type->type,
+ src_entry->name);
- if (!dstEntry) {
- mContext->getDiagnostics()->error(
- DiagMessage(src) << "resource " << resName
+ if (!dst_entry) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(src) << "resource " << res_name
<< " does not override an existing resource");
- mContext->getDiagnostics()->note(
+ context_->GetDiagnostics()->Note(
DiagMessage(src) << "define an <add-resource> tag or use "
<< "--auto-add-overlay");
error = true;
continue;
}
- if (!mergeEntry(mContext, src, dstEntry, srcEntry.get())) {
+ if (!MergeEntry(context_, src, dst_entry, src_entry.get())) {
error = true;
continue;
}
- for (auto& srcConfigValue : srcEntry->values) {
+ for (auto& src_config_value : src_entry->values) {
using CollisionResult = ResourceTable::CollisionResult;
- ResourceConfigValue* dstConfigValue = dstEntry->findValue(
- srcConfigValue->config, srcConfigValue->product);
- if (dstConfigValue) {
- CollisionResult collisionResult = mergeConfigValue(
- mContext, resName, overlay, dstConfigValue, srcConfigValue.get());
- if (collisionResult == CollisionResult::kConflict) {
+ ResourceConfigValue* dst_config_value = dst_entry->FindValue(
+ src_config_value->config, src_config_value->product);
+ if (dst_config_value) {
+ CollisionResult collision_result =
+ MergeConfigValue(context_, res_name, overlay, dst_config_value,
+ src_config_value.get());
+ if (collision_result == CollisionResult::kConflict) {
error = true;
continue;
- } else if (collisionResult == CollisionResult::kKeepOriginal) {
+ } else if (collision_result == CollisionResult::kKeepOriginal) {
continue;
}
} else {
- dstConfigValue = dstEntry->findOrCreateValue(srcConfigValue->config,
- srcConfigValue->product);
+ dst_config_value = dst_entry->FindOrCreateValue(
+ src_config_value->config, src_config_value->product);
}
// Continue if we're taking the new resource.
if (FileReference* f =
- valueCast<FileReference>(srcConfigValue->value.get())) {
- std::unique_ptr<FileReference> newFileRef;
- if (manglePackage) {
- newFileRef = cloneAndMangleFile(srcPackage->name, *f);
+ ValueCast<FileReference>(src_config_value->value.get())) {
+ std::unique_ptr<FileReference> new_file_ref;
+ if (mangle_package) {
+ new_file_ref = CloneAndMangleFile(src_package->name, *f);
} else {
- newFileRef = std::unique_ptr<FileReference>(
- f->clone(&mMasterTable->stringPool));
+ new_file_ref = std::unique_ptr<FileReference>(
+ f->Clone(&master_table_->string_pool));
}
if (callback) {
- if (!callback(resName, srcConfigValue->config, newFileRef.get(),
- f)) {
+ if (!callback(res_name, src_config_value->config,
+ new_file_ref.get(), f)) {
error = true;
continue;
}
}
- dstConfigValue->value = std::move(newFileRef);
+ dst_config_value->value = std::move(new_file_ref);
} else {
- dstConfigValue->value = std::unique_ptr<Value>(
- srcConfigValue->value->clone(&mMasterTable->stringPool));
+ dst_config_value->value = std::unique_ptr<Value>(
+ src_config_value->value->Clone(&master_table_->string_pool));
}
}
}
@@ -341,50 +347,50 @@
return !error;
}
-std::unique_ptr<FileReference> TableMerger::cloneAndMangleFile(
- const std::string& package, const FileReference& fileRef) {
+std::unique_ptr<FileReference> TableMerger::CloneAndMangleFile(
+ const std::string& package, const FileReference& file_ref) {
StringPiece prefix, entry, suffix;
- if (util::extractResFilePathParts(*fileRef.path, &prefix, &entry, &suffix)) {
- std::string mangledEntry =
- NameMangler::mangleEntry(package, entry.toString());
- std::string newPath = prefix.toString() + mangledEntry + suffix.toString();
- std::unique_ptr<FileReference> newFileRef =
+ if (util::ExtractResFilePathParts(*file_ref.path, &prefix, &entry, &suffix)) {
+ std::string mangled_entry =
+ NameMangler::MangleEntry(package, entry.ToString());
+ std::string newPath = prefix.ToString() + mangled_entry + suffix.ToString();
+ std::unique_ptr<FileReference> new_file_ref =
util::make_unique<FileReference>(
- mMasterTable->stringPool.makeRef(newPath));
- newFileRef->setComment(fileRef.getComment());
- newFileRef->setSource(fileRef.getSource());
- return newFileRef;
+ master_table_->string_pool.MakeRef(newPath));
+ new_file_ref->SetComment(file_ref.GetComment());
+ new_file_ref->SetSource(file_ref.GetSource());
+ return new_file_ref;
}
return std::unique_ptr<FileReference>(
- fileRef.clone(&mMasterTable->stringPool));
+ file_ref.Clone(&master_table_->string_pool));
}
-bool TableMerger::mergeFileImpl(const ResourceFile& fileDesc, io::IFile* file,
+bool TableMerger::MergeFileImpl(const ResourceFile& file_desc, io::IFile* file,
bool overlay) {
ResourceTable table;
- std::string path = ResourceUtils::buildResourceFileName(fileDesc, nullptr);
- std::unique_ptr<FileReference> fileRef =
- util::make_unique<FileReference>(table.stringPool.makeRef(path));
- fileRef->setSource(fileDesc.source);
- fileRef->file = file;
+ std::string path = ResourceUtils::BuildResourceFileName(file_desc);
+ std::unique_ptr<FileReference> file_ref =
+ util::make_unique<FileReference>(table.string_pool.MakeRef(path));
+ file_ref->SetSource(file_desc.source);
+ file_ref->file = file;
- ResourceTablePackage* pkg = table.createPackage(fileDesc.name.package, 0x0);
- pkg->findOrCreateType(fileDesc.name.type)
- ->findOrCreateEntry(fileDesc.name.entry)
- ->findOrCreateValue(fileDesc.config, {})
- ->value = std::move(fileRef);
+ ResourceTablePackage* pkg = table.CreatePackage(file_desc.name.package, 0x0);
+ pkg->FindOrCreateType(file_desc.name.type)
+ ->FindOrCreateEntry(file_desc.name.entry)
+ ->FindOrCreateValue(file_desc.config, {})
+ ->value = std::move(file_ref);
- return doMerge(file->getSource(), &table, pkg, false /* mangle */,
- overlay /* overlay */, true /* allow new */, {});
+ return DoMerge(file->GetSource(), &table, pkg, false /* mangle */,
+ overlay /* overlay */, true /* allow_new */, {});
}
-bool TableMerger::mergeFile(const ResourceFile& fileDesc, io::IFile* file) {
- return mergeFileImpl(fileDesc, file, false /* overlay */);
+bool TableMerger::MergeFile(const ResourceFile& file_desc, io::IFile* file) {
+ return MergeFileImpl(file_desc, file, false /* overlay */);
}
-bool TableMerger::mergeFileOverlay(const ResourceFile& fileDesc,
+bool TableMerger::MergeFileOverlay(const ResourceFile& file_desc,
io::IFile* file) {
- return mergeFileImpl(fileDesc, file, true /* overlay */);
+ return MergeFileImpl(file_desc, file, true /* overlay */);
}
} // namespace aapt
diff --git a/tools/aapt2/link/TableMerger.h b/tools/aapt2/link/TableMerger.h
index c2e7181..4ab83c3 100644
--- a/tools/aapt2/link/TableMerger.h
+++ b/tools/aapt2/link/TableMerger.h
@@ -17,6 +17,11 @@
#ifndef AAPT_TABLEMERGER_H
#define AAPT_TABLEMERGER_H
+#include <functional>
+#include <map>
+
+#include "android-base/macros.h"
+
#include "Resource.h"
#include "ResourceTable.h"
#include "ResourceValues.h"
@@ -25,9 +30,6 @@
#include "process/IResourceTableConsumer.h"
#include "util/Util.h"
-#include <functional>
-#include <map>
-
namespace aapt {
struct TableMergerOptions {
@@ -35,7 +37,7 @@
* If true, resources in overlays can be added without previously having
* existed.
*/
- bool autoAddOverlay = false;
+ bool auto_add_overlay = false;
};
/**
@@ -62,15 +64,14 @@
class TableMerger {
public:
/**
- * Note: The outTable ResourceTable must live longer than this TableMerger.
- * References
- * are made to this ResourceTable for efficiency reasons.
+ * Note: The out_table ResourceTable must live longer than this TableMerger.
+ * References are made to this ResourceTable for efficiency reasons.
*/
- TableMerger(IAaptContext* context, ResourceTable* outTable,
+ TableMerger(IAaptContext* context, ResourceTable* out_table,
const TableMergerOptions& options);
- const std::set<std::string>& getMergedPackages() const {
- return mMergedPackages;
+ const std::set<std::string>& merged_packages() const {
+ return merged_packages_;
}
/**
@@ -78,7 +79,7 @@
* An io::IFileCollection is optional and used to find the referenced Files
* and process them.
*/
- bool merge(const Source& src, ResourceTable* table,
+ bool Merge(const Source& src, ResourceTable* table,
io::IFileCollection* collection = nullptr);
/**
@@ -86,7 +87,7 @@
* An io::IFileCollection is optional and used to find the referenced Files
* and process them.
*/
- bool mergeOverlay(const Source& src, ResourceTable* table,
+ bool MergeOverlay(const Source& src, ResourceTable* table,
io::IFileCollection* collection = nullptr);
/**
@@ -95,44 +96,45 @@
* An io::IFileCollection is needed in order to find the referenced Files and
* process them.
*/
- bool mergeAndMangle(const Source& src, const StringPiece& package,
+ bool MergeAndMangle(const Source& src, const StringPiece& package,
ResourceTable* table, io::IFileCollection* collection);
/**
* Merges a compiled file that belongs to this same or empty package. This is
* for local sources.
*/
- bool mergeFile(const ResourceFile& fileDesc, io::IFile* file);
+ bool MergeFile(const ResourceFile& fileDesc, io::IFile* file);
/**
* Merges a compiled file from an overlay, overriding an existing definition.
*/
- bool mergeFileOverlay(const ResourceFile& fileDesc, io::IFile* file);
+ bool MergeFileOverlay(const ResourceFile& fileDesc, io::IFile* file);
private:
+ DISALLOW_COPY_AND_ASSIGN(TableMerger);
+
using FileMergeCallback = std::function<bool(const ResourceNameRef&,
const ConfigDescription& config,
FileReference*, FileReference*)>;
- IAaptContext* mContext;
- ResourceTable* mMasterTable;
- TableMergerOptions mOptions;
- ResourceTablePackage* mMasterPackage;
+ IAaptContext* context_;
+ ResourceTable* master_table_;
+ TableMergerOptions options_;
+ ResourceTablePackage* master_package_;
+ std::set<std::string> merged_packages_;
- std::set<std::string> mMergedPackages;
-
- bool mergeFileImpl(const ResourceFile& fileDesc, io::IFile* file,
+ bool MergeFileImpl(const ResourceFile& file_desc, io::IFile* file,
bool overlay);
- bool mergeImpl(const Source& src, ResourceTable* srcTable,
- io::IFileCollection* collection, bool overlay, bool allowNew);
+ bool MergeImpl(const Source& src, ResourceTable* src_table,
+ io::IFileCollection* collection, bool overlay, bool allow_new);
- bool doMerge(const Source& src, ResourceTable* srcTable,
- ResourceTablePackage* srcPackage, const bool manglePackage,
- const bool overlay, const bool allowNewResources,
+ bool DoMerge(const Source& src, ResourceTable* src_table,
+ ResourceTablePackage* src_package, const bool mangle_package,
+ const bool overlay, const bool allow_new_resources,
const FileMergeCallback& callback);
- std::unique_ptr<FileReference> cloneAndMangleFile(const std::string& package,
+ std::unique_ptr<FileReference> CloneAndMangleFile(const std::string& package,
const FileReference& value);
};
diff --git a/tools/aapt2/link/TableMerger_test.cpp b/tools/aapt2/link/TableMerger_test.cpp
index e0b2b66..742f5a7 100644
--- a/tools/aapt2/link/TableMerger_test.cpp
+++ b/tools/aapt2/link/TableMerger_test.cpp
@@ -15,139 +15,137 @@
*/
#include "link/TableMerger.h"
+
#include "filter/ConfigFilter.h"
#include "io/FileSystem.h"
-#include "test/Builders.h"
-#include "test/Context.h"
-
-#include <gtest/gtest.h>
+#include "test/Test.h"
namespace aapt {
struct TableMergerTest : public ::testing::Test {
- std::unique_ptr<IAaptContext> mContext;
+ std::unique_ptr<IAaptContext> context_;
void SetUp() override {
- mContext =
+ context_ =
test::ContextBuilder()
// We are compiling this package.
- .setCompilationPackage("com.app.a")
+ .SetCompilationPackage("com.app.a")
// Merge all packages that have this package ID.
- .setPackageId(0x7f)
+ .SetPackageId(0x7f)
// Mangle all packages that do not have this package name.
- .setNameManglerPolicy(NameManglerPolicy{"com.app.a", {"com.app.b"}})
+ .SetNameManglerPolicy(NameManglerPolicy{"com.app.a", {"com.app.b"}})
- .build();
+ .Build();
}
};
TEST_F(TableMergerTest, SimpleMerge) {
- std::unique_ptr<ResourceTable> tableA =
+ std::unique_ptr<ResourceTable> table_a =
test::ResourceTableBuilder()
- .setPackageId("com.app.a", 0x7f)
- .addReference("com.app.a:id/foo", "com.app.a:id/bar")
- .addReference("com.app.a:id/bar", "com.app.b:id/foo")
- .addValue(
+ .SetPackageId("com.app.a", 0x7f)
+ .AddReference("com.app.a:id/foo", "com.app.a:id/bar")
+ .AddReference("com.app.a:id/bar", "com.app.b:id/foo")
+ .AddValue(
"com.app.a:styleable/view",
- test::StyleableBuilder().addItem("com.app.b:id/foo").build())
- .build();
+ test::StyleableBuilder().AddItem("com.app.b:id/foo").Build())
+ .Build();
- std::unique_ptr<ResourceTable> tableB = test::ResourceTableBuilder()
- .setPackageId("com.app.b", 0x7f)
- .addSimple("com.app.b:id/foo")
- .build();
+ std::unique_ptr<ResourceTable> table_b = test::ResourceTableBuilder()
+ .SetPackageId("com.app.b", 0x7f)
+ .AddSimple("com.app.b:id/foo")
+ .Build();
- ResourceTable finalTable;
- TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+ ResourceTable final_table;
+ TableMerger merger(context_.get(), &final_table, TableMergerOptions{});
io::FileCollection collection;
- ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_TRUE(merger.Merge({}, table_a.get()));
ASSERT_TRUE(
- merger.mergeAndMangle({}, "com.app.b", tableB.get(), &collection));
+ merger.MergeAndMangle({}, "com.app.b", table_b.get(), &collection));
- EXPECT_TRUE(merger.getMergedPackages().count("com.app.b") != 0);
+ EXPECT_TRUE(merger.merged_packages().count("com.app.b") != 0);
// Entries from com.app.a should not be mangled.
AAPT_EXPECT_TRUE(
- finalTable.findResource(test::parseNameOrDie("com.app.a:id/foo")));
+ final_table.FindResource(test::ParseNameOrDie("com.app.a:id/foo")));
AAPT_EXPECT_TRUE(
- finalTable.findResource(test::parseNameOrDie("com.app.a:id/bar")));
- AAPT_EXPECT_TRUE(finalTable.findResource(
- test::parseNameOrDie("com.app.a:styleable/view")));
+ final_table.FindResource(test::ParseNameOrDie("com.app.a:id/bar")));
+ AAPT_EXPECT_TRUE(final_table.FindResource(
+ test::ParseNameOrDie("com.app.a:styleable/view")));
// The unmangled name should not be present.
AAPT_EXPECT_FALSE(
- finalTable.findResource(test::parseNameOrDie("com.app.b:id/foo")));
+ final_table.FindResource(test::ParseNameOrDie("com.app.b:id/foo")));
// Look for the mangled name.
- AAPT_EXPECT_TRUE(finalTable.findResource(
- test::parseNameOrDie("com.app.a:id/com.app.b$foo")));
+ AAPT_EXPECT_TRUE(final_table.FindResource(
+ test::ParseNameOrDie("com.app.a:id/com.app.b$foo")));
}
TEST_F(TableMergerTest, MergeFile) {
- ResourceTable finalTable;
+ ResourceTable final_table;
TableMergerOptions options;
- options.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, options);
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ResourceFile fileDesc;
- fileDesc.config = test::parseConfigOrDie("hdpi-v4");
- fileDesc.name = test::parseNameOrDie("layout/main");
- fileDesc.source = Source("res/layout-hdpi/main.xml");
- test::TestFile testFile("path/to/res/layout-hdpi/main.xml.flat");
+ ResourceFile file_desc;
+ file_desc.config = test::ParseConfigOrDie("hdpi-v4");
+ file_desc.name = test::ParseNameOrDie("layout/main");
+ file_desc.source = Source("res/layout-hdpi/main.xml");
+ test::TestFile test_file("path/to/res/layout-hdpi/main.xml.flat");
- ASSERT_TRUE(merger.mergeFile(fileDesc, &testFile));
+ ASSERT_TRUE(merger.MergeFile(file_desc, &test_file));
- FileReference* file = test::getValueForConfig<FileReference>(
- &finalTable, "com.app.a:layout/main", test::parseConfigOrDie("hdpi-v4"));
+ FileReference* file = test::GetValueForConfig<FileReference>(
+ &final_table, "com.app.a:layout/main", test::ParseConfigOrDie("hdpi-v4"));
ASSERT_NE(nullptr, file);
EXPECT_EQ(std::string("res/layout-hdpi-v4/main.xml"), *file->path);
}
TEST_F(TableMergerTest, MergeFileOverlay) {
- ResourceTable finalTable;
- TableMergerOptions tableMergerOptions;
- tableMergerOptions.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+ ResourceTable final_table;
+ TableMergerOptions options;
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ResourceFile fileDesc;
- fileDesc.name = test::parseNameOrDie("xml/foo");
- test::TestFile fileA("path/to/fileA.xml.flat");
- test::TestFile fileB("path/to/fileB.xml.flat");
+ ResourceFile file_desc;
+ file_desc.name = test::ParseNameOrDie("xml/foo");
+ test::TestFile file_a("path/to/fileA.xml.flat");
+ test::TestFile file_b("path/to/fileB.xml.flat");
- ASSERT_TRUE(merger.mergeFile(fileDesc, &fileA));
- ASSERT_TRUE(merger.mergeFileOverlay(fileDesc, &fileB));
+ ASSERT_TRUE(merger.MergeFile(file_desc, &file_a));
+ ASSERT_TRUE(merger.MergeFileOverlay(file_desc, &file_b));
}
TEST_F(TableMergerTest, MergeFileReferences) {
- std::unique_ptr<ResourceTable> tableA =
+ std::unique_ptr<ResourceTable> table_a =
test::ResourceTableBuilder()
- .setPackageId("com.app.a", 0x7f)
- .addFileReference("com.app.a:xml/file", "res/xml/file.xml")
- .build();
- std::unique_ptr<ResourceTable> tableB =
+ .SetPackageId("com.app.a", 0x7f)
+ .AddFileReference("com.app.a:xml/file", "res/xml/file.xml")
+ .Build();
+ std::unique_ptr<ResourceTable> table_b =
test::ResourceTableBuilder()
- .setPackageId("com.app.b", 0x7f)
- .addFileReference("com.app.b:xml/file", "res/xml/file.xml")
- .build();
+ .SetPackageId("com.app.b", 0x7f)
+ .AddFileReference("com.app.b:xml/file", "res/xml/file.xml")
+ .Build();
- ResourceTable finalTable;
- TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+ ResourceTable final_table;
+ TableMerger merger(context_.get(), &final_table, TableMergerOptions{});
io::FileCollection collection;
- collection.insertFile("res/xml/file.xml");
+ collection.InsertFile("res/xml/file.xml");
- ASSERT_TRUE(merger.merge({}, tableA.get()));
+ ASSERT_TRUE(merger.Merge({}, table_a.get()));
ASSERT_TRUE(
- merger.mergeAndMangle({}, "com.app.b", tableB.get(), &collection));
+ merger.MergeAndMangle({}, "com.app.b", table_b.get(), &collection));
FileReference* f =
- test::getValue<FileReference>(&finalTable, "com.app.a:xml/file");
+ test::GetValue<FileReference>(&final_table, "com.app.a:xml/file");
ASSERT_NE(f, nullptr);
EXPECT_EQ(std::string("res/xml/file.xml"), *f->path);
- f = test::getValue<FileReference>(&finalTable,
+ f = test::GetValue<FileReference>(&final_table,
"com.app.a:xml/com.app.b$file");
ASSERT_NE(f, nullptr);
EXPECT_EQ(std::string("res/xml/com.app.b$file.xml"), *f->path);
@@ -156,25 +154,25 @@
TEST_F(TableMergerTest, OverrideResourceWithOverlay) {
std::unique_ptr<ResourceTable> base =
test::ResourceTableBuilder()
- .setPackageId("", 0x00)
- .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
- .build();
+ .SetPackageId("", 0x00)
+ .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+ .Build();
std::unique_ptr<ResourceTable> overlay =
test::ResourceTableBuilder()
- .setPackageId("", 0x00)
- .addValue("bool/foo", ResourceUtils::tryParseBool("false"))
- .build();
+ .SetPackageId("", 0x00)
+ .AddValue("bool/foo", ResourceUtils::TryParseBool("false"))
+ .Build();
- ResourceTable finalTable;
- TableMergerOptions tableMergerOptions;
- tableMergerOptions.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+ ResourceTable final_table;
+ TableMergerOptions options;
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, base.get()));
- ASSERT_TRUE(merger.mergeOverlay({}, overlay.get()));
+ ASSERT_TRUE(merger.Merge({}, base.get()));
+ ASSERT_TRUE(merger.MergeOverlay({}, overlay.get()));
BinaryPrimitive* foo =
- test::getValue<BinaryPrimitive>(&finalTable, "com.app.a:bool/foo");
+ test::GetValue<BinaryPrimitive>(&final_table, "com.app.a:bool/foo");
ASSERT_NE(nullptr, foo);
EXPECT_EQ(0x0u, foo->value.data);
}
@@ -182,170 +180,168 @@
TEST_F(TableMergerTest, OverrideSameResourceIdsWithOverlay) {
std::unique_ptr<ResourceTable> base =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
SymbolState::kPublic)
- .build();
+ .Build();
std::unique_ptr<ResourceTable> overlay =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
SymbolState::kPublic)
- .build();
+ .Build();
- ResourceTable finalTable;
- TableMergerOptions tableMergerOptions;
- tableMergerOptions.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+ ResourceTable final_table;
+ TableMergerOptions options;
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, base.get()));
- ASSERT_TRUE(merger.mergeOverlay({}, overlay.get()));
+ ASSERT_TRUE(merger.Merge({}, base.get()));
+ ASSERT_TRUE(merger.MergeOverlay({}, overlay.get()));
}
TEST_F(TableMergerTest, FailToOverrideConflictingTypeIdsWithOverlay) {
std::unique_ptr<ResourceTable> base =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
SymbolState::kPublic)
- .build();
+ .Build();
std::unique_ptr<ResourceTable> overlay =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", ResourceId(0x7f, 0x02, 0x0001),
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", ResourceId(0x7f, 0x02, 0x0001),
SymbolState::kPublic)
- .build();
+ .Build();
- ResourceTable finalTable;
- TableMergerOptions tableMergerOptions;
- tableMergerOptions.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+ ResourceTable final_table;
+ TableMergerOptions options;
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, base.get()));
- ASSERT_FALSE(merger.mergeOverlay({}, overlay.get()));
+ ASSERT_TRUE(merger.Merge({}, base.get()));
+ ASSERT_FALSE(merger.MergeOverlay({}, overlay.get()));
}
TEST_F(TableMergerTest, FailToOverrideConflictingEntryIdsWithOverlay) {
std::unique_ptr<ResourceTable> base =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0001),
SymbolState::kPublic)
- .build();
+ .Build();
std::unique_ptr<ResourceTable> overlay =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0002),
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", ResourceId(0x7f, 0x01, 0x0002),
SymbolState::kPublic)
- .build();
+ .Build();
- ResourceTable finalTable;
- TableMergerOptions tableMergerOptions;
- tableMergerOptions.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, tableMergerOptions);
+ ResourceTable final_table;
+ TableMergerOptions options;
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, base.get()));
- ASSERT_FALSE(merger.mergeOverlay({}, overlay.get()));
+ ASSERT_TRUE(merger.Merge({}, base.get()));
+ ASSERT_FALSE(merger.MergeOverlay({}, overlay.get()));
}
TEST_F(TableMergerTest, MergeAddResourceFromOverlay) {
- std::unique_ptr<ResourceTable> tableA =
+ std::unique_ptr<ResourceTable> table_a =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .setSymbolState("bool/foo", {}, SymbolState::kUndefined)
- .build();
- std::unique_ptr<ResourceTable> tableB =
+ .SetPackageId("", 0x7f)
+ .SetSymbolState("bool/foo", {}, SymbolState::kUndefined)
+ .Build();
+ std::unique_ptr<ResourceTable> table_b =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
- .build();
+ .SetPackageId("", 0x7f)
+ .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+ .Build();
- ResourceTable finalTable;
- TableMerger merger(mContext.get(), &finalTable, TableMergerOptions{});
+ ResourceTable final_table;
+ TableMerger merger(context_.get(), &final_table, TableMergerOptions{});
- ASSERT_TRUE(merger.merge({}, tableA.get()));
- ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
+ ASSERT_TRUE(merger.Merge({}, table_a.get()));
+ ASSERT_TRUE(merger.MergeOverlay({}, table_b.get()));
}
TEST_F(TableMergerTest, MergeAddResourceFromOverlayWithAutoAddOverlay) {
- std::unique_ptr<ResourceTable> tableA =
- test::ResourceTableBuilder().setPackageId("", 0x7f).build();
- std::unique_ptr<ResourceTable> tableB =
+ std::unique_ptr<ResourceTable> table_a =
+ test::ResourceTableBuilder().SetPackageId("", 0x7f).Build();
+ std::unique_ptr<ResourceTable> table_b =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
- .build();
+ .SetPackageId("", 0x7f)
+ .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+ .Build();
- ResourceTable finalTable;
+ ResourceTable final_table;
TableMergerOptions options;
- options.autoAddOverlay = true;
- TableMerger merger(mContext.get(), &finalTable, options);
+ options.auto_add_overlay = true;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, tableA.get()));
- ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
+ ASSERT_TRUE(merger.Merge({}, table_a.get()));
+ ASSERT_TRUE(merger.MergeOverlay({}, table_b.get()));
}
TEST_F(TableMergerTest, FailToMergeNewResourceWithoutAutoAddOverlay) {
- std::unique_ptr<ResourceTable> tableA =
- test::ResourceTableBuilder().setPackageId("", 0x7f).build();
- std::unique_ptr<ResourceTable> tableB =
+ std::unique_ptr<ResourceTable> table_a =
+ test::ResourceTableBuilder().SetPackageId("", 0x7f).Build();
+ std::unique_ptr<ResourceTable> table_b =
test::ResourceTableBuilder()
- .setPackageId("", 0x7f)
- .addValue("bool/foo", ResourceUtils::tryParseBool("true"))
- .build();
+ .SetPackageId("", 0x7f)
+ .AddValue("bool/foo", ResourceUtils::TryParseBool("true"))
+ .Build();
- ResourceTable finalTable;
+ ResourceTable final_table;
TableMergerOptions options;
- options.autoAddOverlay = false;
- TableMerger merger(mContext.get(), &finalTable, options);
+ options.auto_add_overlay = false;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, tableA.get()));
- ASSERT_FALSE(merger.mergeOverlay({}, tableB.get()));
+ ASSERT_TRUE(merger.Merge({}, table_a.get()));
+ ASSERT_FALSE(merger.MergeOverlay({}, table_b.get()));
}
TEST_F(TableMergerTest, OverlaidStyleablesShouldBeMerged) {
- std::unique_ptr<ResourceTable> tableA =
+ std::unique_ptr<ResourceTable> table_a =
test::ResourceTableBuilder()
- .setPackageId("com.app.a", 0x7f)
- .addValue("com.app.a:styleable/Foo",
+ .SetPackageId("com.app.a", 0x7f)
+ .AddValue("com.app.a:styleable/Foo",
test::StyleableBuilder()
- .addItem("com.app.a:attr/bar")
- .addItem("com.app.a:attr/foo", ResourceId(0x01010000))
- .build())
- .build();
+ .AddItem("com.app.a:attr/bar")
+ .AddItem("com.app.a:attr/foo", ResourceId(0x01010000))
+ .Build())
+ .Build();
- std::unique_ptr<ResourceTable> tableB =
+ std::unique_ptr<ResourceTable> table_b =
test::ResourceTableBuilder()
- .setPackageId("com.app.a", 0x7f)
- .addValue("com.app.a:styleable/Foo",
+ .SetPackageId("com.app.a", 0x7f)
+ .AddValue("com.app.a:styleable/Foo",
test::StyleableBuilder()
- .addItem("com.app.a:attr/bat")
- .addItem("com.app.a:attr/foo")
- .build())
- .build();
+ .AddItem("com.app.a:attr/bat")
+ .AddItem("com.app.a:attr/foo")
+ .Build())
+ .Build();
- ResourceTable finalTable;
+ ResourceTable final_table;
TableMergerOptions options;
- options.autoAddOverlay = true;
- TableMerger merger(mContext.get(), &finalTable, options);
+ options.auto_add_overlay = true;
+ TableMerger merger(context_.get(), &final_table, options);
- ASSERT_TRUE(merger.merge({}, tableA.get()));
- ASSERT_TRUE(merger.mergeOverlay({}, tableB.get()));
-
- Debug::printTable(&finalTable, {});
+ ASSERT_TRUE(merger.Merge({}, table_a.get()));
+ ASSERT_TRUE(merger.MergeOverlay({}, table_b.get()));
Styleable* styleable =
- test::getValue<Styleable>(&finalTable, "com.app.a:styleable/Foo");
+ test::GetValue<Styleable>(&final_table, "com.app.a:styleable/Foo");
ASSERT_NE(nullptr, styleable);
- std::vector<Reference> expectedRefs = {
- Reference(test::parseNameOrDie("com.app.a:attr/bar")),
- Reference(test::parseNameOrDie("com.app.a:attr/bat")),
- Reference(test::parseNameOrDie("com.app.a:attr/foo"),
+ std::vector<Reference> expected_refs = {
+ Reference(test::ParseNameOrDie("com.app.a:attr/bar")),
+ Reference(test::ParseNameOrDie("com.app.a:attr/bat")),
+ Reference(test::ParseNameOrDie("com.app.a:attr/foo"),
ResourceId(0x01010000)),
};
- EXPECT_EQ(expectedRefs, styleable->entries);
+ EXPECT_EQ(expected_refs, styleable->entries);
}
} // namespace aapt
diff --git a/tools/aapt2/link/VersionCollapser.cpp b/tools/aapt2/link/VersionCollapser.cpp
index 61a1f86..3df5899 100644
--- a/tools/aapt2/link/VersionCollapser.cpp
+++ b/tools/aapt2/link/VersionCollapser.cpp
@@ -14,50 +14,51 @@
* limitations under the License.
*/
-#include "ResourceTable.h"
#include "link/Linkers.h"
#include <algorithm>
#include <vector>
+#include "ResourceTable.h"
+
namespace aapt {
template <typename Iterator, typename Pred>
class FilterIterator {
public:
FilterIterator(Iterator begin, Iterator end, Pred pred = Pred())
- : mCurrent(begin), mEnd(end), mPred(pred) {
- advance();
+ : current_(begin), end_(end), pred_(pred) {
+ Advance();
}
- bool hasNext() { return mCurrent != mEnd; }
+ bool HasNext() { return current_ != end_; }
- Iterator nextIter() {
- Iterator iter = mCurrent;
- ++mCurrent;
- advance();
+ Iterator NextIter() {
+ Iterator iter = current_;
+ ++current_;
+ Advance();
return iter;
}
- typename Iterator::reference next() { return *nextIter(); }
+ typename Iterator::reference Next() { return *NextIter(); }
private:
- void advance() {
- for (; mCurrent != mEnd; ++mCurrent) {
- if (mPred(*mCurrent)) {
+ void Advance() {
+ for (; current_ != end_; ++current_) {
+ if (pred_(*current_)) {
return;
}
}
}
- Iterator mCurrent, mEnd;
- Pred mPred;
+ Iterator current_, end_;
+ Pred pred_;
};
template <typename Iterator, typename Pred>
-FilterIterator<Iterator, Pred> makeFilterIterator(Iterator begin,
- Iterator end = Iterator(),
- Pred pred = Pred()) {
+FilterIterator<Iterator, Pred> make_filter_iterator(Iterator begin,
+ Iterator end = Iterator(),
+ Pred pred = Pred()) {
return FilterIterator<Iterator, Pred>(begin, end, pred);
}
@@ -68,7 +69,7 @@
* next smallest
* one will be kept.
*/
-static void collapseVersions(int minSdk, ResourceEntry* entry) {
+static void CollapseVersions(int min_sdk, ResourceEntry* entry) {
// First look for all sdks less than minSdk.
for (auto iter = entry->values.rbegin(); iter != entry->values.rend();
++iter) {
@@ -78,15 +79,14 @@
}
const ConfigDescription& config = (*iter)->config;
- if (config.sdkVersion <= minSdk) {
+ if (config.sdkVersion <= min_sdk) {
// This is the first configuration we've found with a smaller or equal SDK
// level
// to the minimum. We MUST keep this one, but remove all others we find,
// which get
// overridden by this one.
- ConfigDescription configWithoutSdk = config;
- configWithoutSdk.sdkVersion = 0;
+ ConfigDescription config_without_sdk = config.CopyWithoutSdkVersion();
auto pred = [&](const std::unique_ptr<ResourceConfigValue>& val) -> bool {
// Check that the value hasn't already been marked for removal.
if (!val) {
@@ -94,16 +94,16 @@
}
// Only return Configs that differ in SDK version.
- configWithoutSdk.sdkVersion = val->config.sdkVersion;
- return configWithoutSdk == val->config &&
- val->config.sdkVersion <= minSdk;
+ config_without_sdk.sdkVersion = val->config.sdkVersion;
+ return config_without_sdk == val->config &&
+ val->config.sdkVersion <= min_sdk;
};
// Remove the rest that match.
- auto filterIter =
- makeFilterIterator(iter + 1, entry->values.rend(), pred);
- while (filterIter.hasNext()) {
- filterIter.next() = {};
+ auto filter_iter =
+ make_filter_iterator(iter + 1, entry->values.rend(), pred);
+ while (filter_iter.HasNext()) {
+ filter_iter.Next() = {};
}
}
}
@@ -121,16 +121,16 @@
// struct
// and take up less space in the resources.arsc table.
bool modified = false;
- for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
- if (configValue->config.sdkVersion != 0 &&
- configValue->config.sdkVersion <= minSdk) {
+ for (std::unique_ptr<ResourceConfigValue>& config_value : entry->values) {
+ if (config_value->config.sdkVersion != 0 &&
+ config_value->config.sdkVersion <= min_sdk) {
// Override the resource with a Configuration without an SDK.
- std::unique_ptr<ResourceConfigValue> newValue =
+ std::unique_ptr<ResourceConfigValue> new_value =
util::make_unique<ResourceConfigValue>(
- configValue->config.copyWithoutSdkVersion(),
- configValue->product);
- newValue->value = std::move(configValue->value);
- configValue = std::move(newValue);
+ config_value->config.CopyWithoutSdkVersion(),
+ config_value->product);
+ new_value->value = std::move(config_value->value);
+ config_value = std::move(new_value);
modified = true;
}
@@ -138,8 +138,7 @@
if (modified) {
// We've modified the keys (ConfigDescription) by changing the sdkVersion to
- // 0.
- // We MUST re-sort to ensure ordering guarantees hold.
+ // 0. We MUST re-sort to ensure ordering guarantees hold.
std::sort(entry->values.begin(), entry->values.end(),
[](const std::unique_ptr<ResourceConfigValue>& a,
const std::unique_ptr<ResourceConfigValue>& b) -> bool {
@@ -148,12 +147,12 @@
}
}
-bool VersionCollapser::consume(IAaptContext* context, ResourceTable* table) {
- const int minSdk = context->getMinSdkVersion();
+bool VersionCollapser::Consume(IAaptContext* context, ResourceTable* table) {
+ const int min_sdk = context->GetMinSdkVersion();
for (auto& package : table->packages) {
for (auto& type : package->types) {
for (auto& entry : type->entries) {
- collapseVersions(minSdk, entry.get());
+ CollapseVersions(min_sdk, entry.get());
}
}
}
diff --git a/tools/aapt2/link/VersionCollapser_test.cpp b/tools/aapt2/link/VersionCollapser_test.cpp
index c0e0ddb..1b5592f 100644
--- a/tools/aapt2/link/VersionCollapser_test.cpp
+++ b/tools/aapt2/link/VersionCollapser_test.cpp
@@ -15,103 +15,103 @@
*/
#include "link/Linkers.h"
+
#include "test/Test.h"
namespace aapt {
-template <typename T>
-using uptr = std::unique_ptr<T>;
-
-static uptr<ResourceTable> buildTableWithConfigs(
+static std::unique_ptr<ResourceTable> BuildTableWithConfigs(
const StringPiece& name, std::initializer_list<std::string> list) {
test::ResourceTableBuilder builder;
for (const std::string& item : list) {
- builder.addSimple(name, test::parseConfigOrDie(item));
+ builder.AddSimple(name, test::ParseConfigOrDie(item));
}
- return builder.build();
+ return builder.Build();
}
TEST(VersionCollapserTest, CollapseVersions) {
- uptr<IAaptContext> context =
- test::ContextBuilder().setMinSdkVersion(7).build();
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder().SetMinSdkVersion(7).Build();
- const StringPiece resName = "@android:string/foo";
+ const StringPiece res_name = "@android:string/foo";
- uptr<ResourceTable> table = buildTableWithConfigs(
- resName,
+ std::unique_ptr<ResourceTable> table = BuildTableWithConfigs(
+ res_name,
{"land-v4", "land-v5", "sw600dp", "land-v6", "land-v14", "land-v21"});
VersionCollapser collapser;
- ASSERT_TRUE(collapser.consume(context.get(), table.get()));
+ ASSERT_TRUE(collapser.Consume(context.get(), table.get()));
// These should be removed.
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v4")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v4")));
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v5")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v5")));
// This one should be removed because it was renamed to 'land', with the
// version dropped.
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v6")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v6")));
// These should remain.
EXPECT_NE(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("sw600dp")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("sw600dp")));
// 'land' should be present because it was renamed from 'land-v6'.
- EXPECT_NE(nullptr, test::getValueForConfig<Id>(
- table.get(), resName, test::parseConfigOrDie("land")));
EXPECT_NE(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v14")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land")));
EXPECT_NE(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v21")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v14")));
+ EXPECT_NE(nullptr,
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v21")));
}
TEST(VersionCollapserTest, CollapseVersionsWhenMinSdkIsHighest) {
- uptr<IAaptContext> context =
- test::ContextBuilder().setMinSdkVersion(21).build();
+ std::unique_ptr<IAaptContext> context =
+ test::ContextBuilder().SetMinSdkVersion(21).Build();
- const StringPiece resName = "@android:string/foo";
+ const StringPiece res_name = "@android:string/foo";
- uptr<ResourceTable> table = buildTableWithConfigs(
- resName, {"land-v4", "land-v5", "sw600dp", "land-v6", "land-v14",
- "land-v21", "land-v22"});
+ std::unique_ptr<ResourceTable> table = BuildTableWithConfigs(
+ res_name, {"land-v4", "land-v5", "sw600dp", "land-v6", "land-v14",
+ "land-v21", "land-v22"});
VersionCollapser collapser;
- ASSERT_TRUE(collapser.consume(context.get(), table.get()));
+ ASSERT_TRUE(collapser.Consume(context.get(), table.get()));
// These should all be removed.
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v4")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v4")));
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v5")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v5")));
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v6")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v6")));
EXPECT_EQ(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v14")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v14")));
// These should remain.
EXPECT_NE(nullptr,
- test::getValueForConfig<Id>(
- table.get(), resName,
- test::parseConfigOrDie("sw600dp").copyWithoutSdkVersion()));
+ test::GetValueForConfig<Id>(
+ table.get(), res_name,
+ test::ParseConfigOrDie("sw600dp").CopyWithoutSdkVersion()));
// land-v21 should have been converted to land.
- EXPECT_NE(nullptr, test::getValueForConfig<Id>(
- table.get(), resName, test::parseConfigOrDie("land")));
+ EXPECT_NE(nullptr,
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land")));
// land-v22 should remain as-is.
EXPECT_NE(nullptr,
- test::getValueForConfig<Id>(table.get(), resName,
- test::parseConfigOrDie("land-v22")));
+ test::GetValueForConfig<Id>(table.get(), res_name,
+ test::ParseConfigOrDie("land-v22")));
}
} // namespace aapt
diff --git a/tools/aapt2/link/XmlNamespaceRemover.cpp b/tools/aapt2/link/XmlNamespaceRemover.cpp
index 6e8d80d..24aa566 100644
--- a/tools/aapt2/link/XmlNamespaceRemover.cpp
+++ b/tools/aapt2/link/XmlNamespaceRemover.cpp
@@ -14,11 +14,12 @@
* limitations under the License.
*/
-#include "ResourceTable.h"
#include "link/Linkers.h"
#include <algorithm>
+#include "ResourceTable.h"
+
namespace aapt {
namespace {
@@ -28,12 +29,12 @@
*/
class XmlVisitor : public xml::Visitor {
public:
- XmlVisitor(bool keepUris) : mKeepUris(keepUris) {}
+ explicit XmlVisitor(bool keep_uris) : keep_uris_(keep_uris) {}
- void visit(xml::Element* el) override {
+ void Visit(xml::Element* el) override {
// Strip namespaces
for (auto& child : el->children) {
- while (child && xml::nodeCast<xml::Namespace>(child.get())) {
+ while (child && xml::NodeCast<xml::Namespace>(child.get())) {
if (child->children.empty()) {
child = {};
} else {
@@ -49,36 +50,38 @@
}),
el->children.end());
- if (!mKeepUris) {
+ if (!keep_uris_) {
for (xml::Attribute& attr : el->attributes) {
- attr.namespaceUri = std::string();
+ attr.namespace_uri = std::string();
}
- el->namespaceUri = std::string();
+ el->namespace_uri = std::string();
}
- xml::Visitor::visit(el);
+ xml::Visitor::Visit(el);
}
private:
- bool mKeepUris;
+ DISALLOW_COPY_AND_ASSIGN(XmlVisitor);
+
+ bool keep_uris_;
};
} // namespace
-bool XmlNamespaceRemover::consume(IAaptContext* context,
+bool XmlNamespaceRemover::Consume(IAaptContext* context,
xml::XmlResource* resource) {
if (!resource->root) {
return false;
}
// Replace any root namespaces until the root is a non-namespace node
- while (xml::nodeCast<xml::Namespace>(resource->root.get())) {
+ while (xml::NodeCast<xml::Namespace>(resource->root.get())) {
if (resource->root->children.empty()) {
break;
}
resource->root = std::move(resource->root->children.front());
resource->root->parent = nullptr;
}
- XmlVisitor visitor(mKeepUris);
- resource->root->accept(&visitor);
+ XmlVisitor visitor(keep_uris_);
+ resource->root->Accept(&visitor);
return true;
}
diff --git a/tools/aapt2/link/XmlNamespaceRemover_test.cpp b/tools/aapt2/link/XmlNamespaceRemover_test.cpp
index d2daaee..a176c03 100644
--- a/tools/aapt2/link/XmlNamespaceRemover_test.cpp
+++ b/tools/aapt2/link/XmlNamespaceRemover_test.cpp
@@ -15,83 +15,94 @@
*/
#include "link/Linkers.h"
+
#include "test/Test.h"
namespace aapt {
class XmlUriTestVisitor : public xml::Visitor {
public:
- void visit(xml::Element* el) override {
+ XmlUriTestVisitor() = default;
+
+ void Visit(xml::Element* el) override {
for (const auto& attr : el->attributes) {
- EXPECT_EQ(std::string(), attr.namespaceUri);
+ EXPECT_EQ(std::string(), attr.namespace_uri);
}
- EXPECT_EQ(std::string(), el->namespaceUri);
- xml::Visitor::visit(el);
+ EXPECT_EQ(std::string(), el->namespace_uri);
+ xml::Visitor::Visit(el);
}
- void visit(xml::Namespace* ns) override {
- EXPECT_EQ(std::string(), ns->namespaceUri);
- xml::Visitor::visit(ns);
+ void Visit(xml::Namespace* ns) override {
+ EXPECT_EQ(std::string(), ns->namespace_uri);
+ xml::Visitor::Visit(ns);
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlUriTestVisitor);
};
class XmlNamespaceTestVisitor : public xml::Visitor {
public:
- void visit(xml::Namespace* ns) override {
- ADD_FAILURE() << "Detected namespace: " << ns->namespacePrefix << "=\""
- << ns->namespaceUri << "\"";
- xml::Visitor::visit(ns);
+ XmlNamespaceTestVisitor() = default;
+
+ void Visit(xml::Namespace* ns) override {
+ ADD_FAILURE() << "Detected namespace: " << ns->namespace_prefix << "=\""
+ << ns->namespace_uri << "\"";
+ xml::Visitor::Visit(ns);
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(XmlNamespaceTestVisitor);
};
class XmlNamespaceRemoverTest : public ::testing::Test {
public:
void SetUp() override {
- mContext =
- test::ContextBuilder().setCompilationPackage("com.app.test").build();
+ context_ =
+ test::ContextBuilder().SetCompilationPackage("com.app.test").Build();
}
protected:
- std::unique_ptr<IAaptContext> mContext;
+ std::unique_ptr<IAaptContext> context_;
};
TEST_F(XmlNamespaceRemoverTest, RemoveUris) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:text="hello" />)EOF");
XmlNamespaceRemover remover;
- ASSERT_TRUE(remover.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(remover.Consume(context_.get(), doc.get()));
xml::Node* root = doc.get()->root.get();
ASSERT_NE(root, nullptr);
XmlUriTestVisitor visitor;
- root->accept(&visitor);
+ root->Accept(&visitor);
}
TEST_F(XmlNamespaceRemoverTest, RemoveNamespaces) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:foo="http://schemas.android.com/apk/res/foo"
foo:bar="foobar"
android:text="hello" />)EOF");
XmlNamespaceRemover remover;
- ASSERT_TRUE(remover.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(remover.Consume(context_.get(), doc.get()));
xml::Node* root = doc.get()->root.get();
ASSERT_NE(root, nullptr);
XmlNamespaceTestVisitor visitor;
- root->accept(&visitor);
+ root->Accept(&visitor);
}
TEST_F(XmlNamespaceRemoverTest, RemoveNestedNamespaces) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:text="hello">
<View xmlns:foo="http://schemas.example.com/foo"
@@ -99,13 +110,13 @@
</View>)EOF");
XmlNamespaceRemover remover;
- ASSERT_TRUE(remover.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(remover.Consume(context_.get(), doc.get()));
xml::Node* root = doc.get()->root.get();
ASSERT_NE(root, nullptr);
XmlNamespaceTestVisitor visitor;
- root->accept(&visitor);
+ root->Accept(&visitor);
}
} // namespace aapt
diff --git a/tools/aapt2/link/XmlReferenceLinker.cpp b/tools/aapt2/link/XmlReferenceLinker.cpp
index 945f98a..a819831 100644
--- a/tools/aapt2/link/XmlReferenceLinker.cpp
+++ b/tools/aapt2/link/XmlReferenceLinker.cpp
@@ -14,10 +14,11 @@
* limitations under the License.
*/
+#include "link/Linkers.h"
+
#include "Diagnostics.h"
#include "ResourceUtils.h"
#include "SdkConstants.h"
-#include "link/Linkers.h"
#include "link/ReferenceLinker.h"
#include "process/IResourceTableConsumer.h"
#include "process/SymbolTable.h"
@@ -37,31 +38,33 @@
*/
class ReferenceVisitor : public ValueVisitor {
public:
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
ReferenceVisitor(IAaptContext* context, SymbolTable* symbols,
- xml::IPackageDeclStack* decls, CallSite* callSite)
- : mContext(context),
- mSymbols(symbols),
- mDecls(decls),
- mCallSite(callSite),
- mError(false) {}
+ xml::IPackageDeclStack* decls, CallSite* callsite)
+ : context_(context),
+ symbols_(symbols),
+ decls_(decls),
+ callsite_(callsite),
+ error_(false) {}
- void visit(Reference* ref) override {
- if (!ReferenceLinker::linkReference(ref, mContext, mSymbols, mDecls,
- mCallSite)) {
- mError = true;
+ void Visit(Reference* ref) override {
+ if (!ReferenceLinker::LinkReference(ref, context_, symbols_, decls_,
+ callsite_)) {
+ error_ = true;
}
}
- bool hasError() const { return mError; }
+ bool HasError() const { return error_; }
private:
- IAaptContext* mContext;
- SymbolTable* mSymbols;
- xml::IPackageDeclStack* mDecls;
- CallSite* mCallSite;
- bool mError;
+ DISALLOW_COPY_AND_ASSIGN(ReferenceVisitor);
+
+ IAaptContext* context_;
+ SymbolTable* symbols_;
+ xml::IPackageDeclStack* decls_;
+ CallSite* callsite_;
+ bool error_;
};
/**
@@ -69,114 +72,117 @@
*/
class XmlVisitor : public xml::PackageAwareVisitor {
public:
- using xml::PackageAwareVisitor::visit;
+ using xml::PackageAwareVisitor::Visit;
XmlVisitor(IAaptContext* context, SymbolTable* symbols, const Source& source,
- std::set<int>* sdkLevelsFound, CallSite* callSite)
- : mContext(context),
- mSymbols(symbols),
- mSource(source),
- mSdkLevelsFound(sdkLevelsFound),
- mCallSite(callSite),
- mReferenceVisitor(context, symbols, this, callSite) {}
+ std::set<int>* sdk_levels_found, CallSite* callsite)
+ : context_(context),
+ symbols_(symbols),
+ source_(source),
+ sdk_levels_found_(sdk_levels_found),
+ callsite_(callsite),
+ reference_visitor_(context, symbols, this, callsite) {}
- void visit(xml::Element* el) override {
- const Source source = mSource.withLine(el->lineNumber);
+ void Visit(xml::Element* el) override {
+ const Source source = source_.WithLine(el->line_number);
for (xml::Attribute& attr : el->attributes) {
- Maybe<xml::ExtractedPackage> maybePackage =
- xml::extractPackageFromNamespace(attr.namespaceUri);
- if (maybePackage) {
+ Maybe<xml::ExtractedPackage> maybe_package =
+ xml::ExtractPackageFromNamespace(attr.namespace_uri);
+ if (maybe_package) {
// There is a valid package name for this attribute. We will look this
// up.
- StringPiece package = maybePackage.value().package;
+ StringPiece package = maybe_package.value().package;
if (package.empty()) {
// Empty package means the 'current' or 'local' package.
- package = mContext->getCompilationPackage();
+ package = context_->GetCompilationPackage();
}
- Reference attrRef(
+ Reference attr_ref(
ResourceNameRef(package, ResourceType::kAttr, attr.name));
- attrRef.privateReference = maybePackage.value().privateNamespace;
+ attr_ref.private_reference = maybe_package.value().private_namespace;
- std::string errStr;
- attr.compiledAttribute = ReferenceLinker::compileXmlAttribute(
- attrRef, mContext->getNameMangler(), mSymbols, mCallSite, &errStr);
+ std::string err_str;
+ attr.compiled_attribute = ReferenceLinker::CompileXmlAttribute(
+ attr_ref, context_->GetNameMangler(), symbols_, callsite_,
+ &err_str);
// Convert the string value into a compiled Value if this is a valid
// attribute.
- if (attr.compiledAttribute) {
- if (attr.compiledAttribute.value().id) {
+ if (attr.compiled_attribute) {
+ if (attr.compiled_attribute.value().id) {
// Record all SDK levels from which the attributes were defined.
- const size_t sdkLevel = findAttributeSdkLevel(
- attr.compiledAttribute.value().id.value());
- if (sdkLevel > 1) {
- mSdkLevelsFound->insert(sdkLevel);
+ const size_t sdk_level = FindAttributeSdkLevel(
+ attr.compiled_attribute.value().id.value());
+ if (sdk_level > 1) {
+ sdk_levels_found_->insert(sdk_level);
}
}
const Attribute* attribute =
- &attr.compiledAttribute.value().attribute;
- attr.compiledValue =
- ResourceUtils::tryParseItemForAttribute(attr.value, attribute);
- if (!attr.compiledValue &&
- !(attribute->typeMask & android::ResTable_map::TYPE_STRING)) {
+ &attr.compiled_attribute.value().attribute;
+ attr.compiled_value =
+ ResourceUtils::TryParseItemForAttribute(attr.value, attribute);
+ if (!attr.compiled_value &&
+ !(attribute->type_mask & android::ResTable_map::TYPE_STRING)) {
// We won't be able to encode this as a string.
- mContext->getDiagnostics()->error(
+ context_->GetDiagnostics()->Error(
DiagMessage(source) << "'" << attr.value << "' "
<< "is incompatible with attribute "
<< package << ":" << attr.name << " "
<< *attribute);
- mError = true;
+ error_ = true;
}
} else {
- mContext->getDiagnostics()->error(DiagMessage(source)
+ context_->GetDiagnostics()->Error(DiagMessage(source)
<< "attribute '" << package << ":"
- << attr.name << "' " << errStr);
- mError = true;
+ << attr.name << "' " << err_str);
+ error_ = true;
}
- } else if (!attr.compiledValue) {
+ } else if (!attr.compiled_value) {
// We still encode references, but only if we haven't manually set this
// to
// another compiled value.
- attr.compiledValue = ResourceUtils::tryParseReference(attr.value);
+ attr.compiled_value = ResourceUtils::TryParseReference(attr.value);
}
- if (attr.compiledValue) {
+ if (attr.compiled_value) {
// With a compiledValue, we must resolve the reference and assign it an
// ID.
- attr.compiledValue->setSource(source);
- attr.compiledValue->accept(&mReferenceVisitor);
+ attr.compiled_value->SetSource(source);
+ attr.compiled_value->Accept(&reference_visitor_);
}
}
// Call the super implementation.
- xml::PackageAwareVisitor::visit(el);
+ xml::PackageAwareVisitor::Visit(el);
}
- bool hasError() { return mError || mReferenceVisitor.hasError(); }
+ bool HasError() { return error_ || reference_visitor_.HasError(); }
private:
- IAaptContext* mContext;
- SymbolTable* mSymbols;
- Source mSource;
- std::set<int>* mSdkLevelsFound;
- CallSite* mCallSite;
- ReferenceVisitor mReferenceVisitor;
- bool mError = false;
+ DISALLOW_COPY_AND_ASSIGN(XmlVisitor);
+
+ IAaptContext* context_;
+ SymbolTable* symbols_;
+ Source source_;
+ std::set<int>* sdk_levels_found_;
+ CallSite* callsite_;
+ ReferenceVisitor reference_visitor_;
+ bool error_ = false;
};
} // namespace
-bool XmlReferenceLinker::consume(IAaptContext* context,
+bool XmlReferenceLinker::Consume(IAaptContext* context,
xml::XmlResource* resource) {
- mSdkLevelsFound.clear();
- CallSite callSite = {resource->file.name};
- XmlVisitor visitor(context, context->getExternalSymbols(),
- resource->file.source, &mSdkLevelsFound, &callSite);
+ sdk_levels_found_.clear();
+ CallSite callsite = {resource->file.name};
+ XmlVisitor visitor(context, context->GetExternalSymbols(),
+ resource->file.source, &sdk_levels_found_, &callsite);
if (resource->root) {
- resource->root->accept(&visitor);
- return !visitor.hasError();
+ resource->root->Accept(&visitor);
+ return !visitor.HasError();
}
return false;
}
diff --git a/tools/aapt2/link/XmlReferenceLinker_test.cpp b/tools/aapt2/link/XmlReferenceLinker_test.cpp
index 35d479f..810f63c 100644
--- a/tools/aapt2/link/XmlReferenceLinker_test.cpp
+++ b/tools/aapt2/link/XmlReferenceLinker_test.cpp
@@ -15,6 +15,7 @@
*/
#include "link/Linkers.h"
+
#include "test/Test.h"
namespace aapt {
@@ -22,72 +23,72 @@
class XmlReferenceLinkerTest : public ::testing::Test {
public:
void SetUp() override {
- mContext =
+ context_ =
test::ContextBuilder()
- .setCompilationPackage("com.app.test")
- .setNameManglerPolicy(
+ .SetCompilationPackage("com.app.test")
+ .SetNameManglerPolicy(
NameManglerPolicy{"com.app.test", {"com.android.support"}})
- .addSymbolSource(
+ .AddSymbolSource(
test::StaticSymbolSourceBuilder()
- .addPublicSymbol(
+ .AddPublicSymbol(
"android:attr/layout_width", ResourceId(0x01010000),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_ENUM |
+ .SetTypeMask(android::ResTable_map::TYPE_ENUM |
android::ResTable_map::TYPE_DIMENSION)
- .addItem("match_parent", 0xffffffff)
- .build())
- .addPublicSymbol(
+ .AddItem("match_parent", 0xffffffff)
+ .Build())
+ .AddPublicSymbol(
"android:attr/background", ResourceId(0x01010001),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_COLOR)
- .build())
- .addPublicSymbol("android:attr/attr",
+ .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+ .Build())
+ .AddPublicSymbol("android:attr/attr",
ResourceId(0x01010002),
- test::AttributeBuilder().build())
- .addPublicSymbol(
+ test::AttributeBuilder().Build())
+ .AddPublicSymbol(
"android:attr/text", ResourceId(0x01010003),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_STRING)
- .build())
+ .SetTypeMask(android::ResTable_map::TYPE_STRING)
+ .Build())
// Add one real symbol that was introduces in v21
- .addPublicSymbol("android:attr/colorAccent",
+ .AddPublicSymbol("android:attr/colorAccent",
ResourceId(0x01010435),
- test::AttributeBuilder().build())
+ test::AttributeBuilder().Build())
// Private symbol.
- .addSymbol("android:color/hidden", ResourceId(0x01020001))
+ .AddSymbol("android:color/hidden", ResourceId(0x01020001))
- .addPublicSymbol("android:id/id", ResourceId(0x01030000))
- .addSymbol("com.app.test:id/id", ResourceId(0x7f030000))
- .addSymbol("com.app.test:color/green",
+ .AddPublicSymbol("android:id/id", ResourceId(0x01030000))
+ .AddSymbol("com.app.test:id/id", ResourceId(0x7f030000))
+ .AddSymbol("com.app.test:color/green",
ResourceId(0x7f020000))
- .addSymbol("com.app.test:color/red", ResourceId(0x7f020001))
- .addSymbol(
+ .AddSymbol("com.app.test:color/red", ResourceId(0x7f020001))
+ .AddSymbol(
"com.app.test:attr/colorAccent", ResourceId(0x7f010000),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_COLOR)
- .build())
- .addPublicSymbol(
+ .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+ .Build())
+ .AddPublicSymbol(
"com.app.test:attr/com.android.support$colorAccent",
ResourceId(0x7f010001),
test::AttributeBuilder()
- .setTypeMask(android::ResTable_map::TYPE_COLOR)
- .build())
- .addPublicSymbol("com.app.test:attr/attr",
+ .SetTypeMask(android::ResTable_map::TYPE_COLOR)
+ .Build())
+ .AddPublicSymbol("com.app.test:attr/attr",
ResourceId(0x7f010002),
- test::AttributeBuilder().build())
- .build())
- .build();
+ test::AttributeBuilder().Build())
+ .Build())
+ .Build();
}
protected:
- std::unique_ptr<IAaptContext> mContext;
+ std::unique_ptr<IAaptContext> context_;
};
TEST_F(XmlReferenceLinkerTest, LinkBasicAttributes) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:background="@color/green"
@@ -95,123 +96,125 @@
class="hello" />)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
- xml::Element* viewEl = xml::findRootElement(doc.get());
- ASSERT_NE(viewEl, nullptr);
+ xml::Element* view_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(view_el, nullptr);
- xml::Attribute* xmlAttr =
- viewEl->findAttribute(xml::kSchemaAndroid, "layout_width");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml::Attribute* xml_attr =
+ view_el->FindAttribute(xml::kSchemaAndroid, "layout_width");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x01010000));
- ASSERT_NE(xmlAttr->compiledValue, nullptr);
- ASSERT_NE(valueCast<BinaryPrimitive>(xmlAttr->compiledValue.get()), nullptr);
+ ASSERT_NE(xml_attr->compiled_value, nullptr);
+ ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()),
+ nullptr);
- xmlAttr = viewEl->findAttribute(xml::kSchemaAndroid, "background");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "background");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x01010001));
- ASSERT_NE(xmlAttr->compiledValue, nullptr);
- Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+ ASSERT_NE(xml_attr->compiled_value, nullptr);
+ Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->name);
EXPECT_EQ(ref->name.value(),
- test::parseNameOrDie("color/green")); // Make sure the name
+ test::ParseNameOrDie("color/green")); // Make sure the name
// didn't change.
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f020000));
- xmlAttr = viewEl->findAttribute(xml::kSchemaAndroid, "text");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
+ xml_attr = view_el->FindAttribute(xml::kSchemaAndroid, "text");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
ASSERT_FALSE(
- xmlAttr->compiledValue); // Strings don't get compiled for memory sake.
+ xml_attr->compiled_value); // Strings don't get compiled for memory sake.
- xmlAttr = viewEl->findAttribute("", "class");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_FALSE(xmlAttr->compiledAttribute);
- ASSERT_EQ(xmlAttr->compiledValue, nullptr);
+ xml_attr = view_el->FindAttribute("", "class");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_FALSE(xml_attr->compiled_attribute);
+ ASSERT_EQ(xml_attr->compiled_value, nullptr);
}
TEST_F(XmlReferenceLinkerTest, PrivateSymbolsAreNotLinked) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:colorAccent="@android:color/hidden" />)EOF");
XmlReferenceLinker linker;
- ASSERT_FALSE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_FALSE(linker.Consume(context_.get(), doc.get()));
}
TEST_F(XmlReferenceLinkerTest,
PrivateSymbolsAreLinkedWhenReferenceHasStarPrefix) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:colorAccent="@*android:color/hidden" />)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
}
TEST_F(XmlReferenceLinkerTest, SdkLevelsAreRecorded) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/android"
android:colorAccent="#ffffff" />)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
- EXPECT_TRUE(linker.getSdkLevels().count(21) == 1);
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
+ EXPECT_TRUE(linker.sdk_levels().count(21) == 1);
}
TEST_F(XmlReferenceLinkerTest, LinkMangledAttributes) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:support="http://schemas.android.com/apk/res/com.android.support"
support:colorAccent="#ff0000" />)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
- xml::Element* viewEl = xml::findRootElement(doc.get());
- ASSERT_NE(viewEl, nullptr);
+ xml::Element* view_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(view_el, nullptr);
- xml::Attribute* xmlAttr = viewEl->findAttribute(
- xml::buildPackageNamespace("com.android.support"), "colorAccent");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml::Attribute* xml_attr = view_el->FindAttribute(
+ xml::BuildPackageNamespace("com.android.support"), "colorAccent");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x7f010001));
- ASSERT_NE(valueCast<BinaryPrimitive>(xmlAttr->compiledValue.get()), nullptr);
+ ASSERT_NE(ValueCast<BinaryPrimitive>(xml_attr->compiled_value.get()),
+ nullptr);
}
TEST_F(XmlReferenceLinkerTest, LinkAutoResReference) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:app="http://schemas.android.com/apk/res-auto"
app:colorAccent="@app:color/red" />)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
- xml::Element* viewEl = xml::findRootElement(doc.get());
- ASSERT_NE(viewEl, nullptr);
+ xml::Element* view_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(view_el, nullptr);
- xml::Attribute* xmlAttr =
- viewEl->findAttribute(xml::kSchemaAuto, "colorAccent");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml::Attribute* xml_attr =
+ view_el->FindAttribute(xml::kSchemaAuto, "colorAccent");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x7f010000));
- Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+ Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->name);
AAPT_ASSERT_TRUE(ref->id);
@@ -220,7 +223,7 @@
TEST_F(XmlReferenceLinkerTest, LinkViewWithShadowedPackageAlias) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:app="http://schemas.android.com/apk/res/android"
app:attr="@app:id/id">
<View xmlns:app="http://schemas.android.com/apk/res/com.app.test"
@@ -228,38 +231,39 @@
</View>)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
- xml::Element* viewEl = xml::findRootElement(doc.get());
- ASSERT_NE(viewEl, nullptr);
+ xml::Element* view_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(view_el, nullptr);
// All attributes and references in this element should be referring to
// "android" (0x01).
- xml::Attribute* xmlAttr = viewEl->findAttribute(xml::kSchemaAndroid, "attr");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml::Attribute* xml_attr =
+ view_el->FindAttribute(xml::kSchemaAndroid, "attr");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x01010002));
- Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+ Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x01030000));
- ASSERT_FALSE(viewEl->getChildElements().empty());
- viewEl = viewEl->getChildElements().front();
- ASSERT_NE(viewEl, nullptr);
+ ASSERT_FALSE(view_el->GetChildElements().empty());
+ view_el = view_el->GetChildElements().front();
+ ASSERT_NE(view_el, nullptr);
// All attributes and references in this element should be referring to
// "com.app.test" (0x7f).
- xmlAttr =
- viewEl->findAttribute(xml::buildPackageNamespace("com.app.test"), "attr");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml_attr = view_el->FindAttribute(xml::BuildPackageNamespace("com.app.test"),
+ "attr");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x7f010002));
- ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+ ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
@@ -267,26 +271,26 @@
TEST_F(XmlReferenceLinkerTest, LinkViewWithLocalPackageAndAliasOfTheSameName) {
std::unique_ptr<xml::XmlResource> doc =
- test::buildXmlDomForPackageName(mContext.get(), R"EOF(
+ test::BuildXmlDomForPackageName(context_.get(), R"EOF(
<View xmlns:android="http://schemas.android.com/apk/res/com.app.test"
android:attr="@id/id"/>)EOF");
XmlReferenceLinker linker;
- ASSERT_TRUE(linker.consume(mContext.get(), doc.get()));
+ ASSERT_TRUE(linker.Consume(context_.get(), doc.get()));
- xml::Element* viewEl = xml::findRootElement(doc.get());
- ASSERT_NE(viewEl, nullptr);
+ xml::Element* view_el = xml::FindRootElement(doc.get());
+ ASSERT_NE(view_el, nullptr);
// All attributes and references in this element should be referring to
// "com.app.test" (0x7f).
- xml::Attribute* xmlAttr =
- viewEl->findAttribute(xml::buildPackageNamespace("com.app.test"), "attr");
- ASSERT_NE(xmlAttr, nullptr);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute);
- AAPT_ASSERT_TRUE(xmlAttr->compiledAttribute.value().id);
- EXPECT_EQ(xmlAttr->compiledAttribute.value().id.value(),
+ xml::Attribute* xml_attr = view_el->FindAttribute(
+ xml::BuildPackageNamespace("com.app.test"), "attr");
+ ASSERT_NE(xml_attr, nullptr);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute);
+ AAPT_ASSERT_TRUE(xml_attr->compiled_attribute.value().id);
+ EXPECT_EQ(xml_attr->compiled_attribute.value().id.value(),
ResourceId(0x7f010002));
- Reference* ref = valueCast<Reference>(xmlAttr->compiledValue.get());
+ Reference* ref = ValueCast<Reference>(xml_attr->compiled_value.get());
ASSERT_NE(ref, nullptr);
AAPT_ASSERT_TRUE(ref->id);
EXPECT_EQ(ref->id.value(), ResourceId(0x7f030000));
diff --git a/tools/aapt2/process/IResourceTableConsumer.h b/tools/aapt2/process/IResourceTableConsumer.h
index a9bde39..4526a79 100644
--- a/tools/aapt2/process/IResourceTableConsumer.h
+++ b/tools/aapt2/process/IResourceTableConsumer.h
@@ -17,16 +17,16 @@
#ifndef AAPT_PROCESS_IRESOURCETABLECONSUMER_H
#define AAPT_PROCESS_IRESOURCETABLECONSUMER_H
+#include <iostream>
+#include <list>
+#include <sstream>
+
#include "Diagnostics.h"
#include "NameMangler.h"
#include "Resource.h"
#include "ResourceValues.h"
#include "Source.h"
-#include <iostream>
-#include <list>
-#include <sstream>
-
namespace aapt {
class ResourceTable;
@@ -35,19 +35,19 @@
struct IAaptContext {
virtual ~IAaptContext() = default;
- virtual SymbolTable* getExternalSymbols() = 0;
- virtual IDiagnostics* getDiagnostics() = 0;
- virtual const std::string& getCompilationPackage() = 0;
- virtual uint8_t getPackageId() = 0;
- virtual NameMangler* getNameMangler() = 0;
- virtual bool verbose() = 0;
- virtual int getMinSdkVersion() = 0;
+ virtual SymbolTable* GetExternalSymbols() = 0;
+ virtual IDiagnostics* GetDiagnostics() = 0;
+ virtual const std::string& GetCompilationPackage() = 0;
+ virtual uint8_t GetPackageId() = 0;
+ virtual NameMangler* GetNameMangler() = 0;
+ virtual bool IsVerbose() = 0;
+ virtual int GetMinSdkVersion() = 0;
};
struct IResourceTableConsumer {
virtual ~IResourceTableConsumer() = default;
- virtual bool consume(IAaptContext* context, ResourceTable* table) = 0;
+ virtual bool Consume(IAaptContext* context, ResourceTable* table) = 0;
};
namespace xml {
@@ -57,7 +57,7 @@
struct IXmlResourceConsumer {
virtual ~IXmlResourceConsumer() = default;
- virtual bool consume(IAaptContext* context, xml::XmlResource* resource) = 0;
+ virtual bool Consume(IAaptContext* context, xml::XmlResource* resource) = 0;
};
} // namespace aapt
diff --git a/tools/aapt2/process/SymbolTable.cpp b/tools/aapt2/process/SymbolTable.cpp
index 00ffeb2..767384d 100644
--- a/tools/aapt2/process/SymbolTable.cpp
+++ b/tools/aapt2/process/SymbolTable.cpp
@@ -15,80 +15,81 @@
*/
#include "process/SymbolTable.h"
+
+#include "androidfw/AssetManager.h"
+#include "androidfw/ResourceTypes.h"
+
#include "ConfigDescription.h"
#include "Resource.h"
#include "ResourceUtils.h"
#include "ValueVisitor.h"
#include "util/Util.h"
-#include <androidfw/AssetManager.h>
-#include <androidfw/ResourceTypes.h>
-
namespace aapt {
-void SymbolTable::appendSource(std::unique_ptr<ISymbolSource> source) {
- mSources.push_back(std::move(source));
+void SymbolTable::AppendSource(std::unique_ptr<ISymbolSource> source) {
+ sources_.push_back(std::move(source));
// We do not clear the cache, because sources earlier in the list take
// precedent.
}
-void SymbolTable::prependSource(std::unique_ptr<ISymbolSource> source) {
- mSources.insert(mSources.begin(), std::move(source));
+void SymbolTable::PrependSource(std::unique_ptr<ISymbolSource> source) {
+ sources_.insert(sources_.begin(), std::move(source));
// We must clear the cache in case we did a lookup before adding this
// resource.
- mCache.clear();
+ cache_.clear();
}
-const SymbolTable::Symbol* SymbolTable::findByName(const ResourceName& name) {
- if (const std::shared_ptr<Symbol>& s = mCache.get(name)) {
+const SymbolTable::Symbol* SymbolTable::FindByName(const ResourceName& name) {
+ if (const std::shared_ptr<Symbol>& s = cache_.get(name)) {
return s.get();
}
// We did not find it in the cache, so look through the sources.
- for (auto& symbolSource : mSources) {
- std::unique_ptr<Symbol> symbol = symbolSource->findByName(name);
+ for (auto& symbolSource : sources_) {
+ std::unique_ptr<Symbol> symbol = symbolSource->FindByName(name);
if (symbol) {
// Take ownership of the symbol into a shared_ptr. We do this because
// LruCache
// doesn't support unique_ptr.
- std::shared_ptr<Symbol> sharedSymbol =
+ std::shared_ptr<Symbol> shared_symbol =
std::shared_ptr<Symbol>(symbol.release());
- mCache.put(name, sharedSymbol);
+ cache_.put(name, shared_symbol);
- if (sharedSymbol->id) {
+ if (shared_symbol->id) {
// The symbol has an ID, so we can also cache this!
- mIdCache.put(sharedSymbol->id.value(), sharedSymbol);
+ id_cache_.put(shared_symbol->id.value(), shared_symbol);
}
- return sharedSymbol.get();
+ return shared_symbol.get();
}
}
return nullptr;
}
-const SymbolTable::Symbol* SymbolTable::findById(const ResourceId& id) {
- if (const std::shared_ptr<Symbol>& s = mIdCache.get(id)) {
+const SymbolTable::Symbol* SymbolTable::FindById(const ResourceId& id) {
+ if (const std::shared_ptr<Symbol>& s = id_cache_.get(id)) {
return s.get();
}
// We did not find it in the cache, so look through the sources.
- for (auto& symbolSource : mSources) {
- std::unique_ptr<Symbol> symbol = symbolSource->findById(id);
+ for (auto& symbolSource : sources_) {
+ std::unique_ptr<Symbol> symbol = symbolSource->FindById(id);
if (symbol) {
// Take ownership of the symbol into a shared_ptr. We do this because
// LruCache
// doesn't support unique_ptr.
- std::shared_ptr<Symbol> sharedSymbol =
+ std::shared_ptr<Symbol> shared_symbol =
std::shared_ptr<Symbol>(symbol.release());
- mIdCache.put(id, sharedSymbol);
- return sharedSymbol.get();
+ id_cache_.put(id, shared_symbol);
+ return shared_symbol.get();
}
}
return nullptr;
}
-const SymbolTable::Symbol* SymbolTable::findByReference(const Reference& ref) {
+const SymbolTable::Symbol* SymbolTable::FindByReference(const Reference& ref) {
// First try the ID. This is because when we lookup by ID, we only fill in the
// ID cache.
// Looking up by name fills in the name and ID cache. So a cache miss will
@@ -102,22 +103,22 @@
// succeeded to lookup by ID. Subsequent lookups will miss then hit.
const SymbolTable::Symbol* symbol = nullptr;
if (ref.id) {
- symbol = findById(ref.id.value());
+ symbol = FindById(ref.id.value());
}
if (ref.name && !symbol) {
- symbol = findByName(ref.name.value());
+ symbol = FindByName(ref.name.value());
}
return symbol;
}
-std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::findByName(
+std::unique_ptr<SymbolTable::Symbol> ResourceTableSymbolSource::FindByName(
const ResourceName& name) {
- Maybe<ResourceTable::SearchResult> result = mTable->findResource(name);
+ Maybe<ResourceTable::SearchResult> result = table_->FindResource(name);
if (!result) {
if (name.type == ResourceType::kAttr) {
// Recurse and try looking up a private attribute.
- return findByName(
+ return FindByName(
ResourceName(name.package, ResourceType::kAttrPrivate, name.entry));
}
return {};
@@ -127,7 +128,7 @@
std::unique_ptr<SymbolTable::Symbol> symbol =
util::make_unique<SymbolTable::Symbol>();
- symbol->isPublic = (sr.entry->symbolStatus.state == SymbolState::kPublic);
+ symbol->is_public = (sr.entry->symbol_status.state == SymbolState::kPublic);
if (sr.package->id && sr.type->id && sr.entry->id) {
symbol->id = ResourceId(sr.package->id.value(), sr.type->id.value(),
@@ -137,10 +138,10 @@
if (name.type == ResourceType::kAttr ||
name.type == ResourceType::kAttrPrivate) {
const ConfigDescription kDefaultConfig;
- ResourceConfigValue* configValue = sr.entry->findValue(kDefaultConfig);
- if (configValue) {
+ ResourceConfigValue* config_value = sr.entry->FindValue(kDefaultConfig);
+ if (config_value) {
// This resource has an Attribute.
- if (Attribute* attr = valueCast<Attribute>(configValue->value.get())) {
+ if (Attribute* attr = ValueCast<Attribute>(config_value->value.get())) {
symbol->attribute = std::make_shared<Attribute>(*attr);
} else {
return {};
@@ -150,13 +151,13 @@
return symbol;
}
-bool AssetManagerSymbolSource::addAssetPath(const StringPiece& path) {
+bool AssetManagerSymbolSource::AddAssetPath(const StringPiece& path) {
int32_t cookie = 0;
- return mAssets.addAssetPath(android::String8(path.data(), path.size()),
+ return assets_.addAssetPath(android::String8(path.data(), path.size()),
&cookie);
}
-static std::unique_ptr<SymbolTable::Symbol> lookupAttributeInTable(
+static std::unique_ptr<SymbolTable::Symbol> LookupAttributeInTable(
const android::ResTable& table, ResourceId id) {
// Try as a bag.
const android::ResTable::bag_entry* entry;
@@ -175,41 +176,42 @@
for (size_t i = 0; i < (size_t)count; i++) {
if (entry[i].map.name.ident == android::ResTable_map::ATTR_TYPE) {
s->attribute = std::make_shared<Attribute>(false);
- s->attribute->typeMask = entry[i].map.value.data;
+ s->attribute->type_mask = entry[i].map.value.data;
break;
}
}
if (s->attribute) {
for (size_t i = 0; i < (size_t)count; i++) {
- const android::ResTable_map& mapEntry = entry[i].map;
- if (Res_INTERNALID(mapEntry.name.ident)) {
- switch (mapEntry.name.ident) {
+ const android::ResTable_map& map_entry = entry[i].map;
+ if (Res_INTERNALID(map_entry.name.ident)) {
+ switch (map_entry.name.ident) {
case android::ResTable_map::ATTR_MIN:
- s->attribute->minInt = static_cast<int32_t>(mapEntry.value.data);
+ s->attribute->min_int = static_cast<int32_t>(map_entry.value.data);
break;
case android::ResTable_map::ATTR_MAX:
- s->attribute->maxInt = static_cast<int32_t>(mapEntry.value.data);
+ s->attribute->max_int = static_cast<int32_t>(map_entry.value.data);
break;
}
continue;
}
- android::ResTable::resource_name entryName;
- if (!table.getResourceName(mapEntry.name.ident, false, &entryName)) {
+ android::ResTable::resource_name entry_name;
+ if (!table.getResourceName(map_entry.name.ident, false, &entry_name)) {
table.unlockBag(entry);
return nullptr;
}
- Maybe<ResourceName> parsedName = ResourceUtils::toResourceName(entryName);
- if (!parsedName) {
+ Maybe<ResourceName> parsed_name =
+ ResourceUtils::ToResourceName(entry_name);
+ if (!parsed_name) {
return nullptr;
}
Attribute::Symbol symbol;
- symbol.symbol.name = parsedName.value();
- symbol.symbol.id = ResourceId(mapEntry.name.ident);
- symbol.value = mapEntry.value.data;
+ symbol.symbol.name = parsed_name.value();
+ symbol.symbol.id = ResourceId(map_entry.name.ident);
+ symbol.value = map_entry.value.data;
s->attribute->symbols.push_back(std::move(symbol));
}
}
@@ -217,81 +219,81 @@
return s;
}
-std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::findByName(
+std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindByName(
const ResourceName& name) {
- const android::ResTable& table = mAssets.getResources(false);
+ const android::ResTable& table = assets_.getResources(false);
- const std::u16string package16 = util::utf8ToUtf16(name.package);
- const std::u16string type16 = util::utf8ToUtf16(toString(name.type));
- const std::u16string entry16 = util::utf8ToUtf16(name.entry);
+ const std::u16string package16 = util::Utf8ToUtf16(name.package);
+ const std::u16string type16 = util::Utf8ToUtf16(ToString(name.type));
+ const std::u16string entry16 = util::Utf8ToUtf16(name.entry);
- uint32_t typeSpecFlags = 0;
- ResourceId resId = table.identifierForName(
+ uint32_t type_spec_flags = 0;
+ ResourceId res_id = table.identifierForName(
entry16.data(), entry16.size(), type16.data(), type16.size(),
- package16.data(), package16.size(), &typeSpecFlags);
- if (!resId.isValid()) {
+ package16.data(), package16.size(), &type_spec_flags);
+ if (!res_id.is_valid()) {
return {};
}
std::unique_ptr<SymbolTable::Symbol> s;
if (name.type == ResourceType::kAttr) {
- s = lookupAttributeInTable(table, resId);
+ s = LookupAttributeInTable(table, res_id);
} else {
s = util::make_unique<SymbolTable::Symbol>();
- s->id = resId;
+ s->id = res_id;
}
if (s) {
- s->isPublic =
- (typeSpecFlags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
+ s->is_public =
+ (type_spec_flags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
return s;
}
return {};
}
-static Maybe<ResourceName> getResourceName(const android::ResTable& table,
+static Maybe<ResourceName> GetResourceName(const android::ResTable& table,
ResourceId id) {
- android::ResTable::resource_name resName = {};
- if (!table.getResourceName(id.id, true, &resName)) {
+ android::ResTable::resource_name res_name = {};
+ if (!table.getResourceName(id.id, true, &res_name)) {
return {};
}
- return ResourceUtils::toResourceName(resName);
+ return ResourceUtils::ToResourceName(res_name);
}
-std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::findById(
+std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindById(
ResourceId id) {
- const android::ResTable& table = mAssets.getResources(false);
- Maybe<ResourceName> maybeName = getResourceName(table, id);
- if (!maybeName) {
+ const android::ResTable& table = assets_.getResources(false);
+ Maybe<ResourceName> maybe_name = GetResourceName(table, id);
+ if (!maybe_name) {
return {};
}
- uint32_t typeSpecFlags = 0;
- table.getResourceFlags(id.id, &typeSpecFlags);
+ uint32_t type_spec_flags = 0;
+ table.getResourceFlags(id.id, &type_spec_flags);
std::unique_ptr<SymbolTable::Symbol> s;
- if (maybeName.value().type == ResourceType::kAttr) {
- s = lookupAttributeInTable(table, id);
+ if (maybe_name.value().type == ResourceType::kAttr) {
+ s = LookupAttributeInTable(table, id);
} else {
s = util::make_unique<SymbolTable::Symbol>();
s->id = id;
}
if (s) {
- s->isPublic =
- (typeSpecFlags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
+ s->is_public =
+ (type_spec_flags & android::ResTable_typeSpec::SPEC_PUBLIC) != 0;
return s;
}
return {};
}
-std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::findByReference(
+std::unique_ptr<SymbolTable::Symbol> AssetManagerSymbolSource::FindByReference(
const Reference& ref) {
// AssetManager always prefers IDs.
if (ref.id) {
- return findById(ref.id.value());
+ return FindById(ref.id.value());
} else if (ref.name) {
- return findByName(ref.name.value());
+ return FindByName(ref.name.value());
}
return {};
}
diff --git a/tools/aapt2/process/SymbolTable.h b/tools/aapt2/process/SymbolTable.h
index 89d87de..25f7565 100644
--- a/tools/aapt2/process/SymbolTable.h
+++ b/tools/aapt2/process/SymbolTable.h
@@ -17,28 +17,28 @@
#ifndef AAPT_PROCESS_SYMBOLTABLE_H
#define AAPT_PROCESS_SYMBOLTABLE_H
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+#include "android-base/macros.h"
+#include "androidfw/AssetManager.h"
+#include "utils/JenkinsHash.h"
+#include "utils/LruCache.h"
+
#include "Resource.h"
#include "ResourceTable.h"
#include "ResourceValues.h"
#include "util/Util.h"
-#include <utils/JenkinsHash.h>
-#include <utils/LruCache.h>
-
-#include <android-base/macros.h>
-#include <androidfw/AssetManager.h>
-#include <algorithm>
-#include <memory>
-#include <vector>
-
namespace aapt {
inline android::hash_t hash_type(const ResourceName& name) {
- std::hash<std::string> strHash;
+ std::hash<std::string> str_hash;
android::hash_t hash = 0;
- hash = android::JenkinsHashMix(hash, (uint32_t)strHash(name.package));
+ hash = android::JenkinsHashMix(hash, (uint32_t)str_hash(name.package));
hash = android::JenkinsHashMix(hash, (uint32_t)name.type);
- hash = android::JenkinsHashMix(hash, (uint32_t)strHash(name.entry));
+ hash = android::JenkinsHashMix(hash, (uint32_t)str_hash(name.entry));
return hash;
}
@@ -60,7 +60,7 @@
Symbol(const Maybe<ResourceId>& i, const std::shared_ptr<Attribute>& attr,
bool pub)
- : id(i), attribute(attr), isPublic(pub) {}
+ : id(i), attribute(attr), is_public(pub) {}
Symbol(const Symbol&) = default;
Symbol(Symbol&&) = default;
@@ -69,36 +69,34 @@
Maybe<ResourceId> id;
std::shared_ptr<Attribute> attribute;
- bool isPublic = false;
+ bool is_public = false;
};
- SymbolTable() : mCache(200), mIdCache(200) {}
+ SymbolTable() : cache_(200), id_cache_(200) {}
- void appendSource(std::unique_ptr<ISymbolSource> source);
- void prependSource(std::unique_ptr<ISymbolSource> source);
+ void AppendSource(std::unique_ptr<ISymbolSource> source);
+ void PrependSource(std::unique_ptr<ISymbolSource> source);
/**
- * Never hold on to the result between calls to findByName or findById. The
- * results
- * are typically stored in a cache which may evict entries.
+ * Never hold on to the result between calls to FindByName or FindById. The
+ * results stored in a cache which may evict entries.
*/
- const Symbol* findByName(const ResourceName& name);
- const Symbol* findById(const ResourceId& id);
+ const Symbol* FindByName(const ResourceName& name);
+ const Symbol* FindById(const ResourceId& id);
/**
* Let's the ISymbolSource decide whether looking up by name or ID is faster,
- * if both
- * are available.
+ * if both are available.
*/
- const Symbol* findByReference(const Reference& ref);
+ const Symbol* FindByReference(const Reference& ref);
private:
- std::vector<std::unique_ptr<ISymbolSource>> mSources;
+ std::vector<std::unique_ptr<ISymbolSource>> sources_;
// We use shared_ptr because unique_ptr is not supported and
// we need automatic deletion.
- android::LruCache<ResourceName, std::shared_ptr<Symbol>> mCache;
- android::LruCache<ResourceId, std::shared_ptr<Symbol>> mIdCache;
+ android::LruCache<ResourceName, std::shared_ptr<Symbol>> cache_;
+ android::LruCache<ResourceId, std::shared_ptr<Symbol>> id_cache_;
DISALLOW_COPY_AND_ASSIGN(SymbolTable);
};
@@ -112,19 +110,19 @@
public:
virtual ~ISymbolSource() = default;
- virtual std::unique_ptr<SymbolTable::Symbol> findByName(
+ virtual std::unique_ptr<SymbolTable::Symbol> FindByName(
const ResourceName& name) = 0;
- virtual std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) = 0;
+ virtual std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) = 0;
/**
* Default implementation tries the name if it exists, else the ID.
*/
- virtual std::unique_ptr<SymbolTable::Symbol> findByReference(
+ virtual std::unique_ptr<SymbolTable::Symbol> FindByReference(
const Reference& ref) {
if (ref.name) {
- return findByName(ref.name.value());
+ return FindByName(ref.name.value());
} else if (ref.id) {
- return findById(ref.id.value());
+ return FindById(ref.id.value());
}
return {};
}
@@ -137,17 +135,17 @@
*/
class ResourceTableSymbolSource : public ISymbolSource {
public:
- explicit ResourceTableSymbolSource(ResourceTable* table) : mTable(table) {}
+ explicit ResourceTableSymbolSource(ResourceTable* table) : table_(table) {}
- std::unique_ptr<SymbolTable::Symbol> findByName(
+ std::unique_ptr<SymbolTable::Symbol> FindByName(
const ResourceName& name) override;
- std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override {
+ std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) override {
return {};
}
private:
- ResourceTable* mTable;
+ ResourceTable* table_;
DISALLOW_COPY_AND_ASSIGN(ResourceTableSymbolSource);
};
@@ -156,16 +154,16 @@
public:
AssetManagerSymbolSource() = default;
- bool addAssetPath(const StringPiece& path);
+ bool AddAssetPath(const StringPiece& path);
- std::unique_ptr<SymbolTable::Symbol> findByName(
+ std::unique_ptr<SymbolTable::Symbol> FindByName(
const ResourceName& name) override;
- std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override;
- std::unique_ptr<SymbolTable::Symbol> findByReference(
+ std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) override;
+ std::unique_ptr<SymbolTable::Symbol> FindByReference(
const Reference& ref) override;
private:
- android::AssetManager mAssets;
+ android::AssetManager assets_;
DISALLOW_COPY_AND_ASSIGN(AssetManagerSymbolSource);
};
diff --git a/tools/aapt2/process/SymbolTable_test.cpp b/tools/aapt2/process/SymbolTable_test.cpp
index 00474f7..9ea0786 100644
--- a/tools/aapt2/process/SymbolTable_test.cpp
+++ b/tools/aapt2/process/SymbolTable_test.cpp
@@ -15,6 +15,7 @@
*/
#include "process/SymbolTable.h"
+
#include "test/Test.h"
namespace aapt {
@@ -22,20 +23,20 @@
TEST(ResourceTableSymbolSourceTest, FindSymbols) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addSimple("android:id/foo", ResourceId(0x01020000))
- .addSimple("android:id/bar")
- .addValue("android:attr/foo", ResourceId(0x01010000),
- test::AttributeBuilder().build())
- .build();
+ .AddSimple("android:id/foo", ResourceId(0x01020000))
+ .AddSimple("android:id/bar")
+ .AddValue("android:attr/foo", ResourceId(0x01010000),
+ test::AttributeBuilder().Build())
+ .Build();
- ResourceTableSymbolSource symbolSource(table.get());
+ ResourceTableSymbolSource symbol_source(table.get());
EXPECT_NE(nullptr,
- symbolSource.findByName(test::parseNameOrDie("android:id/foo")));
+ symbol_source.FindByName(test::ParseNameOrDie("android:id/foo")));
EXPECT_NE(nullptr,
- symbolSource.findByName(test::parseNameOrDie("android:id/bar")));
+ symbol_source.FindByName(test::ParseNameOrDie("android:id/bar")));
std::unique_ptr<SymbolTable::Symbol> s =
- symbolSource.findByName(test::parseNameOrDie("android:attr/foo"));
+ symbol_source.FindByName(test::ParseNameOrDie("android:attr/foo"));
ASSERT_NE(nullptr, s);
EXPECT_NE(nullptr, s->attribute);
}
@@ -43,13 +44,13 @@
TEST(ResourceTableSymbolSourceTest, FindPrivateAttrSymbol) {
std::unique_ptr<ResourceTable> table =
test::ResourceTableBuilder()
- .addValue("android:^attr-private/foo", ResourceId(0x01010000),
- test::AttributeBuilder().build())
- .build();
+ .AddValue("android:^attr-private/foo", ResourceId(0x01010000),
+ test::AttributeBuilder().Build())
+ .Build();
- ResourceTableSymbolSource symbolSource(table.get());
+ ResourceTableSymbolSource symbol_source(table.get());
std::unique_ptr<SymbolTable::Symbol> s =
- symbolSource.findByName(test::parseNameOrDie("android:attr/foo"));
+ symbol_source.FindByName(test::ParseNameOrDie("android:attr/foo"));
ASSERT_NE(nullptr, s);
EXPECT_NE(nullptr, s->attribute);
}
diff --git a/tools/aapt2/proto/ProtoHelpers.cpp b/tools/aapt2/proto/ProtoHelpers.cpp
index 2aa8aa5..38bf4e3 100644
--- a/tools/aapt2/proto/ProtoHelpers.cpp
+++ b/tools/aapt2/proto/ProtoHelpers.cpp
@@ -18,120 +18,151 @@
namespace aapt {
-void serializeStringPoolToPb(const StringPool& pool, pb::StringPool* outPbPool) {
- BigBuffer buffer(1024);
- StringPool::flattenUtf8(&buffer, pool);
+void SerializeStringPoolToPb(const StringPool& pool,
+ pb::StringPool* out_pb_pool) {
+ BigBuffer buffer(1024);
+ StringPool::FlattenUtf8(&buffer, pool);
- std::string* data = outPbPool->mutable_data();
- data->reserve(buffer.size());
+ std::string* data = out_pb_pool->mutable_data();
+ data->reserve(buffer.size());
- size_t offset = 0;
- for (const BigBuffer::Block& block : buffer) {
- data->insert(data->begin() + offset, block.buffer.get(), block.buffer.get() + block.size);
- offset += block.size;
- }
+ size_t offset = 0;
+ for (const BigBuffer::Block& block : buffer) {
+ data->insert(data->begin() + offset, block.buffer.get(),
+ block.buffer.get() + block.size);
+ offset += block.size;
+ }
}
-void serializeSourceToPb(const Source& source, StringPool* srcPool, pb::Source* outPbSource) {
- StringPool::Ref ref = srcPool->makeRef(source.path);
- outPbSource->set_path_idx(static_cast<uint32_t>(ref.getIndex()));
- if (source.line) {
- outPbSource->set_line_no(static_cast<uint32_t>(source.line.value()));
- }
+void SerializeSourceToPb(const Source& source, StringPool* src_pool,
+ pb::Source* out_pb_source) {
+ StringPool::Ref ref = src_pool->MakeRef(source.path);
+ out_pb_source->set_path_idx(static_cast<uint32_t>(ref.index()));
+ if (source.line) {
+ out_pb_source->set_line_no(static_cast<uint32_t>(source.line.value()));
+ }
}
-void deserializeSourceFromPb(const pb::Source& pbSource, const android::ResStringPool& srcPool,
- Source* outSource) {
- if (pbSource.has_path_idx()) {
- outSource->path = util::getString(srcPool, pbSource.path_idx());
- }
+void DeserializeSourceFromPb(const pb::Source& pb_source,
+ const android::ResStringPool& src_pool,
+ Source* out_source) {
+ if (pb_source.has_path_idx()) {
+ out_source->path = util::GetString(src_pool, pb_source.path_idx());
+ }
- if (pbSource.has_line_no()) {
- outSource->line = static_cast<size_t>(pbSource.line_no());
- }
+ if (pb_source.has_line_no()) {
+ out_source->line = static_cast<size_t>(pb_source.line_no());
+ }
}
-pb::SymbolStatus_Visibility serializeVisibilityToPb(SymbolState state) {
- switch (state) {
- case SymbolState::kPrivate: return pb::SymbolStatus_Visibility_Private;
- case SymbolState::kPublic: return pb::SymbolStatus_Visibility_Public;
- default: break;
- }
- return pb::SymbolStatus_Visibility_Unknown;
+pb::SymbolStatus_Visibility SerializeVisibilityToPb(SymbolState state) {
+ switch (state) {
+ case SymbolState::kPrivate:
+ return pb::SymbolStatus_Visibility_Private;
+ case SymbolState::kPublic:
+ return pb::SymbolStatus_Visibility_Public;
+ default:
+ break;
+ }
+ return pb::SymbolStatus_Visibility_Unknown;
}
-SymbolState deserializeVisibilityFromPb(pb::SymbolStatus_Visibility pbVisibility) {
- switch (pbVisibility) {
- case pb::SymbolStatus_Visibility_Private: return SymbolState::kPrivate;
- case pb::SymbolStatus_Visibility_Public: return SymbolState::kPublic;
- default: break;
- }
- return SymbolState::kUndefined;
+SymbolState DeserializeVisibilityFromPb(
+ pb::SymbolStatus_Visibility pb_visibility) {
+ switch (pb_visibility) {
+ case pb::SymbolStatus_Visibility_Private:
+ return SymbolState::kPrivate;
+ case pb::SymbolStatus_Visibility_Public:
+ return SymbolState::kPublic;
+ default:
+ break;
+ }
+ return SymbolState::kUndefined;
}
-void serializeConfig(const ConfigDescription& config, pb::ConfigDescription* outPbConfig) {
- android::ResTable_config flatConfig = config;
- flatConfig.size = sizeof(flatConfig);
- flatConfig.swapHtoD();
- outPbConfig->set_data(&flatConfig, sizeof(flatConfig));
+void SerializeConfig(const ConfigDescription& config,
+ pb::ConfigDescription* out_pb_config) {
+ android::ResTable_config flat_config = config;
+ flat_config.size = sizeof(flat_config);
+ flat_config.swapHtoD();
+ out_pb_config->set_data(&flat_config, sizeof(flat_config));
}
-bool deserializeConfigDescriptionFromPb(const pb::ConfigDescription& pbConfig,
- ConfigDescription* outConfig) {
- if (!pbConfig.has_data()) {
- return false;
- }
+bool DeserializeConfigDescriptionFromPb(const pb::ConfigDescription& pb_config,
+ ConfigDescription* out_config) {
+ if (!pb_config.has_data()) {
+ return false;
+ }
- const android::ResTable_config* config;
- if (pbConfig.data().size() > sizeof(*config)) {
- return false;
- }
+ const android::ResTable_config* config;
+ if (pb_config.data().size() > sizeof(*config)) {
+ return false;
+ }
- config = reinterpret_cast<const android::ResTable_config*>(pbConfig.data().data());
- outConfig->copyFromDtoH(*config);
- return true;
+ config = reinterpret_cast<const android::ResTable_config*>(
+ pb_config.data().data());
+ out_config->copyFromDtoH(*config);
+ return true;
}
-pb::Reference_Type serializeReferenceTypeToPb(Reference::Type type) {
- switch (type) {
- case Reference::Type::kResource: return pb::Reference_Type_Ref;
- case Reference::Type::kAttribute: return pb::Reference_Type_Attr;
- default: break;
- }
- return pb::Reference_Type_Ref;
+pb::Reference_Type SerializeReferenceTypeToPb(Reference::Type type) {
+ switch (type) {
+ case Reference::Type::kResource:
+ return pb::Reference_Type_Ref;
+ case Reference::Type::kAttribute:
+ return pb::Reference_Type_Attr;
+ default:
+ break;
+ }
+ return pb::Reference_Type_Ref;
}
-Reference::Type deserializeReferenceTypeFromPb(pb::Reference_Type pbType) {
- switch (pbType) {
- case pb::Reference_Type_Ref: return Reference::Type::kResource;
- case pb::Reference_Type_Attr: return Reference::Type::kAttribute;
- default: break;
- }
- return Reference::Type::kResource;
+Reference::Type DeserializeReferenceTypeFromPb(pb::Reference_Type pb_type) {
+ switch (pb_type) {
+ case pb::Reference_Type_Ref:
+ return Reference::Type::kResource;
+ case pb::Reference_Type_Attr:
+ return Reference::Type::kAttribute;
+ default:
+ break;
+ }
+ return Reference::Type::kResource;
}
-pb::Plural_Arity serializePluralEnumToPb(size_t pluralIdx) {
- switch (pluralIdx) {
- case Plural::Zero: return pb::Plural_Arity_Zero;
- case Plural::One: return pb::Plural_Arity_One;
- case Plural::Two: return pb::Plural_Arity_Two;
- case Plural::Few: return pb::Plural_Arity_Few;
- case Plural::Many: return pb::Plural_Arity_Many;
- default: break;
- }
- return pb::Plural_Arity_Other;
+pb::Plural_Arity SerializePluralEnumToPb(size_t plural_idx) {
+ switch (plural_idx) {
+ case Plural::Zero:
+ return pb::Plural_Arity_Zero;
+ case Plural::One:
+ return pb::Plural_Arity_One;
+ case Plural::Two:
+ return pb::Plural_Arity_Two;
+ case Plural::Few:
+ return pb::Plural_Arity_Few;
+ case Plural::Many:
+ return pb::Plural_Arity_Many;
+ default:
+ break;
+ }
+ return pb::Plural_Arity_Other;
}
-size_t deserializePluralEnumFromPb(pb::Plural_Arity arity) {
- switch (arity) {
- case pb::Plural_Arity_Zero: return Plural::Zero;
- case pb::Plural_Arity_One: return Plural::One;
- case pb::Plural_Arity_Two: return Plural::Two;
- case pb::Plural_Arity_Few: return Plural::Few;
- case pb::Plural_Arity_Many: return Plural::Many;
- default: break;
- }
- return Plural::Other;
+size_t DeserializePluralEnumFromPb(pb::Plural_Arity arity) {
+ switch (arity) {
+ case pb::Plural_Arity_Zero:
+ return Plural::Zero;
+ case pb::Plural_Arity_One:
+ return Plural::One;
+ case pb::Plural_Arity_Two:
+ return Plural::Two;
+ case pb::Plural_Arity_Few:
+ return Plural::Few;
+ case pb::Plural_Arity_Many:
+ return Plural::Many;
+ default:
+ break;
+ }
+ return Plural::Other;
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/proto/ProtoHelpers.h b/tools/aapt2/proto/ProtoHelpers.h
index 7271e8b..735cda0 100644
--- a/tools/aapt2/proto/ProtoHelpers.h
+++ b/tools/aapt2/proto/ProtoHelpers.h
@@ -17,39 +17,44 @@
#ifndef AAPT_PROTO_PROTOHELPERS_H
#define AAPT_PROTO_PROTOHELPERS_H
+#include "androidfw/ResourceTypes.h"
+
#include "ConfigDescription.h"
#include "ResourceTable.h"
#include "Source.h"
#include "StringPool.h"
-
#include "proto/frameworks/base/tools/aapt2/Format.pb.h"
-#include <androidfw/ResourceTypes.h>
-
namespace aapt {
-void serializeStringPoolToPb(const StringPool& pool, pb::StringPool* outPbPool);
+void SerializeStringPoolToPb(const StringPool& pool,
+ pb::StringPool* out_pb_pool);
-void serializeSourceToPb(const Source& source, StringPool* srcPool,
- pb::Source* outPbSource);
-void deserializeSourceFromPb(const pb::Source& pbSource,
- const android::ResStringPool& srcPool,
- Source* outSource);
+void SerializeSourceToPb(const Source& source, StringPool* src_pool,
+ pb::Source* out_pb_source);
-pb::SymbolStatus_Visibility serializeVisibilityToPb(SymbolState state);
-SymbolState deserializeVisibilityFromPb(
- pb::SymbolStatus_Visibility pbVisibility);
+void DeserializeSourceFromPb(const pb::Source& pb_source,
+ const android::ResStringPool& src_pool,
+ Source* out_source);
-void serializeConfig(const ConfigDescription& config,
- pb::ConfigDescription* outPbConfig);
-bool deserializeConfigDescriptionFromPb(const pb::ConfigDescription& pbConfig,
- ConfigDescription* outConfig);
+pb::SymbolStatus_Visibility SerializeVisibilityToPb(SymbolState state);
-pb::Reference_Type serializeReferenceTypeToPb(Reference::Type type);
-Reference::Type deserializeReferenceTypeFromPb(pb::Reference_Type pbType);
+SymbolState DeserializeVisibilityFromPb(
+ pb::SymbolStatus_Visibility pb_visibility);
-pb::Plural_Arity serializePluralEnumToPb(size_t pluralIdx);
-size_t deserializePluralEnumFromPb(pb::Plural_Arity arity);
+void SerializeConfig(const ConfigDescription& config,
+ pb::ConfigDescription* out_pb_config);
+
+bool DeserializeConfigDescriptionFromPb(const pb::ConfigDescription& pb_config,
+ ConfigDescription* out_config);
+
+pb::Reference_Type SerializeReferenceTypeToPb(Reference::Type type);
+
+Reference::Type DeserializeReferenceTypeFromPb(pb::Reference_Type pb_type);
+
+pb::Plural_Arity SerializePluralEnumToPb(size_t plural_idx);
+
+size_t DeserializePluralEnumFromPb(pb::Plural_Arity arity);
} // namespace aapt
diff --git a/tools/aapt2/proto/ProtoSerialize.h b/tools/aapt2/proto/ProtoSerialize.h
index 378dafd..39c5003 100644
--- a/tools/aapt2/proto/ProtoSerialize.h
+++ b/tools/aapt2/proto/ProtoSerialize.h
@@ -17,15 +17,15 @@
#ifndef AAPT_FLATTEN_TABLEPROTOSERIALIZER_H
#define AAPT_FLATTEN_TABLEPROTOSERIALIZER_H
+#include "android-base/macros.h"
+#include "google/protobuf/io/coded_stream.h"
+#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
+
#include "Diagnostics.h"
#include "ResourceTable.h"
#include "Source.h"
#include "proto/ProtoHelpers.h"
-#include <android-base/macros.h>
-#include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
-
namespace aapt {
class CompiledFileOutputStream {
@@ -42,9 +42,9 @@
private:
DISALLOW_COPY_AND_ASSIGN(CompiledFileOutputStream);
- void ensureAlignedWrite();
+ void EnsureAlignedWrite();
- google::protobuf::io::CodedOutputStream mOut;
+ google::protobuf::io::CodedOutputStream out_;
};
class CompiledFileInputStream {
@@ -58,18 +58,18 @@
private:
DISALLOW_COPY_AND_ASSIGN(CompiledFileInputStream);
- void ensureAlignedRead();
+ void EnsureAlignedRead();
- google::protobuf::io::CodedInputStream mIn;
+ google::protobuf::io::CodedInputStream in_;
};
-std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table);
-std::unique_ptr<ResourceTable> deserializeTableFromPb(
+std::unique_ptr<pb::ResourceTable> SerializeTableToPb(ResourceTable* table);
+std::unique_ptr<ResourceTable> DeserializeTableFromPb(
const pb::ResourceTable& pbTable, const Source& source, IDiagnostics* diag);
-std::unique_ptr<pb::CompiledFile> serializeCompiledFileToPb(
+std::unique_ptr<pb::CompiledFile> SerializeCompiledFileToPb(
const ResourceFile& file);
-std::unique_ptr<ResourceFile> deserializeCompiledFileFromPb(
+std::unique_ptr<ResourceFile> DeserializeCompiledFileFromPb(
const pb::CompiledFile& pbFile, const Source& source, IDiagnostics* diag);
} // namespace aapt
diff --git a/tools/aapt2/proto/TableProtoDeserializer.cpp b/tools/aapt2/proto/TableProtoDeserializer.cpp
index 0dfb01c..d93d495 100644
--- a/tools/aapt2/proto/TableProtoDeserializer.cpp
+++ b/tools/aapt2/proto/TableProtoDeserializer.cpp
@@ -14,13 +14,15 @@
* limitations under the License.
*/
+#include "proto/ProtoSerialize.h"
+
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ValueVisitor.h"
#include "proto/ProtoHelpers.h"
-#include "proto/ProtoSerialize.h"
-
-#include <androidfw/ResourceTypes.h>
namespace aapt {
@@ -28,28 +30,28 @@
class ReferenceIdToNameVisitor : public ValueVisitor {
public:
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
explicit ReferenceIdToNameVisitor(
const std::map<ResourceId, ResourceNameRef>* mapping)
- : mMapping(mapping) {
- assert(mMapping);
+ : mapping_(mapping) {
+ CHECK(mapping_ != nullptr);
}
- void visit(Reference* reference) override {
- if (!reference->id || !reference->id.value().isValid()) {
+ void Visit(Reference* reference) override {
+ if (!reference->id || !reference->id.value().is_valid()) {
return;
}
ResourceId id = reference->id.value();
- auto cacheIter = mMapping->find(id);
- if (cacheIter != mMapping->end()) {
- reference->name = cacheIter->second.toResourceName();
+ auto cache_iter = mapping_->find(id);
+ if (cache_iter != mapping_->end()) {
+ reference->name = cache_iter->second.ToResourceName();
}
}
private:
- const std::map<ResourceId, ResourceNameRef>* mMapping;
+ const std::map<ResourceId, ResourceNameRef>* mapping_;
};
class PackagePbDeserializer {
@@ -58,14 +60,14 @@
const android::ResStringPool* sourcePool,
const android::ResStringPool* symbolPool,
const Source& source, IDiagnostics* diag)
- : mValuePool(valuePool),
- mSourcePool(sourcePool),
- mSymbolPool(symbolPool),
- mSource(source),
- mDiag(diag) {}
+ : value_pool_(valuePool),
+ source_pool_(sourcePool),
+ symbol_pool_(symbolPool),
+ source_(source),
+ diag_(diag) {}
public:
- bool deserializeFromPb(const pb::Package& pbPackage, ResourceTable* table) {
+ bool DeserializeFromPb(const pb::Package& pbPackage, ResourceTable* table) {
Maybe<uint8_t> id;
if (pbPackage.has_package_id()) {
id = static_cast<uint8_t>(pbPackage.package_id());
@@ -74,36 +76,36 @@
std::map<ResourceId, ResourceNameRef> idIndex;
ResourceTablePackage* pkg =
- table->createPackage(pbPackage.package_name(), id);
+ table->CreatePackage(pbPackage.package_name(), id);
for (const pb::Type& pbType : pbPackage.types()) {
- const ResourceType* resType = parseResourceType(pbType.name());
+ const ResourceType* resType = ParseResourceType(pbType.name());
if (!resType) {
- mDiag->error(DiagMessage(mSource) << "unknown type '" << pbType.name()
+ diag_->Error(DiagMessage(source_) << "unknown type '" << pbType.name()
<< "'");
return {};
}
- ResourceTableType* type = pkg->findOrCreateType(*resType);
+ ResourceTableType* type = pkg->FindOrCreateType(*resType);
for (const pb::Entry& pbEntry : pbType.entries()) {
- ResourceEntry* entry = type->findOrCreateEntry(pbEntry.name());
+ ResourceEntry* entry = type->FindOrCreateEntry(pbEntry.name());
// Deserialize the symbol status (public/private with source and
// comments).
if (pbEntry.has_symbol_status()) {
const pb::SymbolStatus& pbStatus = pbEntry.symbol_status();
if (pbStatus.has_source()) {
- deserializeSourceFromPb(pbStatus.source(), *mSourcePool,
- &entry->symbolStatus.source);
+ DeserializeSourceFromPb(pbStatus.source(), *source_pool_,
+ &entry->symbol_status.source);
}
if (pbStatus.has_comment()) {
- entry->symbolStatus.comment = pbStatus.comment();
+ entry->symbol_status.comment = pbStatus.comment();
}
SymbolState visibility =
- deserializeVisibilityFromPb(pbStatus.visibility());
- entry->symbolStatus.state = visibility;
+ DeserializeVisibilityFromPb(pbStatus.visibility());
+ entry->symbol_status.state = visibility;
if (visibility == SymbolState::kPublic) {
// This is a public symbol, we must encode the ID now if there is
@@ -112,22 +114,22 @@
entry->id = static_cast<uint16_t>(pbEntry.id());
}
- if (type->symbolStatus.state != SymbolState::kPublic) {
+ if (type->symbol_status.state != SymbolState::kPublic) {
// If the type has not been made public, do so now.
- type->symbolStatus.state = SymbolState::kPublic;
+ type->symbol_status.state = SymbolState::kPublic;
if (pbType.has_id()) {
type->id = static_cast<uint8_t>(pbType.id());
}
}
} else if (visibility == SymbolState::kPrivate) {
- if (type->symbolStatus.state == SymbolState::kUndefined) {
- type->symbolStatus.state = SymbolState::kPrivate;
+ if (type->symbol_status.state == SymbolState::kUndefined) {
+ type->symbol_status.state = SymbolState::kPrivate;
}
}
}
ResourceId resId(pbPackage.package_id(), pbType.id(), pbEntry.id());
- if (resId.isValid()) {
+ if (resId.is_valid()) {
idIndex[resId] = ResourceNameRef(pkg->name, type->type, entry->name);
}
@@ -135,21 +137,21 @@
const pb::ConfigDescription& pbConfig = pbConfigValue.config();
ConfigDescription config;
- if (!deserializeConfigDescriptionFromPb(pbConfig, &config)) {
- mDiag->error(DiagMessage(mSource) << "invalid configuration");
+ if (!DeserializeConfigDescriptionFromPb(pbConfig, &config)) {
+ diag_->Error(DiagMessage(source_) << "invalid configuration");
return {};
}
ResourceConfigValue* configValue =
- entry->findOrCreateValue(config, pbConfig.product());
+ entry->FindOrCreateValue(config, pbConfig.product());
if (configValue->value) {
// Duplicate config.
- mDiag->error(DiagMessage(mSource) << "duplicate configuration");
+ diag_->Error(DiagMessage(source_) << "duplicate configuration");
return {};
}
- configValue->value = deserializeValueFromPb(
- pbConfigValue.value(), config, &table->stringPool);
+ configValue->value = DeserializeValueFromPb(
+ pbConfigValue.value(), config, &table->string_pool);
if (!configValue->value) {
return {};
}
@@ -158,247 +160,247 @@
}
ReferenceIdToNameVisitor visitor(&idIndex);
- visitAllValuesInPackage(pkg, &visitor);
+ VisitAllValuesInPackage(pkg, &visitor);
return true;
}
private:
- std::unique_ptr<Item> deserializeItemFromPb(const pb::Item& pbItem,
+ std::unique_ptr<Item> DeserializeItemFromPb(const pb::Item& pb_item,
const ConfigDescription& config,
StringPool* pool) {
- if (pbItem.has_ref()) {
- const pb::Reference& pbRef = pbItem.ref();
+ if (pb_item.has_ref()) {
+ const pb::Reference& pb_ref = pb_item.ref();
std::unique_ptr<Reference> ref = util::make_unique<Reference>();
- if (!deserializeReferenceFromPb(pbRef, ref.get())) {
+ if (!DeserializeReferenceFromPb(pb_ref, ref.get())) {
return {};
}
return std::move(ref);
- } else if (pbItem.has_prim()) {
- const pb::Primitive& pbPrim = pbItem.prim();
+ } else if (pb_item.has_prim()) {
+ const pb::Primitive& pb_prim = pb_item.prim();
android::Res_value prim = {};
- prim.dataType = static_cast<uint8_t>(pbPrim.type());
- prim.data = pbPrim.data();
+ prim.dataType = static_cast<uint8_t>(pb_prim.type());
+ prim.data = pb_prim.data();
return util::make_unique<BinaryPrimitive>(prim);
- } else if (pbItem.has_id()) {
+ } else if (pb_item.has_id()) {
return util::make_unique<Id>();
- } else if (pbItem.has_str()) {
- const uint32_t idx = pbItem.str().idx();
- const std::string str = util::getString(*mValuePool, idx);
+ } else if (pb_item.has_str()) {
+ const uint32_t idx = pb_item.str().idx();
+ const std::string str = util::GetString(*value_pool_, idx);
- const android::ResStringPool_span* spans = mValuePool->styleAt(idx);
+ const android::ResStringPool_span* spans = value_pool_->styleAt(idx);
if (spans && spans->name.index != android::ResStringPool_span::END) {
- StyleString styleStr = {str};
+ StyleString style_str = {str};
while (spans->name.index != android::ResStringPool_span::END) {
- styleStr.spans.push_back(
- Span{util::getString(*mValuePool, spans->name.index),
+ style_str.spans.push_back(
+ Span{util::GetString(*value_pool_, spans->name.index),
spans->firstChar, spans->lastChar});
spans++;
}
- return util::make_unique<StyledString>(pool->makeRef(
- styleStr,
+ return util::make_unique<StyledString>(pool->MakeRef(
+ style_str,
StringPool::Context(StringPool::Context::kStylePriority, config)));
}
return util::make_unique<String>(
- pool->makeRef(str, StringPool::Context(config)));
+ pool->MakeRef(str, StringPool::Context(config)));
- } else if (pbItem.has_raw_str()) {
- const uint32_t idx = pbItem.raw_str().idx();
- const std::string str = util::getString(*mValuePool, idx);
+ } else if (pb_item.has_raw_str()) {
+ const uint32_t idx = pb_item.raw_str().idx();
+ const std::string str = util::GetString(*value_pool_, idx);
return util::make_unique<RawString>(
- pool->makeRef(str, StringPool::Context(config)));
+ pool->MakeRef(str, StringPool::Context(config)));
- } else if (pbItem.has_file()) {
- const uint32_t idx = pbItem.file().path_idx();
- const std::string str = util::getString(*mValuePool, idx);
- return util::make_unique<FileReference>(pool->makeRef(
+ } else if (pb_item.has_file()) {
+ const uint32_t idx = pb_item.file().path_idx();
+ const std::string str = util::GetString(*value_pool_, idx);
+ return util::make_unique<FileReference>(pool->MakeRef(
str,
StringPool::Context(StringPool::Context::kHighPriority, config)));
} else {
- mDiag->error(DiagMessage(mSource) << "unknown item");
+ diag_->Error(DiagMessage(source_) << "unknown item");
}
return {};
}
- std::unique_ptr<Value> deserializeValueFromPb(const pb::Value& pbValue,
+ std::unique_ptr<Value> DeserializeValueFromPb(const pb::Value& pb_value,
const ConfigDescription& config,
StringPool* pool) {
- const bool isWeak = pbValue.has_weak() ? pbValue.weak() : false;
+ const bool is_weak = pb_value.has_weak() ? pb_value.weak() : false;
std::unique_ptr<Value> value;
- if (pbValue.has_item()) {
- value = deserializeItemFromPb(pbValue.item(), config, pool);
+ if (pb_value.has_item()) {
+ value = DeserializeItemFromPb(pb_value.item(), config, pool);
if (!value) {
return {};
}
- } else if (pbValue.has_compound_value()) {
- const pb::CompoundValue& pbCompoundValue = pbValue.compound_value();
- if (pbCompoundValue.has_attr()) {
- const pb::Attribute& pbAttr = pbCompoundValue.attr();
- std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(isWeak);
- attr->typeMask = pbAttr.format_flags();
- attr->minInt = pbAttr.min_int();
- attr->maxInt = pbAttr.max_int();
- for (const pb::Attribute_Symbol& pbSymbol : pbAttr.symbols()) {
+ } else if (pb_value.has_compound_value()) {
+ const pb::CompoundValue& pb_compound_value = pb_value.compound_value();
+ if (pb_compound_value.has_attr()) {
+ const pb::Attribute& pb_attr = pb_compound_value.attr();
+ std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(is_weak);
+ attr->type_mask = pb_attr.format_flags();
+ attr->min_int = pb_attr.min_int();
+ attr->max_int = pb_attr.max_int();
+ for (const pb::Attribute_Symbol& pb_symbol : pb_attr.symbols()) {
Attribute::Symbol symbol;
- deserializeItemCommon(pbSymbol, &symbol.symbol);
- if (!deserializeReferenceFromPb(pbSymbol.name(), &symbol.symbol)) {
+ DeserializeItemCommon(pb_symbol, &symbol.symbol);
+ if (!DeserializeReferenceFromPb(pb_symbol.name(), &symbol.symbol)) {
return {};
}
- symbol.value = pbSymbol.value();
+ symbol.value = pb_symbol.value();
attr->symbols.push_back(std::move(symbol));
}
value = std::move(attr);
- } else if (pbCompoundValue.has_style()) {
- const pb::Style& pbStyle = pbCompoundValue.style();
+ } else if (pb_compound_value.has_style()) {
+ const pb::Style& pb_style = pb_compound_value.style();
std::unique_ptr<Style> style = util::make_unique<Style>();
- if (pbStyle.has_parent()) {
+ if (pb_style.has_parent()) {
style->parent = Reference();
- if (!deserializeReferenceFromPb(pbStyle.parent(),
+ if (!DeserializeReferenceFromPb(pb_style.parent(),
&style->parent.value())) {
return {};
}
- if (pbStyle.has_parent_source()) {
- Source parentSource;
- deserializeSourceFromPb(pbStyle.parent_source(), *mSourcePool,
- &parentSource);
- style->parent.value().setSource(std::move(parentSource));
+ if (pb_style.has_parent_source()) {
+ Source parent_source;
+ DeserializeSourceFromPb(pb_style.parent_source(), *source_pool_,
+ &parent_source);
+ style->parent.value().SetSource(std::move(parent_source));
}
}
- for (const pb::Style_Entry& pbEntry : pbStyle.entries()) {
+ for (const pb::Style_Entry& pb_entry : pb_style.entries()) {
Style::Entry entry;
- deserializeItemCommon(pbEntry, &entry.key);
- if (!deserializeReferenceFromPb(pbEntry.key(), &entry.key)) {
+ DeserializeItemCommon(pb_entry, &entry.key);
+ if (!DeserializeReferenceFromPb(pb_entry.key(), &entry.key)) {
return {};
}
- entry.value = deserializeItemFromPb(pbEntry.item(), config, pool);
+ entry.value = DeserializeItemFromPb(pb_entry.item(), config, pool);
if (!entry.value) {
return {};
}
- deserializeItemCommon(pbEntry, entry.value.get());
+ DeserializeItemCommon(pb_entry, entry.value.get());
style->entries.push_back(std::move(entry));
}
value = std::move(style);
- } else if (pbCompoundValue.has_styleable()) {
- const pb::Styleable& pbStyleable = pbCompoundValue.styleable();
+ } else if (pb_compound_value.has_styleable()) {
+ const pb::Styleable& pb_styleable = pb_compound_value.styleable();
std::unique_ptr<Styleable> styleable = util::make_unique<Styleable>();
- for (const pb::Styleable_Entry& pbEntry : pbStyleable.entries()) {
- Reference attrRef;
- deserializeItemCommon(pbEntry, &attrRef);
- deserializeReferenceFromPb(pbEntry.attr(), &attrRef);
- styleable->entries.push_back(std::move(attrRef));
+ for (const pb::Styleable_Entry& pb_entry : pb_styleable.entries()) {
+ Reference attr_ref;
+ DeserializeItemCommon(pb_entry, &attr_ref);
+ DeserializeReferenceFromPb(pb_entry.attr(), &attr_ref);
+ styleable->entries.push_back(std::move(attr_ref));
}
value = std::move(styleable);
- } else if (pbCompoundValue.has_array()) {
- const pb::Array& pbArray = pbCompoundValue.array();
+ } else if (pb_compound_value.has_array()) {
+ const pb::Array& pb_array = pb_compound_value.array();
std::unique_ptr<Array> array = util::make_unique<Array>();
- for (const pb::Array_Entry& pbEntry : pbArray.entries()) {
+ for (const pb::Array_Entry& pb_entry : pb_array.entries()) {
std::unique_ptr<Item> item =
- deserializeItemFromPb(pbEntry.item(), config, pool);
+ DeserializeItemFromPb(pb_entry.item(), config, pool);
if (!item) {
return {};
}
- deserializeItemCommon(pbEntry, item.get());
+ DeserializeItemCommon(pb_entry, item.get());
array->items.push_back(std::move(item));
}
value = std::move(array);
- } else if (pbCompoundValue.has_plural()) {
- const pb::Plural& pbPlural = pbCompoundValue.plural();
+ } else if (pb_compound_value.has_plural()) {
+ const pb::Plural& pb_plural = pb_compound_value.plural();
std::unique_ptr<Plural> plural = util::make_unique<Plural>();
- for (const pb::Plural_Entry& pbEntry : pbPlural.entries()) {
- size_t pluralIdx = deserializePluralEnumFromPb(pbEntry.arity());
+ for (const pb::Plural_Entry& pb_entry : pb_plural.entries()) {
+ size_t pluralIdx = DeserializePluralEnumFromPb(pb_entry.arity());
plural->values[pluralIdx] =
- deserializeItemFromPb(pbEntry.item(), config, pool);
+ DeserializeItemFromPb(pb_entry.item(), config, pool);
if (!plural->values[pluralIdx]) {
return {};
}
- deserializeItemCommon(pbEntry, plural->values[pluralIdx].get());
+ DeserializeItemCommon(pb_entry, plural->values[pluralIdx].get());
}
value = std::move(plural);
} else {
- mDiag->error(DiagMessage(mSource) << "unknown compound value");
+ diag_->Error(DiagMessage(source_) << "unknown compound value");
return {};
}
} else {
- mDiag->error(DiagMessage(mSource) << "unknown value");
+ diag_->Error(DiagMessage(source_) << "unknown value");
return {};
}
- assert(value && "forgot to set value");
+ CHECK(value) << "forgot to set value";
- value->setWeak(isWeak);
- deserializeItemCommon(pbValue, value.get());
+ value->SetWeak(is_weak);
+ DeserializeItemCommon(pb_value, value.get());
return value;
}
- bool deserializeReferenceFromPb(const pb::Reference& pbRef,
- Reference* outRef) {
- outRef->referenceType = deserializeReferenceTypeFromPb(pbRef.type());
- outRef->privateReference = pbRef.private_();
+ bool DeserializeReferenceFromPb(const pb::Reference& pb_ref,
+ Reference* out_ref) {
+ out_ref->reference_type = DeserializeReferenceTypeFromPb(pb_ref.type());
+ out_ref->private_reference = pb_ref.private_();
- if (!pbRef.has_id() && !pbRef.has_symbol_idx()) {
+ if (!pb_ref.has_id() && !pb_ref.has_symbol_idx()) {
return false;
}
- if (pbRef.has_id()) {
- outRef->id = ResourceId(pbRef.id());
+ if (pb_ref.has_id()) {
+ out_ref->id = ResourceId(pb_ref.id());
}
- if (pbRef.has_symbol_idx()) {
- const std::string strSymbol =
- util::getString(*mSymbolPool, pbRef.symbol_idx());
- ResourceNameRef nameRef;
- if (!ResourceUtils::parseResourceName(strSymbol, &nameRef, nullptr)) {
- mDiag->error(DiagMessage(mSource) << "invalid reference name '"
- << strSymbol << "'");
+ if (pb_ref.has_symbol_idx()) {
+ const std::string str_symbol =
+ util::GetString(*symbol_pool_, pb_ref.symbol_idx());
+ ResourceNameRef name_ref;
+ if (!ResourceUtils::ParseResourceName(str_symbol, &name_ref, nullptr)) {
+ diag_->Error(DiagMessage(source_) << "invalid reference name '"
+ << str_symbol << "'");
return false;
}
- outRef->name = nameRef.toResourceName();
+ out_ref->name = name_ref.ToResourceName();
}
return true;
}
template <typename T>
- void deserializeItemCommon(const T& pbItem, Value* outValue) {
- if (pbItem.has_source()) {
+ void DeserializeItemCommon(const T& pb_item, Value* out_value) {
+ if (pb_item.has_source()) {
Source source;
- deserializeSourceFromPb(pbItem.source(), *mSourcePool, &source);
- outValue->setSource(std::move(source));
+ DeserializeSourceFromPb(pb_item.source(), *source_pool_, &source);
+ out_value->SetSource(std::move(source));
}
- if (pbItem.has_comment()) {
- outValue->setComment(pbItem.comment());
+ if (pb_item.has_comment()) {
+ out_value->SetComment(pb_item.comment());
}
}
private:
- const android::ResStringPool* mValuePool;
- const android::ResStringPool* mSourcePool;
- const android::ResStringPool* mSymbolPool;
- const Source mSource;
- IDiagnostics* mDiag;
+ const android::ResStringPool* value_pool_;
+ const android::ResStringPool* source_pool_;
+ const android::ResStringPool* symbol_pool_;
+ const Source source_;
+ IDiagnostics* diag_;
};
} // namespace
-std::unique_ptr<ResourceTable> deserializeTableFromPb(
- const pb::ResourceTable& pbTable, const Source& source,
+std::unique_ptr<ResourceTable> DeserializeTableFromPb(
+ const pb::ResourceTable& pb_table, const Source& source,
IDiagnostics* diag) {
// We import the android namespace because on Windows NO_ERROR is a macro, not
// an enum, which
@@ -407,78 +409,79 @@
std::unique_ptr<ResourceTable> table = util::make_unique<ResourceTable>();
- if (!pbTable.has_string_pool()) {
- diag->error(DiagMessage(source) << "no string pool found");
+ if (!pb_table.has_string_pool()) {
+ diag->Error(DiagMessage(source) << "no string pool found");
return {};
}
- ResStringPool valuePool;
- status_t result = valuePool.setTo(pbTable.string_pool().data().data(),
- pbTable.string_pool().data().size());
+ ResStringPool value_pool;
+ status_t result = value_pool.setTo(pb_table.string_pool().data().data(),
+ pb_table.string_pool().data().size());
if (result != NO_ERROR) {
- diag->error(DiagMessage(source) << "invalid string pool");
+ diag->Error(DiagMessage(source) << "invalid string pool");
return {};
}
- ResStringPool sourcePool;
- if (pbTable.has_source_pool()) {
- result = sourcePool.setTo(pbTable.source_pool().data().data(),
- pbTable.source_pool().data().size());
+ ResStringPool source_pool;
+ if (pb_table.has_source_pool()) {
+ result = source_pool.setTo(pb_table.source_pool().data().data(),
+ pb_table.source_pool().data().size());
if (result != NO_ERROR) {
- diag->error(DiagMessage(source) << "invalid source pool");
+ diag->Error(DiagMessage(source) << "invalid source pool");
return {};
}
}
- ResStringPool symbolPool;
- if (pbTable.has_symbol_pool()) {
- result = symbolPool.setTo(pbTable.symbol_pool().data().data(),
- pbTable.symbol_pool().data().size());
+ ResStringPool symbol_pool;
+ if (pb_table.has_symbol_pool()) {
+ result = symbol_pool.setTo(pb_table.symbol_pool().data().data(),
+ pb_table.symbol_pool().data().size());
if (result != NO_ERROR) {
- diag->error(DiagMessage(source) << "invalid symbol pool");
+ diag->Error(DiagMessage(source) << "invalid symbol pool");
return {};
}
}
- PackagePbDeserializer packagePbDeserializer(&valuePool, &sourcePool,
- &symbolPool, source, diag);
- for (const pb::Package& pbPackage : pbTable.packages()) {
- if (!packagePbDeserializer.deserializeFromPb(pbPackage, table.get())) {
+ PackagePbDeserializer package_pb_deserializer(&value_pool, &source_pool,
+ &symbol_pool, source, diag);
+ for (const pb::Package& pb_package : pb_table.packages()) {
+ if (!package_pb_deserializer.DeserializeFromPb(pb_package, table.get())) {
return {};
}
}
return table;
}
-std::unique_ptr<ResourceFile> deserializeCompiledFileFromPb(
- const pb::CompiledFile& pbFile, const Source& source, IDiagnostics* diag) {
+std::unique_ptr<ResourceFile> DeserializeCompiledFileFromPb(
+ const pb::CompiledFile& pb_file, const Source& source, IDiagnostics* diag) {
std::unique_ptr<ResourceFile> file = util::make_unique<ResourceFile>();
- ResourceNameRef nameRef;
+ ResourceNameRef name_ref;
// Need to create an lvalue here so that nameRef can point to something real.
- if (!ResourceUtils::parseResourceName(pbFile.resource_name(), &nameRef)) {
- diag->error(DiagMessage(source)
+ if (!ResourceUtils::ParseResourceName(pb_file.resource_name(), &name_ref)) {
+ diag->Error(DiagMessage(source)
<< "invalid resource name in compiled file header: "
- << pbFile.resource_name());
+ << pb_file.resource_name());
return {};
}
- file->name = nameRef.toResourceName();
- file->source.path = pbFile.source_path();
- deserializeConfigDescriptionFromPb(pbFile.config(), &file->config);
+ file->name = name_ref.ToResourceName();
+ file->source.path = pb_file.source_path();
+ DeserializeConfigDescriptionFromPb(pb_file.config(), &file->config);
- for (const pb::CompiledFile_Symbol& pbSymbol : pbFile.exported_symbols()) {
+ for (const pb::CompiledFile_Symbol& pb_symbol : pb_file.exported_symbols()) {
// Need to create an lvalue here so that nameRef can point to something
// real.
- if (!ResourceUtils::parseResourceName(pbSymbol.resource_name(), &nameRef)) {
- diag->error(DiagMessage(source)
+ if (!ResourceUtils::ParseResourceName(pb_symbol.resource_name(),
+ &name_ref)) {
+ diag->Error(DiagMessage(source)
<< "invalid resource name for exported symbol in "
"compiled file header: "
- << pbFile.resource_name());
+ << pb_file.resource_name());
return {};
}
- file->exportedSymbols.push_back(
- SourcedResourceName{nameRef.toResourceName(), pbSymbol.line_no()});
+ file->exported_symbols.push_back(
+ SourcedResourceName{name_ref.ToResourceName(), pb_symbol.line_no()});
}
return file;
}
diff --git a/tools/aapt2/proto/TableProtoSerializer.cpp b/tools/aapt2/proto/TableProtoSerializer.cpp
index a5c2cbc..68db6b3 100644
--- a/tools/aapt2/proto/TableProtoSerializer.cpp
+++ b/tools/aapt2/proto/TableProtoSerializer.cpp
@@ -22,6 +22,8 @@
#include "proto/ProtoSerialize.h"
#include "util/BigBuffer.h"
+#include <android-base/logging.h>
+
using google::protobuf::io::CodedOutputStream;
using google::protobuf::io::CodedInputStream;
using google::protobuf::io::ZeroCopyOutputStream;
@@ -31,179 +33,185 @@
namespace {
class PbSerializerVisitor : public RawValueVisitor {
-public:
- using RawValueVisitor::visit;
+ public:
+ using RawValueVisitor::Visit;
- /**
- * Constructor to use when expecting to serialize any value.
- */
- PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool, pb::Value* outPbValue) :
- mSourcePool(sourcePool), mSymbolPool(symbolPool), mOutPbValue(outPbValue),
- mOutPbItem(nullptr) {
+ /**
+ * Constructor to use when expecting to serialize any value.
+ */
+ PbSerializerVisitor(StringPool* source_pool, StringPool* symbol_pool,
+ pb::Value* out_pb_value)
+ : source_pool_(source_pool),
+ symbol_pool_(symbol_pool),
+ out_pb_value_(out_pb_value),
+ out_pb_item_(nullptr) {}
+
+ /**
+ * Constructor to use when expecting to serialize an Item.
+ */
+ PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool,
+ pb::Item* outPbItem)
+ : source_pool_(sourcePool),
+ symbol_pool_(symbolPool),
+ out_pb_value_(nullptr),
+ out_pb_item_(outPbItem) {}
+
+ void Visit(Reference* ref) override {
+ SerializeReferenceToPb(*ref, pb_item()->mutable_ref());
+ }
+
+ void Visit(String* str) override {
+ pb_item()->mutable_str()->set_idx(str->value.index());
+ }
+
+ void Visit(StyledString* str) override {
+ pb_item()->mutable_str()->set_idx(str->value.index());
+ }
+
+ void Visit(FileReference* file) override {
+ pb_item()->mutable_file()->set_path_idx(file->path.index());
+ }
+
+ void Visit(Id* id) override { pb_item()->mutable_id(); }
+
+ void Visit(RawString* raw_str) override {
+ pb_item()->mutable_raw_str()->set_idx(raw_str->value.index());
+ }
+
+ void Visit(BinaryPrimitive* prim) override {
+ android::Res_value val = {};
+ prim->Flatten(&val);
+
+ pb::Primitive* pb_prim = pb_item()->mutable_prim();
+ pb_prim->set_type(val.dataType);
+ pb_prim->set_data(val.data);
+ }
+
+ void VisitItem(Item* item) override { LOG(FATAL) << "unimplemented item"; }
+
+ void Visit(Attribute* attr) override {
+ pb::Attribute* pb_attr = pb_compound_value()->mutable_attr();
+ pb_attr->set_format_flags(attr->type_mask);
+ pb_attr->set_min_int(attr->min_int);
+ pb_attr->set_max_int(attr->max_int);
+
+ for (auto& symbol : attr->symbols) {
+ pb::Attribute_Symbol* pb_symbol = pb_attr->add_symbols();
+ SerializeItemCommonToPb(symbol.symbol, pb_symbol);
+ SerializeReferenceToPb(symbol.symbol, pb_symbol->mutable_name());
+ pb_symbol->set_value(symbol.value);
+ }
+ }
+
+ void Visit(Style* style) override {
+ pb::Style* pb_style = pb_compound_value()->mutable_style();
+ if (style->parent) {
+ SerializeReferenceToPb(style->parent.value(), pb_style->mutable_parent());
+ SerializeSourceToPb(style->parent.value().GetSource(), source_pool_,
+ pb_style->mutable_parent_source());
}
- /**
- * Constructor to use when expecting to serialize an Item.
- */
- PbSerializerVisitor(StringPool* sourcePool, StringPool* symbolPool, pb::Item* outPbItem) :
- mSourcePool(sourcePool), mSymbolPool(symbolPool), mOutPbValue(nullptr),
- mOutPbItem(outPbItem) {
+ for (Style::Entry& entry : style->entries) {
+ pb::Style_Entry* pb_entry = pb_style->add_entries();
+ SerializeReferenceToPb(entry.key, pb_entry->mutable_key());
+
+ pb::Item* pb_item = pb_entry->mutable_item();
+ SerializeItemCommonToPb(entry.key, pb_entry);
+ PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, pb_item);
+ entry.value->Accept(&sub_visitor);
+ }
+ }
+
+ void Visit(Styleable* styleable) override {
+ pb::Styleable* pb_styleable = pb_compound_value()->mutable_styleable();
+ for (Reference& entry : styleable->entries) {
+ pb::Styleable_Entry* pb_entry = pb_styleable->add_entries();
+ SerializeItemCommonToPb(entry, pb_entry);
+ SerializeReferenceToPb(entry, pb_entry->mutable_attr());
+ }
+ }
+
+ void Visit(Array* array) override {
+ pb::Array* pb_array = pb_compound_value()->mutable_array();
+ for (auto& value : array->items) {
+ pb::Array_Entry* pb_entry = pb_array->add_entries();
+ SerializeItemCommonToPb(*value, pb_entry);
+ PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_,
+ pb_entry->mutable_item());
+ value->Accept(&sub_visitor);
+ }
+ }
+
+ void Visit(Plural* plural) override {
+ pb::Plural* pb_plural = pb_compound_value()->mutable_plural();
+ const size_t count = plural->values.size();
+ for (size_t i = 0; i < count; i++) {
+ if (!plural->values[i]) {
+ // No plural value set here.
+ continue;
+ }
+
+ pb::Plural_Entry* pb_entry = pb_plural->add_entries();
+ pb_entry->set_arity(SerializePluralEnumToPb(i));
+ pb::Item* pb_element = pb_entry->mutable_item();
+ SerializeItemCommonToPb(*plural->values[i], pb_entry);
+ PbSerializerVisitor sub_visitor(source_pool_, symbol_pool_, pb_element);
+ plural->values[i]->Accept(&sub_visitor);
+ }
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(PbSerializerVisitor);
+
+ pb::Item* pb_item() {
+ if (out_pb_value_) {
+ return out_pb_value_->mutable_item();
+ }
+ return out_pb_item_;
+ }
+
+ pb::CompoundValue* pb_compound_value() {
+ CHECK(out_pb_value_ != nullptr);
+ return out_pb_value_->mutable_compound_value();
+ }
+
+ template <typename T>
+ void SerializeItemCommonToPb(const Item& item, T* pb_item) {
+ SerializeSourceToPb(item.GetSource(), source_pool_,
+ pb_item->mutable_source());
+ if (!item.GetComment().empty()) {
+ pb_item->set_comment(item.GetComment());
+ }
+ }
+
+ void SerializeReferenceToPb(const Reference& ref, pb::Reference* pb_ref) {
+ if (ref.id) {
+ pb_ref->set_id(ref.id.value().id);
}
- void visit(Reference* ref) override {
- serializeReferenceToPb(*ref, getPbItem()->mutable_ref());
+ if (ref.name) {
+ StringPool::Ref symbol_ref =
+ symbol_pool_->MakeRef(ref.name.value().ToString());
+ pb_ref->set_symbol_idx(static_cast<uint32_t>(symbol_ref.index()));
}
- void visit(String* str) override {
- getPbItem()->mutable_str()->set_idx(str->value.getIndex());
- }
+ pb_ref->set_private_(ref.private_reference);
+ pb_ref->set_type(SerializeReferenceTypeToPb(ref.reference_type));
+ }
- void visit(StyledString* str) override {
- getPbItem()->mutable_str()->set_idx(str->value.getIndex());
- }
-
- void visit(FileReference* file) override {
- getPbItem()->mutable_file()->set_path_idx(file->path.getIndex());
- }
-
- void visit(Id* id) override {
- getPbItem()->mutable_id();
- }
-
- void visit(RawString* rawStr) override {
- getPbItem()->mutable_raw_str()->set_idx(rawStr->value.getIndex());
- }
-
- void visit(BinaryPrimitive* prim) override {
- android::Res_value val = {};
- prim->flatten(&val);
-
- pb::Primitive* pbPrim = getPbItem()->mutable_prim();
- pbPrim->set_type(val.dataType);
- pbPrim->set_data(val.data);
- }
-
- void visitItem(Item* item) override {
- assert(false && "unimplemented item");
- }
-
- void visit(Attribute* attr) override {
- pb::Attribute* pbAttr = getPbCompoundValue()->mutable_attr();
- pbAttr->set_format_flags(attr->typeMask);
- pbAttr->set_min_int(attr->minInt);
- pbAttr->set_max_int(attr->maxInt);
-
- for (auto& symbol : attr->symbols) {
- pb::Attribute_Symbol* pbSymbol = pbAttr->add_symbols();
- serializeItemCommonToPb(symbol.symbol, pbSymbol);
- serializeReferenceToPb(symbol.symbol, pbSymbol->mutable_name());
- pbSymbol->set_value(symbol.value);
- }
- }
-
- void visit(Style* style) override {
- pb::Style* pbStyle = getPbCompoundValue()->mutable_style();
- if (style->parent) {
- serializeReferenceToPb(style->parent.value(), pbStyle->mutable_parent());
- serializeSourceToPb(style->parent.value().getSource(),
- mSourcePool,
- pbStyle->mutable_parent_source());
- }
-
- for (Style::Entry& entry : style->entries) {
- pb::Style_Entry* pbEntry = pbStyle->add_entries();
- serializeReferenceToPb(entry.key, pbEntry->mutable_key());
-
- pb::Item* pbItem = pbEntry->mutable_item();
- serializeItemCommonToPb(entry.key, pbEntry);
- PbSerializerVisitor subVisitor(mSourcePool, mSymbolPool, pbItem);
- entry.value->accept(&subVisitor);
- }
- }
-
- void visit(Styleable* styleable) override {
- pb::Styleable* pbStyleable = getPbCompoundValue()->mutable_styleable();
- for (Reference& entry : styleable->entries) {
- pb::Styleable_Entry* pbEntry = pbStyleable->add_entries();
- serializeItemCommonToPb(entry, pbEntry);
- serializeReferenceToPb(entry, pbEntry->mutable_attr());
- }
- }
-
- void visit(Array* array) override {
- pb::Array* pbArray = getPbCompoundValue()->mutable_array();
- for (auto& value : array->items) {
- pb::Array_Entry* pbEntry = pbArray->add_entries();
- serializeItemCommonToPb(*value, pbEntry);
- PbSerializerVisitor subVisitor(mSourcePool, mSymbolPool, pbEntry->mutable_item());
- value->accept(&subVisitor);
- }
- }
-
- void visit(Plural* plural) override {
- pb::Plural* pbPlural = getPbCompoundValue()->mutable_plural();
- const size_t count = plural->values.size();
- for (size_t i = 0; i < count; i++) {
- if (!plural->values[i]) {
- // No plural value set here.
- continue;
- }
-
- pb::Plural_Entry* pbEntry = pbPlural->add_entries();
- pbEntry->set_arity(serializePluralEnumToPb(i));
- pb::Item* pbElement = pbEntry->mutable_item();
- serializeItemCommonToPb(*plural->values[i], pbEntry);
- PbSerializerVisitor subVisitor(mSourcePool, mSymbolPool, pbElement);
- plural->values[i]->accept(&subVisitor);
- }
- }
-
-private:
- pb::Item* getPbItem() {
- if (mOutPbValue) {
- return mOutPbValue->mutable_item();
- }
- return mOutPbItem;
- }
-
- pb::CompoundValue* getPbCompoundValue() {
- assert(mOutPbValue);
- return mOutPbValue->mutable_compound_value();
- }
-
- template <typename T>
- void serializeItemCommonToPb(const Item& item, T* pbItem) {
- serializeSourceToPb(item.getSource(), mSourcePool, pbItem->mutable_source());
- if (!item.getComment().empty()) {
- pbItem->set_comment(item.getComment());
- }
- }
-
- void serializeReferenceToPb(const Reference& ref, pb::Reference* pbRef) {
- if (ref.id) {
- pbRef->set_id(ref.id.value().id);
- }
-
- if (ref.name) {
- StringPool::Ref symbolRef = mSymbolPool->makeRef(ref.name.value().toString());
- pbRef->set_symbol_idx(static_cast<uint32_t>(symbolRef.getIndex()));
- }
-
- pbRef->set_private_(ref.privateReference);
- pbRef->set_type(serializeReferenceTypeToPb(ref.referenceType));
- }
-
- StringPool* mSourcePool;
- StringPool* mSymbolPool;
- pb::Value* mOutPbValue;
- pb::Item* mOutPbItem;
+ StringPool* source_pool_;
+ StringPool* symbol_pool_;
+ pb::Value* out_pb_value_;
+ pb::Item* out_pb_item_;
};
-} // namespace
+} // namespace
-std::unique_ptr<pb::ResourceTable> serializeTableToPb(ResourceTable* table) {
- // We must do this before writing the resources, since the string pool IDs may change.
- table->stringPool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
+std::unique_ptr<pb::ResourceTable> SerializeTableToPb(ResourceTable* table) {
+ // We must do this before writing the resources, since the string pool IDs may
+ // change.
+ table->string_pool.Sort(
+ [](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
int diff = a.context.priority - b.context.priority;
if (diff < 0) return true;
if (diff > 0) return false;
@@ -211,192 +219,195 @@
if (diff < 0) return true;
if (diff > 0) return false;
return a.value < b.value;
- });
- table->stringPool.prune();
+ });
+ table->string_pool.Prune();
- auto pbTable = util::make_unique<pb::ResourceTable>();
- serializeStringPoolToPb(table->stringPool, pbTable->mutable_string_pool());
+ auto pb_table = util::make_unique<pb::ResourceTable>();
+ SerializeStringPoolToPb(table->string_pool, pb_table->mutable_string_pool());
- StringPool sourcePool, symbolPool;
+ StringPool source_pool, symbol_pool;
- for (auto& package : table->packages) {
- pb::Package* pbPackage = pbTable->add_packages();
- if (package->id) {
- pbPackage->set_package_id(package->id.value());
+ for (auto& package : table->packages) {
+ pb::Package* pb_package = pb_table->add_packages();
+ if (package->id) {
+ pb_package->set_package_id(package->id.value());
+ }
+ pb_package->set_package_name(package->name);
+
+ for (auto& type : package->types) {
+ pb::Type* pb_type = pb_package->add_types();
+ if (type->id) {
+ pb_type->set_id(type->id.value());
+ }
+ pb_type->set_name(ToString(type->type).ToString());
+
+ for (auto& entry : type->entries) {
+ pb::Entry* pb_entry = pb_type->add_entries();
+ if (entry->id) {
+ pb_entry->set_id(entry->id.value());
}
- pbPackage->set_package_name(package->name);
+ pb_entry->set_name(entry->name);
- for (auto& type : package->types) {
- pb::Type* pbType = pbPackage->add_types();
- if (type->id) {
- pbType->set_id(type->id.value());
- }
- pbType->set_name(toString(type->type).toString());
+ // Write the SymbolStatus struct.
+ pb::SymbolStatus* pb_status = pb_entry->mutable_symbol_status();
+ pb_status->set_visibility(
+ SerializeVisibilityToPb(entry->symbol_status.state));
+ SerializeSourceToPb(entry->symbol_status.source, &source_pool,
+ pb_status->mutable_source());
+ pb_status->set_comment(entry->symbol_status.comment);
- for (auto& entry : type->entries) {
- pb::Entry* pbEntry = pbType->add_entries();
- if (entry->id) {
- pbEntry->set_id(entry->id.value());
- }
- pbEntry->set_name(entry->name);
+ for (auto& config_value : entry->values) {
+ pb::ConfigValue* pb_config_value = pb_entry->add_config_values();
+ SerializeConfig(config_value->config,
+ pb_config_value->mutable_config());
+ if (!config_value->product.empty()) {
+ pb_config_value->mutable_config()->set_product(
+ config_value->product);
+ }
- // Write the SymbolStatus struct.
- pb::SymbolStatus* pbStatus = pbEntry->mutable_symbol_status();
- pbStatus->set_visibility(serializeVisibilityToPb(entry->symbolStatus.state));
- serializeSourceToPb(entry->symbolStatus.source, &sourcePool,
- pbStatus->mutable_source());
- pbStatus->set_comment(entry->symbolStatus.comment);
+ pb::Value* pb_value = pb_config_value->mutable_value();
+ SerializeSourceToPb(config_value->value->GetSource(), &source_pool,
+ pb_value->mutable_source());
+ if (!config_value->value->GetComment().empty()) {
+ pb_value->set_comment(config_value->value->GetComment());
+ }
- for (auto& configValue : entry->values) {
- pb::ConfigValue* pbConfigValue = pbEntry->add_config_values();
- serializeConfig(configValue->config, pbConfigValue->mutable_config());
- if (!configValue->product.empty()) {
- pbConfigValue->mutable_config()->set_product(configValue->product);
- }
+ if (config_value->value->IsWeak()) {
+ pb_value->set_weak(true);
+ }
- pb::Value* pbValue = pbConfigValue->mutable_value();
- serializeSourceToPb(configValue->value->getSource(), &sourcePool,
- pbValue->mutable_source());
- if (!configValue->value->getComment().empty()) {
- pbValue->set_comment(configValue->value->getComment());
- }
-
- if (configValue->value->isWeak()) {
- pbValue->set_weak(true);
- }
-
- PbSerializerVisitor visitor(&sourcePool, &symbolPool, pbValue);
- configValue->value->accept(&visitor);
- }
- }
+ PbSerializerVisitor visitor(&source_pool, &symbol_pool, pb_value);
+ config_value->value->Accept(&visitor);
}
+ }
}
+ }
- serializeStringPoolToPb(sourcePool, pbTable->mutable_source_pool());
- serializeStringPoolToPb(symbolPool, pbTable->mutable_symbol_pool());
- return pbTable;
+ SerializeStringPoolToPb(source_pool, pb_table->mutable_source_pool());
+ SerializeStringPoolToPb(symbol_pool, pb_table->mutable_symbol_pool());
+ return pb_table;
}
-std::unique_ptr<pb::CompiledFile> serializeCompiledFileToPb(const ResourceFile& file) {
- auto pbFile = util::make_unique<pb::CompiledFile>();
- pbFile->set_resource_name(file.name.toString());
- pbFile->set_source_path(file.source.path);
- serializeConfig(file.config, pbFile->mutable_config());
+std::unique_ptr<pb::CompiledFile> SerializeCompiledFileToPb(
+ const ResourceFile& file) {
+ auto pb_file = util::make_unique<pb::CompiledFile>();
+ pb_file->set_resource_name(file.name.ToString());
+ pb_file->set_source_path(file.source.path);
+ SerializeConfig(file.config, pb_file->mutable_config());
- for (const SourcedResourceName& exported : file.exportedSymbols) {
- pb::CompiledFile_Symbol* pbSymbol = pbFile->add_exported_symbols();
- pbSymbol->set_resource_name(exported.name.toString());
- pbSymbol->set_line_no(exported.line);
- }
- return pbFile;
+ for (const SourcedResourceName& exported : file.exported_symbols) {
+ pb::CompiledFile_Symbol* pb_symbol = pb_file->add_exported_symbols();
+ pb_symbol->set_resource_name(exported.name.ToString());
+ pb_symbol->set_line_no(exported.line);
+ }
+ return pb_file;
}
-CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out) : mOut(out) {
-}
+CompiledFileOutputStream::CompiledFileOutputStream(ZeroCopyOutputStream* out)
+ : out_(out) {}
-void CompiledFileOutputStream::ensureAlignedWrite() {
- const int padding = mOut.ByteCount() % 4;
- if (padding > 0) {
- uint32_t zero = 0u;
- mOut.WriteRaw(&zero, padding);
- }
+void CompiledFileOutputStream::EnsureAlignedWrite() {
+ const int padding = out_.ByteCount() % 4;
+ if (padding > 0) {
+ uint32_t zero = 0u;
+ out_.WriteRaw(&zero, padding);
+ }
}
void CompiledFileOutputStream::WriteLittleEndian32(uint32_t val) {
- ensureAlignedWrite();
- mOut.WriteLittleEndian32(val);
+ EnsureAlignedWrite();
+ out_.WriteLittleEndian32(val);
}
-void CompiledFileOutputStream::WriteCompiledFile(const pb::CompiledFile* compiledFile) {
- ensureAlignedWrite();
- mOut.WriteLittleEndian64(static_cast<uint64_t>(compiledFile->ByteSize()));
- compiledFile->SerializeWithCachedSizes(&mOut);
+void CompiledFileOutputStream::WriteCompiledFile(
+ const pb::CompiledFile* compiled_file) {
+ EnsureAlignedWrite();
+ out_.WriteLittleEndian64(static_cast<uint64_t>(compiled_file->ByteSize()));
+ compiled_file->SerializeWithCachedSizes(&out_);
}
void CompiledFileOutputStream::WriteData(const BigBuffer* buffer) {
- ensureAlignedWrite();
- mOut.WriteLittleEndian64(static_cast<uint64_t>(buffer->size()));
- for (const BigBuffer::Block& block : *buffer) {
- mOut.WriteRaw(block.buffer.get(), block.size);
- }
+ EnsureAlignedWrite();
+ out_.WriteLittleEndian64(static_cast<uint64_t>(buffer->size()));
+ for (const BigBuffer::Block& block : *buffer) {
+ out_.WriteRaw(block.buffer.get(), block.size);
+ }
}
void CompiledFileOutputStream::WriteData(const void* data, size_t len) {
- ensureAlignedWrite();
- mOut.WriteLittleEndian64(static_cast<uint64_t>(len));
- mOut.WriteRaw(data, len);
+ EnsureAlignedWrite();
+ out_.WriteLittleEndian64(static_cast<uint64_t>(len));
+ out_.WriteRaw(data, len);
}
-bool CompiledFileOutputStream::HadError() {
- return mOut.HadError();
+bool CompiledFileOutputStream::HadError() { return out_.HadError(); }
+
+CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size)
+ : in_(static_cast<const uint8_t*>(data), size) {}
+
+void CompiledFileInputStream::EnsureAlignedRead() {
+ const int padding = in_.CurrentPosition() % 4;
+ if (padding > 0) {
+ // Reads are always 4 byte aligned.
+ in_.Skip(padding);
+ }
}
-CompiledFileInputStream::CompiledFileInputStream(const void* data, size_t size) :
- mIn(static_cast<const uint8_t*>(data), size) {
+bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* out_val) {
+ EnsureAlignedRead();
+ return in_.ReadLittleEndian32(out_val);
}
-void CompiledFileInputStream::ensureAlignedRead() {
- const int padding = mIn.CurrentPosition() % 4;
- if (padding > 0) {
- // Reads are always 4 byte aligned.
- mIn.Skip(padding);
- }
+bool CompiledFileInputStream::ReadCompiledFile(pb::CompiledFile* out_val) {
+ EnsureAlignedRead();
+
+ uint64_t pb_size = 0u;
+ if (!in_.ReadLittleEndian64(&pb_size)) {
+ return false;
+ }
+
+ CodedInputStream::Limit l = in_.PushLimit(static_cast<int>(pb_size));
+
+ // Check that we haven't tried to read past the end.
+ if (static_cast<uint64_t>(in_.BytesUntilLimit()) != pb_size) {
+ in_.PopLimit(l);
+ in_.PushLimit(0);
+ return false;
+ }
+
+ if (!out_val->ParsePartialFromCodedStream(&in_)) {
+ in_.PopLimit(l);
+ in_.PushLimit(0);
+ return false;
+ }
+
+ in_.PopLimit(l);
+ return true;
}
-bool CompiledFileInputStream::ReadLittleEndian32(uint32_t* outVal) {
- ensureAlignedRead();
- return mIn.ReadLittleEndian32(outVal);
+bool CompiledFileInputStream::ReadDataMetaData(uint64_t* out_offset,
+ uint64_t* out_len) {
+ EnsureAlignedRead();
+
+ uint64_t pb_size = 0u;
+ if (!in_.ReadLittleEndian64(&pb_size)) {
+ return false;
+ }
+
+ // Check that we aren't trying to read past the end.
+ if (pb_size > static_cast<uint64_t>(in_.BytesUntilLimit())) {
+ in_.PushLimit(0);
+ return false;
+ }
+
+ uint64_t offset = static_cast<uint64_t>(in_.CurrentPosition());
+ if (!in_.Skip(pb_size)) {
+ return false;
+ }
+
+ *out_offset = offset;
+ *out_len = pb_size;
+ return true;
}
-bool CompiledFileInputStream::ReadCompiledFile(pb::CompiledFile* outVal) {
- ensureAlignedRead();
-
- uint64_t pbSize = 0u;
- if (!mIn.ReadLittleEndian64(&pbSize)) {
- return false;
- }
-
- CodedInputStream::Limit l = mIn.PushLimit(static_cast<int>(pbSize));
-
- // Check that we haven't tried to read past the end.
- if (static_cast<uint64_t>(mIn.BytesUntilLimit()) != pbSize) {
- mIn.PopLimit(l);
- mIn.PushLimit(0);
- return false;
- }
-
- if (!outVal->ParsePartialFromCodedStream(&mIn)) {
- mIn.PopLimit(l);
- mIn.PushLimit(0);
- return false;
- }
-
- mIn.PopLimit(l);
- return true;
-}
-
-bool CompiledFileInputStream::ReadDataMetaData(uint64_t* outOffset, uint64_t* outLen) {
- ensureAlignedRead();
-
- uint64_t pbSize = 0u;
- if (!mIn.ReadLittleEndian64(&pbSize)) {
- return false;
- }
-
- // Check that we aren't trying to read past the end.
- if (pbSize > static_cast<uint64_t>(mIn.BytesUntilLimit())) {
- mIn.PushLimit(0);
- return false;
- }
-
- uint64_t offset = static_cast<uint64_t>(mIn.CurrentPosition());
- if (!mIn.Skip(pbSize)) {
- return false;
- }
-
- *outOffset = offset;
- *outLen = pbSize;
- return true;
-}
-
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/proto/TableProtoSerializer_test.cpp b/tools/aapt2/proto/TableProtoSerializer_test.cpp
index 2bd9767..fdd5197 100644
--- a/tools/aapt2/proto/TableProtoSerializer_test.cpp
+++ b/tools/aapt2/proto/TableProtoSerializer_test.cpp
@@ -14,200 +14,211 @@
* limitations under the License.
*/
-#include "ResourceTable.h"
#include "proto/ProtoSerialize.h"
+
+#include "ResourceTable.h"
#include "test/Test.h"
-using namespace google::protobuf::io;
+using ::google::protobuf::io::StringOutputStream;
namespace aapt {
TEST(TableProtoSerializer, SerializeSinglePackage) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .setPackageId("com.app.a", 0x7f)
- .addFileReference("com.app.a:layout/main", ResourceId(0x7f020000),
- "res/layout/main.xml")
- .addReference("com.app.a:layout/other", ResourceId(0x7f020001),
- "com.app.a:layout/main")
- .addString("com.app.a:string/text", {}, "hi")
- .addValue("com.app.a:id/foo", {}, util::make_unique<Id>())
- .build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .SetPackageId("com.app.a", 0x7f)
+ .AddFileReference("com.app.a:layout/main", ResourceId(0x7f020000),
+ "res/layout/main.xml")
+ .AddReference("com.app.a:layout/other", ResourceId(0x7f020001),
+ "com.app.a:layout/main")
+ .AddString("com.app.a:string/text", {}, "hi")
+ .AddValue("com.app.a:id/foo", {}, util::make_unique<Id>())
+ .Build();
- Symbol publicSymbol;
- publicSymbol.state = SymbolState::kPublic;
- ASSERT_TRUE(table->setSymbolState(test::parseNameOrDie("com.app.a:layout/main"),
- ResourceId(0x7f020000),
- publicSymbol, context->getDiagnostics()));
+ Symbol public_symbol;
+ public_symbol.state = SymbolState::kPublic;
+ ASSERT_TRUE(table->SetSymbolState(
+ test::ParseNameOrDie("com.app.a:layout/main"), ResourceId(0x7f020000),
+ public_symbol, context->GetDiagnostics()));
- Id* id = test::getValue<Id>(table.get(), "com.app.a:id/foo");
- ASSERT_NE(nullptr, id);
+ Id* id = test::GetValue<Id>(table.get(), "com.app.a:id/foo");
+ ASSERT_NE(nullptr, id);
- // Make a plural.
- std::unique_ptr<Plural> plural = util::make_unique<Plural>();
- plural->values[Plural::One] = util::make_unique<String>(table->stringPool.makeRef("one"));
- ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:plurals/hey"),
- ConfigDescription{}, {}, std::move(plural),
- context->getDiagnostics()));
+ // Make a plural.
+ std::unique_ptr<Plural> plural = util::make_unique<Plural>();
+ plural->values[Plural::One] =
+ util::make_unique<String>(table->string_pool.MakeRef("one"));
+ ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:plurals/hey"),
+ ConfigDescription{}, {}, std::move(plural),
+ context->GetDiagnostics()));
- // Make a resource with different products.
- ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:integer/one"),
- test::parseConfigOrDie("land"), {},
- test::buildPrimitive(android::Res_value::TYPE_INT_DEC, 123u),
- context->getDiagnostics()));
- ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:integer/one"),
- test::parseConfigOrDie("land"), "tablet",
- test::buildPrimitive(android::Res_value::TYPE_INT_DEC, 321u),
- context->getDiagnostics()));
+ // Make a resource with different products.
+ ASSERT_TRUE(table->AddResource(
+ test::ParseNameOrDie("com.app.a:integer/one"),
+ test::ParseConfigOrDie("land"), {},
+ test::BuildPrimitive(android::Res_value::TYPE_INT_DEC, 123u),
+ context->GetDiagnostics()));
+ ASSERT_TRUE(table->AddResource(
+ test::ParseNameOrDie("com.app.a:integer/one"),
+ test::ParseConfigOrDie("land"), "tablet",
+ test::BuildPrimitive(android::Res_value::TYPE_INT_DEC, 321u),
+ context->GetDiagnostics()));
- // Make a reference with both resource name and resource ID.
- // The reference should point to a resource outside of this table to test that both
- // name and id get serialized.
- Reference expectedRef;
- expectedRef.name = test::parseNameOrDie("android:layout/main");
- expectedRef.id = ResourceId(0x01020000);
- ASSERT_TRUE(table->addResource(test::parseNameOrDie("com.app.a:layout/abc"),
- ConfigDescription::defaultConfig(), {},
- util::make_unique<Reference>(expectedRef),
- context->getDiagnostics()));
+ // Make a reference with both resource name and resource ID.
+ // The reference should point to a resource outside of this table to test that
+ // both
+ // name and id get serialized.
+ Reference expected_ref;
+ expected_ref.name = test::ParseNameOrDie("android:layout/main");
+ expected_ref.id = ResourceId(0x01020000);
+ ASSERT_TRUE(table->AddResource(test::ParseNameOrDie("com.app.a:layout/abc"),
+ ConfigDescription::DefaultConfig(), {},
+ util::make_unique<Reference>(expected_ref),
+ context->GetDiagnostics()));
- std::unique_ptr<pb::ResourceTable> pbTable = serializeTableToPb(table.get());
- ASSERT_NE(nullptr, pbTable);
+ std::unique_ptr<pb::ResourceTable> pb_table = SerializeTableToPb(table.get());
+ ASSERT_NE(nullptr, pb_table);
- std::unique_ptr<ResourceTable> newTable = deserializeTableFromPb(*pbTable,
- Source{ "test" },
- context->getDiagnostics());
- ASSERT_NE(nullptr, newTable);
+ std::unique_ptr<ResourceTable> new_table = DeserializeTableFromPb(
+ *pb_table, Source{"test"}, context->GetDiagnostics());
+ ASSERT_NE(nullptr, new_table);
- Id* newId = test::getValue<Id>(newTable.get(), "com.app.a:id/foo");
- ASSERT_NE(nullptr, newId);
- EXPECT_EQ(id->isWeak(), newId->isWeak());
+ Id* new_id = test::GetValue<Id>(new_table.get(), "com.app.a:id/foo");
+ ASSERT_NE(nullptr, new_id);
+ EXPECT_EQ(id->IsWeak(), new_id->IsWeak());
- Maybe<ResourceTable::SearchResult> result = newTable->findResource(
- test::parseNameOrDie("com.app.a:layout/main"));
- AAPT_ASSERT_TRUE(result);
- EXPECT_EQ(SymbolState::kPublic, result.value().type->symbolStatus.state);
- EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbolStatus.state);
+ Maybe<ResourceTable::SearchResult> result =
+ new_table->FindResource(test::ParseNameOrDie("com.app.a:layout/main"));
+ AAPT_ASSERT_TRUE(result);
+ EXPECT_EQ(SymbolState::kPublic, result.value().type->symbol_status.state);
+ EXPECT_EQ(SymbolState::kPublic, result.value().entry->symbol_status.state);
- // Find the product-dependent values
- BinaryPrimitive* prim = test::getValueForConfigAndProduct<BinaryPrimitive>(
- newTable.get(), "com.app.a:integer/one", test::parseConfigOrDie("land"), "");
- ASSERT_NE(nullptr, prim);
- EXPECT_EQ(123u, prim->value.data);
+ // Find the product-dependent values
+ BinaryPrimitive* prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
+ new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"),
+ "");
+ ASSERT_NE(nullptr, prim);
+ EXPECT_EQ(123u, prim->value.data);
- prim = test::getValueForConfigAndProduct<BinaryPrimitive>(
- newTable.get(), "com.app.a:integer/one", test::parseConfigOrDie("land"), "tablet");
- ASSERT_NE(nullptr, prim);
- EXPECT_EQ(321u, prim->value.data);
+ prim = test::GetValueForConfigAndProduct<BinaryPrimitive>(
+ new_table.get(), "com.app.a:integer/one", test::ParseConfigOrDie("land"),
+ "tablet");
+ ASSERT_NE(nullptr, prim);
+ EXPECT_EQ(321u, prim->value.data);
- Reference* actualRef = test::getValue<Reference>(newTable.get(), "com.app.a:layout/abc");
- ASSERT_NE(nullptr, actualRef);
- AAPT_ASSERT_TRUE(actualRef->name);
- AAPT_ASSERT_TRUE(actualRef->id);
- EXPECT_EQ(expectedRef.name.value(), actualRef->name.value());
- EXPECT_EQ(expectedRef.id.value(), actualRef->id.value());
+ Reference* actual_ref =
+ test::GetValue<Reference>(new_table.get(), "com.app.a:layout/abc");
+ ASSERT_NE(nullptr, actual_ref);
+ AAPT_ASSERT_TRUE(actual_ref->name);
+ AAPT_ASSERT_TRUE(actual_ref->id);
+ EXPECT_EQ(expected_ref.name.value(), actual_ref->name.value());
+ EXPECT_EQ(expected_ref.id.value(), actual_ref->id.value());
}
TEST(TableProtoSerializer, SerializeFileHeader) {
- std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+ std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();
- ResourceFile f;
- f.config = test::parseConfigOrDie("hdpi-v9");
- f.name = test::parseNameOrDie("com.app.a:layout/main");
- f.source.path = "res/layout-hdpi-v9/main.xml";
- f.exportedSymbols.push_back(SourcedResourceName{ test::parseNameOrDie("id/unchecked"), 23u });
+ ResourceFile f;
+ f.config = test::ParseConfigOrDie("hdpi-v9");
+ f.name = test::ParseNameOrDie("com.app.a:layout/main");
+ f.source.path = "res/layout-hdpi-v9/main.xml";
+ f.exported_symbols.push_back(
+ SourcedResourceName{test::ParseNameOrDie("id/unchecked"), 23u});
- const std::string expectedData1 = "123";
- const std::string expectedData2 = "1234";
+ const std::string expected_data1 = "123";
+ const std::string expected_data2 = "1234";
- std::string outputStr;
- {
- std::unique_ptr<pb::CompiledFile> pbFile1 = serializeCompiledFileToPb(f);
+ std::string output_str;
+ {
+ std::unique_ptr<pb::CompiledFile> pb_file1 = SerializeCompiledFileToPb(f);
- f.name.entry = "__" + f.name.entry + "$0";
- std::unique_ptr<pb::CompiledFile> pbFile2 = serializeCompiledFileToPb(f);
+ f.name.entry = "__" + f.name.entry + "$0";
+ std::unique_ptr<pb::CompiledFile> pb_file2 = SerializeCompiledFileToPb(f);
- StringOutputStream outStream(&outputStr);
- CompiledFileOutputStream outFileStream(&outStream);
- outFileStream.WriteLittleEndian32(2);
- outFileStream.WriteCompiledFile(pbFile1.get());
- outFileStream.WriteData(expectedData1.data(), expectedData1.size());
- outFileStream.WriteCompiledFile(pbFile2.get());
- outFileStream.WriteData(expectedData2.data(), expectedData2.size());
- ASSERT_FALSE(outFileStream.HadError());
- }
+ StringOutputStream out_stream(&output_str);
+ CompiledFileOutputStream out_file_stream(&out_stream);
+ out_file_stream.WriteLittleEndian32(2);
+ out_file_stream.WriteCompiledFile(pb_file1.get());
+ out_file_stream.WriteData(expected_data1.data(), expected_data1.size());
+ out_file_stream.WriteCompiledFile(pb_file2.get());
+ out_file_stream.WriteData(expected_data2.data(), expected_data2.size());
+ ASSERT_FALSE(out_file_stream.HadError());
+ }
- CompiledFileInputStream inFileStream(outputStr.data(), outputStr.size());
- uint32_t numFiles = 0;
- ASSERT_TRUE(inFileStream.ReadLittleEndian32(&numFiles));
- ASSERT_EQ(2u, numFiles);
+ CompiledFileInputStream in_file_stream(output_str.data(), output_str.size());
+ uint32_t num_files = 0;
+ ASSERT_TRUE(in_file_stream.ReadLittleEndian32(&num_files));
+ ASSERT_EQ(2u, num_files);
- // Read the first compiled file.
+ // Read the first compiled file.
- pb::CompiledFile newPbFile;
- ASSERT_TRUE(inFileStream.ReadCompiledFile(&newPbFile));
+ pb::CompiledFile new_pb_file;
+ ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file));
- std::unique_ptr<ResourceFile> file = deserializeCompiledFileFromPb(newPbFile, Source("test"),
- context->getDiagnostics());
- ASSERT_NE(nullptr, file);
+ std::unique_ptr<ResourceFile> file = DeserializeCompiledFileFromPb(
+ new_pb_file, Source("test"), context->GetDiagnostics());
+ ASSERT_NE(nullptr, file);
- uint64_t offset, len;
- ASSERT_TRUE(inFileStream.ReadDataMetaData(&offset, &len));
+ uint64_t offset, len;
+ ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
- std::string actualData(outputStr.data() + offset, len);
- EXPECT_EQ(expectedData1, actualData);
+ std::string actual_data(output_str.data() + offset, len);
+ EXPECT_EQ(expected_data1, actual_data);
- // Expect the data to be aligned.
- EXPECT_EQ(0u, offset & 0x03);
+ // Expect the data to be aligned.
+ EXPECT_EQ(0u, offset & 0x03);
- ASSERT_EQ(1u, file->exportedSymbols.size());
- EXPECT_EQ(test::parseNameOrDie("id/unchecked"), file->exportedSymbols[0].name);
+ ASSERT_EQ(1u, file->exported_symbols.size());
+ EXPECT_EQ(test::ParseNameOrDie("id/unchecked"),
+ file->exported_symbols[0].name);
- // Read the second compiled file.
+ // Read the second compiled file.
- ASSERT_TRUE(inFileStream.ReadCompiledFile(&newPbFile));
+ ASSERT_TRUE(in_file_stream.ReadCompiledFile(&new_pb_file));
- file = deserializeCompiledFileFromPb(newPbFile, Source("test"), context->getDiagnostics());
- ASSERT_NE(nullptr, file);
+ file = DeserializeCompiledFileFromPb(new_pb_file, Source("test"),
+ context->GetDiagnostics());
+ ASSERT_NE(nullptr, file);
- ASSERT_TRUE(inFileStream.ReadDataMetaData(&offset, &len));
+ ASSERT_TRUE(in_file_stream.ReadDataMetaData(&offset, &len));
- actualData = std::string(outputStr.data() + offset, len);
- EXPECT_EQ(expectedData2, actualData);
+ actual_data = std::string(output_str.data() + offset, len);
+ EXPECT_EQ(expected_data2, actual_data);
- // Expect the data to be aligned.
- EXPECT_EQ(0u, offset & 0x03);
+ // Expect the data to be aligned.
+ EXPECT_EQ(0u, offset & 0x03);
}
TEST(TableProtoSerializer, DeserializeCorruptHeaderSafely) {
- ResourceFile f;
- std::unique_ptr<pb::CompiledFile> pbFile = serializeCompiledFileToPb(f);
+ ResourceFile f;
+ std::unique_ptr<pb::CompiledFile> pb_file = SerializeCompiledFileToPb(f);
- const std::string expectedData = "1234";
+ const std::string expected_data = "1234";
- std::string outputStr;
- {
- StringOutputStream outStream(&outputStr);
- CompiledFileOutputStream outFileStream(&outStream);
- outFileStream.WriteLittleEndian32(1);
- outFileStream.WriteCompiledFile(pbFile.get());
- outFileStream.WriteData(expectedData.data(), expectedData.size());
- ASSERT_FALSE(outFileStream.HadError());
- }
+ std::string output_str;
+ {
+ StringOutputStream out_stream(&output_str);
+ CompiledFileOutputStream out_file_stream(&out_stream);
+ out_file_stream.WriteLittleEndian32(1);
+ out_file_stream.WriteCompiledFile(pb_file.get());
+ out_file_stream.WriteData(expected_data.data(), expected_data.size());
+ ASSERT_FALSE(out_file_stream.HadError());
+ }
- outputStr[4] = 0xff;
+ output_str[4] = 0xff;
- CompiledFileInputStream inFileStream(outputStr.data(), outputStr.size());
+ CompiledFileInputStream in_file_stream(output_str.data(), output_str.size());
- uint32_t numFiles = 0;
- EXPECT_TRUE(inFileStream.ReadLittleEndian32(&numFiles));
- EXPECT_EQ(1u, numFiles);
+ uint32_t num_files = 0;
+ EXPECT_TRUE(in_file_stream.ReadLittleEndian32(&num_files));
+ EXPECT_EQ(1u, num_files);
- pb::CompiledFile newPbFile;
- EXPECT_FALSE(inFileStream.ReadCompiledFile(&newPbFile));
+ pb::CompiledFile new_pb_file;
+ EXPECT_FALSE(in_file_stream.ReadCompiledFile(&new_pb_file));
- uint64_t offset, len;
- EXPECT_FALSE(inFileStream.ReadDataMetaData(&offset, &len));
+ uint64_t offset, len;
+ EXPECT_FALSE(in_file_stream.ReadDataMetaData(&offset, &len));
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/split/TableSplitter.cpp b/tools/aapt2/split/TableSplitter.cpp
index 08b9ee9..7aad86f 100644
--- a/tools/aapt2/split/TableSplitter.cpp
+++ b/tools/aapt2/split/TableSplitter.cpp
@@ -14,251 +14,278 @@
* limitations under the License.
*/
-#include "ConfigDescription.h"
-#include "ResourceTable.h"
#include "split/TableSplitter.h"
-#include "util/Util.h"
#include <algorithm>
#include <map>
#include <set>
#include <unordered_map>
#include <vector>
+#include "android-base/logging.h"
+
+#include "ConfigDescription.h"
+#include "ResourceTable.h"
+#include "util/Util.h"
namespace aapt {
using ConfigClaimedMap = std::unordered_map<ResourceConfigValue*, bool>;
-using ConfigDensityGroups = std::map<ConfigDescription, std::vector<ResourceConfigValue*>>;
+using ConfigDensityGroups =
+ std::map<ConfigDescription, std::vector<ResourceConfigValue*>>;
-static ConfigDescription copyWithoutDensity(const ConfigDescription& config) {
- ConfigDescription withoutDensity = config;
- withoutDensity.density = 0;
- return withoutDensity;
+static ConfigDescription CopyWithoutDensity(const ConfigDescription& config) {
+ ConfigDescription without_density = config;
+ without_density.density = 0;
+ return without_density;
}
/**
* Selects values that match exactly the constraints given.
*/
class SplitValueSelector {
-public:
- explicit SplitValueSelector(const SplitConstraints& constraints) {
- for (const ConfigDescription& config : constraints.configs) {
- if (config.density == 0) {
- mDensityIndependentConfigs.insert(config);
- } else {
- mDensityDependentConfigToDensityMap[copyWithoutDensity(config)] = config.density;
- }
+ public:
+ explicit SplitValueSelector(const SplitConstraints& constraints) {
+ for (const ConfigDescription& config : constraints.configs) {
+ if (config.density == 0) {
+ density_independent_configs_.insert(config);
+ } else {
+ density_dependent_config_to_density_map_[CopyWithoutDensity(config)] =
+ config.density;
+ }
+ }
+ }
+
+ std::vector<ResourceConfigValue*> SelectValues(
+ const ConfigDensityGroups& density_groups,
+ ConfigClaimedMap* claimed_values) {
+ std::vector<ResourceConfigValue*> selected;
+
+ // Select the regular values.
+ for (auto& entry : *claimed_values) {
+ // Check if the entry has a density.
+ ResourceConfigValue* config_value = entry.first;
+ if (config_value->config.density == 0 && !entry.second) {
+ // This is still available.
+ if (density_independent_configs_.find(config_value->config) !=
+ density_independent_configs_.end()) {
+ selected.push_back(config_value);
+
+ // Mark the entry as taken.
+ entry.second = true;
}
+ }
}
- std::vector<ResourceConfigValue*> selectValues(const ConfigDensityGroups& densityGroups,
- ConfigClaimedMap* claimedValues) {
- std::vector<ResourceConfigValue*> selected;
+ // Now examine the densities
+ for (auto& entry : density_groups) {
+ // We do not care if the value is claimed, since density values can be
+ // in multiple splits.
+ const ConfigDescription& config = entry.first;
+ const std::vector<ResourceConfigValue*>& related_values = entry.second;
+ auto density_value_iter =
+ density_dependent_config_to_density_map_.find(config);
+ if (density_value_iter !=
+ density_dependent_config_to_density_map_.end()) {
+ // Select the best one!
+ ConfigDescription target_density = config;
+ target_density.density = density_value_iter->second;
- // Select the regular values.
- for (auto& entry : *claimedValues) {
- // Check if the entry has a density.
- ResourceConfigValue* configValue = entry.first;
- if (configValue->config.density == 0 && !entry.second) {
- // This is still available.
- if (mDensityIndependentConfigs.find(configValue->config) !=
- mDensityIndependentConfigs.end()) {
- selected.push_back(configValue);
-
- // Mark the entry as taken.
- entry.second = true;
- }
- }
+ ResourceConfigValue* best_value = nullptr;
+ for (ResourceConfigValue* this_value : related_values) {
+ if (!best_value ||
+ this_value->config.isBetterThan(best_value->config,
+ &target_density)) {
+ best_value = this_value;
+ }
}
+ CHECK(best_value != nullptr);
- // Now examine the densities
- for (auto& entry : densityGroups) {
- // We do not care if the value is claimed, since density values can be
- // in multiple splits.
- const ConfigDescription& config = entry.first;
- const std::vector<ResourceConfigValue*>& relatedValues = entry.second;
- auto densityValueIter = mDensityDependentConfigToDensityMap.find(config);
- if (densityValueIter != mDensityDependentConfigToDensityMap.end()) {
- // Select the best one!
- ConfigDescription targetDensity = config;
- targetDensity.density = densityValueIter->second;
-
- ResourceConfigValue* bestValue = nullptr;
- for (ResourceConfigValue* thisValue : relatedValues) {
- if (!bestValue ||
- thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
- bestValue = thisValue;
- }
- }
- assert(bestValue);
-
- // When we select one of these, they are all claimed such that the base
- // doesn't include any anymore.
- (*claimedValues)[bestValue] = true;
- selected.push_back(bestValue);
- }
- }
- return selected;
+ // When we select one of these, they are all claimed such that the base
+ // doesn't include any anymore.
+ (*claimed_values)[best_value] = true;
+ selected.push_back(best_value);
+ }
}
+ return selected;
+ }
-private:
- std::set<ConfigDescription> mDensityIndependentConfigs;
- std::map<ConfigDescription, uint16_t> mDensityDependentConfigToDensityMap;
+ private:
+ DISALLOW_COPY_AND_ASSIGN(SplitValueSelector);
+
+ std::set<ConfigDescription> density_independent_configs_;
+ std::map<ConfigDescription, uint16_t>
+ density_dependent_config_to_density_map_;
};
/**
- * Marking non-preferred densities as claimed will make sure the base doesn't include them,
+ * Marking non-preferred densities as claimed will make sure the base doesn't
+ * include them,
* leaving only the preferred density behind.
*/
-static void markNonPreferredDensitiesAsClaimed(uint16_t preferredDensity,
- const ConfigDensityGroups& densityGroups,
- ConfigClaimedMap* configClaimedMap) {
- for (auto& entry : densityGroups) {
- const ConfigDescription& config = entry.first;
- const std::vector<ResourceConfigValue*>& relatedValues = entry.second;
+static void MarkNonPreferredDensitiesAsClaimed(
+ uint16_t preferred_density, const ConfigDensityGroups& density_groups,
+ ConfigClaimedMap* config_claimed_map) {
+ for (auto& entry : density_groups) {
+ const ConfigDescription& config = entry.first;
+ const std::vector<ResourceConfigValue*>& related_values = entry.second;
- ConfigDescription targetDensity = config;
- targetDensity.density = preferredDensity;
- ResourceConfigValue* bestValue = nullptr;
- for (ResourceConfigValue* thisValue : relatedValues) {
- if (!bestValue) {
- bestValue = thisValue;
- } else if (thisValue->config.isBetterThan(bestValue->config, &targetDensity)) {
- // Claim the previous value so that it is not included in the base.
- (*configClaimedMap)[bestValue] = true;
- bestValue = thisValue;
- } else {
- // Claim this value so that it is not included in the base.
- (*configClaimedMap)[thisValue] = true;
- }
- }
- assert(bestValue);
+ ConfigDescription target_density = config;
+ target_density.density = preferred_density;
+ ResourceConfigValue* best_value = nullptr;
+ for (ResourceConfigValue* this_value : related_values) {
+ if (!best_value) {
+ best_value = this_value;
+ } else if (this_value->config.isBetterThan(best_value->config,
+ &target_density)) {
+ // Claim the previous value so that it is not included in the base.
+ (*config_claimed_map)[best_value] = true;
+ best_value = this_value;
+ } else {
+ // Claim this value so that it is not included in the base.
+ (*config_claimed_map)[this_value] = true;
+ }
}
+ CHECK(best_value != nullptr);
+ }
}
-bool TableSplitter::verifySplitConstraints(IAaptContext* context) {
- bool error = false;
- for (size_t i = 0; i < mSplitConstraints.size(); i++) {
- for (size_t j = i + 1; j < mSplitConstraints.size(); j++) {
- for (const ConfigDescription& config : mSplitConstraints[i].configs) {
- if (mSplitConstraints[j].configs.find(config) !=
- mSplitConstraints[j].configs.end()) {
- context->getDiagnostics()->error(DiagMessage() << "config '" << config
- << "' appears in multiple splits, "
- << "target split ambiguous");
- error = true;
- }
- }
+bool TableSplitter::VerifySplitConstraints(IAaptContext* context) {
+ bool error = false;
+ for (size_t i = 0; i < split_constraints_.size(); i++) {
+ for (size_t j = i + 1; j < split_constraints_.size(); j++) {
+ for (const ConfigDescription& config : split_constraints_[i].configs) {
+ if (split_constraints_[j].configs.find(config) !=
+ split_constraints_[j].configs.end()) {
+ context->GetDiagnostics()->Error(DiagMessage()
+ << "config '" << config
+ << "' appears in multiple splits, "
+ << "target split ambiguous");
+ error = true;
}
+ }
}
- return !error;
+ }
+ return !error;
}
-void TableSplitter::splitTable(ResourceTable* originalTable) {
- const size_t splitCount = mSplitConstraints.size();
- for (auto& pkg : originalTable->packages) {
- // Initialize all packages for splits.
- for (size_t idx = 0; idx < splitCount; idx++) {
- ResourceTable* splitTable = mSplits[idx].get();
- splitTable->createPackage(pkg->name, pkg->id);
- }
-
- for (auto& type : pkg->types) {
- if (type->type == ResourceType::kMipmap) {
- // Always keep mipmaps.
- continue;
- }
-
- for (auto& entry : type->entries) {
- if (mConfigFilter) {
- // First eliminate any resource that we definitely don't want.
- for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
- if (!mConfigFilter->match(configValue->config)) {
- // null out the entry. We will clean up and remove nulls at the end
- // for performance reasons.
- configValue.reset();
- }
- }
- }
-
- // Organize the values into two separate buckets. Those that are density-dependent
- // and those that are density-independent.
- // One density technically matches all density, it's just that some densities
- // match better. So we need to be aware of the full set of densities to make this
- // decision.
- ConfigDensityGroups densityGroups;
- ConfigClaimedMap configClaimedMap;
- for (const std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
- if (configValue) {
- configClaimedMap[configValue.get()] = false;
-
- if (configValue->config.density != 0) {
- // Create a bucket for this density-dependent config.
- densityGroups[copyWithoutDensity(configValue->config)]
- .push_back(configValue.get());
- }
- }
- }
-
- // First we check all the splits. If it doesn't match one of the splits, we
- // leave it in the base.
- for (size_t idx = 0; idx < splitCount; idx++) {
- const SplitConstraints& splitConstraint = mSplitConstraints[idx];
- ResourceTable* splitTable = mSplits[idx].get();
-
- // Select the values we want from this entry for this split.
- SplitValueSelector selector(splitConstraint);
- std::vector<ResourceConfigValue*> selectedValues =
- selector.selectValues(densityGroups, &configClaimedMap);
-
- // No need to do any work if we selected nothing.
- if (!selectedValues.empty()) {
- // Create the same resource structure in the split. We do this lazily
- // because we might not have actual values for each type/entry.
- ResourceTablePackage* splitPkg = splitTable->findPackage(pkg->name);
- ResourceTableType* splitType = splitPkg->findOrCreateType(type->type);
- if (!splitType->id) {
- splitType->id = type->id;
- splitType->symbolStatus = type->symbolStatus;
- }
-
- ResourceEntry* splitEntry = splitType->findOrCreateEntry(entry->name);
- if (!splitEntry->id) {
- splitEntry->id = entry->id;
- splitEntry->symbolStatus = entry->symbolStatus;
- }
-
- // Copy the selected values into the new Split Entry.
- for (ResourceConfigValue* configValue : selectedValues) {
- ResourceConfigValue* newConfigValue = splitEntry->findOrCreateValue(
- configValue->config, configValue->product);
- newConfigValue->value = std::unique_ptr<Value>(
- configValue->value->clone(&splitTable->stringPool));
- }
- }
- }
-
- if (mPreferredDensity) {
- markNonPreferredDensitiesAsClaimed(mPreferredDensity.value(),
- densityGroups,
- &configClaimedMap);
- }
-
- // All splits are handled, now check to see what wasn't claimed and remove
- // whatever exists in other splits.
- for (std::unique_ptr<ResourceConfigValue>& configValue : entry->values) {
- if (configValue && configClaimedMap[configValue.get()]) {
- // Claimed, remove from base.
- configValue.reset();
- }
- }
-
- // Now erase all nullptrs.
- entry->values.erase(
- std::remove(entry->values.begin(), entry->values.end(), nullptr),
- entry->values.end());
- }
- }
+void TableSplitter::SplitTable(ResourceTable* original_table) {
+ const size_t split_count = split_constraints_.size();
+ for (auto& pkg : original_table->packages) {
+ // Initialize all packages for splits.
+ for (size_t idx = 0; idx < split_count; idx++) {
+ ResourceTable* split_table = splits_[idx].get();
+ split_table->CreatePackage(pkg->name, pkg->id);
}
+
+ for (auto& type : pkg->types) {
+ if (type->type == ResourceType::kMipmap) {
+ // Always keep mipmaps.
+ continue;
+ }
+
+ for (auto& entry : type->entries) {
+ if (options_.config_filter) {
+ // First eliminate any resource that we definitely don't want.
+ for (std::unique_ptr<ResourceConfigValue>& config_value :
+ entry->values) {
+ if (!options_.config_filter->Match(config_value->config)) {
+ // null out the entry. We will clean up and remove nulls at the
+ // end for performance reasons.
+ config_value.reset();
+ }
+ }
+ }
+
+ // Organize the values into two separate buckets. Those that are
+ // density-dependent
+ // and those that are density-independent.
+ // One density technically matches all density, it's just that some
+ // densities
+ // match better. So we need to be aware of the full set of densities to
+ // make this
+ // decision.
+ ConfigDensityGroups density_groups;
+ ConfigClaimedMap config_claimed_map;
+ for (const std::unique_ptr<ResourceConfigValue>& config_value :
+ entry->values) {
+ if (config_value) {
+ config_claimed_map[config_value.get()] = false;
+
+ if (config_value->config.density != 0) {
+ // Create a bucket for this density-dependent config.
+ density_groups[CopyWithoutDensity(config_value->config)]
+ .push_back(config_value.get());
+ }
+ }
+ }
+
+ // First we check all the splits. If it doesn't match one of the splits,
+ // we
+ // leave it in the base.
+ for (size_t idx = 0; idx < split_count; idx++) {
+ const SplitConstraints& split_constraint = split_constraints_[idx];
+ ResourceTable* split_table = splits_[idx].get();
+
+ // Select the values we want from this entry for this split.
+ SplitValueSelector selector(split_constraint);
+ std::vector<ResourceConfigValue*> selected_values =
+ selector.SelectValues(density_groups, &config_claimed_map);
+
+ // No need to do any work if we selected nothing.
+ if (!selected_values.empty()) {
+ // Create the same resource structure in the split. We do this
+ // lazily because we might not have actual values for each
+ // type/entry.
+ ResourceTablePackage* split_pkg =
+ split_table->FindPackage(pkg->name);
+ ResourceTableType* split_type =
+ split_pkg->FindOrCreateType(type->type);
+ if (!split_type->id) {
+ split_type->id = type->id;
+ split_type->symbol_status = type->symbol_status;
+ }
+
+ ResourceEntry* split_entry =
+ split_type->FindOrCreateEntry(entry->name);
+ if (!split_entry->id) {
+ split_entry->id = entry->id;
+ split_entry->symbol_status = entry->symbol_status;
+ }
+
+ // Copy the selected values into the new Split Entry.
+ for (ResourceConfigValue* config_value : selected_values) {
+ ResourceConfigValue* new_config_value =
+ split_entry->FindOrCreateValue(config_value->config,
+ config_value->product);
+ new_config_value->value = std::unique_ptr<Value>(
+ config_value->value->Clone(&split_table->string_pool));
+ }
+ }
+ }
+
+ if (options_.preferred_density) {
+ MarkNonPreferredDensitiesAsClaimed(options_.preferred_density.value(),
+ density_groups,
+ &config_claimed_map);
+ }
+
+ // All splits are handled, now check to see what wasn't claimed and
+ // remove
+ // whatever exists in other splits.
+ for (std::unique_ptr<ResourceConfigValue>& config_value :
+ entry->values) {
+ if (config_value && config_claimed_map[config_value.get()]) {
+ // Claimed, remove from base.
+ config_value.reset();
+ }
+ }
+
+ // Now erase all nullptrs.
+ entry->values.erase(
+ std::remove(entry->values.begin(), entry->values.end(), nullptr),
+ entry->values.end());
+ }
+ }
+ }
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/split/TableSplitter.h b/tools/aapt2/split/TableSplitter.h
index d7ecc82..1ae3271 100644
--- a/tools/aapt2/split/TableSplitter.h
+++ b/tools/aapt2/split/TableSplitter.h
@@ -17,15 +17,15 @@
#ifndef AAPT_SPLIT_TABLESPLITTER_H
#define AAPT_SPLIT_TABLESPLITTER_H
+#include <set>
+#include <vector>
+#include "android-base/macros.h"
+
#include "ConfigDescription.h"
#include "ResourceTable.h"
#include "filter/ConfigFilter.h"
#include "process/IResourceTableConsumer.h"
-#include <android-base/macros.h>
-#include <set>
-#include <vector>
-
namespace aapt {
struct SplitConstraints {
@@ -36,39 +36,36 @@
/**
* The preferred density to keep in the table, stripping out all others.
*/
- Maybe<uint16_t> preferredDensity;
+ Maybe<uint16_t> preferred_density;
/**
* Configuration filter that determines which resource configuration values
* end up in
* the final table.
*/
- IConfigFilter* configFilter = nullptr;
+ IConfigFilter* config_filter = nullptr;
};
class TableSplitter {
public:
TableSplitter(const std::vector<SplitConstraints>& splits,
const TableSplitterOptions& options)
- : mSplitConstraints(splits),
- mPreferredDensity(options.preferredDensity),
- mConfigFilter(options.configFilter) {
- for (size_t i = 0; i < mSplitConstraints.size(); i++) {
- mSplits.push_back(util::make_unique<ResourceTable>());
+ : split_constraints_(splits), options_(options) {
+ for (size_t i = 0; i < split_constraints_.size(); i++) {
+ splits_.push_back(util::make_unique<ResourceTable>());
}
}
- bool verifySplitConstraints(IAaptContext* context);
+ bool VerifySplitConstraints(IAaptContext* context);
- void splitTable(ResourceTable* originalTable);
+ void SplitTable(ResourceTable* original_table);
- std::vector<std::unique_ptr<ResourceTable>>& getSplits() { return mSplits; }
+ std::vector<std::unique_ptr<ResourceTable>>& splits() { return splits_; }
private:
- std::vector<SplitConstraints> mSplitConstraints;
- std::vector<std::unique_ptr<ResourceTable>> mSplits;
- Maybe<uint16_t> mPreferredDensity;
- IConfigFilter* mConfigFilter;
+ std::vector<SplitConstraints> split_constraints_;
+ std::vector<std::unique_ptr<ResourceTable>> splits_;
+ TableSplitterOptions options_;
DISALLOW_COPY_AND_ASSIGN(TableSplitter);
};
diff --git a/tools/aapt2/split/TableSplitter_test.cpp b/tools/aapt2/split/TableSplitter_test.cpp
index 5150e82..088dac3 100644
--- a/tools/aapt2/split/TableSplitter_test.cpp
+++ b/tools/aapt2/split/TableSplitter_test.cpp
@@ -15,155 +15,192 @@
*/
#include "split/TableSplitter.h"
+
#include "test/Test.h"
namespace aapt {
TEST(TableSplitterTest, NoSplitPreferredDensity) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addFileReference("android:drawable/icon", "res/drawable-mdpi/icon.png",
- test::parseConfigOrDie("mdpi"))
- .addFileReference("android:drawable/icon", "res/drawable-hdpi/icon.png",
- test::parseConfigOrDie("hdpi"))
- .addFileReference("android:drawable/icon", "res/drawable-xhdpi/icon.png",
- test::parseConfigOrDie("xhdpi"))
- .addFileReference("android:drawable/icon", "res/drawable-xxhdpi/icon.png",
- test::parseConfigOrDie("xxhdpi"))
- .addSimple("android:string/one")
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .AddFileReference("android:drawable/icon",
+ "res/drawable-mdpi/icon.png",
+ test::ParseConfigOrDie("mdpi"))
+ .AddFileReference("android:drawable/icon",
+ "res/drawable-hdpi/icon.png",
+ test::ParseConfigOrDie("hdpi"))
+ .AddFileReference("android:drawable/icon",
+ "res/drawable-xhdpi/icon.png",
+ test::ParseConfigOrDie("xhdpi"))
+ .AddFileReference("android:drawable/icon",
+ "res/drawable-xxhdpi/icon.png",
+ test::ParseConfigOrDie("xxhdpi"))
+ .AddSimple("android:string/one")
+ .Build();
- TableSplitterOptions options;
- options.preferredDensity = ConfigDescription::DENSITY_XHIGH;
- TableSplitter splitter({}, options);
- splitter.splitTable(table.get());
+ TableSplitterOptions options;
+ options.preferred_density = ConfigDescription::DENSITY_XHIGH;
+ TableSplitter splitter({}, options);
+ splitter.SplitTable(table.get());
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(),
- "android:drawable/icon",
- test::parseConfigOrDie("mdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(),
- "android:drawable/icon",
- test::parseConfigOrDie("hdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(table.get(),
- "android:drawable/icon",
- test::parseConfigOrDie("xhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(),
- "android:drawable/icon",
- test::parseConfigOrDie("xxhdpi")));
- EXPECT_NE(nullptr, test::getValue<Id>(table.get(), "android:string/one"));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/icon",
+ test::ParseConfigOrDie("mdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/icon",
+ test::ParseConfigOrDie("hdpi")));
+ EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/icon",
+ test::ParseConfigOrDie("xhdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/icon",
+ test::ParseConfigOrDie("xxhdpi")));
+ EXPECT_NE(nullptr, test::GetValue<Id>(table.get(), "android:string/one"));
}
TEST(TableSplitterTest, SplitTableByDensity) {
- std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addFileReference("android:drawable/foo", "res/drawable-mdpi/foo.png",
- test::parseConfigOrDie("mdpi"))
- .addFileReference("android:drawable/foo", "res/drawable-hdpi/foo.png",
- test::parseConfigOrDie("hdpi"))
- .addFileReference("android:drawable/foo", "res/drawable-xhdpi/foo.png",
- test::parseConfigOrDie("xhdpi"))
- .addFileReference("android:drawable/foo", "res/drawable-xxhdpi/foo.png",
- test::parseConfigOrDie("xxhdpi"))
- .build();
+ std::unique_ptr<ResourceTable> table =
+ test::ResourceTableBuilder()
+ .AddFileReference("android:drawable/foo", "res/drawable-mdpi/foo.png",
+ test::ParseConfigOrDie("mdpi"))
+ .AddFileReference("android:drawable/foo", "res/drawable-hdpi/foo.png",
+ test::ParseConfigOrDie("hdpi"))
+ .AddFileReference("android:drawable/foo",
+ "res/drawable-xhdpi/foo.png",
+ test::ParseConfigOrDie("xhdpi"))
+ .AddFileReference("android:drawable/foo",
+ "res/drawable-xxhdpi/foo.png",
+ test::ParseConfigOrDie("xxhdpi"))
+ .Build();
- std::vector<SplitConstraints> constraints;
- constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("mdpi") } });
- constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("hdpi") } });
- constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("xhdpi") } });
+ std::vector<SplitConstraints> constraints;
+ constraints.push_back(SplitConstraints{{test::ParseConfigOrDie("mdpi")}});
+ constraints.push_back(SplitConstraints{{test::ParseConfigOrDie("hdpi")}});
+ constraints.push_back(SplitConstraints{{test::ParseConfigOrDie("xhdpi")}});
- TableSplitter splitter(constraints, TableSplitterOptions{});
- splitter.splitTable(table.get());
+ TableSplitter splitter(constraints, TableSplitterOptions{});
+ splitter.SplitTable(table.get());
- ASSERT_EQ(3u, splitter.getSplits().size());
+ ASSERT_EQ(3u, splitter.splits().size());
- ResourceTable* splitOne = splitter.getSplits()[0].get();
- ResourceTable* splitTwo = splitter.getSplits()[1].get();
- ResourceTable* splitThree = splitter.getSplits()[2].get();
+ ResourceTable* split_one = splitter.splits()[0].get();
+ ResourceTable* split_two = splitter.splits()[1].get();
+ ResourceTable* split_three = splitter.splits()[2].get();
- // Just xxhdpi should be in the base.
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
- test::parseConfigOrDie("mdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
- test::parseConfigOrDie("hdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
- test::parseConfigOrDie("xhdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(table.get(), "android:drawable/foo",
- test::parseConfigOrDie("xxhdpi")));
+ // Just xxhdpi should be in the base.
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/foo",
+ test::ParseConfigOrDie("mdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/foo",
+ test::ParseConfigOrDie("hdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/foo",
+ test::ParseConfigOrDie("xhdpi")));
+ EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+ table.get(), "android:drawable/foo",
+ test::ParseConfigOrDie("xxhdpi")));
- // Each split should have one and only one drawable.
- EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
- test::parseConfigOrDie("mdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
- test::parseConfigOrDie("hdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
- test::parseConfigOrDie("xhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitOne, "android:drawable/foo",
- test::parseConfigOrDie("xxhdpi")));
+ // Each split should have one and only one drawable.
+ EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+ split_one, "android:drawable/foo",
+ test::ParseConfigOrDie("mdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_one, "android:drawable/foo",
+ test::ParseConfigOrDie("hdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_one, "android:drawable/foo",
+ test::ParseConfigOrDie("xhdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_one, "android:drawable/foo",
+ test::ParseConfigOrDie("xxhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
- test::parseConfigOrDie("mdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
- test::parseConfigOrDie("hdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
- test::parseConfigOrDie("xhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitTwo, "android:drawable/foo",
- test::parseConfigOrDie("xxhdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_two, "android:drawable/foo",
+ test::ParseConfigOrDie("mdpi")));
+ EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+ split_two, "android:drawable/foo",
+ test::ParseConfigOrDie("hdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_two, "android:drawable/foo",
+ test::ParseConfigOrDie("xhdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_two, "android:drawable/foo",
+ test::ParseConfigOrDie("xxhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
- test::parseConfigOrDie("mdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
- test::parseConfigOrDie("hdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
- test::parseConfigOrDie("xhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<FileReference>(splitThree, "android:drawable/foo",
- test::parseConfigOrDie("xxhdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_three, "android:drawable/foo",
+ test::ParseConfigOrDie("mdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_three, "android:drawable/foo",
+ test::ParseConfigOrDie("hdpi")));
+ EXPECT_NE(nullptr, test::GetValueForConfig<FileReference>(
+ split_three, "android:drawable/foo",
+ test::ParseConfigOrDie("xhdpi")));
+ EXPECT_EQ(nullptr, test::GetValueForConfig<FileReference>(
+ split_three, "android:drawable/foo",
+ test::ParseConfigOrDie("xxhdpi")));
}
TEST(TableSplitterTest, SplitTableByConfigAndDensity) {
- ResourceTable table;
+ ResourceTable table;
- const ResourceName foo = test::parseNameOrDie("android:string/foo");
- ASSERT_TRUE(table.addResource(foo, test::parseConfigOrDie("land-hdpi"), {},
- util::make_unique<Id>(),
- test::getDiagnostics()));
- ASSERT_TRUE(table.addResource(foo, test::parseConfigOrDie("land-xhdpi"), {},
- util::make_unique<Id>(),
- test::getDiagnostics()));
- ASSERT_TRUE(table.addResource(foo, test::parseConfigOrDie("land-xxhdpi"), {},
- util::make_unique<Id>(),
- test::getDiagnostics()));
+ const ResourceName foo = test::ParseNameOrDie("android:string/foo");
+ ASSERT_TRUE(table.AddResource(foo, test::ParseConfigOrDie("land-hdpi"), {},
+ util::make_unique<Id>(),
+ test::GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(foo, test::ParseConfigOrDie("land-xhdpi"), {},
+ util::make_unique<Id>(),
+ test::GetDiagnostics()));
+ ASSERT_TRUE(table.AddResource(foo, test::ParseConfigOrDie("land-xxhdpi"), {},
+ util::make_unique<Id>(),
+ test::GetDiagnostics()));
- std::vector<SplitConstraints> constraints;
- constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("land-mdpi") } });
- constraints.push_back(SplitConstraints{ { test::parseConfigOrDie("land-xhdpi") } });
+ std::vector<SplitConstraints> constraints;
+ constraints.push_back(
+ SplitConstraints{{test::ParseConfigOrDie("land-mdpi")}});
+ constraints.push_back(
+ SplitConstraints{{test::ParseConfigOrDie("land-xhdpi")}});
- TableSplitter splitter(constraints, TableSplitterOptions{});
- splitter.splitTable(&table);
+ TableSplitter splitter(constraints, TableSplitterOptions{});
+ splitter.SplitTable(&table);
- ASSERT_EQ(2u, splitter.getSplits().size());
+ ASSERT_EQ(2u, splitter.splits().size());
- ResourceTable* splitOne = splitter.getSplits()[0].get();
- ResourceTable* splitTwo = splitter.getSplits()[1].get();
+ ResourceTable* split_one = splitter.splits()[0].get();
+ ResourceTable* split_two = splitter.splits()[1].get();
- // All but the xxhdpi resource should be gone, since there were closer matches in land-xhdpi.
- EXPECT_EQ(nullptr, test::getValueForConfig<Id>(&table, "android:string/foo",
- test::parseConfigOrDie("land-hdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<Id>(&table, "android:string/foo",
- test::parseConfigOrDie("land-xhdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<Id>(&table, "android:string/foo",
- test::parseConfigOrDie("land-xxhdpi")));
+ // All but the xxhdpi resource should be gone, since there were closer matches
+ // in land-xhdpi.
+ EXPECT_EQ(nullptr,
+ test::GetValueForConfig<Id>(&table, "android:string/foo",
+ test::ParseConfigOrDie("land-hdpi")));
+ EXPECT_EQ(nullptr,
+ test::GetValueForConfig<Id>(&table, "android:string/foo",
+ test::ParseConfigOrDie("land-xhdpi")));
+ EXPECT_NE(nullptr,
+ test::GetValueForConfig<Id>(&table, "android:string/foo",
+ test::ParseConfigOrDie("land-xxhdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<Id>(splitOne, "android:string/foo",
- test::parseConfigOrDie("land-hdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitOne, "android:string/foo",
- test::parseConfigOrDie("land-xhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitOne, "android:string/foo",
- test::parseConfigOrDie("land-xxhdpi")));
+ EXPECT_NE(nullptr,
+ test::GetValueForConfig<Id>(split_one, "android:string/foo",
+ test::ParseConfigOrDie("land-hdpi")));
+ EXPECT_EQ(nullptr,
+ test::GetValueForConfig<Id>(split_one, "android:string/foo",
+ test::ParseConfigOrDie("land-xhdpi")));
+ EXPECT_EQ(nullptr,
+ test::GetValueForConfig<Id>(split_one, "android:string/foo",
+ test::ParseConfigOrDie("land-xxhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitTwo, "android:string/foo",
- test::parseConfigOrDie("land-hdpi")));
- EXPECT_NE(nullptr, test::getValueForConfig<Id>(splitTwo, "android:string/foo",
- test::parseConfigOrDie("land-xhdpi")));
- EXPECT_EQ(nullptr, test::getValueForConfig<Id>(splitTwo, "android:string/foo",
- test::parseConfigOrDie("land-xxhdpi")));
+ EXPECT_EQ(nullptr,
+ test::GetValueForConfig<Id>(split_two, "android:string/foo",
+ test::ParseConfigOrDie("land-hdpi")));
+ EXPECT_NE(nullptr,
+ test::GetValueForConfig<Id>(split_two, "android:string/foo",
+ test::ParseConfigOrDie("land-xhdpi")));
+ EXPECT_EQ(nullptr,
+ test::GetValueForConfig<Id>(split_two, "android:string/foo",
+ test::ParseConfigOrDie("land-xxhdpi")));
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/test/Builders.h b/tools/aapt2/test/Builders.h
index c647159..9377306 100644
--- a/tools/aapt2/test/Builders.h
+++ b/tools/aapt2/test/Builders.h
@@ -17,139 +17,142 @@
#ifndef AAPT_TEST_BUILDERS_H
#define AAPT_TEST_BUILDERS_H
+#include <memory>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
#include "ResourceTable.h"
#include "ResourceValues.h"
#include "test/Common.h"
#include "util/Util.h"
#include "xml/XmlDom.h"
-#include <memory>
-
namespace aapt {
namespace test {
class ResourceTableBuilder {
- private:
- DummyDiagnosticsImpl mDiagnostics;
- std::unique_ptr<ResourceTable> mTable = util::make_unique<ResourceTable>();
-
public:
ResourceTableBuilder() = default;
- StringPool* getStringPool() { return &mTable->stringPool; }
+ StringPool* string_pool() { return &table_->string_pool; }
- ResourceTableBuilder& setPackageId(const StringPiece& packageName,
+ ResourceTableBuilder& SetPackageId(const StringPiece& package_name,
uint8_t id) {
- ResourceTablePackage* package = mTable->createPackage(packageName, id);
- assert(package);
+ ResourceTablePackage* package = table_->CreatePackage(package_name, id);
+ CHECK(package != nullptr);
return *this;
}
- ResourceTableBuilder& addSimple(const StringPiece& name,
+ ResourceTableBuilder& AddSimple(const StringPiece& name,
const ResourceId& id = {}) {
- return addValue(name, id, util::make_unique<Id>());
+ return AddValue(name, id, util::make_unique<Id>());
}
- ResourceTableBuilder& addSimple(const StringPiece& name,
+ ResourceTableBuilder& AddSimple(const StringPiece& name,
const ConfigDescription& config,
const ResourceId& id = {}) {
- return addValue(name, config, id, util::make_unique<Id>());
+ return AddValue(name, config, id, util::make_unique<Id>());
}
- ResourceTableBuilder& addReference(const StringPiece& name,
+ ResourceTableBuilder& AddReference(const StringPiece& name,
const StringPiece& ref) {
- return addReference(name, {}, ref);
+ return AddReference(name, {}, ref);
}
- ResourceTableBuilder& addReference(const StringPiece& name,
+ ResourceTableBuilder& AddReference(const StringPiece& name,
const ResourceId& id,
const StringPiece& ref) {
- return addValue(name, id,
- util::make_unique<Reference>(parseNameOrDie(ref)));
+ return AddValue(name, id,
+ util::make_unique<Reference>(ParseNameOrDie(ref)));
}
- ResourceTableBuilder& addString(const StringPiece& name,
+ ResourceTableBuilder& AddString(const StringPiece& name,
const StringPiece& str) {
- return addString(name, {}, str);
+ return AddString(name, {}, str);
}
- ResourceTableBuilder& addString(const StringPiece& name, const ResourceId& id,
+ ResourceTableBuilder& AddString(const StringPiece& name, const ResourceId& id,
const StringPiece& str) {
- return addValue(name, id,
- util::make_unique<String>(mTable->stringPool.makeRef(str)));
+ return AddValue(
+ name, id, util::make_unique<String>(table_->string_pool.MakeRef(str)));
}
- ResourceTableBuilder& addString(const StringPiece& name, const ResourceId& id,
+ ResourceTableBuilder& AddString(const StringPiece& name, const ResourceId& id,
const ConfigDescription& config,
const StringPiece& str) {
- return addValue(name, config, id,
- util::make_unique<String>(mTable->stringPool.makeRef(str)));
+ return AddValue(name, config, id, util::make_unique<String>(
+ table_->string_pool.MakeRef(str)));
}
- ResourceTableBuilder& addFileReference(const StringPiece& name,
+ ResourceTableBuilder& AddFileReference(const StringPiece& name,
const StringPiece& path) {
- return addFileReference(name, {}, path);
+ return AddFileReference(name, {}, path);
}
- ResourceTableBuilder& addFileReference(const StringPiece& name,
+ ResourceTableBuilder& AddFileReference(const StringPiece& name,
const ResourceId& id,
const StringPiece& path) {
- return addValue(name, id, util::make_unique<FileReference>(
- mTable->stringPool.makeRef(path)));
+ return AddValue(name, id, util::make_unique<FileReference>(
+ table_->string_pool.MakeRef(path)));
}
- ResourceTableBuilder& addFileReference(const StringPiece& name,
+ ResourceTableBuilder& AddFileReference(const StringPiece& name,
const StringPiece& path,
const ConfigDescription& config) {
- return addValue(name, config, {}, util::make_unique<FileReference>(
- mTable->stringPool.makeRef(path)));
+ return AddValue(name, config, {}, util::make_unique<FileReference>(
+ table_->string_pool.MakeRef(path)));
}
- ResourceTableBuilder& addValue(const StringPiece& name,
+ ResourceTableBuilder& AddValue(const StringPiece& name,
std::unique_ptr<Value> value) {
- return addValue(name, {}, std::move(value));
+ return AddValue(name, {}, std::move(value));
}
- ResourceTableBuilder& addValue(const StringPiece& name, const ResourceId& id,
+ ResourceTableBuilder& AddValue(const StringPiece& name, const ResourceId& id,
std::unique_ptr<Value> value) {
- return addValue(name, {}, id, std::move(value));
+ return AddValue(name, {}, id, std::move(value));
}
- ResourceTableBuilder& addValue(const StringPiece& name,
+ ResourceTableBuilder& AddValue(const StringPiece& name,
const ConfigDescription& config,
const ResourceId& id,
std::unique_ptr<Value> value) {
- ResourceName resName = parseNameOrDie(name);
- bool result = mTable->addResourceAllowMangled(
- resName, id, config, {}, std::move(value), &mDiagnostics);
- assert(result);
+ ResourceName res_name = ParseNameOrDie(name);
+ CHECK(table_->AddResourceAllowMangled(res_name, id, config, {},
+ std::move(value), &diagnostics_));
return *this;
}
- ResourceTableBuilder& setSymbolState(const StringPiece& name,
+ ResourceTableBuilder& SetSymbolState(const StringPiece& name,
const ResourceId& id,
SymbolState state) {
- ResourceName resName = parseNameOrDie(name);
+ ResourceName res_name = ParseNameOrDie(name);
Symbol symbol;
symbol.state = state;
- bool result =
- mTable->setSymbolStateAllowMangled(resName, id, symbol, &mDiagnostics);
- assert(result);
+ CHECK(table_->SetSymbolStateAllowMangled(res_name, id, symbol,
+ &diagnostics_));
return *this;
}
- std::unique_ptr<ResourceTable> build() { return std::move(mTable); }
+ std::unique_ptr<ResourceTable> Build() { return std::move(table_); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ResourceTableBuilder);
+
+ DummyDiagnosticsImpl diagnostics_;
+ std::unique_ptr<ResourceTable> table_ = util::make_unique<ResourceTable>();
};
-inline std::unique_ptr<Reference> buildReference(
+inline std::unique_ptr<Reference> BuildReference(
const StringPiece& ref, const Maybe<ResourceId>& id = {}) {
std::unique_ptr<Reference> reference =
- util::make_unique<Reference>(parseNameOrDie(ref));
+ util::make_unique<Reference>(ParseNameOrDie(ref));
reference->id = id;
return reference;
}
-inline std::unique_ptr<BinaryPrimitive> buildPrimitive(uint8_t type,
+inline std::unique_ptr<BinaryPrimitive> BuildPrimitive(uint8_t type,
uint32_t data) {
android::Res_value value = {};
value.size = sizeof(value);
@@ -160,107 +163,119 @@
template <typename T>
class ValueBuilder {
- private:
- std::unique_ptr<Value> mValue;
-
public:
template <typename... Args>
explicit ValueBuilder(Args&&... args)
- : mValue(new T{std::forward<Args>(args)...}) {}
+ : value_(new T{std::forward<Args>(args)...}) {}
template <typename... Args>
- ValueBuilder& setSource(Args&&... args) {
- mValue->setSource(Source{std::forward<Args>(args)...});
+ ValueBuilder& SetSource(Args&&... args) {
+ value_->SetSource(Source{std::forward<Args>(args)...});
return *this;
}
- ValueBuilder& setComment(const StringPiece& str) {
- mValue->setComment(str);
+ ValueBuilder& SetComment(const StringPiece& str) {
+ value_->SetComment(str);
return *this;
}
- std::unique_ptr<Value> build() { return std::move(mValue); }
+ std::unique_ptr<Value> Build() { return std::move(value_); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ValueBuilder);
+
+ std::unique_ptr<Value> value_;
};
class AttributeBuilder {
- private:
- std::unique_ptr<Attribute> mAttr;
-
public:
explicit AttributeBuilder(bool weak = false)
- : mAttr(util::make_unique<Attribute>(weak)) {
- mAttr->typeMask = android::ResTable_map::TYPE_ANY;
+ : attr_(util::make_unique<Attribute>(weak)) {
+ attr_->type_mask = android::ResTable_map::TYPE_ANY;
}
- AttributeBuilder& setTypeMask(uint32_t typeMask) {
- mAttr->typeMask = typeMask;
+ AttributeBuilder& SetTypeMask(uint32_t typeMask) {
+ attr_->type_mask = typeMask;
return *this;
}
- AttributeBuilder& addItem(const StringPiece& name, uint32_t value) {
- mAttr->symbols.push_back(Attribute::Symbol{
+ AttributeBuilder& AddItem(const StringPiece& name, uint32_t value) {
+ attr_->symbols.push_back(Attribute::Symbol{
Reference(ResourceName({}, ResourceType::kId, name)), value});
return *this;
}
- std::unique_ptr<Attribute> build() { return std::move(mAttr); }
+ std::unique_ptr<Attribute> Build() { return std::move(attr_); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AttributeBuilder);
+
+ std::unique_ptr<Attribute> attr_;
};
class StyleBuilder {
- private:
- std::unique_ptr<Style> mStyle = util::make_unique<Style>();
-
public:
- StyleBuilder& setParent(const StringPiece& str) {
- mStyle->parent = Reference(parseNameOrDie(str));
+ StyleBuilder() = default;
+
+ StyleBuilder& SetParent(const StringPiece& str) {
+ style_->parent = Reference(ParseNameOrDie(str));
return *this;
}
- StyleBuilder& addItem(const StringPiece& str, std::unique_ptr<Item> value) {
- mStyle->entries.push_back(
- Style::Entry{Reference(parseNameOrDie(str)), std::move(value)});
+ StyleBuilder& AddItem(const StringPiece& str, std::unique_ptr<Item> value) {
+ style_->entries.push_back(
+ Style::Entry{Reference(ParseNameOrDie(str)), std::move(value)});
return *this;
}
- StyleBuilder& addItem(const StringPiece& str, const ResourceId& id,
+ StyleBuilder& AddItem(const StringPiece& str, const ResourceId& id,
std::unique_ptr<Item> value) {
- addItem(str, std::move(value));
- mStyle->entries.back().key.id = id;
+ AddItem(str, std::move(value));
+ style_->entries.back().key.id = id;
return *this;
}
- std::unique_ptr<Style> build() { return std::move(mStyle); }
+ std::unique_ptr<Style> Build() { return std::move(style_); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(StyleBuilder);
+
+ std::unique_ptr<Style> style_ = util::make_unique<Style>();
};
class StyleableBuilder {
- private:
- std::unique_ptr<Styleable> mStyleable = util::make_unique<Styleable>();
-
public:
- StyleableBuilder& addItem(const StringPiece& str,
+ StyleableBuilder() = default;
+
+ StyleableBuilder& AddItem(const StringPiece& str,
const Maybe<ResourceId>& id = {}) {
- mStyleable->entries.push_back(Reference(parseNameOrDie(str)));
- mStyleable->entries.back().id = id;
+ styleable_->entries.push_back(Reference(ParseNameOrDie(str)));
+ styleable_->entries.back().id = id;
return *this;
}
- std::unique_ptr<Styleable> build() { return std::move(mStyleable); }
+ std::unique_ptr<Styleable> Build() { return std::move(styleable_); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(StyleableBuilder);
+
+ std::unique_ptr<Styleable> styleable_ = util::make_unique<Styleable>();
};
-inline std::unique_ptr<xml::XmlResource> buildXmlDom(const StringPiece& str) {
+inline std::unique_ptr<xml::XmlResource> BuildXmlDom(const StringPiece& str) {
std::stringstream in;
in << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" << str;
StdErrDiagnostics diag;
std::unique_ptr<xml::XmlResource> doc =
- xml::inflate(&in, &diag, Source("test.xml"));
- assert(doc);
+ xml::Inflate(&in, &diag, Source("test.xml"));
+ CHECK(doc != nullptr) << "failed to parse inline XML string";
return doc;
}
-inline std::unique_ptr<xml::XmlResource> buildXmlDomForPackageName(
+inline std::unique_ptr<xml::XmlResource> BuildXmlDomForPackageName(
IAaptContext* context, const StringPiece& str) {
- std::unique_ptr<xml::XmlResource> doc = buildXmlDom(str);
- doc->file.name.package = context->getCompilationPackage();
+ std::unique_ptr<xml::XmlResource> doc = BuildXmlDom(str);
+ doc->file.name.package = context->GetCompilationPackage();
return doc;
}
diff --git a/tools/aapt2/test/Common.h b/tools/aapt2/test/Common.h
index 2d571e7..3689201 100644
--- a/tools/aapt2/test/Common.h
+++ b/tools/aapt2/test/Common.h
@@ -17,6 +17,12 @@
#ifndef AAPT_TEST_COMMON_H
#define AAPT_TEST_COMMON_H
+#include <iostream>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+#include "gtest/gtest.h"
+
#include "ConfigDescription.h"
#include "Debug.h"
#include "ResourceTable.h"
@@ -26,9 +32,6 @@
#include "process/IResourceTableConsumer.h"
#include "util/StringPiece.h"
-#include <gtest/gtest.h>
-#include <iostream>
-
//
// GTEST 1.7 doesn't explicitly cast to bool, which causes explicit operators to
// fail to compile.
@@ -42,80 +45,81 @@
namespace test {
struct DummyDiagnosticsImpl : public IDiagnostics {
- void log(Level level, DiagMessageActual& actualMsg) override {
+ void Log(Level level, DiagMessageActual& actual_msg) override {
switch (level) {
case Level::Note:
return;
case Level::Warn:
- std::cerr << actualMsg.source << ": warn: " << actualMsg.message << "."
- << std::endl;
+ std::cerr << actual_msg.source << ": warn: " << actual_msg.message
+ << "." << std::endl;
break;
case Level::Error:
- std::cerr << actualMsg.source << ": error: " << actualMsg.message << "."
- << std::endl;
+ std::cerr << actual_msg.source << ": error: " << actual_msg.message
+ << "." << std::endl;
break;
}
}
};
-inline IDiagnostics* getDiagnostics() {
+inline IDiagnostics* GetDiagnostics() {
static DummyDiagnosticsImpl diag;
return &diag;
}
-inline ResourceName parseNameOrDie(const StringPiece& str) {
+inline ResourceName ParseNameOrDie(const StringPiece& str) {
ResourceNameRef ref;
- bool result = ResourceUtils::parseResourceName(str, &ref);
- assert(result && "invalid resource name");
- return ref.toResourceName();
+ CHECK(ResourceUtils::ParseResourceName(str, &ref)) << "invalid resource name";
+ return ref.ToResourceName();
}
-inline ConfigDescription parseConfigOrDie(const StringPiece& str) {
+inline ConfigDescription ParseConfigOrDie(const StringPiece& str) {
ConfigDescription config;
- bool result = ConfigDescription::parse(str, &config);
- assert(result && "invalid configuration");
+ CHECK(ConfigDescription::Parse(str, &config)) << "invalid configuration";
return config;
}
template <typename T>
-T* getValueForConfigAndProduct(ResourceTable* table, const StringPiece& resName,
+T* GetValueForConfigAndProduct(ResourceTable* table,
+ const StringPiece& res_name,
const ConfigDescription& config,
const StringPiece& product) {
Maybe<ResourceTable::SearchResult> result =
- table->findResource(parseNameOrDie(resName));
+ table->FindResource(ParseNameOrDie(res_name));
if (result) {
- ResourceConfigValue* configValue =
- result.value().entry->findValue(config, product);
- if (configValue) {
- return valueCast<T>(configValue->value.get());
+ ResourceConfigValue* config_value =
+ result.value().entry->FindValue(config, product);
+ if (config_value) {
+ return ValueCast<T>(config_value->value.get());
}
}
return nullptr;
}
template <typename T>
-T* getValueForConfig(ResourceTable* table, const StringPiece& resName,
+T* GetValueForConfig(ResourceTable* table, const StringPiece& res_name,
const ConfigDescription& config) {
- return getValueForConfigAndProduct<T>(table, resName, config, {});
+ return GetValueForConfigAndProduct<T>(table, res_name, config, {});
}
template <typename T>
-T* getValue(ResourceTable* table, const StringPiece& resName) {
- return getValueForConfig<T>(table, resName, {});
+T* GetValue(ResourceTable* table, const StringPiece& res_name) {
+ return GetValueForConfig<T>(table, res_name, {});
}
class TestFile : public io::IFile {
- private:
- Source mSource;
-
public:
- explicit TestFile(const StringPiece& path) : mSource(path) {}
+ explicit TestFile(const StringPiece& path) : source_(path) {}
- std::unique_ptr<io::IData> openAsData() override { return {}; }
+ std::unique_ptr<io::IData> OpenAsData() override { return {}; }
- const Source& getSource() const override { return mSource; }
+ const Source& GetSource() const override { return source_; }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(TestFile);
+
+ Source source_;
};
} // namespace test
diff --git a/tools/aapt2/test/Context.h b/tools/aapt2/test/Context.h
index 6c7f6f7..7986329 100644
--- a/tools/aapt2/test/Context.h
+++ b/tools/aapt2/test/Context.h
@@ -17,152 +17,158 @@
#ifndef AAPT_TEST_CONTEXT_H
#define AAPT_TEST_CONTEXT_H
+#include <list>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
#include "NameMangler.h"
#include "process/IResourceTableConsumer.h"
#include "process/SymbolTable.h"
#include "test/Common.h"
#include "util/Util.h"
-#include <cassert>
-#include <list>
-
namespace aapt {
namespace test {
class Context : public IAaptContext {
public:
- SymbolTable* getExternalSymbols() override { return &mSymbols; }
+ Context() = default;
- IDiagnostics* getDiagnostics() override { return &mDiagnostics; }
+ SymbolTable* GetExternalSymbols() override { return &symbols_; }
- const std::string& getCompilationPackage() override {
- assert(mCompilationPackage && "package name not set");
- return mCompilationPackage.value();
+ IDiagnostics* GetDiagnostics() override { return &diagnostics_; }
+
+ const std::string& GetCompilationPackage() override {
+ CHECK(bool(compilation_package_)) << "package name not set";
+ return compilation_package_.value();
}
- uint8_t getPackageId() override {
- assert(mPackageId && "package ID not set");
- return mPackageId.value();
+ uint8_t GetPackageId() override {
+ CHECK(bool(package_id_)) << "package ID not set";
+ return package_id_.value();
}
- NameMangler* getNameMangler() override { return &mNameMangler; }
+ NameMangler* GetNameMangler() override { return &name_mangler_; }
- bool verbose() override { return false; }
+ bool IsVerbose() override { return false; }
- int getMinSdkVersion() override { return mMinSdkVersion; }
+ int GetMinSdkVersion() override { return min_sdk_version_; }
private:
+ DISALLOW_COPY_AND_ASSIGN(Context);
+
friend class ContextBuilder;
- Maybe<std::string> mCompilationPackage;
- Maybe<uint8_t> mPackageId;
- StdErrDiagnostics mDiagnostics;
- SymbolTable mSymbols;
- NameMangler mNameMangler = NameMangler({});
- int mMinSdkVersion = 0;
+ Maybe<std::string> compilation_package_;
+ Maybe<uint8_t> package_id_;
+ StdErrDiagnostics diagnostics_;
+ SymbolTable symbols_;
+ NameMangler name_mangler_ = NameMangler({});
+ int min_sdk_version_ = 0;
};
class ContextBuilder {
- private:
- std::unique_ptr<Context> mContext = std::unique_ptr<Context>(new Context());
-
public:
- ContextBuilder& setCompilationPackage(const StringPiece& package) {
- mContext->mCompilationPackage = package.toString();
+ ContextBuilder& SetCompilationPackage(const StringPiece& package) {
+ context_->compilation_package_ = package.ToString();
return *this;
}
- ContextBuilder& setPackageId(uint8_t id) {
- mContext->mPackageId = id;
+ ContextBuilder& SetPackageId(uint8_t id) {
+ context_->package_id_ = id;
return *this;
}
- ContextBuilder& setNameManglerPolicy(const NameManglerPolicy& policy) {
- mContext->mNameMangler = NameMangler(policy);
+ ContextBuilder& SetNameManglerPolicy(const NameManglerPolicy& policy) {
+ context_->name_mangler_ = NameMangler(policy);
return *this;
}
- ContextBuilder& addSymbolSource(std::unique_ptr<ISymbolSource> src) {
- mContext->getExternalSymbols()->appendSource(std::move(src));
+ ContextBuilder& AddSymbolSource(std::unique_ptr<ISymbolSource> src) {
+ context_->GetExternalSymbols()->AppendSource(std::move(src));
return *this;
}
- ContextBuilder& setMinSdkVersion(int minSdk) {
- mContext->mMinSdkVersion = minSdk;
+ ContextBuilder& SetMinSdkVersion(int min_sdk) {
+ context_->min_sdk_version_ = min_sdk;
return *this;
}
- std::unique_ptr<Context> build() { return std::move(mContext); }
+ std::unique_ptr<Context> Build() { return std::move(context_); }
+
+ private:
+ std::unique_ptr<Context> context_ = std::unique_ptr<Context>(new Context());
};
class StaticSymbolSourceBuilder {
public:
- StaticSymbolSourceBuilder& addPublicSymbol(
+ StaticSymbolSourceBuilder& AddPublicSymbol(
const StringPiece& name, ResourceId id,
std::unique_ptr<Attribute> attr = {}) {
std::unique_ptr<SymbolTable::Symbol> symbol =
util::make_unique<SymbolTable::Symbol>(id, std::move(attr), true);
- mSymbolSource->mNameMap[parseNameOrDie(name)] = symbol.get();
- mSymbolSource->mIdMap[id] = symbol.get();
- mSymbolSource->mSymbols.push_back(std::move(symbol));
+ symbol_source_->name_map_[ParseNameOrDie(name)] = symbol.get();
+ symbol_source_->id_map_[id] = symbol.get();
+ symbol_source_->symbols_.push_back(std::move(symbol));
return *this;
}
- StaticSymbolSourceBuilder& addSymbol(const StringPiece& name, ResourceId id,
+ StaticSymbolSourceBuilder& AddSymbol(const StringPiece& name, ResourceId id,
std::unique_ptr<Attribute> attr = {}) {
std::unique_ptr<SymbolTable::Symbol> symbol =
util::make_unique<SymbolTable::Symbol>(id, std::move(attr), false);
- mSymbolSource->mNameMap[parseNameOrDie(name)] = symbol.get();
- mSymbolSource->mIdMap[id] = symbol.get();
- mSymbolSource->mSymbols.push_back(std::move(symbol));
+ symbol_source_->name_map_[ParseNameOrDie(name)] = symbol.get();
+ symbol_source_->id_map_[id] = symbol.get();
+ symbol_source_->symbols_.push_back(std::move(symbol));
return *this;
}
- std::unique_ptr<ISymbolSource> build() { return std::move(mSymbolSource); }
+ std::unique_ptr<ISymbolSource> Build() { return std::move(symbol_source_); }
private:
class StaticSymbolSource : public ISymbolSource {
public:
StaticSymbolSource() = default;
- std::unique_ptr<SymbolTable::Symbol> findByName(
+ std::unique_ptr<SymbolTable::Symbol> FindByName(
const ResourceName& name) override {
- auto iter = mNameMap.find(name);
- if (iter != mNameMap.end()) {
- return cloneSymbol(iter->second);
+ auto iter = name_map_.find(name);
+ if (iter != name_map_.end()) {
+ return CloneSymbol(iter->second);
}
return nullptr;
}
- std::unique_ptr<SymbolTable::Symbol> findById(ResourceId id) override {
- auto iter = mIdMap.find(id);
- if (iter != mIdMap.end()) {
- return cloneSymbol(iter->second);
+ std::unique_ptr<SymbolTable::Symbol> FindById(ResourceId id) override {
+ auto iter = id_map_.find(id);
+ if (iter != id_map_.end()) {
+ return CloneSymbol(iter->second);
}
return nullptr;
}
- std::list<std::unique_ptr<SymbolTable::Symbol>> mSymbols;
- std::map<ResourceName, SymbolTable::Symbol*> mNameMap;
- std::map<ResourceId, SymbolTable::Symbol*> mIdMap;
+ std::list<std::unique_ptr<SymbolTable::Symbol>> symbols_;
+ std::map<ResourceName, SymbolTable::Symbol*> name_map_;
+ std::map<ResourceId, SymbolTable::Symbol*> id_map_;
private:
- std::unique_ptr<SymbolTable::Symbol> cloneSymbol(SymbolTable::Symbol* sym) {
+ std::unique_ptr<SymbolTable::Symbol> CloneSymbol(SymbolTable::Symbol* sym) {
std::unique_ptr<SymbolTable::Symbol> clone =
util::make_unique<SymbolTable::Symbol>();
clone->id = sym->id;
if (sym->attribute) {
clone->attribute =
- std::unique_ptr<Attribute>(sym->attribute->clone(nullptr));
+ std::unique_ptr<Attribute>(sym->attribute->Clone(nullptr));
}
- clone->isPublic = sym->isPublic;
+ clone->is_public = sym->is_public;
return clone;
}
DISALLOW_COPY_AND_ASSIGN(StaticSymbolSource);
};
- std::unique_ptr<StaticSymbolSource> mSymbolSource =
+ std::unique_ptr<StaticSymbolSource> symbol_source_ =
util::make_unique<StaticSymbolSource>();
};
diff --git a/tools/aapt2/test/Test.h b/tools/aapt2/test/Test.h
index c9188bf..ec07432 100644
--- a/tools/aapt2/test/Test.h
+++ b/tools/aapt2/test/Test.h
@@ -17,14 +17,10 @@
#ifndef AAPT_TEST_TEST_H
#define AAPT_TEST_TEST_H
+#include "gtest/gtest.h"
+
#include "test/Builders.h"
#include "test/Common.h"
#include "test/Context.h"
-#include <gtest/gtest.h>
-
-namespace aapt {
-namespace test {} // namespace test
-} // namespace aapt
-
#endif // AAPT_TEST_TEST_H
diff --git a/tools/aapt2/unflatten/BinaryResourceParser.cpp b/tools/aapt2/unflatten/BinaryResourceParser.cpp
index 546b607..aeabcff 100644
--- a/tools/aapt2/unflatten/BinaryResourceParser.cpp
+++ b/tools/aapt2/unflatten/BinaryResourceParser.cpp
@@ -15,6 +15,16 @@
*/
#include "unflatten/BinaryResourceParser.h"
+
+#include <algorithm>
+#include <map>
+#include <string>
+
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+#include "androidfw/TypeWrappers.h"
+
#include "ResourceTable.h"
#include "ResourceUtils.h"
#include "ResourceValues.h"
@@ -23,13 +33,6 @@
#include "unflatten/ResChunkPullParser.h"
#include "util/Util.h"
-#include <android-base/macros.h>
-#include <androidfw/ResourceTypes.h>
-#include <androidfw/TypeWrappers.h>
-#include <algorithm>
-#include <map>
-#include <string>
-
namespace aapt {
using namespace android;
@@ -41,29 +44,31 @@
* given a mapping from resource ID to resource name.
*/
class ReferenceIdToNameVisitor : public ValueVisitor {
- private:
- const std::map<ResourceId, ResourceName>* mMapping;
-
public:
- using ValueVisitor::visit;
+ using ValueVisitor::Visit;
explicit ReferenceIdToNameVisitor(
const std::map<ResourceId, ResourceName>* mapping)
- : mMapping(mapping) {
- assert(mMapping);
+ : mapping_(mapping) {
+ CHECK(mapping_ != nullptr);
}
- void visit(Reference* reference) override {
- if (!reference->id || !reference->id.value().isValid()) {
+ void Visit(Reference* reference) override {
+ if (!reference->id || !reference->id.value().is_valid()) {
return;
}
ResourceId id = reference->id.value();
- auto cacheIter = mMapping->find(id);
- if (cacheIter != mMapping->end()) {
- reference->name = cacheIter->second;
+ auto cache_iter = mapping_->find(id);
+ if (cache_iter != mapping_->end()) {
+ reference->name = cache_iter->second;
}
}
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ReferenceIdToNameVisitor);
+
+ const std::map<ResourceId, ResourceName>* mapping_;
};
} // namespace
@@ -72,33 +77,32 @@
ResourceTable* table,
const Source& source,
const void* data, size_t len)
- : mContext(context),
- mTable(table),
- mSource(source),
- mData(data),
- mDataLen(len) {}
+ : context_(context),
+ table_(table),
+ source_(source),
+ data_(data),
+ data_len_(len) {}
-bool BinaryResourceParser::parse() {
- ResChunkPullParser parser(mData, mDataLen);
+bool BinaryResourceParser::Parse() {
+ ResChunkPullParser parser(data_, data_len_);
bool error = false;
- while (ResChunkPullParser::isGoodEvent(parser.next())) {
- if (parser.getChunk()->type != android::RES_TABLE_TYPE) {
- mContext->getDiagnostics()->warn(DiagMessage(mSource)
+ while (ResChunkPullParser::IsGoodEvent(parser.Next())) {
+ if (parser.chunk()->type != android::RES_TABLE_TYPE) {
+ context_->GetDiagnostics()->Warn(DiagMessage(source_)
<< "unknown chunk of type '"
- << (int)parser.getChunk()->type << "'");
+ << (int)parser.chunk()->type << "'");
continue;
}
- if (!parseTable(parser.getChunk())) {
+ if (!ParseTable(parser.chunk())) {
error = true;
}
}
- if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
- << "corrupt resource table: "
- << parser.getLastError());
+ if (parser.event() == ResChunkPullParser::Event::kBadDocument) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "corrupt resource table: " << parser.error());
return false;
}
return !error;
@@ -108,212 +112,210 @@
* Parses the resource table, which contains all the packages, types, and
* entries.
*/
-bool BinaryResourceParser::parseTable(const ResChunk_header* chunk) {
- const ResTable_header* tableHeader = convertTo<ResTable_header>(chunk);
- if (!tableHeader) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+bool BinaryResourceParser::ParseTable(const ResChunk_header* chunk) {
+ const ResTable_header* table_header = ConvertTo<ResTable_header>(chunk);
+ if (!table_header) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "corrupt ResTable_header chunk");
return false;
}
- ResChunkPullParser parser(getChunkData(&tableHeader->header),
- getChunkDataLen(&tableHeader->header));
- while (ResChunkPullParser::isGoodEvent(parser.next())) {
- switch (util::deviceToHost16(parser.getChunk()->type)) {
+ ResChunkPullParser parser(GetChunkData(&table_header->header),
+ GetChunkDataLen(&table_header->header));
+ while (ResChunkPullParser::IsGoodEvent(parser.Next())) {
+ switch (util::DeviceToHost16(parser.chunk()->type)) {
case android::RES_STRING_POOL_TYPE:
- if (mValuePool.getError() == NO_INIT) {
- status_t err = mValuePool.setTo(
- parser.getChunk(), util::deviceToHost32(parser.getChunk()->size));
+ if (value_pool_.getError() == NO_INIT) {
+ status_t err = value_pool_.setTo(
+ parser.chunk(), util::DeviceToHost32(parser.chunk()->size));
if (err != NO_ERROR) {
- mContext->getDiagnostics()->error(
- DiagMessage(mSource) << "corrupt string pool in ResTable: "
- << mValuePool.getError());
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "corrupt string pool in ResTable: "
+ << value_pool_.getError());
return false;
}
// Reserve some space for the strings we are going to add.
- mTable->stringPool.hintWillAdd(mValuePool.size(),
- mValuePool.styleCount());
+ table_->string_pool.HintWillAdd(value_pool_.size(),
+ value_pool_.styleCount());
} else {
- mContext->getDiagnostics()->warn(
- DiagMessage(mSource) << "unexpected string pool in ResTable");
+ context_->GetDiagnostics()->Warn(
+ DiagMessage(source_) << "unexpected string pool in ResTable");
}
break;
case android::RES_TABLE_PACKAGE_TYPE:
- if (!parsePackage(parser.getChunk())) {
+ if (!ParsePackage(parser.chunk())) {
return false;
}
break;
default:
- mContext->getDiagnostics()->warn(
- DiagMessage(mSource)
+ context_->GetDiagnostics()->Warn(
+ DiagMessage(source_)
<< "unexpected chunk type "
- << (int)util::deviceToHost16(parser.getChunk()->type));
+ << (int)util::DeviceToHost16(parser.chunk()->type));
break;
}
}
- if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
- << "corrupt resource table: "
- << parser.getLastError());
+ if (parser.event() == ResChunkPullParser::Event::kBadDocument) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "corrupt resource table: " << parser.error());
return false;
}
return true;
}
-bool BinaryResourceParser::parsePackage(const ResChunk_header* chunk) {
- const ResTable_package* packageHeader = convertTo<ResTable_package>(chunk);
- if (!packageHeader) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+bool BinaryResourceParser::ParsePackage(const ResChunk_header* chunk) {
+ const ResTable_package* package_header = ConvertTo<ResTable_package>(chunk);
+ if (!package_header) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "corrupt ResTable_package chunk");
return false;
}
- uint32_t packageId = util::deviceToHost32(packageHeader->id);
- if (packageId > std::numeric_limits<uint8_t>::max()) {
- mContext->getDiagnostics()->error(
- DiagMessage(mSource) << "package ID is too big (" << packageId << ")");
+ uint32_t package_id = util::DeviceToHost32(package_header->id);
+ if (package_id > std::numeric_limits<uint8_t>::max()) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "package ID is too big (" << package_id << ")");
return false;
}
// Extract the package name.
- size_t len = strnlen16((const char16_t*)packageHeader->name,
- arraysize(packageHeader->name));
- std::u16string packageName;
- packageName.resize(len);
+ size_t len = strnlen16((const char16_t*)package_header->name,
+ arraysize(package_header->name));
+ std::u16string package_name;
+ package_name.resize(len);
for (size_t i = 0; i < len; i++) {
- packageName[i] = util::deviceToHost16(packageHeader->name[i]);
+ package_name[i] = util::DeviceToHost16(package_header->name[i]);
}
- ResourceTablePackage* package = mTable->createPackage(
- util::utf16ToUtf8(packageName), static_cast<uint8_t>(packageId));
+ ResourceTablePackage* package = table_->CreatePackage(
+ util::Utf16ToUtf8(package_name), static_cast<uint8_t>(package_id));
if (!package) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
- << "incompatible package '" << packageName
- << "' with ID " << packageId);
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "incompatible package '" << package_name
+ << "' with ID " << package_id);
return false;
}
// There can be multiple packages in a table, so
// clear the type and key pool in case they were set from a previous package.
- mTypePool.uninit();
- mKeyPool.uninit();
+ type_pool_.uninit();
+ key_pool_.uninit();
- ResChunkPullParser parser(getChunkData(&packageHeader->header),
- getChunkDataLen(&packageHeader->header));
- while (ResChunkPullParser::isGoodEvent(parser.next())) {
- switch (util::deviceToHost16(parser.getChunk()->type)) {
+ ResChunkPullParser parser(GetChunkData(&package_header->header),
+ GetChunkDataLen(&package_header->header));
+ while (ResChunkPullParser::IsGoodEvent(parser.Next())) {
+ switch (util::DeviceToHost16(parser.chunk()->type)) {
case android::RES_STRING_POOL_TYPE:
- if (mTypePool.getError() == NO_INIT) {
- status_t err = mTypePool.setTo(
- parser.getChunk(), util::deviceToHost32(parser.getChunk()->size));
+ if (type_pool_.getError() == NO_INIT) {
+ status_t err = type_pool_.setTo(
+ parser.chunk(), util::DeviceToHost32(parser.chunk()->size));
if (err != NO_ERROR) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "corrupt type string pool in "
<< "ResTable_package: "
- << mTypePool.getError());
+ << type_pool_.getError());
return false;
}
- } else if (mKeyPool.getError() == NO_INIT) {
- status_t err = mKeyPool.setTo(
- parser.getChunk(), util::deviceToHost32(parser.getChunk()->size));
+ } else if (key_pool_.getError() == NO_INIT) {
+ status_t err = key_pool_.setTo(
+ parser.chunk(), util::DeviceToHost32(parser.chunk()->size));
if (err != NO_ERROR) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "corrupt key string pool in "
<< "ResTable_package: "
- << mKeyPool.getError());
+ << key_pool_.getError());
return false;
}
} else {
- mContext->getDiagnostics()->warn(DiagMessage(mSource)
+ context_->GetDiagnostics()->Warn(DiagMessage(source_)
<< "unexpected string pool");
}
break;
case android::RES_TABLE_TYPE_SPEC_TYPE:
- if (!parseTypeSpec(parser.getChunk())) {
+ if (!ParseTypeSpec(parser.chunk())) {
return false;
}
break;
case android::RES_TABLE_TYPE_TYPE:
- if (!parseType(package, parser.getChunk())) {
+ if (!ParseType(package, parser.chunk())) {
return false;
}
break;
default:
- mContext->getDiagnostics()->warn(
- DiagMessage(mSource)
+ context_->GetDiagnostics()->Warn(
+ DiagMessage(source_)
<< "unexpected chunk type "
- << (int)util::deviceToHost16(parser.getChunk()->type));
+ << (int)util::DeviceToHost16(parser.chunk()->type));
break;
}
}
- if (parser.getEvent() == ResChunkPullParser::Event::BadDocument) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
- << "corrupt ResTable_package: "
- << parser.getLastError());
+ if (parser.event() == ResChunkPullParser::Event::kBadDocument) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "corrupt ResTable_package: " << parser.error());
return false;
}
// Now go through the table and change local resource ID references to
// symbolic references.
- ReferenceIdToNameVisitor visitor(&mIdIndex);
- visitAllValuesInTable(mTable, &visitor);
+ ReferenceIdToNameVisitor visitor(&id_index_);
+ VisitAllValuesInTable(table_, &visitor);
return true;
}
-bool BinaryResourceParser::parseTypeSpec(const ResChunk_header* chunk) {
- if (mTypePool.getError() != NO_ERROR) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+bool BinaryResourceParser::ParseTypeSpec(const ResChunk_header* chunk) {
+ if (type_pool_.getError() != NO_ERROR) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "missing type string pool");
return false;
}
- const ResTable_typeSpec* typeSpec = convertTo<ResTable_typeSpec>(chunk);
- if (!typeSpec) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ const ResTable_typeSpec* type_spec = ConvertTo<ResTable_typeSpec>(chunk);
+ if (!type_spec) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "corrupt ResTable_typeSpec chunk");
return false;
}
- if (typeSpec->id == 0) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ if (type_spec->id == 0) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "ResTable_typeSpec has invalid id: "
- << typeSpec->id);
+ << type_spec->id);
return false;
}
return true;
}
-bool BinaryResourceParser::parseType(const ResourceTablePackage* package,
+bool BinaryResourceParser::ParseType(const ResourceTablePackage* package,
const ResChunk_header* chunk) {
- if (mTypePool.getError() != NO_ERROR) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ if (type_pool_.getError() != NO_ERROR) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "missing type string pool");
return false;
}
- if (mKeyPool.getError() != NO_ERROR) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ if (key_pool_.getError() != NO_ERROR) {
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "missing key string pool");
return false;
}
- const ResTable_type* type = convertTo<ResTable_type>(chunk);
+ const ResTable_type* type = ConvertTo<ResTable_type>(chunk);
if (!type) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "corrupt ResTable_type chunk");
return false;
}
if (type->id == 0) {
- mContext->getDiagnostics()->error(DiagMessage(mSource)
+ context_->GetDiagnostics()->Error(DiagMessage(source_)
<< "ResTable_type has invalid id: "
<< (int)type->id);
return false;
@@ -322,12 +324,12 @@
ConfigDescription config;
config.copyFromDtoH(type->config);
- const std::string typeStr = util::getString(mTypePool, type->id - 1);
+ const std::string type_str = util::GetString(type_pool_, type->id - 1);
- const ResourceType* parsedType = parseResourceType(typeStr);
- if (!parsedType) {
- mContext->getDiagnostics()->error(
- DiagMessage(mSource) << "invalid type name '" << typeStr
+ const ResourceType* parsed_type = ParseResourceType(type_str);
+ if (!parsed_type) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "invalid type name '" << type_str
<< "' for type with ID " << (int)type->id);
return false;
}
@@ -340,91 +342,90 @@
}
const ResourceName name(
- package->name, *parsedType,
- util::getString(mKeyPool, util::deviceToHost32(entry->key.index)));
+ package->name, *parsed_type,
+ util::GetString(key_pool_, util::DeviceToHost32(entry->key.index)));
- const ResourceId resId(package->id.value(), type->id,
- static_cast<uint16_t>(it.index()));
+ const ResourceId res_id(package->id.value(), type->id,
+ static_cast<uint16_t>(it.index()));
- std::unique_ptr<Value> resourceValue;
+ std::unique_ptr<Value> resource_value;
if (entry->flags & ResTable_entry::FLAG_COMPLEX) {
const ResTable_map_entry* mapEntry =
static_cast<const ResTable_map_entry*>(entry);
// TODO(adamlesinski): Check that the entry count is valid.
- resourceValue = parseMapEntry(name, config, mapEntry);
+ resource_value = ParseMapEntry(name, config, mapEntry);
} else {
const Res_value* value =
(const Res_value*)((const uint8_t*)entry +
- util::deviceToHost32(entry->size));
- resourceValue = parseValue(name, config, value, entry->flags);
+ util::DeviceToHost32(entry->size));
+ resource_value = ParseValue(name, config, value, entry->flags);
}
- if (!resourceValue) {
- mContext->getDiagnostics()->error(
- DiagMessage(mSource) << "failed to parse value for resource " << name
- << " (" << resId << ") with configuration '"
+ if (!resource_value) {
+ context_->GetDiagnostics()->Error(
+ DiagMessage(source_) << "failed to parse value for resource " << name
+ << " (" << res_id << ") with configuration '"
<< config << "'");
return false;
}
- if (!mTable->addResourceAllowMangled(name, config, {},
- std::move(resourceValue),
- mContext->getDiagnostics())) {
+ if (!table_->AddResourceAllowMangled(name, config, {},
+ std::move(resource_value),
+ context_->GetDiagnostics())) {
return false;
}
if ((entry->flags & ResTable_entry::FLAG_PUBLIC) != 0) {
Symbol symbol;
symbol.state = SymbolState::kPublic;
- symbol.source = mSource.withLine(0);
- if (!mTable->setSymbolStateAllowMangled(name, resId, symbol,
- mContext->getDiagnostics())) {
+ symbol.source = source_.WithLine(0);
+ if (!table_->SetSymbolStateAllowMangled(name, res_id, symbol,
+ context_->GetDiagnostics())) {
return false;
}
}
// Add this resource name->id mapping to the index so
// that we can resolve all ID references to name references.
- auto cacheIter = mIdIndex.find(resId);
- if (cacheIter == mIdIndex.end()) {
- mIdIndex.insert({resId, name});
+ auto cache_iter = id_index_.find(res_id);
+ if (cache_iter == id_index_.end()) {
+ id_index_.insert({res_id, name});
}
}
return true;
}
-std::unique_ptr<Item> BinaryResourceParser::parseValue(
+std::unique_ptr<Item> BinaryResourceParser::ParseValue(
const ResourceNameRef& name, const ConfigDescription& config,
const Res_value* value, uint16_t flags) {
if (name.type == ResourceType::kId) {
return util::make_unique<Id>();
}
- const uint32_t data = util::deviceToHost32(value->data);
+ const uint32_t data = util::DeviceToHost32(value->data);
if (value->dataType == Res_value::TYPE_STRING) {
- const std::string str = util::getString(mValuePool, data);
+ const std::string str = util::GetString(value_pool_, data);
- const ResStringPool_span* spans = mValuePool.styleAt(data);
+ const ResStringPool_span* spans = value_pool_.styleAt(data);
// Check if the string has a valid style associated with it.
if (spans != nullptr && spans->name.index != ResStringPool_span::END) {
- StyleString styleStr = {str};
+ StyleString style_str = {str};
while (spans->name.index != ResStringPool_span::END) {
- styleStr.spans.push_back(
- Span{util::getString(mValuePool, spans->name.index),
+ style_str.spans.push_back(
+ Span{util::GetString(value_pool_, spans->name.index),
spans->firstChar, spans->lastChar});
spans++;
}
- return util::make_unique<StyledString>(mTable->stringPool.makeRef(
- styleStr,
+ return util::make_unique<StyledString>(table_->string_pool.MakeRef(
+ style_str,
StringPool::Context(StringPool::Context::kStylePriority, config)));
} else {
- if (name.type != ResourceType::kString &&
- util::stringStartsWith(str, "res/")) {
+ if (name.type != ResourceType::kString && util::StartsWith(str, "res/")) {
// This must be a FileReference.
- return util::make_unique<FileReference>(mTable->stringPool.makeRef(
+ return util::make_unique<FileReference>(table_->string_pool.MakeRef(
str,
StringPool::Context(StringPool::Context::kHighPriority, config)));
}
@@ -432,7 +433,7 @@
// There are no styles associated with this string, so treat it as
// a simple string.
return util::make_unique<String>(
- mTable->stringPool.makeRef(str, StringPool::Context(config)));
+ table_->string_pool.MakeRef(str, StringPool::Context(config)));
}
}
@@ -444,9 +445,9 @@
if (data == 0) {
// A reference of 0, must be the magic @null reference.
- Res_value nullType = {};
- nullType.dataType = Res_value::TYPE_REFERENCE;
- return util::make_unique<BinaryPrimitive>(nullType);
+ Res_value null_type = {};
+ null_type.dataType = Res_value::TYPE_REFERENCE;
+ return util::make_unique<BinaryPrimitive>(null_type);
}
// This is a normal reference.
@@ -457,87 +458,88 @@
return util::make_unique<BinaryPrimitive>(*value);
}
-std::unique_ptr<Value> BinaryResourceParser::parseMapEntry(
+std::unique_ptr<Value> BinaryResourceParser::ParseMapEntry(
const ResourceNameRef& name, const ConfigDescription& config,
const ResTable_map_entry* map) {
switch (name.type) {
case ResourceType::kStyle:
- return parseStyle(name, config, map);
+ return ParseStyle(name, config, map);
case ResourceType::kAttrPrivate:
// fallthrough
case ResourceType::kAttr:
- return parseAttr(name, config, map);
+ return ParseAttr(name, config, map);
case ResourceType::kArray:
- return parseArray(name, config, map);
+ return ParseArray(name, config, map);
case ResourceType::kPlurals:
- return parsePlural(name, config, map);
+ return ParsePlural(name, config, map);
default:
- assert(false && "unknown map type");
+ LOG(FATAL) << "unknown map type";
break;
}
return {};
}
-std::unique_ptr<Style> BinaryResourceParser::parseStyle(
+std::unique_ptr<Style> BinaryResourceParser::ParseStyle(
const ResourceNameRef& name, const ConfigDescription& config,
const ResTable_map_entry* map) {
std::unique_ptr<Style> style = util::make_unique<Style>();
- if (util::deviceToHost32(map->parent.ident) != 0) {
+ if (util::DeviceToHost32(map->parent.ident) != 0) {
// The parent is a regular reference to a resource.
- style->parent = Reference(util::deviceToHost32(map->parent.ident));
+ style->parent = Reference(util::DeviceToHost32(map->parent.ident));
}
- for (const ResTable_map& mapEntry : map) {
- if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
+ for (const ResTable_map& map_entry : map) {
+ if (Res_INTERNALID(util::DeviceToHost32(map_entry.name.ident))) {
continue;
}
- Style::Entry styleEntry;
- styleEntry.key = Reference(util::deviceToHost32(mapEntry.name.ident));
- styleEntry.value = parseValue(name, config, &mapEntry.value, 0);
- if (!styleEntry.value) {
+ Style::Entry style_entry;
+ style_entry.key = Reference(util::DeviceToHost32(map_entry.name.ident));
+ style_entry.value = ParseValue(name, config, &map_entry.value, 0);
+ if (!style_entry.value) {
return {};
}
- style->entries.push_back(std::move(styleEntry));
+ style->entries.push_back(std::move(style_entry));
}
return style;
}
-std::unique_ptr<Attribute> BinaryResourceParser::parseAttr(
+std::unique_ptr<Attribute> BinaryResourceParser::ParseAttr(
const ResourceNameRef& name, const ConfigDescription& config,
const ResTable_map_entry* map) {
- const bool isWeak =
- (util::deviceToHost16(map->flags) & ResTable_entry::FLAG_WEAK) != 0;
- std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(isWeak);
+ const bool is_weak =
+ (util::DeviceToHost16(map->flags) & ResTable_entry::FLAG_WEAK) != 0;
+ std::unique_ptr<Attribute> attr = util::make_unique<Attribute>(is_weak);
// First we must discover what type of attribute this is. Find the type mask.
- auto typeMaskIter =
+ auto type_mask_iter =
std::find_if(begin(map), end(map), [](const ResTable_map& entry) -> bool {
- return util::deviceToHost32(entry.name.ident) ==
+ return util::DeviceToHost32(entry.name.ident) ==
ResTable_map::ATTR_TYPE;
});
- if (typeMaskIter != end(map)) {
- attr->typeMask = util::deviceToHost32(typeMaskIter->value.data);
+ if (type_mask_iter != end(map)) {
+ attr->type_mask = util::DeviceToHost32(type_mask_iter->value.data);
}
- for (const ResTable_map& mapEntry : map) {
- if (Res_INTERNALID(util::deviceToHost32(mapEntry.name.ident))) {
- switch (util::deviceToHost32(mapEntry.name.ident)) {
+ for (const ResTable_map& map_entry : map) {
+ if (Res_INTERNALID(util::DeviceToHost32(map_entry.name.ident))) {
+ switch (util::DeviceToHost32(map_entry.name.ident)) {
case ResTable_map::ATTR_MIN:
- attr->minInt = static_cast<int32_t>(mapEntry.value.data);
+ attr->min_int = static_cast<int32_t>(map_entry.value.data);
break;
case ResTable_map::ATTR_MAX:
- attr->maxInt = static_cast<int32_t>(mapEntry.value.data);
+ attr->max_int = static_cast<int32_t>(map_entry.value.data);
break;
}
continue;
}
- if (attr->typeMask & (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) {
+ if (attr->type_mask &
+ (ResTable_map::TYPE_ENUM | ResTable_map::TYPE_FLAGS)) {
Attribute::Symbol symbol;
- symbol.value = util::deviceToHost32(mapEntry.value.data);
- symbol.symbol = Reference(util::deviceToHost32(mapEntry.name.ident));
+ symbol.value = util::DeviceToHost32(map_entry.value.data);
+ symbol.symbol = Reference(util::DeviceToHost32(map_entry.name.ident));
attr->symbols.push_back(std::move(symbol));
}
}
@@ -546,27 +548,27 @@
return attr;
}
-std::unique_ptr<Array> BinaryResourceParser::parseArray(
+std::unique_ptr<Array> BinaryResourceParser::ParseArray(
const ResourceNameRef& name, const ConfigDescription& config,
const ResTable_map_entry* map) {
std::unique_ptr<Array> array = util::make_unique<Array>();
- for (const ResTable_map& mapEntry : map) {
- array->items.push_back(parseValue(name, config, &mapEntry.value, 0));
+ for (const ResTable_map& map_entry : map) {
+ array->items.push_back(ParseValue(name, config, &map_entry.value, 0));
}
return array;
}
-std::unique_ptr<Plural> BinaryResourceParser::parsePlural(
+std::unique_ptr<Plural> BinaryResourceParser::ParsePlural(
const ResourceNameRef& name, const ConfigDescription& config,
const ResTable_map_entry* map) {
std::unique_ptr<Plural> plural = util::make_unique<Plural>();
- for (const ResTable_map& mapEntry : map) {
- std::unique_ptr<Item> item = parseValue(name, config, &mapEntry.value, 0);
+ for (const ResTable_map& map_entry : map) {
+ std::unique_ptr<Item> item = ParseValue(name, config, &map_entry.value, 0);
if (!item) {
return {};
}
- switch (util::deviceToHost32(mapEntry.name.ident)) {
+ switch (util::DeviceToHost32(map_entry.name.ident)) {
case ResTable_map::ATTR_ZERO:
plural->values[Plural::Zero] = std::move(item);
break;
diff --git a/tools/aapt2/unflatten/BinaryResourceParser.h b/tools/aapt2/unflatten/BinaryResourceParser.h
index 99f2bd4..dc668fd 100644
--- a/tools/aapt2/unflatten/BinaryResourceParser.h
+++ b/tools/aapt2/unflatten/BinaryResourceParser.h
@@ -17,16 +17,17 @@
#ifndef AAPT_BINARY_RESOURCE_PARSER_H
#define AAPT_BINARY_RESOURCE_PARSER_H
+#include <string>
+
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+
#include "ResourceTable.h"
#include "ResourceValues.h"
#include "Source.h"
-
#include "process/IResourceTableConsumer.h"
#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
-#include <string>
-
namespace aapt {
struct SymbolTable_entry;
@@ -45,44 +46,44 @@
* add any resources parsed to `table`. `source` is for logging purposes.
*/
BinaryResourceParser(IAaptContext* context, ResourceTable* table,
- const Source& source, const void* data, size_t dataLen);
-
- BinaryResourceParser(const BinaryResourceParser&) = delete; // No copy.
+ const Source& source, const void* data, size_t data_len);
/*
* Parses the binary resource table and returns true if successful.
*/
- bool parse();
+ bool Parse();
private:
- bool parseTable(const android::ResChunk_header* chunk);
- bool parsePackage(const android::ResChunk_header* chunk);
- bool parseTypeSpec(const android::ResChunk_header* chunk);
- bool parseType(const ResourceTablePackage* package,
+ DISALLOW_COPY_AND_ASSIGN(BinaryResourceParser);
+
+ bool ParseTable(const android::ResChunk_header* chunk);
+ bool ParsePackage(const android::ResChunk_header* chunk);
+ bool ParseTypeSpec(const android::ResChunk_header* chunk);
+ bool ParseType(const ResourceTablePackage* package,
const android::ResChunk_header* chunk);
- std::unique_ptr<Item> parseValue(const ResourceNameRef& name,
+ std::unique_ptr<Item> ParseValue(const ResourceNameRef& name,
const ConfigDescription& config,
const android::Res_value* value,
uint16_t flags);
- std::unique_ptr<Value> parseMapEntry(const ResourceNameRef& name,
+ std::unique_ptr<Value> ParseMapEntry(const ResourceNameRef& name,
const ConfigDescription& config,
const android::ResTable_map_entry* map);
- std::unique_ptr<Style> parseStyle(const ResourceNameRef& name,
+ std::unique_ptr<Style> ParseStyle(const ResourceNameRef& name,
const ConfigDescription& config,
const android::ResTable_map_entry* map);
- std::unique_ptr<Attribute> parseAttr(const ResourceNameRef& name,
+ std::unique_ptr<Attribute> ParseAttr(const ResourceNameRef& name,
const ConfigDescription& config,
const android::ResTable_map_entry* map);
- std::unique_ptr<Array> parseArray(const ResourceNameRef& name,
+ std::unique_ptr<Array> ParseArray(const ResourceNameRef& name,
const ConfigDescription& config,
const android::ResTable_map_entry* map);
- std::unique_ptr<Plural> parsePlural(const ResourceNameRef& name,
+ std::unique_ptr<Plural> ParsePlural(const ResourceNameRef& name,
const ConfigDescription& config,
const android::ResTable_map_entry* map);
@@ -92,30 +93,30 @@
* read and added to the Value.
* Returns true if the mapEntry was meta data.
*/
- bool collectMetaData(const android::ResTable_map& mapEntry, Value* value);
+ bool CollectMetaData(const android::ResTable_map& map_entry, Value* value);
- IAaptContext* mContext;
- ResourceTable* mTable;
+ IAaptContext* context_;
+ ResourceTable* table_;
- const Source mSource;
+ const Source source_;
- const void* mData;
- const size_t mDataLen;
+ const void* data_;
+ const size_t data_len_;
// The standard value string pool for resource values.
- android::ResStringPool mValuePool;
+ android::ResStringPool value_pool_;
// The string pool that holds the names of the types defined
// in this table.
- android::ResStringPool mTypePool;
+ android::ResStringPool type_pool_;
// The string pool that holds the names of the entries defined
// in this table.
- android::ResStringPool mKeyPool;
+ android::ResStringPool key_pool_;
// A mapping of resource ID to resource name. When we finish parsing
// we use this to convert all resource IDs to symbolic references.
- std::map<ResourceId, ResourceName> mIdIndex;
+ std::map<ResourceId, ResourceName> id_index_;
};
} // namespace aapt
@@ -128,11 +129,11 @@
inline const ResTable_map* begin(const ResTable_map_entry* map) {
return (const ResTable_map*)((const uint8_t*)map +
- aapt::util::deviceToHost32(map->size));
+ aapt::util::DeviceToHost32(map->size));
}
inline const ResTable_map* end(const ResTable_map_entry* map) {
- return begin(map) + aapt::util::deviceToHost32(map->count);
+ return begin(map) + aapt::util::DeviceToHost32(map->count);
}
} // namespace android
diff --git a/tools/aapt2/unflatten/ResChunkPullParser.cpp b/tools/aapt2/unflatten/ResChunkPullParser.cpp
index 6f8bb1b..5d71ff3 100644
--- a/tools/aapt2/unflatten/ResChunkPullParser.cpp
+++ b/tools/aapt2/unflatten/ResChunkPullParser.cpp
@@ -15,55 +15,60 @@
*/
#include "unflatten/ResChunkPullParser.h"
-#include "util/Util.h"
-#include <androidfw/ResourceTypes.h>
#include <cstddef>
+#include "android-base/logging.h"
+#include "androidfw/ResourceTypes.h"
+
+#include "util/Util.h"
+
namespace aapt {
using android::ResChunk_header;
-ResChunkPullParser::Event ResChunkPullParser::next() {
- if (!isGoodEvent(mEvent)) {
- return mEvent;
- }
+ResChunkPullParser::Event ResChunkPullParser::Next() {
+ if (!IsGoodEvent(event_)) {
+ return event_;
+ }
- if (mEvent == Event::StartDocument) {
- mCurrentChunk = mData;
- } else {
- mCurrentChunk = (const ResChunk_header*)
- (((const char*) mCurrentChunk) + util::deviceToHost32(mCurrentChunk->size));
- }
+ if (event_ == Event::kStartDocument) {
+ current_chunk_ = data_;
+ } else {
+ current_chunk_ =
+ (const ResChunk_header*)(((const char*)current_chunk_) +
+ util::DeviceToHost32(current_chunk_->size));
+ }
- const std::ptrdiff_t diff = (const char*) mCurrentChunk - (const char*) mData;
- assert(diff >= 0 && "diff is negative");
- const size_t offset = static_cast<const size_t>(diff);
+ const std::ptrdiff_t diff = (const char*)current_chunk_ - (const char*)data_;
+ CHECK(diff >= 0) << "diff is negative";
+ const size_t offset = static_cast<const size_t>(diff);
- if (offset == mLen) {
- mCurrentChunk = nullptr;
- return (mEvent = Event::EndDocument);
- } else if (offset + sizeof(ResChunk_header) > mLen) {
- mLastError = "chunk is past the end of the document";
- mCurrentChunk = nullptr;
- return (mEvent = Event::BadDocument);
- }
+ if (offset == len_) {
+ current_chunk_ = nullptr;
+ return (event_ = Event::kEndDocument);
+ } else if (offset + sizeof(ResChunk_header) > len_) {
+ error_ = "chunk is past the end of the document";
+ current_chunk_ = nullptr;
+ return (event_ = Event::kBadDocument);
+ }
- if (util::deviceToHost16(mCurrentChunk->headerSize) < sizeof(ResChunk_header)) {
- mLastError = "chunk has too small header";
- mCurrentChunk = nullptr;
- return (mEvent = Event::BadDocument);
- } else if (util::deviceToHost32(mCurrentChunk->size) <
- util::deviceToHost16(mCurrentChunk->headerSize)) {
- mLastError = "chunk's total size is smaller than header";
- mCurrentChunk = nullptr;
- return (mEvent = Event::BadDocument);
- } else if (offset + util::deviceToHost32(mCurrentChunk->size) > mLen) {
- mLastError = "chunk's data extends past the end of the document";
- mCurrentChunk = nullptr;
- return (mEvent = Event::BadDocument);
- }
- return (mEvent = Event::Chunk);
+ if (util::DeviceToHost16(current_chunk_->headerSize) <
+ sizeof(ResChunk_header)) {
+ error_ = "chunk has too small header";
+ current_chunk_ = nullptr;
+ return (event_ = Event::kBadDocument);
+ } else if (util::DeviceToHost32(current_chunk_->size) <
+ util::DeviceToHost16(current_chunk_->headerSize)) {
+ error_ = "chunk's total size is smaller than header";
+ current_chunk_ = nullptr;
+ return (event_ = Event::kBadDocument);
+ } else if (offset + util::DeviceToHost32(current_chunk_->size) > len_) {
+ error_ = "chunk's data extends past the end of the document";
+ current_chunk_ = nullptr;
+ return (event_ = Event::kBadDocument);
+ }
+ return (event_ = Event::kChunk);
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/unflatten/ResChunkPullParser.h b/tools/aapt2/unflatten/ResChunkPullParser.h
index 24fa63d..437fc5c 100644
--- a/tools/aapt2/unflatten/ResChunkPullParser.h
+++ b/tools/aapt2/unflatten/ResChunkPullParser.h
@@ -17,11 +17,13 @@
#ifndef AAPT_RES_CHUNK_PULL_PARSER_H
#define AAPT_RES_CHUNK_PULL_PARSER_H
-#include "util/Util.h"
-
-#include <androidfw/ResourceTypes.h>
#include <string>
+#include "android-base/macros.h"
+#include "androidfw/ResourceTypes.h"
+
+#include "util/Util.h"
+
namespace aapt {
/**
@@ -39,17 +41,17 @@
class ResChunkPullParser {
public:
enum class Event {
- StartDocument,
- EndDocument,
- BadDocument,
+ kStartDocument,
+ kEndDocument,
+ kBadDocument,
- Chunk,
+ kChunk,
};
/**
* Returns false if the event is EndDocument or BadDocument.
*/
- static bool isGoodEvent(Event event);
+ static bool IsGoodEvent(Event event);
/**
* Create a ResChunkPullParser to read android::ResChunk_headers
@@ -57,68 +59,66 @@
*/
ResChunkPullParser(const void* data, size_t len);
- ResChunkPullParser(const ResChunkPullParser&) = delete;
-
- Event getEvent() const;
- const std::string& getLastError() const;
- const android::ResChunk_header* getChunk() const;
+ Event event() const;
+ const std::string& error() const;
+ const android::ResChunk_header* chunk() const;
/**
* Move to the next android::ResChunk_header.
*/
- Event next();
+ Event Next();
private:
- Event mEvent;
- const android::ResChunk_header* mData;
- size_t mLen;
- const android::ResChunk_header* mCurrentChunk;
- std::string mLastError;
+ DISALLOW_COPY_AND_ASSIGN(ResChunkPullParser);
+
+ Event event_;
+ const android::ResChunk_header* data_;
+ size_t len_;
+ const android::ResChunk_header* current_chunk_;
+ std::string error_;
};
template <typename T>
-inline static const T* convertTo(const android::ResChunk_header* chunk) {
- if (util::deviceToHost16(chunk->headerSize) < sizeof(T)) {
+inline static const T* ConvertTo(const android::ResChunk_header* chunk) {
+ if (util::DeviceToHost16(chunk->headerSize) < sizeof(T)) {
return nullptr;
}
return reinterpret_cast<const T*>(chunk);
}
-inline static const uint8_t* getChunkData(
+inline static const uint8_t* GetChunkData(
const android::ResChunk_header* chunk) {
return reinterpret_cast<const uint8_t*>(chunk) +
- util::deviceToHost16(chunk->headerSize);
+ util::DeviceToHost16(chunk->headerSize);
}
-inline static uint32_t getChunkDataLen(const android::ResChunk_header* chunk) {
- return util::deviceToHost32(chunk->size) -
- util::deviceToHost16(chunk->headerSize);
+inline static uint32_t GetChunkDataLen(const android::ResChunk_header* chunk) {
+ return util::DeviceToHost32(chunk->size) -
+ util::DeviceToHost16(chunk->headerSize);
}
//
// Implementation
//
-inline bool ResChunkPullParser::isGoodEvent(ResChunkPullParser::Event event) {
- return event != Event::EndDocument && event != Event::BadDocument;
+inline bool ResChunkPullParser::IsGoodEvent(ResChunkPullParser::Event event) {
+ return event != Event::kEndDocument && event != Event::kBadDocument;
}
inline ResChunkPullParser::ResChunkPullParser(const void* data, size_t len)
- : mEvent(Event::StartDocument),
- mData(reinterpret_cast<const android::ResChunk_header*>(data)),
- mLen(len),
- mCurrentChunk(nullptr) {}
+ : event_(Event::kStartDocument),
+ data_(reinterpret_cast<const android::ResChunk_header*>(data)),
+ len_(len),
+ current_chunk_(nullptr) {}
-inline ResChunkPullParser::Event ResChunkPullParser::getEvent() const {
- return mEvent;
+inline ResChunkPullParser::Event ResChunkPullParser::event() const {
+ return event_;
}
-inline const std::string& ResChunkPullParser::getLastError() const {
- return mLastError;
-}
+inline const std::string& ResChunkPullParser::error() const { return error_; }
-inline const android::ResChunk_header* ResChunkPullParser::getChunk() const {
- return mCurrentChunk;
+inline const android::ResChunk_header* ResChunkPullParser::chunk() const {
+ return current_chunk_;
}
} // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer.cpp b/tools/aapt2/util/BigBuffer.cpp
index de4ecd2..ef99dca 100644
--- a/tools/aapt2/util/BigBuffer.cpp
+++ b/tools/aapt2/util/BigBuffer.cpp
@@ -20,58 +20,60 @@
#include <memory>
#include <vector>
+#include "android-base/logging.h"
+
namespace aapt {
-void* BigBuffer::nextBlockImpl(size_t size) {
- if (!mBlocks.empty()) {
- Block& block = mBlocks.back();
- if (block.mBlockSize - block.size >= size) {
- void* outBuffer = block.buffer.get() + block.size;
- block.size += size;
- mSize += size;
- return outBuffer;
- }
+void* BigBuffer::NextBlockImpl(size_t size) {
+ if (!blocks_.empty()) {
+ Block& block = blocks_.back();
+ if (block.block_size_ - block.size >= size) {
+ void* out_buffer = block.buffer.get() + block.size;
+ block.size += size;
+ size_ += size;
+ return out_buffer;
}
+ }
- const size_t actualSize = std::max(mBlockSize, size);
+ const size_t actual_size = std::max(block_size_, size);
- Block block = {};
+ Block block = {};
- // Zero-allocate the block's buffer.
- block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[actualSize]());
- assert(block.buffer);
+ // Zero-allocate the block's buffer.
+ block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[actual_size]());
+ CHECK(block.buffer);
- block.size = size;
- block.mBlockSize = actualSize;
+ block.size = size;
+ block.block_size_ = actual_size;
- mBlocks.push_back(std::move(block));
- mSize += size;
- return mBlocks.back().buffer.get();
+ blocks_.push_back(std::move(block));
+ size_ += size;
+ return blocks_.back().buffer.get();
}
-void* BigBuffer::nextBlock(size_t* outSize) {
- if (!mBlocks.empty()) {
- Block& block = mBlocks.back();
- if (block.size != block.mBlockSize) {
- void* outBuffer = block.buffer.get() + block.size;
- size_t size = block.mBlockSize - block.size;
- block.size = block.mBlockSize;
- mSize += size;
- *outSize = size;
- return outBuffer;
- }
+void* BigBuffer::NextBlock(size_t* out_size) {
+ if (!blocks_.empty()) {
+ Block& block = blocks_.back();
+ if (block.size != block.block_size_) {
+ void* out_buffer = block.buffer.get() + block.size;
+ size_t size = block.block_size_ - block.size;
+ block.size = block.block_size_;
+ size_ += size;
+ *out_size = size;
+ return out_buffer;
}
+ }
- // Zero-allocate the block's buffer.
- Block block = {};
- block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[mBlockSize]());
- assert(block.buffer);
- block.size = mBlockSize;
- block.mBlockSize = mBlockSize;
- mBlocks.push_back(std::move(block));
- mSize += mBlockSize;
- *outSize = mBlockSize;
- return mBlocks.back().buffer.get();
+ // Zero-allocate the block's buffer.
+ Block block = {};
+ block.buffer = std::unique_ptr<uint8_t[]>(new uint8_t[block_size_]());
+ CHECK(block.buffer);
+ block.size = block_size_;
+ block.block_size_ = block_size_;
+ blocks_.push_back(std::move(block));
+ size_ += block_size_;
+ *out_size = block_size_;
+ return blocks_.back().buffer.get();
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer.h b/tools/aapt2/util/BigBuffer.h
index b273733..d23c41d 100644
--- a/tools/aapt2/util/BigBuffer.h
+++ b/tools/aapt2/util/BigBuffer.h
@@ -17,12 +17,14 @@
#ifndef AAPT_BIG_BUFFER_H
#define AAPT_BIG_BUFFER_H
-#include <cassert>
#include <cstring>
#include <memory>
#include <type_traits>
#include <vector>
+#include "android-base/logging.h"
+#include "android-base/macros.h"
+
namespace aapt {
/**
@@ -54,18 +56,16 @@
/**
* The size of the memory block allocation.
*/
- size_t mBlockSize;
+ size_t block_size_;
};
typedef std::vector<Block>::const_iterator const_iterator;
/**
* Create a BigBuffer with block allocation sizes
- * of blockSize.
+ * of block_size.
*/
- explicit BigBuffer(size_t blockSize);
-
- BigBuffer(const BigBuffer&) = delete; // No copying.
+ explicit BigBuffer(size_t block_size);
BigBuffer(BigBuffer&& rhs);
@@ -79,104 +79,106 @@
* a POD type. The elements are zero-initialized.
*/
template <typename T>
- T* nextBlock(size_t count = 1);
+ T* NextBlock(size_t count = 1);
/**
- * Returns the next block available and puts the size in outCount.
+ * Returns the next block available and puts the size in out_count.
* This is useful for grabbing blocks where the size doesn't matter.
- * Use backUp() to give back any bytes that were not used.
+ * Use BackUp() to give back any bytes that were not used.
*/
- void* nextBlock(size_t* outCount);
+ void* NextBlock(size_t* out_count);
/**
- * Backs up count bytes. This must only be called after nextBlock()
- * and can not be larger than sizeof(T) * count of the last nextBlock()
+ * Backs up count bytes. This must only be called after NextBlock()
+ * and can not be larger than sizeof(T) * count of the last NextBlock()
* call.
*/
- void backUp(size_t count);
+ void BackUp(size_t count);
/**
* Moves the specified BigBuffer into this one. When this method
* returns, buffer is empty.
*/
- void appendBuffer(BigBuffer&& buffer);
+ void AppendBuffer(BigBuffer&& buffer);
/**
* Pads the block with 'bytes' bytes of zero values.
*/
- void pad(size_t bytes);
+ void Pad(size_t bytes);
/**
* Pads the block so that it aligns on a 4 byte boundary.
*/
- void align4();
+ void Align4();
- size_t getBlockSize() const;
+ size_t block_size() const;
const_iterator begin() const;
const_iterator end() const;
private:
+ DISALLOW_COPY_AND_ASSIGN(BigBuffer);
+
/**
* Returns a pointer to a buffer of the requested size.
* The buffer is zero-initialized.
*/
- void* nextBlockImpl(size_t size);
+ void* NextBlockImpl(size_t size);
- size_t mBlockSize;
- size_t mSize;
- std::vector<Block> mBlocks;
+ size_t block_size_;
+ size_t size_;
+ std::vector<Block> blocks_;
};
-inline BigBuffer::BigBuffer(size_t blockSize)
- : mBlockSize(blockSize), mSize(0) {}
+inline BigBuffer::BigBuffer(size_t block_size)
+ : block_size_(block_size), size_(0) {}
inline BigBuffer::BigBuffer(BigBuffer&& rhs)
- : mBlockSize(rhs.mBlockSize),
- mSize(rhs.mSize),
- mBlocks(std::move(rhs.mBlocks)) {}
+ : block_size_(rhs.block_size_),
+ size_(rhs.size_),
+ blocks_(std::move(rhs.blocks_)) {}
-inline size_t BigBuffer::size() const { return mSize; }
+inline size_t BigBuffer::size() const { return size_; }
-inline size_t BigBuffer::getBlockSize() const { return mBlockSize; }
+inline size_t BigBuffer::block_size() const { return block_size_; }
template <typename T>
-inline T* BigBuffer::nextBlock(size_t count) {
+inline T* BigBuffer::NextBlock(size_t count) {
static_assert(std::is_standard_layout<T>::value,
"T must be standard_layout type");
- assert(count != 0);
- return reinterpret_cast<T*>(nextBlockImpl(sizeof(T) * count));
+ CHECK(count != 0);
+ return reinterpret_cast<T*>(NextBlockImpl(sizeof(T) * count));
}
-inline void BigBuffer::backUp(size_t count) {
- Block& block = mBlocks.back();
+inline void BigBuffer::BackUp(size_t count) {
+ Block& block = blocks_.back();
block.size -= count;
- mSize -= count;
+ size_ -= count;
}
-inline void BigBuffer::appendBuffer(BigBuffer&& buffer) {
- std::move(buffer.mBlocks.begin(), buffer.mBlocks.end(),
- std::back_inserter(mBlocks));
- mSize += buffer.mSize;
- buffer.mBlocks.clear();
- buffer.mSize = 0;
+inline void BigBuffer::AppendBuffer(BigBuffer&& buffer) {
+ std::move(buffer.blocks_.begin(), buffer.blocks_.end(),
+ std::back_inserter(blocks_));
+ size_ += buffer.size_;
+ buffer.blocks_.clear();
+ buffer.size_ = 0;
}
-inline void BigBuffer::pad(size_t bytes) { nextBlock<char>(bytes); }
+inline void BigBuffer::Pad(size_t bytes) { NextBlock<char>(bytes); }
-inline void BigBuffer::align4() {
- const size_t unaligned = mSize % 4;
+inline void BigBuffer::Align4() {
+ const size_t unaligned = size_ % 4;
if (unaligned != 0) {
- pad(4 - unaligned);
+ Pad(4 - unaligned);
}
}
inline BigBuffer::const_iterator BigBuffer::begin() const {
- return mBlocks.begin();
+ return blocks_.begin();
}
inline BigBuffer::const_iterator BigBuffer::end() const {
- return mBlocks.end();
+ return blocks_.end();
}
} // namespace aapt
diff --git a/tools/aapt2/util/BigBuffer_test.cpp b/tools/aapt2/util/BigBuffer_test.cpp
index 2a24f12..12c0b3e 100644
--- a/tools/aapt2/util/BigBuffer_test.cpp
+++ b/tools/aapt2/util/BigBuffer_test.cpp
@@ -16,83 +16,83 @@
#include "util/BigBuffer.h"
-#include <gtest/gtest.h>
+#include "test/Test.h"
namespace aapt {
TEST(BigBufferTest, AllocateSingleBlock) {
- BigBuffer buffer(4);
+ BigBuffer buffer(4);
- EXPECT_NE(nullptr, buffer.nextBlock<char>(2));
- EXPECT_EQ(2u, buffer.size());
+ EXPECT_NE(nullptr, buffer.NextBlock<char>(2));
+ EXPECT_EQ(2u, buffer.size());
}
TEST(BigBufferTest, ReturnSameBlockIfNextAllocationFits) {
- BigBuffer buffer(16);
+ BigBuffer buffer(16);
- char* b1 = buffer.nextBlock<char>(8);
- EXPECT_NE(nullptr, b1);
+ char* b1 = buffer.NextBlock<char>(8);
+ EXPECT_NE(nullptr, b1);
- char* b2 = buffer.nextBlock<char>(4);
- EXPECT_NE(nullptr, b2);
+ char* b2 = buffer.NextBlock<char>(4);
+ EXPECT_NE(nullptr, b2);
- EXPECT_EQ(b1 + 8, b2);
+ EXPECT_EQ(b1 + 8, b2);
}
TEST(BigBufferTest, AllocateExactSizeBlockIfLargerThanBlockSize) {
- BigBuffer buffer(16);
+ BigBuffer buffer(16);
- EXPECT_NE(nullptr, buffer.nextBlock<char>(32));
- EXPECT_EQ(32u, buffer.size());
+ EXPECT_NE(nullptr, buffer.NextBlock<char>(32));
+ EXPECT_EQ(32u, buffer.size());
}
TEST(BigBufferTest, AppendAndMoveBlock) {
- BigBuffer buffer(16);
+ BigBuffer buffer(16);
- uint32_t* b1 = buffer.nextBlock<uint32_t>();
+ uint32_t* b1 = buffer.NextBlock<uint32_t>();
+ ASSERT_NE(nullptr, b1);
+ *b1 = 33;
+
+ {
+ BigBuffer buffer2(16);
+ b1 = buffer2.NextBlock<uint32_t>();
ASSERT_NE(nullptr, b1);
- *b1 = 33;
+ *b1 = 44;
- {
- BigBuffer buffer2(16);
- b1 = buffer2.nextBlock<uint32_t>();
- ASSERT_NE(nullptr, b1);
- *b1 = 44;
+ buffer.AppendBuffer(std::move(buffer2));
+ EXPECT_EQ(0u, buffer2.size());
+ EXPECT_EQ(buffer2.begin(), buffer2.end());
+ }
- buffer.appendBuffer(std::move(buffer2));
- EXPECT_EQ(0u, buffer2.size());
- EXPECT_EQ(buffer2.begin(), buffer2.end());
- }
+ EXPECT_EQ(2 * sizeof(uint32_t), buffer.size());
- EXPECT_EQ(2 * sizeof(uint32_t), buffer.size());
+ auto b = buffer.begin();
+ ASSERT_NE(b, buffer.end());
+ ASSERT_EQ(sizeof(uint32_t), b->size);
+ ASSERT_EQ(33u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
+ ++b;
- auto b = buffer.begin();
- ASSERT_NE(b, buffer.end());
- ASSERT_EQ(sizeof(uint32_t), b->size);
- ASSERT_EQ(33u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
- ++b;
+ ASSERT_NE(b, buffer.end());
+ ASSERT_EQ(sizeof(uint32_t), b->size);
+ ASSERT_EQ(44u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
+ ++b;
- ASSERT_NE(b, buffer.end());
- ASSERT_EQ(sizeof(uint32_t), b->size);
- ASSERT_EQ(44u, *reinterpret_cast<uint32_t*>(b->buffer.get()));
- ++b;
-
- ASSERT_EQ(b, buffer.end());
+ ASSERT_EQ(b, buffer.end());
}
TEST(BigBufferTest, PadAndAlignProperly) {
- BigBuffer buffer(16);
+ BigBuffer buffer(16);
- ASSERT_NE(buffer.nextBlock<char>(2), nullptr);
- ASSERT_EQ(2u, buffer.size());
- buffer.pad(2);
- ASSERT_EQ(4u, buffer.size());
- buffer.align4();
- ASSERT_EQ(4u, buffer.size());
- buffer.pad(2);
- ASSERT_EQ(6u, buffer.size());
- buffer.align4();
- ASSERT_EQ(8u, buffer.size());
+ ASSERT_NE(buffer.NextBlock<char>(2), nullptr);
+ ASSERT_EQ(2u, buffer.size());
+ buffer.Pad(2);
+ ASSERT_EQ(4u, buffer.size());
+ buffer.Align4();
+ ASSERT_EQ(4u, buffer.size());
+ buffer.Pad(2);
+ ASSERT_EQ(6u, buffer.size());
+ buffer.Align4();
+ ASSERT_EQ(8u, buffer.size());
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/util/Files.cpp b/tools/aapt2/util/Files.cpp
index 4cba921..f034607 100644
--- a/tools/aapt2/util/Files.cpp
+++ b/tools/aapt2/util/Files.cpp
@@ -15,15 +15,20 @@
*/
#include "util/Files.h"
-#include "util/Util.h"
+
+#include <dirent.h>
+#include <sys/stat.h>
#include <algorithm>
-#include <android-base/file.h>
#include <cerrno>
#include <cstdio>
-#include <dirent.h>
#include <string>
-#include <sys/stat.h>
+
+#include "android-base/errors.h"
+#include "android-base/file.h"
+#include "android-base/logging.h"
+
+#include "util/Util.h"
#ifdef _WIN32
// Windows includes.
@@ -33,244 +38,230 @@
namespace aapt {
namespace file {
-FileType getFileType(const StringPiece& path) {
- struct stat sb;
- if (stat(path.data(), &sb) < 0) {
- if (errno == ENOENT || errno == ENOTDIR) {
- return FileType::kNonexistant;
- }
- return FileType::kUnknown;
+FileType GetFileType(const StringPiece& path) {
+ struct stat sb;
+ if (stat(path.data(), &sb) < 0) {
+ if (errno == ENOENT || errno == ENOTDIR) {
+ return FileType::kNonexistant;
}
+ return FileType::kUnknown;
+ }
- if (S_ISREG(sb.st_mode)) {
- return FileType::kRegular;
- } else if (S_ISDIR(sb.st_mode)) {
- return FileType::kDirectory;
- } else if (S_ISCHR(sb.st_mode)) {
- return FileType::kCharDev;
- } else if (S_ISBLK(sb.st_mode)) {
- return FileType::kBlockDev;
- } else if (S_ISFIFO(sb.st_mode)) {
- return FileType::kFifo;
+ if (S_ISREG(sb.st_mode)) {
+ return FileType::kRegular;
+ } else if (S_ISDIR(sb.st_mode)) {
+ return FileType::kDirectory;
+ } else if (S_ISCHR(sb.st_mode)) {
+ return FileType::kCharDev;
+ } else if (S_ISBLK(sb.st_mode)) {
+ return FileType::kBlockDev;
+ } else if (S_ISFIFO(sb.st_mode)) {
+ return FileType::kFifo;
#if defined(S_ISLNK)
- } else if (S_ISLNK(sb.st_mode)) {
- return FileType::kSymlink;
+ } else if (S_ISLNK(sb.st_mode)) {
+ return FileType::kSymlink;
#endif
#if defined(S_ISSOCK)
- } else if (S_ISSOCK(sb.st_mode)) {
- return FileType::kSocket;
+ } else if (S_ISSOCK(sb.st_mode)) {
+ return FileType::kSocket;
#endif
- } else {
- return FileType::kUnknown;
- }
+ } else {
+ return FileType::kUnknown;
+ }
}
-std::vector<std::string> listFiles(const StringPiece& root, std::string* outError) {
- DIR* dir = opendir(root.data());
- if (dir == nullptr) {
- if (outError) {
- std::stringstream errorStr;
- errorStr << "unable to open file: " << strerror(errno);
- *outError = errorStr.str();
- }
- return {};
- }
-
- std::vector<std::string> files;
- dirent* entry;
- while ((entry = readdir(dir))) {
- files.emplace_back(entry->d_name);
- }
-
- closedir(dir);
- return files;
-}
-
-inline static int mkdirImpl(const StringPiece& path) {
+inline static int MkdirImpl(const StringPiece& path) {
#ifdef _WIN32
- return _mkdir(path.toString().c_str());
+ return _mkdir(path.ToString().c_str());
#else
- return mkdir(path.toString().c_str(), S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP);
+ return mkdir(path.ToString().c_str(),
+ S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP);
#endif
}
bool mkdirs(const StringPiece& path) {
- const char* start = path.begin();
- const char* end = path.end();
- for (const char* current = start; current != end; ++current) {
- if (*current == sDirSep && current != start) {
- StringPiece parentPath(start, current - start);
- int result = mkdirImpl(parentPath);
- if (result < 0 && errno != EEXIST) {
- return false;
- }
- }
- }
- return mkdirImpl(path) == 0 || errno == EEXIST;
-}
-
-StringPiece getStem(const StringPiece& path) {
- const char* start = path.begin();
- const char* end = path.end();
- for (const char* current = end - 1; current != start - 1; --current) {
- if (*current == sDirSep) {
- return StringPiece(start, current - start);
- }
- }
- return {};
-}
-
-StringPiece getFilename(const StringPiece& path) {
- const char* end = path.end();
- const char* lastDirSep = path.begin();
- for (const char* c = path.begin(); c != end; ++c) {
- if (*c == sDirSep) {
- lastDirSep = c + 1;
- }
- }
- return StringPiece(lastDirSep, end - lastDirSep);
-}
-
-StringPiece getExtension(const StringPiece& path) {
- StringPiece filename = getFilename(path);
- const char* const end = filename.end();
- const char* c = std::find(filename.begin(), end, '.');
- if (c != end) {
- return StringPiece(c, end - c);
- }
- return {};
-}
-
-void appendPath(std::string* base, StringPiece part) {
- assert(base);
- const bool baseHasTrailingSep = (!base->empty() && *(base->end() - 1) == sDirSep);
- const bool partHasLeadingSep = (!part.empty() && *(part.begin()) == sDirSep);
- if (baseHasTrailingSep && partHasLeadingSep) {
- // Remove the part's leading sep
- part = part.substr(1, part.size() - 1);
- } else if (!baseHasTrailingSep && !partHasLeadingSep) {
- // None of the pieces has a separator.
- *base += sDirSep;
- }
- base->append(part.data(), part.size());
-}
-
-std::string packageToPath(const StringPiece& package) {
- std::string outPath;
- for (StringPiece part : util::tokenize(package, '.')) {
- appendPath(&outPath, part);
- }
- return outPath;
-}
-
-Maybe<android::FileMap> mmapPath(const StringPiece& path, std::string* outError) {
- std::unique_ptr<FILE, decltype(fclose)*> f = { fopen(path.data(), "rb"), fclose };
- if (!f) {
- if (outError) *outError = strerror(errno);
- return {};
- }
-
- int fd = fileno(f.get());
-
- struct stat fileStats = {};
- if (fstat(fd, &fileStats) != 0) {
- if (outError) *outError = strerror(errno);
- return {};
- }
-
- android::FileMap fileMap;
- if (fileStats.st_size == 0) {
- // mmap doesn't like a length of 0. Instead we return an empty FileMap.
- return std::move(fileMap);
- }
-
- if (!fileMap.create(path.data(), fd, 0, fileStats.st_size, true)) {
- if (outError) *outError = strerror(errno);
- return {};
- }
- return std::move(fileMap);
-}
-
-bool appendArgsFromFile(const StringPiece& path, std::vector<std::string>* outArgList,
- std::string* outError) {
- std::string contents;
- if (!android::base::ReadFileToString(path.toString(), &contents)) {
- if (outError) *outError = "failed to read argument-list file";
+ const char* start = path.begin();
+ const char* end = path.end();
+ for (const char* current = start; current != end; ++current) {
+ if (*current == sDirSep && current != start) {
+ StringPiece parent_path(start, current - start);
+ int result = MkdirImpl(parent_path);
+ if (result < 0 && errno != EEXIST) {
return false;
+ }
}
-
- for (StringPiece line : util::tokenize(contents, ' ')) {
- line = util::trimWhitespace(line);
- if (!line.empty()) {
- outArgList->push_back(line.toString());
- }
- }
- return true;
+ }
+ return MkdirImpl(path) == 0 || errno == EEXIST;
}
-bool FileFilter::setPattern(const StringPiece& pattern) {
- mPatternTokens = util::splitAndLowercase(pattern, ':');
- return true;
+StringPiece GetStem(const StringPiece& path) {
+ const char* start = path.begin();
+ const char* end = path.end();
+ for (const char* current = end - 1; current != start - 1; --current) {
+ if (*current == sDirSep) {
+ return StringPiece(start, current - start);
+ }
+ }
+ return {};
+}
+
+StringPiece GetFilename(const StringPiece& path) {
+ const char* end = path.end();
+ const char* last_dir_sep = path.begin();
+ for (const char* c = path.begin(); c != end; ++c) {
+ if (*c == sDirSep) {
+ last_dir_sep = c + 1;
+ }
+ }
+ return StringPiece(last_dir_sep, end - last_dir_sep);
+}
+
+StringPiece GetExtension(const StringPiece& path) {
+ StringPiece filename = GetFilename(path);
+ const char* const end = filename.end();
+ const char* c = std::find(filename.begin(), end, '.');
+ if (c != end) {
+ return StringPiece(c, end - c);
+ }
+ return {};
+}
+
+void AppendPath(std::string* base, StringPiece part) {
+ CHECK(base != nullptr);
+ const bool base_has_trailing_sep =
+ (!base->empty() && *(base->end() - 1) == sDirSep);
+ const bool part_has_leading_sep =
+ (!part.empty() && *(part.begin()) == sDirSep);
+ if (base_has_trailing_sep && part_has_leading_sep) {
+ // Remove the part's leading sep
+ part = part.substr(1, part.size() - 1);
+ } else if (!base_has_trailing_sep && !part_has_leading_sep) {
+ // None of the pieces has a separator.
+ *base += sDirSep;
+ }
+ base->append(part.data(), part.size());
+}
+
+std::string PackageToPath(const StringPiece& package) {
+ std::string out_path;
+ for (StringPiece part : util::Tokenize(package, '.')) {
+ AppendPath(&out_path, part);
+ }
+ return out_path;
+}
+
+Maybe<android::FileMap> MmapPath(const StringPiece& path,
+ std::string* out_error) {
+ std::unique_ptr<FILE, decltype(fclose)*> f = {fopen(path.data(), "rb"),
+ fclose};
+ if (!f) {
+ if (out_error) *out_error = android::base::SystemErrorCodeToString(errno);
+ return {};
+ }
+
+ int fd = fileno(f.get());
+
+ struct stat filestats = {};
+ if (fstat(fd, &filestats) != 0) {
+ if (out_error) *out_error = android::base::SystemErrorCodeToString(errno);
+ return {};
+ }
+
+ android::FileMap filemap;
+ if (filestats.st_size == 0) {
+ // mmap doesn't like a length of 0. Instead we return an empty FileMap.
+ return std::move(filemap);
+ }
+
+ if (!filemap.create(path.data(), fd, 0, filestats.st_size, true)) {
+ if (out_error) *out_error = android::base::SystemErrorCodeToString(errno);
+ return {};
+ }
+ return std::move(filemap);
+}
+
+bool AppendArgsFromFile(const StringPiece& path,
+ std::vector<std::string>* out_arglist,
+ std::string* out_error) {
+ std::string contents;
+ if (!android::base::ReadFileToString(path.ToString(), &contents)) {
+ if (out_error) *out_error = "failed to read argument-list file";
+ return false;
+ }
+
+ for (StringPiece line : util::Tokenize(contents, ' ')) {
+ line = util::TrimWhitespace(line);
+ if (!line.empty()) {
+ out_arglist->push_back(line.ToString());
+ }
+ }
+ return true;
+}
+
+bool FileFilter::SetPattern(const StringPiece& pattern) {
+ pattern_tokens_ = util::SplitAndLowercase(pattern, ':');
+ return true;
}
bool FileFilter::operator()(const std::string& filename, FileType type) const {
- if (filename == "." || filename == "..") {
- return false;
+ if (filename == "." || filename == "..") {
+ return false;
+ }
+
+ const char kDir[] = "dir";
+ const char kFile[] = "file";
+ const size_t filename_len = filename.length();
+ bool chatty = true;
+ for (const std::string& token : pattern_tokens_) {
+ const char* token_str = token.c_str();
+ if (*token_str == '!') {
+ chatty = false;
+ token_str++;
}
- const char kDir[] = "dir";
- const char kFile[] = "file";
- const size_t filenameLen = filename.length();
- bool chatty = true;
- for (const std::string& token : mPatternTokens) {
- const char* tokenStr = token.c_str();
- if (*tokenStr == '!') {
- chatty = false;
- tokenStr++;
- }
-
- if (strncasecmp(tokenStr, kDir, sizeof(kDir)) == 0) {
- if (type != FileType::kDirectory) {
- continue;
- }
- tokenStr += sizeof(kDir);
- }
-
- if (strncasecmp(tokenStr, kFile, sizeof(kFile)) == 0) {
- if (type != FileType::kRegular) {
- continue;
- }
- tokenStr += sizeof(kFile);
- }
-
- bool ignore = false;
- size_t n = strlen(tokenStr);
- if (*tokenStr == '*') {
- // Math suffix.
- tokenStr++;
- n--;
- if (n <= filenameLen) {
- ignore = strncasecmp(tokenStr, filename.c_str() + filenameLen - n, n) == 0;
- }
- } else if (n > 1 && tokenStr[n - 1] == '*') {
- // Match prefix.
- ignore = strncasecmp(tokenStr, filename.c_str(), n - 1) == 0;
- } else {
- ignore = strcasecmp(tokenStr, filename.c_str()) == 0;
- }
-
- if (ignore) {
- if (chatty) {
- mDiag->warn(DiagMessage() << "skipping "
- << (type == FileType::kDirectory ? "dir '" : "file '")
- << filename << "' due to ignore pattern '"
- << token << "'");
- }
- return false;
- }
+ if (strncasecmp(token_str, kDir, sizeof(kDir)) == 0) {
+ if (type != FileType::kDirectory) {
+ continue;
+ }
+ token_str += sizeof(kDir);
}
- return true;
+
+ if (strncasecmp(token_str, kFile, sizeof(kFile)) == 0) {
+ if (type != FileType::kRegular) {
+ continue;
+ }
+ token_str += sizeof(kFile);
+ }
+
+ bool ignore = false;
+ size_t n = strlen(token_str);
+ if (*token_str == '*') {
+ // Math suffix.
+ token_str++;
+ n--;
+ if (n <= filename_len) {
+ ignore =
+ strncasecmp(token_str, filename.c_str() + filename_len - n, n) == 0;
+ }
+ } else if (n > 1 && token_str[n - 1] == '*') {
+ // Match prefix.
+ ignore = strncasecmp(token_str, filename.c_str(), n - 1) == 0;
+ } else {
+ ignore = strcasecmp(token_str, filename.c_str()) == 0;
+ }
+
+ if (ignore) {
+ if (chatty) {
+ diag_->Warn(DiagMessage()
+ << "skipping "
+ << (type == FileType::kDirectory ? "dir '" : "file '")
+ << filename << "' due to ignore pattern '" << token << "'");
+ }
+ return false;
+ }
+ }
+ return true;
}
-} // namespace file
-} // namespace aapt
+} // namespace file
+} // namespace aapt
diff --git a/tools/aapt2/util/Files.h b/tools/aapt2/util/Files.h
index d90c6b6..a157dbd 100644
--- a/tools/aapt2/util/Files.h
+++ b/tools/aapt2/util/Files.h
@@ -17,18 +17,18 @@
#ifndef AAPT_FILES_H
#define AAPT_FILES_H
-#include "Diagnostics.h"
-#include "Maybe.h"
-#include "Source.h"
-
-#include "util/StringPiece.h"
-
-#include <utils/FileMap.h>
-#include <cassert>
#include <memory>
#include <string>
#include <vector>
+#include "android-base/macros.h"
+#include "utils/FileMap.h"
+
+#include "Diagnostics.h"
+#include "Maybe.h"
+#include "Source.h"
+#include "util/StringPiece.h"
+
namespace aapt {
namespace file {
@@ -50,18 +50,12 @@
kSocket,
};
-FileType getFileType(const StringPiece& path);
-
-/*
- * Lists files under the directory `root`. Files are listed
- * with just their leaf (filename) names.
- */
-std::vector<std::string> listFiles(const StringPiece& root);
+FileType GetFileType(const StringPiece& path);
/*
* Appends a path to `base`, separated by the directory separator.
*/
-void appendPath(std::string* base, StringPiece part);
+void AppendPath(std::string* base, StringPiece part);
/*
* Makes all the directories in `path`. The last element in the path
@@ -72,46 +66,45 @@
/**
* Returns all but the last part of the path.
*/
-StringPiece getStem(const StringPiece& path);
+StringPiece GetStem(const StringPiece& path);
/**
* Returns the last part of the path with extension.
*/
-StringPiece getFilename(const StringPiece& path);
+StringPiece GetFilename(const StringPiece& path);
/**
* Returns the extension of the path. This is the entire string after
* the first '.' of the last part of the path.
*/
-StringPiece getExtension(const StringPiece& path);
+StringPiece GetExtension(const StringPiece& path);
/**
* Converts a package name (com.android.app) to a path: com/android/app
*/
-std::string packageToPath(const StringPiece& package);
+std::string PackageToPath(const StringPiece& package);
/**
* Creates a FileMap for the file at path.
*/
-Maybe<android::FileMap> mmapPath(const StringPiece& path,
- std::string* outError);
+Maybe<android::FileMap> MmapPath(const StringPiece& path,
+ std::string* out_error);
/**
* Reads the file at path and appends each line to the outArgList vector.
*/
-bool appendArgsFromFile(const StringPiece& path,
- std::vector<std::string>* outArgList,
- std::string* outError);
+bool AppendArgsFromFile(const StringPiece& path,
+ std::vector<std::string>* out_arglist,
+ std::string* out_error);
/*
* Filter that determines which resource files/directories are
* processed by AAPT. Takes a pattern string supplied by the user.
- * Pattern format is specified in the
- * FileFilter::setPattern(const std::string&) method.
+ * Pattern format is specified in the FileFilter::SetPattern() method.
*/
class FileFilter {
public:
- explicit FileFilter(IDiagnostics* diag) : mDiag(diag) {}
+ explicit FileFilter(IDiagnostics* diag) : diag_(diag) {}
/*
* Patterns syntax:
@@ -127,7 +120,7 @@
* - Otherwise the full string is matched.
* - match is not case-sensitive.
*/
- bool setPattern(const StringPiece& pattern);
+ bool SetPattern(const StringPiece& pattern);
/**
* Applies the filter, returning true for pass, false for fail.
@@ -135,8 +128,10 @@
bool operator()(const std::string& filename, FileType type) const;
private:
- IDiagnostics* mDiag;
- std::vector<std::string> mPatternTokens;
+ DISALLOW_COPY_AND_ASSIGN(FileFilter);
+
+ IDiagnostics* diag_;
+ std::vector<std::string> pattern_tokens_;
};
} // namespace file
diff --git a/tools/aapt2/util/Files_test.cpp b/tools/aapt2/util/Files_test.cpp
index efb0459..219c183 100644
--- a/tools/aapt2/util/Files_test.cpp
+++ b/tools/aapt2/util/Files_test.cpp
@@ -14,45 +14,46 @@
* limitations under the License.
*/
-#include "test/Test.h"
#include "util/Files.h"
#include <sstream>
+#include "test/Test.h"
+
namespace aapt {
namespace file {
class FilesTest : public ::testing::Test {
-public:
- void SetUp() override {
- std::stringstream builder;
- builder << "hello" << sDirSep << "there";
- mExpectedPath = builder.str();
- }
+ public:
+ void SetUp() override {
+ std::stringstream builder;
+ builder << "hello" << sDirSep << "there";
+ expected_path_ = builder.str();
+ }
-protected:
- std::string mExpectedPath;
+ protected:
+ std::string expected_path_;
};
-TEST_F(FilesTest, appendPath) {
- std::string base = "hello";
- appendPath(&base, "there");
- EXPECT_EQ(mExpectedPath, base);
+TEST_F(FilesTest, AppendPath) {
+ std::string base = "hello";
+ AppendPath(&base, "there");
+ EXPECT_EQ(expected_path_, base);
}
-TEST_F(FilesTest, appendPathWithLeadingOrTrailingSeparators) {
- std::string base = "hello/";
- appendPath(&base, "there");
- EXPECT_EQ(mExpectedPath, base);
+TEST_F(FilesTest, AppendPathWithLeadingOrTrailingSeparators) {
+ std::string base = "hello/";
+ AppendPath(&base, "there");
+ EXPECT_EQ(expected_path_, base);
- base = "hello";
- appendPath(&base, "/there");
- EXPECT_EQ(mExpectedPath, base);
+ base = "hello";
+ AppendPath(&base, "/there");
+ EXPECT_EQ(expected_path_, base);
- base = "hello/";
- appendPath(&base, "/there");
- EXPECT_EQ(mExpectedPath, base);
+ base = "hello/";
+ AppendPath(&base, "/there");
+ EXPECT_EQ(expected_path_, base);
}
-} // namespace files
-} // namespace aapt
+} // namespace files
+} // namespace aapt
diff --git a/tools/aapt2/util/ImmutableMap.h b/tools/aapt2/util/ImmutableMap.h
index 6f48764..59858e4 100644
--- a/tools/aapt2/util/ImmutableMap.h
+++ b/tools/aapt2/util/ImmutableMap.h
@@ -17,39 +17,31 @@
#ifndef AAPT_UTIL_IMMUTABLEMAP_H
#define AAPT_UTIL_IMMUTABLEMAP_H
-#include "util/TypeTraits.h"
-
#include <utility>
#include <vector>
+#include "util/TypeTraits.h"
+
namespace aapt {
template <typename TKey, typename TValue>
class ImmutableMap {
static_assert(is_comparable<TKey, TKey>::value, "key is not comparable");
- private:
- std::vector<std::pair<TKey, TValue>> mData;
-
- explicit ImmutableMap(std::vector<std::pair<TKey, TValue>> data)
- : mData(std::move(data)) {}
-
public:
- using const_iterator = typename decltype(mData)::const_iterator;
+ using const_iterator =
+ typename std::vector<std::pair<TKey, TValue>>::const_iterator;
ImmutableMap(ImmutableMap&&) = default;
ImmutableMap& operator=(ImmutableMap&&) = default;
- ImmutableMap(const ImmutableMap&) = delete;
- ImmutableMap& operator=(const ImmutableMap&) = delete;
-
- static ImmutableMap<TKey, TValue> createPreSorted(
+ static ImmutableMap<TKey, TValue> CreatePreSorted(
std::initializer_list<std::pair<TKey, TValue>> list) {
return ImmutableMap(
std::vector<std::pair<TKey, TValue>>(list.begin(), list.end()));
}
- static ImmutableMap<TKey, TValue> createAndSort(
+ static ImmutableMap<TKey, TValue> CreateAndSort(
std::initializer_list<std::pair<TKey, TValue>> list) {
std::vector<std::pair<TKey, TValue>> data(list.begin(), list.end());
std::sort(data.begin(), data.end());
@@ -64,17 +56,25 @@
return candidate.first < target;
};
- const_iterator endIter = end();
- auto iter = std::lower_bound(mData.begin(), endIter, key, cmp);
- if (iter == endIter || iter->first == key) {
+ const_iterator end_iter = end();
+ auto iter = std::lower_bound(data_.begin(), end_iter, key, cmp);
+ if (iter == end_iter || iter->first == key) {
return iter;
}
- return endIter;
+ return end_iter;
}
- const_iterator begin() const { return mData.begin(); }
+ const_iterator begin() const { return data_.begin(); }
- const_iterator end() const { return mData.end(); }
+ const_iterator end() const { return data_.end(); }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ImmutableMap);
+
+ explicit ImmutableMap(std::vector<std::pair<TKey, TValue>> data)
+ : data_(std::move(data)) {}
+
+ std::vector<std::pair<TKey, TValue>> data_;
};
} // namespace aapt
diff --git a/tools/aapt2/util/Maybe.h b/tools/aapt2/util/Maybe.h
index 90a0198..b43f8e8 100644
--- a/tools/aapt2/util/Maybe.h
+++ b/tools/aapt2/util/Maybe.h
@@ -17,12 +17,13 @@
#ifndef AAPT_MAYBE_H
#define AAPT_MAYBE_H
-#include "util/TypeTraits.h"
-
-#include <cassert>
#include <type_traits>
#include <utility>
+#include "android-base/logging.h"
+
+#include "util/TypeTraits.h"
+
namespace aapt {
/**
@@ -88,7 +89,7 @@
*/
const T& value() const;
- T valueOrDefault(const T& def) const;
+ T value_or_default(const T& def) const;
private:
template <typename U>
@@ -102,55 +103,55 @@
void destroy();
- bool mNothing;
+ bool nothing_;
- typename std::aligned_storage<sizeof(T), alignof(T)>::type mStorage;
+ typename std::aligned_storage<sizeof(T), alignof(T)>::type storage_;
};
template <typename T>
-Maybe<T>::Maybe() : mNothing(true) {}
+Maybe<T>::Maybe() : nothing_(true) {}
template <typename T>
Maybe<T>::~Maybe() {
- if (!mNothing) {
+ if (!nothing_) {
destroy();
}
}
template <typename T>
-Maybe<T>::Maybe(const Maybe& rhs) : mNothing(rhs.mNothing) {
- if (!rhs.mNothing) {
- new (&mStorage) T(reinterpret_cast<const T&>(rhs.mStorage));
+Maybe<T>::Maybe(const Maybe& rhs) : nothing_(rhs.nothing_) {
+ if (!rhs.nothing_) {
+ new (&storage_) T(reinterpret_cast<const T&>(rhs.storage_));
}
}
template <typename T>
template <typename U>
-Maybe<T>::Maybe(const Maybe<U>& rhs) : mNothing(rhs.mNothing) {
- if (!rhs.mNothing) {
- new (&mStorage) T(reinterpret_cast<const U&>(rhs.mStorage));
+Maybe<T>::Maybe(const Maybe<U>& rhs) : nothing_(rhs.nothing_) {
+ if (!rhs.nothing_) {
+ new (&storage_) T(reinterpret_cast<const U&>(rhs.storage_));
}
}
template <typename T>
-Maybe<T>::Maybe(Maybe&& rhs) : mNothing(rhs.mNothing) {
- if (!rhs.mNothing) {
- rhs.mNothing = true;
+Maybe<T>::Maybe(Maybe&& rhs) : nothing_(rhs.nothing_) {
+ if (!rhs.nothing_) {
+ rhs.nothing_ = true;
// Move the value from rhs.
- new (&mStorage) T(std::move(reinterpret_cast<T&>(rhs.mStorage)));
+ new (&storage_) T(std::move(reinterpret_cast<T&>(rhs.storage_)));
rhs.destroy();
}
}
template <typename T>
template <typename U>
-Maybe<T>::Maybe(Maybe<U>&& rhs) : mNothing(rhs.mNothing) {
- if (!rhs.mNothing) {
- rhs.mNothing = true;
+Maybe<T>::Maybe(Maybe<U>&& rhs) : nothing_(rhs.nothing_) {
+ if (!rhs.nothing_) {
+ rhs.nothing_ = true;
// Move the value from rhs.
- new (&mStorage) T(std::move(reinterpret_cast<U&>(rhs.mStorage)));
+ new (&storage_) T(std::move(reinterpret_cast<U&>(rhs.storage_)));
rhs.destroy();
}
}
@@ -170,21 +171,21 @@
template <typename T>
template <typename U>
Maybe<T>& Maybe<T>::copy(const Maybe<U>& rhs) {
- if (mNothing && rhs.mNothing) {
+ if (nothing_ && rhs.nothing_) {
// Both are nothing, nothing to do.
return *this;
- } else if (!mNothing && !rhs.mNothing) {
+ } else if (!nothing_ && !rhs.nothing_) {
// We both are something, so assign rhs to us.
- reinterpret_cast<T&>(mStorage) = reinterpret_cast<const U&>(rhs.mStorage);
- } else if (mNothing) {
+ reinterpret_cast<T&>(storage_) = reinterpret_cast<const U&>(rhs.storage_);
+ } else if (nothing_) {
// We are nothing but rhs is something.
- mNothing = rhs.mNothing;
+ nothing_ = rhs.nothing_;
// Copy the value from rhs.
- new (&mStorage) T(reinterpret_cast<const U&>(rhs.mStorage));
+ new (&storage_) T(reinterpret_cast<const U&>(rhs.storage_));
} else {
// We are something but rhs is nothing, so destroy our value.
- mNothing = rhs.mNothing;
+ nothing_ = rhs.nothing_;
destroy();
}
return *this;
@@ -205,69 +206,69 @@
template <typename T>
template <typename U>
Maybe<T>& Maybe<T>::move(Maybe<U>&& rhs) {
- if (mNothing && rhs.mNothing) {
+ if (nothing_ && rhs.nothing_) {
// Both are nothing, nothing to do.
return *this;
- } else if (!mNothing && !rhs.mNothing) {
+ } else if (!nothing_ && !rhs.nothing_) {
// We both are something, so move assign rhs to us.
- rhs.mNothing = true;
- reinterpret_cast<T&>(mStorage) =
- std::move(reinterpret_cast<U&>(rhs.mStorage));
+ rhs.nothing_ = true;
+ reinterpret_cast<T&>(storage_) =
+ std::move(reinterpret_cast<U&>(rhs.storage_));
rhs.destroy();
- } else if (mNothing) {
+ } else if (nothing_) {
// We are nothing but rhs is something.
- mNothing = false;
- rhs.mNothing = true;
+ nothing_ = false;
+ rhs.nothing_ = true;
// Move the value from rhs.
- new (&mStorage) T(std::move(reinterpret_cast<U&>(rhs.mStorage)));
+ new (&storage_) T(std::move(reinterpret_cast<U&>(rhs.storage_)));
rhs.destroy();
} else {
// We are something but rhs is nothing, so destroy our value.
- mNothing = true;
+ nothing_ = true;
destroy();
}
return *this;
}
template <typename T>
-Maybe<T>::Maybe(const T& value) : mNothing(false) {
- new (&mStorage) T(value);
+Maybe<T>::Maybe(const T& value) : nothing_(false) {
+ new (&storage_) T(value);
}
template <typename T>
-Maybe<T>::Maybe(T&& value) : mNothing(false) {
- new (&mStorage) T(std::forward<T>(value));
+Maybe<T>::Maybe(T&& value) : nothing_(false) {
+ new (&storage_) T(std::forward<T>(value));
}
template <typename T>
Maybe<T>::operator bool() const {
- return !mNothing;
+ return !nothing_;
}
template <typename T>
T& Maybe<T>::value() {
- assert(!mNothing && "Maybe<T>::value() called on Nothing");
- return reinterpret_cast<T&>(mStorage);
+ CHECK(!nothing_) << "Maybe<T>::value() called on Nothing";
+ return reinterpret_cast<T&>(storage_);
}
template <typename T>
const T& Maybe<T>::value() const {
- assert(!mNothing && "Maybe<T>::value() called on Nothing");
- return reinterpret_cast<const T&>(mStorage);
+ CHECK(!nothing_) << "Maybe<T>::value() called on Nothing";
+ return reinterpret_cast<const T&>(storage_);
}
template <typename T>
-T Maybe<T>::valueOrDefault(const T& def) const {
- if (mNothing) {
+T Maybe<T>::value_or_default(const T& def) const {
+ if (nothing_) {
return def;
}
- return reinterpret_cast<const T&>(mStorage);
+ return reinterpret_cast<const T&>(storage_);
}
template <typename T>
void Maybe<T>::destroy() {
- reinterpret_cast<T&>(mStorage).~T();
+ reinterpret_cast<T&>(storage_).~T();
}
template <typename T>
diff --git a/tools/aapt2/util/Maybe_test.cpp b/tools/aapt2/util/Maybe_test.cpp
index 5d42dc3..ca14793 100644
--- a/tools/aapt2/util/Maybe_test.cpp
+++ b/tools/aapt2/util/Maybe_test.cpp
@@ -14,122 +14,116 @@
* limitations under the License.
*/
-#include "test/Common.h"
#include "util/Maybe.h"
-#include <gtest/gtest.h>
#include <string>
+#include "test/Test.h"
+
namespace aapt {
struct Dummy {
- Dummy() {
- data = new int;
- *data = 1;
- std::cerr << "Construct Dummy{0x" << (void *) this
- << "} with data=0x" << (void*) data
- << std::endl;
+ Dummy() {
+ data = new int;
+ *data = 1;
+ std::cerr << "Construct Dummy{0x" << (void*)this << "} with data=0x"
+ << (void*)data << std::endl;
+ }
+
+ Dummy(const Dummy& rhs) {
+ data = nullptr;
+ if (rhs.data) {
+ data = new int;
+ *data = *rhs.data;
}
+ std::cerr << "CopyConstruct Dummy{0x" << (void*)this << "} from Dummy{0x"
+ << (const void*)&rhs << "}" << std::endl;
+ }
- Dummy(const Dummy& rhs) {
- data = nullptr;
- if (rhs.data) {
- data = new int;
- *data = *rhs.data;
- }
- std::cerr << "CopyConstruct Dummy{0x" << (void *) this
- << "} from Dummy{0x" << (const void*) &rhs
- << "}" << std::endl;
+ Dummy(Dummy&& rhs) {
+ data = rhs.data;
+ rhs.data = nullptr;
+ std::cerr << "MoveConstruct Dummy{0x" << (void*)this << "} from Dummy{0x"
+ << (const void*)&rhs << "}" << std::endl;
+ }
+
+ Dummy& operator=(const Dummy& rhs) {
+ delete data;
+ data = nullptr;
+
+ if (rhs.data) {
+ data = new int;
+ *data = *rhs.data;
}
+ std::cerr << "CopyAssign Dummy{0x" << (void*)this << "} from Dummy{0x"
+ << (const void*)&rhs << "}" << std::endl;
+ return *this;
+ }
- Dummy(Dummy&& rhs) {
- data = rhs.data;
- rhs.data = nullptr;
- std::cerr << "MoveConstruct Dummy{0x" << (void *) this
- << "} from Dummy{0x" << (const void*) &rhs
- << "}" << std::endl;
- }
+ Dummy& operator=(Dummy&& rhs) {
+ delete data;
+ data = rhs.data;
+ rhs.data = nullptr;
+ std::cerr << "MoveAssign Dummy{0x" << (void*)this << "} from Dummy{0x"
+ << (const void*)&rhs << "}" << std::endl;
+ return *this;
+ }
- Dummy& operator=(const Dummy& rhs) {
- delete data;
- data = nullptr;
+ ~Dummy() {
+ std::cerr << "Destruct Dummy{0x" << (void*)this << "} with data=0x"
+ << (void*)data << std::endl;
+ delete data;
+ }
- if (rhs.data) {
- data = new int;
- *data = *rhs.data;
- }
- std::cerr << "CopyAssign Dummy{0x" << (void *) this
- << "} from Dummy{0x" << (const void*) &rhs
- << "}" << std::endl;
- return *this;
- }
-
- Dummy& operator=(Dummy&& rhs) {
- delete data;
- data = rhs.data;
- rhs.data = nullptr;
- std::cerr << "MoveAssign Dummy{0x" << (void *) this
- << "} from Dummy{0x" << (const void*) &rhs
- << "}" << std::endl;
- return *this;
- }
-
- ~Dummy() {
- std::cerr << "Destruct Dummy{0x" << (void *) this
- << "} with data=0x" << (void*) data
- << std::endl;
- delete data;
- }
-
- int* data;
+ int* data;
};
TEST(MaybeTest, MakeNothing) {
- Maybe<int> val = make_nothing<int>();
- AAPT_EXPECT_FALSE(val);
+ Maybe<int> val = make_nothing<int>();
+ AAPT_EXPECT_FALSE(val);
- Maybe<std::string> val2 = make_nothing<std::string>();
- AAPT_EXPECT_FALSE(val2);
+ Maybe<std::string> val2 = make_nothing<std::string>();
+ AAPT_EXPECT_FALSE(val2);
- val2 = make_nothing<std::string>();
- AAPT_EXPECT_FALSE(val2);
+ val2 = make_nothing<std::string>();
+ AAPT_EXPECT_FALSE(val2);
}
TEST(MaybeTest, MakeSomething) {
- Maybe<int> val = make_value(23);
- AAPT_ASSERT_TRUE(val);
- EXPECT_EQ(23, val.value());
+ Maybe<int> val = make_value(23);
+ AAPT_ASSERT_TRUE(val);
+ EXPECT_EQ(23, val.value());
- Maybe<std::string> val2 = make_value(std::string("hey"));
- AAPT_ASSERT_TRUE(val2);
- EXPECT_EQ(std::string("hey"), val2.value());
+ Maybe<std::string> val2 = make_value(std::string("hey"));
+ AAPT_ASSERT_TRUE(val2);
+ EXPECT_EQ(std::string("hey"), val2.value());
}
TEST(MaybeTest, Lifecycle) {
- Maybe<Dummy> val = make_nothing<Dummy>();
+ Maybe<Dummy> val = make_nothing<Dummy>();
- Maybe<Dummy> val2 = make_value(Dummy());
+ Maybe<Dummy> val2 = make_value(Dummy());
}
TEST(MaybeTest, MoveAssign) {
- Maybe<Dummy> val;
- {
- Maybe<Dummy> val2 = Dummy();
- val = std::move(val2);
- }
+ Maybe<Dummy> val;
+ {
+ Maybe<Dummy> val2 = Dummy();
+ val = std::move(val2);
+ }
}
TEST(MaybeTest, Equality) {
- Maybe<int> a = 1;
- Maybe<int> b = 1;
- Maybe<int> c;
+ Maybe<int> a = 1;
+ Maybe<int> b = 1;
+ Maybe<int> c;
- Maybe<int> emptyA, emptyB;
+ Maybe<int> emptyA, emptyB;
- EXPECT_EQ(a, b);
- EXPECT_EQ(b, a);
- EXPECT_NE(a, c);
- EXPECT_EQ(emptyA, emptyB);
+ EXPECT_EQ(a, b);
+ EXPECT_EQ(b, a);
+ EXPECT_NE(a, c);
+ EXPECT_EQ(emptyA, emptyB);
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/util/StringPiece.h b/tools/aapt2/util/StringPiece.h
index de93822..5144b1f 100644
--- a/tools/aapt2/util/StringPiece.h
+++ b/tools/aapt2/util/StringPiece.h
@@ -17,12 +17,13 @@
#ifndef AAPT_STRING_PIECE_H
#define AAPT_STRING_PIECE_H
-#include <utils/JenkinsHash.h>
-#include <utils/String8.h>
-#include <utils/Unicode.h>
#include <ostream>
#include <string>
+#include "utils/JenkinsHash.h"
+#include "utils/String8.h"
+#include "utils/Unicode.h"
+
namespace aapt {
/**
@@ -60,7 +61,7 @@
size_t length() const;
size_t size() const;
bool empty() const;
- std::basic_string<TChar> toString() const;
+ std::basic_string<TChar> ToString() const;
bool contains(const BasicStringPiece<TChar>& rhs) const;
int compare(const BasicStringPiece<TChar>& rhs) const;
@@ -73,8 +74,8 @@
const_iterator end() const;
private:
- const TChar* mData;
- size_t mLength;
+ const TChar* data_;
+ size_t length_;
};
using StringPiece = BasicStringPiece<char>;
@@ -89,43 +90,43 @@
template <typename TChar>
inline BasicStringPiece<TChar>::BasicStringPiece()
- : mData(nullptr), mLength(0) {}
+ : data_(nullptr), length_(0) {}
template <typename TChar>
inline BasicStringPiece<TChar>::BasicStringPiece(
const BasicStringPiece<TChar>& str)
- : mData(str.mData), mLength(str.mLength) {}
+ : data_(str.data_), length_(str.length_) {}
template <typename TChar>
inline BasicStringPiece<TChar>::BasicStringPiece(
const std::basic_string<TChar>& str)
- : mData(str.data()), mLength(str.length()) {}
+ : data_(str.data()), length_(str.length()) {}
template <>
inline BasicStringPiece<char>::BasicStringPiece(const char* str)
- : mData(str), mLength(str != nullptr ? strlen(str) : 0) {}
+ : data_(str), length_(str != nullptr ? strlen(str) : 0) {}
template <>
inline BasicStringPiece<char16_t>::BasicStringPiece(const char16_t* str)
- : mData(str), mLength(str != nullptr ? strlen16(str) : 0) {}
+ : data_(str), length_(str != nullptr ? strlen16(str) : 0) {}
template <typename TChar>
inline BasicStringPiece<TChar>::BasicStringPiece(const TChar* str, size_t len)
- : mData(str), mLength(len) {}
+ : data_(str), length_(len) {}
template <typename TChar>
inline BasicStringPiece<TChar>& BasicStringPiece<TChar>::operator=(
const BasicStringPiece<TChar>& rhs) {
- mData = rhs.mData;
- mLength = rhs.mLength;
+ data_ = rhs.data_;
+ length_ = rhs.length_;
return *this;
}
template <typename TChar>
inline BasicStringPiece<TChar>& BasicStringPiece<TChar>::assign(
const TChar* str, size_t len) {
- mData = str;
- mLength = len;
+ data_ = str;
+ length_ = len;
return *this;
}
@@ -133,13 +134,13 @@
inline BasicStringPiece<TChar> BasicStringPiece<TChar>::substr(
size_t start, size_t len) const {
if (len == npos) {
- len = mLength - start;
+ len = length_ - start;
}
- if (start > mLength || start + len > mLength) {
+ if (start > length_ || start + len > length_) {
return BasicStringPiece<TChar>();
}
- return BasicStringPiece<TChar>(mData + start, len);
+ return BasicStringPiece<TChar>(data_ + start, len);
}
template <typename TChar>
@@ -151,49 +152,49 @@
template <typename TChar>
inline const TChar* BasicStringPiece<TChar>::data() const {
- return mData;
+ return data_;
}
template <typename TChar>
inline size_t BasicStringPiece<TChar>::length() const {
- return mLength;
+ return length_;
}
template <typename TChar>
inline size_t BasicStringPiece<TChar>::size() const {
- return mLength;
+ return length_;
}
template <typename TChar>
inline bool BasicStringPiece<TChar>::empty() const {
- return mLength == 0;
+ return length_ == 0;
}
template <typename TChar>
-inline std::basic_string<TChar> BasicStringPiece<TChar>::toString() const {
- return std::basic_string<TChar>(mData, mLength);
+inline std::basic_string<TChar> BasicStringPiece<TChar>::ToString() const {
+ return std::basic_string<TChar>(data_, length_);
}
template <>
inline bool BasicStringPiece<char>::contains(
const BasicStringPiece<char>& rhs) const {
- if (!mData || !rhs.mData) {
+ if (!data_ || !rhs.data_) {
return false;
}
- if (rhs.mLength > mLength) {
+ if (rhs.length_ > length_) {
return false;
}
- return strstr(mData, rhs.mData) != nullptr;
+ return strstr(data_, rhs.data_) != nullptr;
}
template <>
inline int BasicStringPiece<char>::compare(
const BasicStringPiece<char>& rhs) const {
const char nullStr = '\0';
- const char* b1 = mData != nullptr ? mData : &nullStr;
- const char* e1 = b1 + mLength;
- const char* b2 = rhs.mData != nullptr ? rhs.mData : &nullStr;
- const char* e2 = b2 + rhs.mLength;
+ const char* b1 = data_ != nullptr ? data_ : &nullStr;
+ const char* e1 = b1 + length_;
+ const char* b2 = rhs.data_ != nullptr ? rhs.data_ : &nullStr;
+ const char* e2 = b2 + rhs.length_;
while (b1 < e1 && b2 < e2) {
const int d = static_cast<int>(*b1++) - static_cast<int>(*b2++);
@@ -201,7 +202,7 @@
return d;
}
}
- return static_cast<int>(mLength - rhs.mLength);
+ return static_cast<int>(length_ - rhs.length_);
}
inline ::std::ostream& operator<<(::std::ostream& out,
@@ -213,22 +214,22 @@
template <>
inline bool BasicStringPiece<char16_t>::contains(
const BasicStringPiece<char16_t>& rhs) const {
- if (!mData || !rhs.mData) {
+ if (!data_ || !rhs.data_) {
return false;
}
- if (rhs.mLength > mLength) {
+ if (rhs.length_ > length_) {
return false;
}
- return strstr16(mData, rhs.mData) != nullptr;
+ return strstr16(data_, rhs.data_) != nullptr;
}
template <>
inline int BasicStringPiece<char16_t>::compare(
const BasicStringPiece<char16_t>& rhs) const {
const char16_t nullStr = u'\0';
- const char16_t* b1 = mData != nullptr ? mData : &nullStr;
- const char16_t* b2 = rhs.mData != nullptr ? rhs.mData : &nullStr;
- return strzcmp16(b1, mLength, b2, rhs.mLength);
+ const char16_t* b1 = data_ != nullptr ? data_ : &nullStr;
+ const char16_t* b2 = rhs.data_ != nullptr ? rhs.data_ : &nullStr;
+ return strzcmp16(b1, length_, b2, rhs.length_);
}
template <typename TChar>
@@ -258,13 +259,13 @@
template <typename TChar>
inline typename BasicStringPiece<TChar>::const_iterator
BasicStringPiece<TChar>::begin() const {
- return mData;
+ return data_;
}
template <typename TChar>
inline typename BasicStringPiece<TChar>::const_iterator
BasicStringPiece<TChar>::end() const {
- return mData + mLength;
+ return data_ + length_;
}
inline ::std::ostream& operator<<(::std::ostream& out,
diff --git a/tools/aapt2/util/StringPiece_test.cpp b/tools/aapt2/util/StringPiece_test.cpp
index a87065a..048961d 100644
--- a/tools/aapt2/util/StringPiece_test.cpp
+++ b/tools/aapt2/util/StringPiece_test.cpp
@@ -14,81 +14,82 @@
* limitations under the License.
*/
+#include "util/StringPiece.h"
+
#include <algorithm>
-#include <gtest/gtest.h>
#include <string>
#include <vector>
-#include "util/StringPiece.h"
+#include "test/Test.h"
namespace aapt {
TEST(StringPieceTest, CompareNonNullTerminatedPiece) {
- StringPiece a("hello world", 5);
- StringPiece b("hello moon", 5);
- EXPECT_EQ(a, b);
+ StringPiece a("hello world", 5);
+ StringPiece b("hello moon", 5);
+ EXPECT_EQ(a, b);
- StringPiece16 a16(u"hello world", 5);
- StringPiece16 b16(u"hello moon", 5);
- EXPECT_EQ(a16, b16);
+ StringPiece16 a16(u"hello world", 5);
+ StringPiece16 b16(u"hello moon", 5);
+ EXPECT_EQ(a16, b16);
}
TEST(StringPieceTest, PiecesHaveCorrectSortOrder) {
- std::string testing("testing");
- std::string banana("banana");
- std::string car("car");
+ std::string testing("testing");
+ std::string banana("banana");
+ std::string car("car");
- EXPECT_TRUE(StringPiece(testing) > banana);
- EXPECT_TRUE(StringPiece(testing) > car);
- EXPECT_TRUE(StringPiece(banana) < testing);
- EXPECT_TRUE(StringPiece(banana) < car);
- EXPECT_TRUE(StringPiece(car) < testing);
- EXPECT_TRUE(StringPiece(car) > banana);
+ EXPECT_TRUE(StringPiece(testing) > banana);
+ EXPECT_TRUE(StringPiece(testing) > car);
+ EXPECT_TRUE(StringPiece(banana) < testing);
+ EXPECT_TRUE(StringPiece(banana) < car);
+ EXPECT_TRUE(StringPiece(car) < testing);
+ EXPECT_TRUE(StringPiece(car) > banana);
}
TEST(StringPieceTest, PiecesHaveCorrectSortOrderUtf8) {
- std::string testing("testing");
- std::string banana("banana");
- std::string car("car");
+ std::string testing("testing");
+ std::string banana("banana");
+ std::string car("car");
- EXPECT_TRUE(StringPiece(testing) > banana);
- EXPECT_TRUE(StringPiece(testing) > car);
- EXPECT_TRUE(StringPiece(banana) < testing);
- EXPECT_TRUE(StringPiece(banana) < car);
- EXPECT_TRUE(StringPiece(car) < testing);
- EXPECT_TRUE(StringPiece(car) > banana);
+ EXPECT_TRUE(StringPiece(testing) > banana);
+ EXPECT_TRUE(StringPiece(testing) > car);
+ EXPECT_TRUE(StringPiece(banana) < testing);
+ EXPECT_TRUE(StringPiece(banana) < car);
+ EXPECT_TRUE(StringPiece(car) < testing);
+ EXPECT_TRUE(StringPiece(car) > banana);
}
TEST(StringPieceTest, ContainsOtherStringPiece) {
- StringPiece text("I am a leaf on the wind.");
- StringPiece startNeedle("I am");
- StringPiece endNeedle("wind.");
- StringPiece middleNeedle("leaf");
- StringPiece emptyNeedle("");
- StringPiece missingNeedle("soar");
- StringPiece longNeedle("This string is longer than the text.");
+ StringPiece text("I am a leaf on the wind.");
+ StringPiece start_needle("I am");
+ StringPiece end_needle("wind.");
+ StringPiece middle_needle("leaf");
+ StringPiece empty_needle("");
+ StringPiece missing_needle("soar");
+ StringPiece long_needle("This string is longer than the text.");
- EXPECT_TRUE(text.contains(startNeedle));
- EXPECT_TRUE(text.contains(endNeedle));
- EXPECT_TRUE(text.contains(middleNeedle));
- EXPECT_TRUE(text.contains(emptyNeedle));
- EXPECT_FALSE(text.contains(missingNeedle));
- EXPECT_FALSE(text.contains(longNeedle));
+ EXPECT_TRUE(text.contains(start_needle));
+ EXPECT_TRUE(text.contains(end_needle));
+ EXPECT_TRUE(text.contains(middle_needle));
+ EXPECT_TRUE(text.contains(empty_needle));
+ EXPECT_FALSE(text.contains(missing_needle));
+ EXPECT_FALSE(text.contains(long_needle));
- StringPiece16 text16(u"I am a leaf on the wind.");
- StringPiece16 startNeedle16(u"I am");
- StringPiece16 endNeedle16(u"wind.");
- StringPiece16 middleNeedle16(u"leaf");
- StringPiece16 emptyNeedle16(u"");
- StringPiece16 missingNeedle16(u"soar");
- StringPiece16 longNeedle16(u"This string is longer than the text.");
+ StringPiece16 text16(u"I am a leaf on the wind.");
+ StringPiece16 start_needle16(u"I am");
+ StringPiece16 end_needle16(u"wind.");
+ StringPiece16 middle_needle16(u"leaf");
+ StringPiece16 empty_needle16(u"");
+ StringPiece16 missing_needle16(u"soar");
+ StringPiece16 long_needle16(u"This string is longer than the text.");
- EXPECT_TRUE(text16.contains(startNeedle16));
- EXPECT_TRUE(text16.contains(endNeedle16));
- EXPECT_TRUE(text16.contains(middleNeedle16));
- EXPECT_TRUE(text16.contains(emptyNeedle16));
- EXPECT_FALSE(text16.contains(missingNeedle16));
- EXPECT_FALSE(text16.contains(longNeedle16));
+ EXPECT_TRUE(text16.contains(start_needle16));
+ EXPECT_TRUE(text16.contains(end_needle16));
+ EXPECT_TRUE(text16.contains(middle_needle16));
+ EXPECT_TRUE(text16.contains(empty_needle16));
+ EXPECT_FALSE(text16.contains(missing_needle16));
+ EXPECT_FALSE(text16.contains(long_needle16));
}
-} // namespace aapt
+} // namespace aapt
diff --git a/tools/aapt2/util/Util.cpp b/tools/aapt2/util/Util.cpp
index b0bec62..d5c0c8a 100644
--- a/tools/aapt2/util/Util.cpp
+++ b/tools/aapt2/util/Util.cpp
@@ -14,559 +14,558 @@
* limitations under the License.
*/
+#include "util/Util.h"
#include "util/BigBuffer.h"
#include "util/Maybe.h"
#include "util/StringPiece.h"
-#include "util/Util.h"
+#include <utils/Unicode.h>
#include <algorithm>
#include <ostream>
#include <string>
-#include <utils/Unicode.h>
#include <vector>
namespace aapt {
namespace util {
-static std::vector<std::string> splitAndTransform(const StringPiece& str, char sep,
- const std::function<char(char)>& f) {
- std::vector<std::string> parts;
- const StringPiece::const_iterator end = std::end(str);
- StringPiece::const_iterator start = std::begin(str);
- StringPiece::const_iterator current;
- do {
- current = std::find(start, end, sep);
- parts.emplace_back(str.substr(start, current).toString());
- if (f) {
- std::string& part = parts.back();
- std::transform(part.begin(), part.end(), part.begin(), f);
- }
- start = current + 1;
- } while (current != end);
- return parts;
+static std::vector<std::string> SplitAndTransform(
+ const StringPiece& str, char sep, const std::function<char(char)>& f) {
+ std::vector<std::string> parts;
+ const StringPiece::const_iterator end = std::end(str);
+ StringPiece::const_iterator start = std::begin(str);
+ StringPiece::const_iterator current;
+ do {
+ current = std::find(start, end, sep);
+ parts.emplace_back(str.substr(start, current).ToString());
+ if (f) {
+ std::string& part = parts.back();
+ std::transform(part.begin(), part.end(), part.begin(), f);
+ }
+ start = current + 1;
+ } while (current != end);
+ return parts;
}
-std::vector<std::string> split(const StringPiece& str, char sep) {
- return splitAndTransform(str, sep, nullptr);
+std::vector<std::string> Split(const StringPiece& str, char sep) {
+ return SplitAndTransform(str, sep, nullptr);
}
-std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep) {
- return splitAndTransform(str, sep, ::tolower);
+std::vector<std::string> SplitAndLowercase(const StringPiece& str, char sep) {
+ return SplitAndTransform(str, sep, ::tolower);
}
-bool stringStartsWith(const StringPiece& str, const StringPiece& prefix) {
- if (str.size() < prefix.size()) {
- return false;
- }
- return str.substr(0, prefix.size()) == prefix;
+bool StartsWith(const StringPiece& str, const StringPiece& prefix) {
+ if (str.size() < prefix.size()) {
+ return false;
+ }
+ return str.substr(0, prefix.size()) == prefix;
}
-bool stringEndsWith(const StringPiece& str, const StringPiece& suffix) {
- if (str.size() < suffix.size()) {
- return false;
- }
- return str.substr(str.size() - suffix.size(), suffix.size()) == suffix;
+bool EndsWith(const StringPiece& str, const StringPiece& suffix) {
+ if (str.size() < suffix.size()) {
+ return false;
+ }
+ return str.substr(str.size() - suffix.size(), suffix.size()) == suffix;
}
-StringPiece trimWhitespace(const StringPiece& str) {
- if (str.size() == 0 || str.data() == nullptr) {
- return str;
- }
+StringPiece TrimWhitespace(const StringPiece& str) {
+ if (str.size() == 0 || str.data() == nullptr) {
+ return str;
+ }
- const char* start = str.data();
- const char* end = str.data() + str.length();
+ const char* start = str.data();
+ const char* end = str.data() + str.length();
- while (start != end && isspace(*start)) {
- start++;
- }
+ while (start != end && isspace(*start)) {
+ start++;
+ }
- while (end != start && isspace(*(end - 1))) {
- end--;
- }
+ while (end != start && isspace(*(end - 1))) {
+ end--;
+ }
- return StringPiece(start, end - start);
+ return StringPiece(start, end - start);
}
-StringPiece::const_iterator findNonAlphaNumericAndNotInSet(const StringPiece& str,
- const StringPiece& allowedChars) {
- const auto endIter = str.end();
- for (auto iter = str.begin(); iter != endIter; ++iter) {
- char c = *iter;
- if ((c >= u'a' && c <= u'z') ||
- (c >= u'A' && c <= u'Z') ||
- (c >= u'0' && c <= u'9')) {
- continue;
- }
-
- bool match = false;
- for (char i : allowedChars) {
- if (c == i) {
- match = true;
- break;
- }
- }
-
- if (!match) {
- return iter;
- }
+StringPiece::const_iterator FindNonAlphaNumericAndNotInSet(
+ const StringPiece& str, const StringPiece& allowed_chars) {
+ const auto end_iter = str.end();
+ for (auto iter = str.begin(); iter != end_iter; ++iter) {
+ char c = *iter;
+ if ((c >= u'a' && c <= u'z') || (c >= u'A' && c <= u'Z') ||
+ (c >= u'0' && c <= u'9')) {
+ continue;
}
- return endIter;
+
+ bool match = false;
+ for (char i : allowed_chars) {
+ if (c == i) {
+ match = true;
+ break;
+ }
+ }
+
+ if (!match) {
+ return iter;
+ }
+ }
+ return end_iter;
}
-bool isJavaClassName(const StringPiece& str) {
- size_t pieces = 0;
- for (const StringPiece& piece : tokenize(str, '.')) {
- pieces++;
- if (piece.empty()) {
- return false;
- }
-
- // Can't have starting or trailing $ character.
- if (piece.data()[0] == '$' || piece.data()[piece.size() - 1] == '$') {
- return false;
- }
-
- if (findNonAlphaNumericAndNotInSet(piece, "$_") != piece.end()) {
- return false;
- }
+bool IsJavaClassName(const StringPiece& str) {
+ size_t pieces = 0;
+ for (const StringPiece& piece : Tokenize(str, '.')) {
+ pieces++;
+ if (piece.empty()) {
+ return false;
}
- return pieces >= 2;
+
+ // Can't have starting or trailing $ character.
+ if (piece.data()[0] == '$' || piece.data()[piece.size() - 1] == '$') {
+ return false;
+ }
+
+ if (FindNonAlphaNumericAndNotInSet(piece, "$_") != piece.end()) {
+ return false;
+ }
+ }
+ return pieces >= 2;
}
-bool isJavaPackageName(const StringPiece& str) {
- if (str.empty()) {
- return false;
+bool IsJavaPackageName(const StringPiece& str) {
+ if (str.empty()) {
+ return false;
+ }
+
+ size_t pieces = 0;
+ for (const StringPiece& piece : Tokenize(str, '.')) {
+ pieces++;
+ if (piece.empty()) {
+ return false;
}
- size_t pieces = 0;
- for (const StringPiece& piece : tokenize(str, '.')) {
- pieces++;
- if (piece.empty()) {
- return false;
- }
-
- if (piece.data()[0] == '_' || piece.data()[piece.size() - 1] == '_') {
- return false;
- }
-
- if (findNonAlphaNumericAndNotInSet(piece, "_") != piece.end()) {
- return false;
- }
+ if (piece.data()[0] == '_' || piece.data()[piece.size() - 1] == '_') {
+ return false;
}
- return pieces >= 1;
+
+ if (FindNonAlphaNumericAndNotInSet(piece, "_") != piece.end()) {
+ return false;
+ }
+ }
+ return pieces >= 1;
}
-Maybe<std::string> getFullyQualifiedClassName(const StringPiece& package,
- const StringPiece& className) {
- if (className.empty()) {
- return {};
- }
+Maybe<std::string> GetFullyQualifiedClassName(const StringPiece& package,
+ const StringPiece& classname) {
+ if (classname.empty()) {
+ return {};
+ }
- if (util::isJavaClassName(className)) {
- return className.toString();
- }
+ if (util::IsJavaClassName(classname)) {
+ return classname.ToString();
+ }
- if (package.empty()) {
- return {};
- }
+ if (package.empty()) {
+ return {};
+ }
- std::string result(package.data(), package.size());
- if (className.data()[0] != '.') {
- result += '.';
- }
+ std::string result(package.data(), package.size());
+ if (classname.data()[0] != '.') {
+ result += '.';
+ }
- result.append(className.data(), className.size());
- if (!isJavaClassName(result)) {
- return {};
- }
- return result;
+ result.append(classname.data(), classname.size());
+ if (!IsJavaClassName(result)) {
+ return {};
+ }
+ return result;
}
-static size_t consumeDigits(const char* start, const char* end) {
- const char* c = start;
- for (; c != end && *c >= '0' && *c <= '9'; c++) {}
- return static_cast<size_t>(c - start);
+static size_t ConsumeDigits(const char* start, const char* end) {
+ const char* c = start;
+ for (; c != end && *c >= '0' && *c <= '9'; c++) {
+ }
+ return static_cast<size_t>(c - start);
}
-bool verifyJavaStringFormat(const StringPiece& str) {
- const char* c = str.begin();
- const char* const end = str.end();
+bool VerifyJavaStringFormat(const StringPiece& str) {
+ const char* c = str.begin();
+ const char* const end = str.end();
- size_t argCount = 0;
- bool nonpositional = false;
- while (c != end) {
- if (*c == '%' && c + 1 < end) {
- c++;
+ size_t arg_count = 0;
+ bool nonpositional = false;
+ while (c != end) {
+ if (*c == '%' && c + 1 < end) {
+ c++;
- if (*c == '%') {
- c++;
- continue;
- }
+ if (*c == '%') {
+ c++;
+ continue;
+ }
- argCount++;
+ arg_count++;
- size_t numDigits = consumeDigits(c, end);
- if (numDigits > 0) {
- c += numDigits;
- if (c != end && *c != '$') {
- // The digits were a size, but not a positional argument.
- nonpositional = true;
- }
- } else if (*c == '<') {
- // Reusing last argument, bad idea since positions can be moved around
- // during translation.
- nonpositional = true;
-
- c++;
-
- // Optionally we can have a $ after
- if (c != end && *c == '$') {
- c++;
- }
- } else {
- nonpositional = true;
- }
-
- // Ignore size, width, flags, etc.
- while (c != end && (*c == '-' ||
- *c == '#' ||
- *c == '+' ||
- *c == ' ' ||
- *c == ',' ||
- *c == '(' ||
- (*c >= '0' && *c <= '9'))) {
- c++;
- }
-
- /*
- * This is a shortcut to detect strings that are going to Time.format()
- * instead of String.format()
- *
- * Comparison of String.format() and Time.format() args:
- *
- * String: ABC E GH ST X abcdefgh nost x
- * Time: DEFGHKMS W Za d hkm s w yz
- *
- * Therefore we know it's definitely Time if we have:
- * DFKMWZkmwyz
- */
- if (c != end) {
- switch (*c) {
- case 'D':
- case 'F':
- case 'K':
- case 'M':
- case 'W':
- case 'Z':
- case 'k':
- case 'm':
- case 'w':
- case 'y':
- case 'z':
- return true;
- }
- }
+ size_t num_digits = ConsumeDigits(c, end);
+ if (num_digits > 0) {
+ c += num_digits;
+ if (c != end && *c != '$') {
+ // The digits were a size, but not a positional argument.
+ nonpositional = true;
}
+ } else if (*c == '<') {
+ // Reusing last argument, bad idea since positions can be moved around
+ // during translation.
+ nonpositional = true;
- if (c != end) {
- c++;
+ c++;
+
+ // Optionally we can have a $ after
+ if (c != end && *c == '$') {
+ c++;
}
+ } else {
+ nonpositional = true;
+ }
+
+ // Ignore size, width, flags, etc.
+ while (c != end && (*c == '-' || *c == '#' || *c == '+' || *c == ' ' ||
+ *c == ',' || *c == '(' || (*c >= '0' && *c <= '9'))) {
+ c++;
+ }
+
+ /*
+ * This is a shortcut to detect strings that are going to Time.format()
+ * instead of String.format()
+ *
+ * Comparison of String.format() and Time.format() args:
+ *
+ * String: ABC E GH ST X abcdefgh nost x
+ * Time: DEFGHKMS W Za d hkm s w yz
+ *
+ * Therefore we know it's definitely Time if we have:
+ * DFKMWZkmwyz
+ */
+ if (c != end) {
+ switch (*c) {
+ case 'D':
+ case 'F':
+ case 'K':
+ case 'M':
+ case 'W':
+ case 'Z':
+ case 'k':
+ case 'm':
+ case 'w':
+ case 'y':
+ case 'z':
+ return true;
+ }
+ }
}
- if (argCount > 1 && nonpositional) {
- // Multiple arguments were specified, but some or all were non positional. Translated
- // strings may rearrange the order of the arguments, which will break the string.
- return false;
+ if (c != end) {
+ c++;
}
- return true;
+ }
+
+ if (arg_count > 1 && nonpositional) {
+ // Multiple arguments were specified, but some or all were non positional.
+ // Translated
+ // strings may rearrange the order of the arguments, which will break the
+ // string.
+ return false;
+ }
+ return true;
}
-static Maybe<std::string> parseUnicodeCodepoint(const char** start, const char* end) {
- char32_t code = 0;
- for (size_t i = 0; i < 4 && *start != end; i++, (*start)++) {
- char c = **start;
- char32_t a;
- if (c >= '0' && c <= '9') {
- a = c - '0';
- } else if (c >= 'a' && c <= 'f') {
- a = c - 'a' + 10;
- } else if (c >= 'A' && c <= 'F') {
- a = c - 'A' + 10;
- } else {
- return {};
- }
- code = (code << 4) | a;
+static Maybe<std::string> ParseUnicodeCodepoint(const char** start,
+ const char* end) {
+ char32_t code = 0;
+ for (size_t i = 0; i < 4 && *start != end; i++, (*start)++) {
+ char c = **start;
+ char32_t a;
+ if (c >= '0' && c <= '9') {
+ a = c - '0';
+ } else if (c >= 'a' && c <= 'f') {
+ a = c - 'a' + 10;
+ } else if (c >= 'A' && c <= 'F') {
+ a = c - 'A' + 10;
+ } else {
+ return {};
}
+ code = (code << 4) | a;
+ }
- ssize_t len = utf32_to_utf8_length(&code, 1);
- if (len < 0) {
- return {};
- }
+ ssize_t len = utf32_to_utf8_length(&code, 1);
+ if (len < 0) {
+ return {};
+ }
- std::string resultUtf8;
- resultUtf8.resize(len);
- utf32_to_utf8(&code, 1, &*resultUtf8.begin(), len + 1);
- return resultUtf8;
+ std::string result_utf8;
+ result_utf8.resize(len);
+ utf32_to_utf8(&code, 1, &*result_utf8.begin(), len + 1);
+ return result_utf8;
}
-StringBuilder& StringBuilder::append(const StringPiece& str) {
- if (!mError.empty()) {
- return *this;
- }
-
- // Where the new data will be appended to.
- size_t newDataIndex = mStr.size();
-
- const char* const end = str.end();
- const char* start = str.begin();
- const char* current = start;
- while (current != end) {
- if (mLastCharWasEscape) {
- switch (*current) {
- case 't':
- mStr += '\t';
- break;
- case 'n':
- mStr += '\n';
- break;
- case '#':
- mStr += '#';
- break;
- case '@':
- mStr += '@';
- break;
- case '?':
- mStr += '?';
- break;
- case '"':
- mStr += '"';
- break;
- case '\'':
- mStr += '\'';
- break;
- case '\\':
- mStr += '\\';
- break;
- case 'u': {
- current++;
- Maybe<std::string> c = parseUnicodeCodepoint(¤t, end);
- if (!c) {
- mError = "invalid unicode escape sequence";
- return *this;
- }
- mStr += c.value();
- current -= 1;
- break;
- }
-
- default:
- // Ignore.
- break;
- }
- mLastCharWasEscape = false;
- start = current + 1;
- } else if (*current == '"') {
- if (!mQuote && mTrailingSpace) {
- // We found an opening quote, and we have
- // trailing space, so we should append that
- // space now.
- if (mTrailingSpace) {
- // We had trailing whitespace, so
- // replace with a single space.
- if (!mStr.empty()) {
- mStr += ' ';
- }
- mTrailingSpace = false;
- }
- }
- mQuote = !mQuote;
- mStr.append(start, current - start);
- start = current + 1;
- } else if (*current == '\'' && !mQuote) {
- // This should be escaped.
- mError = "unescaped apostrophe";
- return *this;
- } else if (*current == '\\') {
- // This is an escape sequence, convert to the real value.
- if (!mQuote && mTrailingSpace) {
- // We had trailing whitespace, so
- // replace with a single space.
- if (!mStr.empty()) {
- mStr += ' ';
- }
- mTrailingSpace = false;
- }
- mStr.append(start, current - start);
- start = current + 1;
- mLastCharWasEscape = true;
- } else if (!mQuote) {
- // This is not quoted text, so look for whitespace.
- if (isspace(*current)) {
- // We found whitespace, see if we have seen some
- // before.
- if (!mTrailingSpace) {
- // We didn't see a previous adjacent space,
- // so mark that we did.
- mTrailingSpace = true;
- mStr.append(start, current - start);
- }
-
- // Keep skipping whitespace.
- start = current + 1;
- } else if (mTrailingSpace) {
- // We saw trailing space before, so replace all
- // that trailing space with one space.
- if (!mStr.empty()) {
- mStr += ' ';
- }
- mTrailingSpace = false;
- }
- }
- current++;
- }
- mStr.append(start, end - start);
-
- // Accumulate the added string's UTF-16 length.
- ssize_t len = utf8_to_utf16_length(
- reinterpret_cast<const uint8_t*>(mStr.data()) + newDataIndex,
- mStr.size() - newDataIndex);
- if (len < 0) {
- mError = "invalid unicode code point";
- return *this;
- }
- mUtf16Len += len;
+StringBuilder& StringBuilder::Append(const StringPiece& str) {
+ if (!error_.empty()) {
return *this;
-}
+ }
-std::u16string utf8ToUtf16(const StringPiece& utf8) {
- ssize_t utf16Length = utf8_to_utf16_length(reinterpret_cast<const uint8_t*>(utf8.data()),
- utf8.length());
- if (utf16Length <= 0) {
- return {};
- }
+ // Where the new data will be appended to.
+ size_t new_data_index = str_.size();
- std::u16string utf16;
- utf16.resize(utf16Length);
- utf8_to_utf16(reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length(),
- &*utf16.begin(), utf16Length + 1);
- return utf16;
-}
-
-std::string utf16ToUtf8(const StringPiece16& utf16) {
- ssize_t utf8Length = utf16_to_utf8_length(utf16.data(), utf16.length());
- if (utf8Length <= 0) {
- return {};
- }
-
- std::string utf8;
- utf8.resize(utf8Length);
- utf16_to_utf8(utf16.data(), utf16.length(), &*utf8.begin(), utf8Length + 1);
- return utf8;
-}
-
-bool writeAll(std::ostream& out, const BigBuffer& buffer) {
- for (const auto& b : buffer) {
- if (!out.write(reinterpret_cast<const char*>(b.buffer.get()), b.size)) {
- return false;
+ const char* const end = str.end();
+ const char* start = str.begin();
+ const char* current = start;
+ while (current != end) {
+ if (last_char_was_escape_) {
+ switch (*current) {
+ case 't':
+ str_ += '\t';
+ break;
+ case 'n':
+ str_ += '\n';
+ break;
+ case '#':
+ str_ += '#';
+ break;
+ case '@':
+ str_ += '@';
+ break;
+ case '?':
+ str_ += '?';
+ break;
+ case '"':
+ str_ += '"';
+ break;
+ case '\'':
+ str_ += '\'';
+ break;
+ case '\\':
+ str_ += '\\';
+ break;
+ case 'u': {
+ current++;
+ Maybe<std::string> c = ParseUnicodeCodepoint(¤t, end);
+ if (!c) {
+ error_ = "invalid unicode escape sequence";
+ return *this;
+ }
+ str_ += c.value();
+ current -= 1;
+ break;
}
+
+ default:
+ // Ignore.
+ break;
+ }
+ last_char_was_escape_ = false;
+ start = current + 1;
+ } else if (*current == '"') {
+ if (!quote_ && trailing_space_) {
+ // We found an opening quote, and we have
+ // trailing space, so we should append that
+ // space now.
+ if (trailing_space_) {
+ // We had trailing whitespace, so
+ // replace with a single space.
+ if (!str_.empty()) {
+ str_ += ' ';
+ }
+ trailing_space_ = false;
+ }
+ }
+ quote_ = !quote_;
+ str_.append(start, current - start);
+ start = current + 1;
+ } else if (*current == '\'' && !quote_) {
+ // This should be escaped.
+ error_ = "unescaped apostrophe";
+ return *this;
+ } else if (*current == '\\') {
+ // This is an escape sequence, convert to the real value.
+ if (!quote_ && trailing_space_) {
+ // We had trailing whitespace, so
+ // replace with a single space.
+ if (!str_.empty()) {
+ str_ += ' ';
+ }
+ trailing_space_ = false;
+ }
+ str_.append(start, current - start);
+ start = current + 1;
+ last_char_was_escape_ = true;
+ } else if (!quote_) {
+ // This is not quoted text, so look for whitespace.
+ if (isspace(*current)) {
+ // We found whitespace, see if we have seen some
+ // before.
+ if (!trailing_space_) {
+ // We didn't see a previous adjacent space,
+ // so mark that we did.
+ trailing_space_ = true;
+ str_.append(start, current - start);
+ }
+
+ // Keep skipping whitespace.
+ start = current + 1;
+ } else if (trailing_space_) {
+ // We saw trailing space before, so replace all
+ // that trailing space with one space.
+ if (!str_.empty()) {
+ str_ += ' ';
+ }
+ trailing_space_ = false;
+ }
}
- return true;
+ current++;
+ }
+ str_.append(start, end - start);
+
+ // Accumulate the added string's UTF-16 length.
+ ssize_t len = utf8_to_utf16_length(
+ reinterpret_cast<const uint8_t*>(str_.data()) + new_data_index,
+ str_.size() - new_data_index);
+ if (len < 0) {
+ error_ = "invalid unicode code point";
+ return *this;
+ }
+ utf16_len_ += len;
+ return *this;
}
-std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer) {
- std::unique_ptr<uint8_t[]> data = std::unique_ptr<uint8_t[]>(new uint8_t[buffer.size()]);
- uint8_t* p = data.get();
- for (const auto& block : buffer) {
- memcpy(p, block.buffer.get(), block.size);
- p += block.size;
+std::u16string Utf8ToUtf16(const StringPiece& utf8) {
+ ssize_t utf16_length = utf8_to_utf16_length(
+ reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length());
+ if (utf16_length <= 0) {
+ return {};
+ }
+
+ std::u16string utf16;
+ utf16.resize(utf16_length);
+ utf8_to_utf16(reinterpret_cast<const uint8_t*>(utf8.data()), utf8.length(),
+ &*utf16.begin(), utf16_length + 1);
+ return utf16;
+}
+
+std::string Utf16ToUtf8(const StringPiece16& utf16) {
+ ssize_t utf8_length = utf16_to_utf8_length(utf16.data(), utf16.length());
+ if (utf8_length <= 0) {
+ return {};
+ }
+
+ std::string utf8;
+ utf8.resize(utf8_length);
+ utf16_to_utf8(utf16.data(), utf16.length(), &*utf8.begin(), utf8_length + 1);
+ return utf8;
+}
+
+bool WriteAll(std::ostream& out, const BigBuffer& buffer) {
+ for (const auto& b : buffer) {
+ if (!out.write(reinterpret_cast<const char*>(b.buffer.get()), b.size)) {
+ return false;
}
- return data;
+ }
+ return true;
+}
+
+std::unique_ptr<uint8_t[]> Copy(const BigBuffer& buffer) {
+ std::unique_ptr<uint8_t[]> data =
+ std::unique_ptr<uint8_t[]>(new uint8_t[buffer.size()]);
+ uint8_t* p = data.get();
+ for (const auto& block : buffer) {
+ memcpy(p, block.buffer.get(), block.size);
+ p += block.size;
+ }
+ return data;
}
typename Tokenizer::iterator& Tokenizer::iterator::operator++() {
- const char* start = mToken.end();
- const char* end = mStr.end();
- if (start == end) {
- mEnd = true;
- mToken.assign(mToken.end(), 0);
- return *this;
- }
-
- start += 1;
- const char* current = start;
- while (current != end) {
- if (*current == mSeparator) {
- mToken.assign(start, current - start);
- return *this;
- }
- ++current;
- }
- mToken.assign(start, end - start);
+ const char* start = token_.end();
+ const char* end = str_.end();
+ if (start == end) {
+ end_ = true;
+ token_.assign(token_.end(), 0);
return *this;
+ }
+
+ start += 1;
+ const char* current = start;
+ while (current != end) {
+ if (*current == separator_) {
+ token_.assign(start, current - start);
+ return *this;
+ }
+ ++current;
+ }
+ token_.assign(start, end - start);
+ return *this;
}
bool Tokenizer::iterator::operator==(const iterator& rhs) const {
- // We check equality here a bit differently.
- // We need to know that the addresses are the same.
- return mToken.begin() == rhs.mToken.begin() && mToken.end() == rhs.mToken.end() &&
- mEnd == rhs.mEnd;
+ // We check equality here a bit differently.
+ // We need to know that the addresses are the same.
+ return token_.begin() == rhs.token_.begin() &&
+ token_.end() == rhs.token_.end() && end_ == rhs.end_;
}
bool Tokenizer::iterator::operator!=(const iterator& rhs) const {
- return !(*this == rhs);
+ return !(*this == rhs);
}
-Tokenizer::iterator::iterator(StringPiece s, char sep, StringPiece tok, bool end) :
- mStr(s), mSeparator(sep), mToken(tok), mEnd(end) {
-}
+Tokenizer::iterator::iterator(StringPiece s, char sep, StringPiece tok,
+ bool end)
+ : str_(s), separator_(sep), token_(tok), end_(end) {}
-Tokenizer::Tokenizer(StringPiece str, char sep) :
- mBegin(++iterator(str, sep, StringPiece(str.begin() - 1, 0), false)),
- mEnd(str, sep, StringPiece(str.end(), 0), true) {
-}
+Tokenizer::Tokenizer(StringPiece str, char sep)
+ : begin_(++iterator(str, sep, StringPiece(str.begin() - 1, 0), false)),
+ end_(str, sep, StringPiece(str.end(), 0), true) {}
-bool extractResFilePathParts(const StringPiece& path, StringPiece* outPrefix,
- StringPiece* outEntry, StringPiece* outSuffix) {
- const StringPiece resPrefix("res/");
- if (!stringStartsWith(path, resPrefix)) {
- return false;
+bool ExtractResFilePathParts(const StringPiece& path, StringPiece* out_prefix,
+ StringPiece* out_entry, StringPiece* out_suffix) {
+ const StringPiece res_prefix("res/");
+ if (!StartsWith(path, res_prefix)) {
+ return false;
+ }
+
+ StringPiece::const_iterator last_occurence = path.end();
+ for (auto iter = path.begin() + res_prefix.size(); iter != path.end();
+ ++iter) {
+ if (*iter == '/') {
+ last_occurence = iter;
}
+ }
- StringPiece::const_iterator lastOccurence = path.end();
- for (auto iter = path.begin() + resPrefix.size(); iter != path.end(); ++iter) {
- if (*iter == '/') {
- lastOccurence = iter;
- }
- }
+ if (last_occurence == path.end()) {
+ return false;
+ }
- if (lastOccurence == path.end()) {
- return false;
- }
-
- auto iter = std::find(lastOccurence, path.end(), '.');
- *outSuffix = StringPiece(iter, path.end() - iter);
- *outEntry = StringPiece(lastOccurence + 1, iter - lastOccurence - 1);
- *outPrefix = StringPiece(path.begin(), lastOccurence - path.begin() + 1);
- return true;
+ auto iter = std::find(last_occurence, path.end(), '.');
+ *out_suffix = StringPiece(iter, path.end() - iter);
+ *out_entry = StringPiece(last_occurence + 1, iter - last_occurence - 1);
+ *out_prefix = StringPiece(path.begin(), last_occurence - path.begin() + 1);
+ return true;
}
-StringPiece16 getString16(const android::ResStringPool& pool, size_t idx) {
- size_t len;
- const char16_t* str = pool.stringAt(idx, &len);
- if (str != nullptr) {
- return StringPiece16(str, len);
- }
- return StringPiece16();
+StringPiece16 GetString16(const android::ResStringPool& pool, size_t idx) {
+ size_t len;
+ const char16_t* str = pool.stringAt(idx, &len);
+ if (str != nullptr) {
+ return StringPiece16(str, len);
+ }
+ return StringPiece16();
}
-std::string getString(const android::ResStringPool& pool, size_t idx) {
- size_t len;
- const char* str = pool.string8At(idx, &len);
- if (str != nullptr) {
- return std::string(str, len);
- }
- return utf16ToUtf8(getString16(pool, idx));
+std::string GetString(const android::ResStringPool& pool, size_t idx) {
+ size_t len;
+ const char* str = pool.string8At(idx, &len);
+ if (str != nullptr) {
+ return std::string(str, len);
+ }
+ return Utf16ToUtf8(GetString16(pool, idx));
}
-} // namespace util
-} // namespace aapt
+} // namespace util
+} // namespace aapt
diff --git a/tools/aapt2/util/Util.h b/tools/aapt2/util/Util.h
index 077e193..05e9cc5 100644
--- a/tools/aapt2/util/Util.h
+++ b/tools/aapt2/util/Util.h
@@ -17,40 +17,53 @@
#ifndef AAPT_UTIL_H
#define AAPT_UTIL_H
-#include "util/BigBuffer.h"
-#include "util/Maybe.h"
-#include "util/StringPiece.h"
-
-#include <androidfw/ResourceTypes.h>
#include <functional>
#include <memory>
#include <ostream>
#include <string>
#include <vector>
+#include "androidfw/ResourceTypes.h"
+#include "utils/ByteOrder.h"
+
+#include "util/BigBuffer.h"
+#include "util/Maybe.h"
+#include "util/StringPiece.h"
+
+#ifdef _WIN32
+// TODO(adamlesinski): remove once http://b/32447322 is resolved.
+// utils/ByteOrder.h includes winsock2.h on WIN32,
+// which will pull in the ERROR definition. This conflicts
+// with android-base/logging.h, which takes care of undefining
+// ERROR, but it gets included too early (before winsock2.h).
+#ifdef ERROR
+#undef ERROR
+#endif
+#endif
+
namespace aapt {
namespace util {
-std::vector<std::string> split(const StringPiece& str, char sep);
-std::vector<std::string> splitAndLowercase(const StringPiece& str, char sep);
+std::vector<std::string> Split(const StringPiece& str, char sep);
+std::vector<std::string> SplitAndLowercase(const StringPiece& str, char sep);
/**
* Returns true if the string starts with prefix.
*/
-bool stringStartsWith(const StringPiece& str, const StringPiece& prefix);
+bool StartsWith(const StringPiece& str, const StringPiece& prefix);
/**
* Returns true if the string ends with suffix.
*/
-bool stringEndsWith(const StringPiece& str, const StringPiece& suffix);
+bool EndsWith(const StringPiece& str, const StringPiece& suffix);
/**
* Creates a new StringPiece16 that points to a substring
* of the original string without leading or trailing whitespace.
*/
-StringPiece trimWhitespace(const StringPiece& str);
+StringPiece TrimWhitespace(const StringPiece& str);
-StringPiece trimWhitespace(const StringPiece& str);
+StringPiece TrimWhitespace(const StringPiece& str);
/**
* UTF-16 isspace(). It basically checks for lower range characters that are
@@ -62,18 +75,18 @@
* Returns an iterator to the first character that is not alpha-numeric and that
* is not in the allowedChars set.
*/
-StringPiece::const_iterator findNonAlphaNumericAndNotInSet(
- const StringPiece& str, const StringPiece& allowedChars);
+StringPiece::const_iterator FindNonAlphaNumericAndNotInSet(
+ const StringPiece& str, const StringPiece& allowed_chars);
/**
* Tests that the string is a valid Java class name.
*/
-bool isJavaClassName(const StringPiece& str);
+bool IsJavaClassName(const StringPiece& str);
/**
* Tests that the string is a valid Java package name.
*/
-bool isJavaPackageName(const StringPiece& str);
+bool IsJavaPackageName(const StringPiece& str);
/**
* Converts the class name to a fully qualified class name from the given
@@ -84,8 +97,8 @@
* .a.b --> package.a.b
* asdf.adsf --> asdf.adsf
*/
-Maybe<std::string> getFullyQualifiedClassName(const StringPiece& package,
- const StringPiece& className);
+Maybe<std::string> GetFullyQualifiedClassName(const StringPiece& package,
+ const StringPiece& class_name);
/**
* Makes a std::unique_ptr<> with the template parameter inferred by the
@@ -103,15 +116,15 @@
* separator.
*/
template <typename Container>
-::std::function<::std::ostream&(::std::ostream&)> joiner(
+::std::function<::std::ostream&(::std::ostream&)> Joiner(
const Container& container, const char* sep) {
using std::begin;
using std::end;
- const auto beginIter = begin(container);
- const auto endIter = end(container);
- return [beginIter, endIter, sep](::std::ostream& out) -> ::std::ostream& {
- for (auto iter = beginIter; iter != endIter; ++iter) {
- if (iter != beginIter) {
+ const auto begin_iter = begin(container);
+ const auto end_iter = end(container);
+ return [begin_iter, end_iter, sep](::std::ostream& out) -> ::std::ostream& {
+ for (auto iter = begin_iter; iter != end_iter; ++iter) {
+ if (iter != begin_iter) {
out << sep;
}
out << *iter;
@@ -120,31 +133,12 @@
};
}
-inline ::std::function<::std::ostream&(::std::ostream&)> formatSize(
- size_t size) {
- return [size](::std::ostream& out) -> ::std::ostream& {
- constexpr size_t K = 1024u;
- constexpr size_t M = K * K;
- constexpr size_t G = M * K;
- if (size < K) {
- out << size << "B";
- } else if (size < M) {
- out << (double(size) / K) << " KiB";
- } else if (size < G) {
- out << (double(size) / M) << " MiB";
- } else {
- out << (double(size) / G) << " GiB";
- }
- return out;
- };
-}
-
/**
* Helper method to extract a UTF-16 string from a StringPool. If the string is
* stored as UTF-8,
* the conversion to UTF-16 happens within ResStringPool.
*/
-StringPiece16 getString16(const android::ResStringPool& pool, size_t idx);
+StringPiece16 GetString16(const android::ResStringPool& pool, size_t idx);
/**
* Helper method to extract a UTF-8 string from a StringPool. If the string is
@@ -154,7 +148,7 @@
* which maintains no state or cache. This means we must return an std::string
* copy.
*/
-std::string getString(const android::ResStringPool& pool, size_t idx);
+std::string GetString(const android::ResStringPool& pool, size_t idx);
/**
* Checks that the Java string format contains no non-positional arguments
@@ -165,53 +159,53 @@
* which will
* break the string interpolation.
*/
-bool verifyJavaStringFormat(const StringPiece& str);
+bool VerifyJavaStringFormat(const StringPiece& str);
class StringBuilder {
public:
- StringBuilder& append(const StringPiece& str);
- const std::string& str() const;
- const std::string& error() const;
+ StringBuilder& Append(const StringPiece& str);
+ const std::string& ToString() const;
+ const std::string& Error() const;
// When building StyledStrings, we need UTF-16 indices into the string,
// which is what the Java layer expects when dealing with java
// String.charAt().
- size_t utf16Len() const;
+ size_t Utf16Len() const;
- operator bool() const;
+ explicit operator bool() const;
private:
- std::string mStr;
- size_t mUtf16Len = 0;
- bool mQuote = false;
- bool mTrailingSpace = false;
- bool mLastCharWasEscape = false;
- std::string mError;
+ std::string str_;
+ size_t utf16_len_ = 0;
+ bool quote_ = false;
+ bool trailing_space_ = false;
+ bool last_char_was_escape_ = false;
+ std::string error_;
};
-inline const std::string& StringBuilder::str() const { return mStr; }
+inline const std::string& StringBuilder::ToString() const { return str_; }
-inline const std::string& StringBuilder::error() const { return mError; }
+inline const std::string& StringBuilder::Error() const { return error_; }
-inline size_t StringBuilder::utf16Len() const { return mUtf16Len; }
+inline size_t StringBuilder::Utf16Len() const { return utf16_len_; }
-inline StringBuilder::operator bool() const { return mError.empty(); }
+inline StringBuilder::operator bool() const { return error_.empty(); }
/**
* Converts a UTF8 string to a UTF16 string.
*/
-std::u16string utf8ToUtf16(const StringPiece& utf8);
-std::string utf16ToUtf8(const StringPiece16& utf16);
+std::u16string Utf8ToUtf16(const StringPiece& utf8);
+std::string Utf16ToUtf8(const StringPiece16& utf16);
/**
* Writes the entire BigBuffer to the output stream.
*/
-bool writeAll(std::ostream& out, const BigBuffer& buffer);
+bool WriteAll(std::ostream& out, const BigBuffer& buffer);
/*
* Copies the entire BigBuffer into a single buffer.
*/
-std::unique_ptr<uint8_t[]> copy(const BigBuffer& buffer);
+std::unique_ptr<uint8_t[]> Copy(const BigBuffer& buffer);
/**
* A Tokenizer implemented as an iterable collection. It does not allocate
@@ -226,7 +220,7 @@
iterator& operator++();
- StringPiece operator*() { return mToken; }
+ StringPiece operator*() { return token_; }
bool operator==(const iterator& rhs) const;
bool operator!=(const iterator& rhs) const;
@@ -235,34 +229,34 @@
iterator(StringPiece s, char sep, StringPiece tok, bool end);
- StringPiece mStr;
- char mSeparator;
- StringPiece mToken;
- bool mEnd;
+ StringPiece str_;
+ char separator_;
+ StringPiece token_;
+ bool end_;
};
Tokenizer(StringPiece str, char sep);
- iterator begin() { return mBegin; }
+ iterator begin() { return begin_; }
- iterator end() { return mEnd; }
+ iterator end() { return end_; }
private:
- const iterator mBegin;
- const iterator mEnd;
+ const iterator begin_;
+ const iterator end_;
};
-inline Tokenizer tokenize(const StringPiece& str, char sep) {
+inline Tokenizer Tokenize(const StringPiece& str, char sep) {
return Tokenizer(str, sep);
}
-inline uint16_t hostToDevice16(uint16_t value) { return htods(value); }
+inline uint16_t HostToDevice16(uint16_t value) { return htods(value); }
-inline uint32_t hostToDevice32(uint32_t value) { return htodl(value); }
+inline uint32_t HostToDevice32(uint32_t value) { return htodl(value); }
-inline uint16_t deviceToHost16(uint16_t value) { return dtohs(value); }
+inline uint16_t DeviceToHost16(uint16_t value) { return dtohs(value); }
-inline uint32_t deviceToHost32(uint32_t value) { return dtohl(value); }
+inline uint32_t DeviceToHost32(uint32_t value) { return dtohl(value); }
/**
* Given a path like: res/xml-sw600dp/foo.xml
@@ -273,8 +267,8 @@
*
* Returns true if successful.
*/
-bool extractResFilePathParts(const StringPiece& path, StringPiece* outPrefix,
- StringPiece* outEntry, StringPiece* outSuffix);
+bool ExtractResFilePathParts(const StringPiece& path, StringPiece* out_prefix,
+ StringPiece* out_entry, StringPiece* out_suffix);
} // namespace util
diff --git a/tools/aapt2/util/Util_test.cpp b/tools/aapt2/util/Util_test.cpp
index 0e27213..cac3de4 100644
--- a/tools/aapt2/util/Util_test.cpp
+++ b/tools/aapt2/util/Util_test.cpp
@@ -14,191 +14,196 @@
* limitations under the License.
*/
-#include "test/Test.h"
-#include "util/StringPiece.h"
#include "util/Util.h"
#include <string>
+#include "test/Test.h"
+
namespace aapt {
TEST(UtilTest, TrimOnlyWhitespace) {
- const std::string full = "\n ";
+ const std::string full = "\n ";
- StringPiece trimmed = util::trimWhitespace(full);
- EXPECT_TRUE(trimmed.empty());
- EXPECT_EQ(0u, trimmed.size());
+ StringPiece trimmed = util::TrimWhitespace(full);
+ EXPECT_TRUE(trimmed.empty());
+ EXPECT_EQ(0u, trimmed.size());
}
TEST(UtilTest, StringEndsWith) {
- EXPECT_TRUE(util::stringEndsWith("hello.xml", ".xml"));
+ EXPECT_TRUE(util::EndsWith("hello.xml", ".xml"));
}
TEST(UtilTest, StringStartsWith) {
- EXPECT_TRUE(util::stringStartsWith("hello.xml", "he"));
+ EXPECT_TRUE(util::StartsWith("hello.xml", "he"));
}
TEST(UtilTest, StringBuilderSplitEscapeSequence) {
- EXPECT_EQ(StringPiece("this is a new\nline."),
- util::StringBuilder().append("this is a new\\")
- .append("nline.")
- .str());
+ EXPECT_EQ(StringPiece("this is a new\nline."), util::StringBuilder()
+ .Append("this is a new\\")
+ .Append("nline.")
+ .ToString());
}
TEST(UtilTest, StringBuilderWhitespaceRemoval) {
- EXPECT_EQ(StringPiece("hey guys this is so cool"),
- util::StringBuilder().append(" hey guys ")
- .append(" this is so cool ")
- .str());
+ EXPECT_EQ(StringPiece("hey guys this is so cool"),
+ util::StringBuilder()
+ .Append(" hey guys ")
+ .Append(" this is so cool ")
+ .ToString());
- EXPECT_EQ(StringPiece(" wow, so many \t spaces. what?"),
- util::StringBuilder().append(" \" wow, so many \t ")
- .append("spaces. \"what? ")
- .str());
+ EXPECT_EQ(StringPiece(" wow, so many \t spaces. what?"),
+ util::StringBuilder()
+ .Append(" \" wow, so many \t ")
+ .Append("spaces. \"what? ")
+ .ToString());
- EXPECT_EQ(StringPiece("where is the pie?"),
- util::StringBuilder().append(" where \t ")
- .append(" \nis the "" pie?")
- .str());
+ EXPECT_EQ(StringPiece("where is the pie?"), util::StringBuilder()
+ .Append(" where \t ")
+ .Append(" \nis the "
+ " pie?")
+ .ToString());
}
TEST(UtilTest, StringBuilderEscaping) {
- EXPECT_EQ(StringPiece("hey guys\n this \t is so\\ cool"),
- util::StringBuilder().append(" hey guys\\n ")
- .append(" this \\t is so\\\\ cool ")
- .str());
+ EXPECT_EQ(StringPiece("hey guys\n this \t is so\\ cool"),
+ util::StringBuilder()
+ .Append(" hey guys\\n ")
+ .Append(" this \\t is so\\\\ cool ")
+ .ToString());
- EXPECT_EQ(StringPiece("@?#\\\'"),
- util::StringBuilder().append("\\@\\?\\#\\\\\\'")
- .str());
+ EXPECT_EQ(StringPiece("@?#\\\'"),
+ util::StringBuilder().Append("\\@\\?\\#\\\\\\'").ToString());
}
TEST(UtilTest, StringBuilderMisplacedQuote) {
- util::StringBuilder builder{};
- EXPECT_FALSE(builder.append("they're coming!"));
+ util::StringBuilder builder{};
+ EXPECT_FALSE(builder.Append("they're coming!"));
}
TEST(UtilTest, StringBuilderUnicodeCodes) {
- EXPECT_EQ(std::string("\u00AF\u0AF0 woah"),
- util::StringBuilder().append("\\u00AF\\u0AF0 woah")
- .str());
+ EXPECT_EQ(std::string("\u00AF\u0AF0 woah"),
+ util::StringBuilder().Append("\\u00AF\\u0AF0 woah").ToString());
- EXPECT_FALSE(util::StringBuilder().append("\\u00 yo"));
+ EXPECT_FALSE(util::StringBuilder().Append("\\u00 yo"));
}
TEST(UtilTest, TokenizeInput) {
- auto tokenizer = util::tokenize(StringPiece("this| is|the|end"), '|');
- auto iter = tokenizer.begin();
- ASSERT_EQ(*iter, StringPiece("this"));
- ++iter;
- ASSERT_EQ(*iter, StringPiece(" is"));
- ++iter;
- ASSERT_EQ(*iter, StringPiece("the"));
- ++iter;
- ASSERT_EQ(*iter, StringPiece("end"));
- ++iter;
- ASSERT_EQ(tokenizer.end(), iter);
+ auto tokenizer = util::Tokenize(StringPiece("this| is|the|end"), '|');
+ auto iter = tokenizer.begin();
+ ASSERT_EQ(*iter, StringPiece("this"));
+ ++iter;
+ ASSERT_EQ(*iter, StringPiece(" is"));
+ ++iter;
+ ASSERT_EQ(*iter, StringPiece("the"));
+ ++iter;
+ ASSERT_EQ(*iter, StringPiece("end"));
+ ++iter;
+ ASSERT_EQ(tokenizer.end(), iter);
}
TEST(UtilTest, TokenizeEmptyString) {
- auto tokenizer = util::tokenize(StringPiece(""), '|');
- auto iter = tokenizer.begin();
- ASSERT_NE(tokenizer.end(), iter);
- ASSERT_EQ(StringPiece(), *iter);
- ++iter;
- ASSERT_EQ(tokenizer.end(), iter);
+ auto tokenizer = util::Tokenize(StringPiece(""), '|');
+ auto iter = tokenizer.begin();
+ ASSERT_NE(tokenizer.end(), iter);
+ ASSERT_EQ(StringPiece(), *iter);
+ ++iter;
+ ASSERT_EQ(tokenizer.end(), iter);
}
TEST(UtilTest, TokenizeAtEnd) {
- auto tokenizer = util::tokenize(StringPiece("one."), '.');
- auto iter = tokenizer.begin();
- ASSERT_EQ(*iter, StringPiece("one"));
- ++iter;
- ASSERT_NE(iter, tokenizer.end());
- ASSERT_EQ(*iter, StringPiece());
+ auto tokenizer = util::Tokenize(StringPiece("one."), '.');
+ auto iter = tokenizer.begin();
+ ASSERT_EQ(*iter, StringPiece("one"));
+ ++iter;
+ ASSERT_NE(iter, tokenizer.end());
+ ASSERT_EQ(*iter, StringPiece());
}
TEST(UtilTest, IsJavaClassName) {
- EXPECT_TRUE(util::isJavaClassName("android.test.Class"));
- EXPECT_TRUE(util::isJavaClassName("android.test.Class$Inner"));
- EXPECT_TRUE(util::isJavaClassName("android_test.test.Class"));
- EXPECT_TRUE(util::isJavaClassName("_android_.test._Class_"));
- EXPECT_FALSE(util::isJavaClassName("android.test.$Inner"));
- EXPECT_FALSE(util::isJavaClassName("android.test.Inner$"));
- EXPECT_FALSE(util::isJavaClassName(".test.Class"));
- EXPECT_FALSE(util::isJavaClassName("android"));
+ EXPECT_TRUE(util::IsJavaClassName("android.test.Class"));
+ EXPECT_TRUE(util::IsJavaClassName("android.test.Class$Inner"));
+ EXPECT_TRUE(util::IsJavaClassName("android_test.test.Class"));
+ EXPECT_TRUE(util::IsJavaClassName("_android_.test._Class_"));
+ EXPECT_FALSE(util::IsJavaClassName("android.test.$Inner"));
+ EXPECT_FALSE(util::IsJavaClassName("android.test.Inner$"));
+ EXPECT_FALSE(util::IsJavaClassName(".test.Class"));
+ EXPECT_FALSE(util::IsJavaClassName("android"));
}
TEST(UtilTest, IsJavaPackageName) {
- EXPECT_TRUE(util::isJavaPackageName("android"));
- EXPECT_TRUE(util::isJavaPackageName("android.test"));
- EXPECT_TRUE(util::isJavaPackageName("android.test_thing"));
- EXPECT_FALSE(util::isJavaPackageName("_android"));
- EXPECT_FALSE(util::isJavaPackageName("android_"));
- EXPECT_FALSE(util::isJavaPackageName("android."));
- EXPECT_FALSE(util::isJavaPackageName(".android"));
- EXPECT_FALSE(util::isJavaPackageName("android._test"));
- EXPECT_FALSE(util::isJavaPackageName(".."));
+ EXPECT_TRUE(util::IsJavaPackageName("android"));
+ EXPECT_TRUE(util::IsJavaPackageName("android.test"));
+ EXPECT_TRUE(util::IsJavaPackageName("android.test_thing"));
+ EXPECT_FALSE(util::IsJavaPackageName("_android"));
+ EXPECT_FALSE(util::IsJavaPackageName("android_"));
+ EXPECT_FALSE(util::IsJavaPackageName("android."));
+ EXPECT_FALSE(util::IsJavaPackageName(".android"));
+ EXPECT_FALSE(util::IsJavaPackageName("android._test"));
+ EXPECT_FALSE(util::IsJavaPackageName(".."));
}
TEST(UtilTest, FullyQualifiedClassName) {
- Maybe<std::string> res = util::getFullyQualifiedClassName("android", ".asdf");
- AAPT_ASSERT_TRUE(res);
- EXPECT_EQ(res.value(), "android.asdf");
+ Maybe<std::string> res = util::GetFullyQualifiedClassName("android", ".asdf");
+ AAPT_ASSERT_TRUE(res);
+ EXPECT_EQ(res.value(), "android.asdf");
- res = util::getFullyQualifiedClassName("android", ".a.b");
- AAPT_ASSERT_TRUE(res);
- EXPECT_EQ(res.value(), "android.a.b");
+ res = util::GetFullyQualifiedClassName("android", ".a.b");
+ AAPT_ASSERT_TRUE(res);
+ EXPECT_EQ(res.value(), "android.a.b");
- res = util::getFullyQualifiedClassName("android", "a.b");
- AAPT_ASSERT_TRUE(res);
- EXPECT_EQ(res.value(), "a.b");
+ res = util::GetFullyQualifiedClassName("android", "a.b");
+ AAPT_ASSERT_TRUE(res);
+ EXPECT_EQ(res.value(), "a.b");
- res = util::getFullyQualifiedClassName("", "a.b");
- AAPT_ASSERT_TRUE(res);
- EXPECT_EQ(res.value(), "a.b");
+ res = util::GetFullyQualifiedClassName("", "a.b");
+ AAPT_ASSERT_TRUE(res);
+ EXPECT_EQ(res.value(), "a.b");
- res = util::getFullyQualifiedClassName("android", "Class");
- AAPT_ASSERT_TRUE(res);
- EXPECT_EQ(res.value(), "android.Class");
+ res = util::GetFullyQualifiedClassName("android", "Class");
+ AAPT_ASSERT_TRUE(res);
+ EXPECT_EQ(res.value(), "android.Class");
- res = util::getFullyQualifiedClassName("", "");
- AAPT_ASSERT_FALSE(res);
+ res = util::GetFullyQualifiedClassName("", "");
+ AAPT_ASSERT_FALSE(res);
- res = util::getFullyQualifiedClassName("android", "./Apple");
- AAPT_ASSERT_FALSE(res);
+ res = util::GetFullyQualifiedClassName("android", "./Apple");
+ AAPT_ASSERT_FALSE(res);
}
TEST(UtilTest, ExtractResourcePathComponents) {
- StringPiece prefix, entry, suffix;
- ASSERT_TRUE(util::extractResFilePathParts("res/xml-sw600dp/entry.xml", &prefix, &entry,
- &suffix));
- EXPECT_EQ(prefix, "res/xml-sw600dp/");
- EXPECT_EQ(entry, "entry");
- EXPECT_EQ(suffix, ".xml");
+ StringPiece prefix, entry, suffix;
+ ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.xml",
+ &prefix, &entry, &suffix));
+ EXPECT_EQ(prefix, "res/xml-sw600dp/");
+ EXPECT_EQ(entry, "entry");
+ EXPECT_EQ(suffix, ".xml");
- ASSERT_TRUE(util::extractResFilePathParts("res/xml-sw600dp/entry.9.png", &prefix, &entry,
- &suffix));
+ ASSERT_TRUE(util::ExtractResFilePathParts("res/xml-sw600dp/entry.9.png",
+ &prefix, &entry, &suffix));
- EXPECT_EQ(prefix, "res/xml-sw600dp/");
- EXPECT_EQ(entry, "entry");
- EXPECT_EQ(suffix, ".9.png");
+ EXPECT_EQ(prefix, "res/xml-sw600dp/");
+ EXPECT_EQ(entry, "entry");
+ EXPECT_EQ(suffix, ".9.png");
- EXPECT_FALSE(util::extractResFilePathParts("AndroidManifest.xml", &prefix, &entry, &suffix));
- EXPECT_FALSE(util::extractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
+ EXPECT_FALSE(util::ExtractResFilePathParts("AndroidManifest.xml", &prefix,
+ &entry, &suffix));
+ EXPECT_FALSE(
+ util::ExtractResFilePathParts("res/.xml", &prefix, &entry, &suffix));
- ASSERT_TRUE(util::extractResFilePathParts("res//.", &prefix, &entry, &suffix));
- EXPECT_EQ(prefix, "res//");
- EXPECT_EQ(entry, "");
- EXPECT_EQ(suffix, ".");
+ ASSERT_TRUE(
+ util::ExtractResFilePathParts("res//.", &prefix, &entry, &suffix));
+ EXPECT_EQ(prefix, "res//");
+ EXPECT_EQ(entry, "");
+ EXPECT_EQ(suffix, ".");
}
TEST(UtilTest, VerifyJavaStringFormat) {
- ASSERT_TRUE(util::verifyJavaStringFormat("%09.34f"));
- ASSERT_TRUE(util::verifyJavaStringFormat("%9$.34f %8$"));
- ASSERT_TRUE(util::verifyJavaStringFormat("%% %%"));
- ASSERT_FALSE(util::verifyJavaStringFormat("%09$f %f"));
- ASSERT_FALSE(util::verifyJavaStringFormat("%09f %08s"));
+ ASSERT_TRUE(util::VerifyJavaStringFormat("%09.34f"));
+ ASSERT_TRUE(util::VerifyJavaStringFormat("%9$.34f %8$"));
+ ASSERT_TRUE(util::VerifyJavaStringFormat("%% %%"));
+ ASSERT_FALSE(util::VerifyJavaStringFormat("%09$f %f"));
+ ASSERT_FALSE(util::VerifyJavaStringFormat("%09f %08s"));
}
-} // namespace aapt
+} // namespace aapt
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