e4bb9eb5af
This allows us to preserve the various product definitions during the compile phase, and allows us to select the product in the link phase. This allows compiled files to remain product-independent, so that they do not need to be recompiled when switching targets. Bug:25958912 Change-Id: Iaa7eed25c834b67a39cdc9be43613e8b5ab6cdd7
260 lines
9.1 KiB
C++
260 lines
9.1 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#include "ResourceTable.h"
|
|
#include "ResourceValues.h"
|
|
#include "ValueVisitor.h"
|
|
#include "compile/PseudolocaleGenerator.h"
|
|
#include "compile/Pseudolocalizer.h"
|
|
|
|
namespace aapt {
|
|
|
|
std::unique_ptr<StyledString> pseudolocalizeStyledString(StyledString* string,
|
|
Pseudolocalizer::Method method,
|
|
StringPool* pool) {
|
|
Pseudolocalizer localizer(method);
|
|
|
|
const StringPiece16 originalText = *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 });
|
|
}
|
|
|
|
// The ranges are all represented with a single value. This is the start of one range and
|
|
// end of another.
|
|
struct Range {
|
|
size_t start;
|
|
|
|
// Once the new string is localized, these are the pointers to the spans to adjust.
|
|
// 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;
|
|
};
|
|
|
|
auto cmp = [](const Range& r, size_t index) -> bool {
|
|
return r.start < index;
|
|
};
|
|
|
|
// Construct the ranges. The ranges are represented like so: [0, 2, 5, 7]
|
|
// The ranges are the spaces in between. In this example, with a total string length of 9,
|
|
// the vector represents: (0,1], (2,4], (5,6], (7,9]
|
|
//
|
|
std::vector<Range> ranges;
|
|
ranges.push_back(Range{ 0 });
|
|
ranges.push_back(Range{ originalText.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;
|
|
} else {
|
|
ranges.insert(iter,
|
|
Range{ span.firstChar, &localized.spans[i].firstChar, 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;
|
|
} else {
|
|
ranges.insert(iter,
|
|
Range{ span.lastChar, nullptr, &localized.spans[i].lastChar });
|
|
}
|
|
}
|
|
|
|
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;
|
|
if (i + 1 < ranges.size()) {
|
|
len = ranges[i + 1].start - start;
|
|
}
|
|
|
|
if (ranges[i].updateStart) {
|
|
*ranges[i].updateStart = localized.str.size();
|
|
}
|
|
|
|
if (ranges[i].updateEnd) {
|
|
*ranges[i].updateEnd = localized.str.size();
|
|
}
|
|
|
|
localized.str += localizer.text(originalText.substr(start, len));
|
|
}
|
|
|
|
localized.str += localizer.end();
|
|
|
|
std::unique_ptr<StyledString> localizedString = util::make_unique<StyledString>(
|
|
pool->makeRef(localized));
|
|
localizedString->setSource(string->getSource());
|
|
return localizedString;
|
|
}
|
|
|
|
namespace {
|
|
|
|
struct Visitor : public RawValueVisitor {
|
|
StringPool* mPool;
|
|
Pseudolocalizer::Method mMethod;
|
|
Pseudolocalizer mLocalizer;
|
|
|
|
// Either value or item will be populated upon visiting the value.
|
|
std::unique_ptr<Value> mValue;
|
|
std::unique_ptr<Item> mItem;
|
|
|
|
Visitor(StringPool* pool, Pseudolocalizer::Method method) :
|
|
mPool(pool), mMethod(method), mLocalizer(method) {
|
|
}
|
|
|
|
void visit(Array* array) override {
|
|
std::unique_ptr<Array> localized = util::make_unique<Array>();
|
|
localized->items.resize(array->items.size());
|
|
for (size_t i = 0; i < array->items.size(); i++) {
|
|
Visitor subVisitor(mPool, mMethod);
|
|
array->items[i]->accept(&subVisitor);
|
|
if (subVisitor.mItem) {
|
|
localized->items[i] = std::move(subVisitor.mItem);
|
|
} else {
|
|
localized->items[i] = std::unique_ptr<Item>(array->items[i]->clone(mPool));
|
|
}
|
|
}
|
|
localized->setSource(array->getSource());
|
|
localized->setWeak(true);
|
|
mValue = std::move(localized);
|
|
}
|
|
|
|
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);
|
|
if (plural->values[i]) {
|
|
plural->values[i]->accept(&subVisitor);
|
|
if (subVisitor.mValue) {
|
|
localized->values[i] = std::move(subVisitor.mItem);
|
|
} else {
|
|
localized->values[i] = std::unique_ptr<Item>(plural->values[i]->clone(mPool));
|
|
}
|
|
}
|
|
}
|
|
localized->setSource(plural->getSource());
|
|
localized->setWeak(true);
|
|
mValue = std::move(localized);
|
|
}
|
|
|
|
void visit(String* string) override {
|
|
if (!string->isTranslateable()) {
|
|
return;
|
|
}
|
|
|
|
std::u16string result = mLocalizer.start() + mLocalizer.text(*string->value) +
|
|
mLocalizer.end();
|
|
std::unique_ptr<String> localized = util::make_unique<String>(mPool->makeRef(result));
|
|
localized->setSource(string->getSource());
|
|
localized->setWeak(true);
|
|
mItem = std::move(localized);
|
|
}
|
|
|
|
void visit(StyledString* string) override {
|
|
if (!string->isTranslateable()) {
|
|
return;
|
|
}
|
|
|
|
mItem = pseudolocalizeStyledString(string, mMethod, mPool);
|
|
mItem->setWeak(true);
|
|
}
|
|
};
|
|
|
|
ConfigDescription modifyConfigForPseudoLocale(const ConfigDescription& base,
|
|
Pseudolocalizer::Method m) {
|
|
ConfigDescription modified = base;
|
|
switch (m) {
|
|
case Pseudolocalizer::Method::kAccent:
|
|
modified.language[0] = 'e';
|
|
modified.language[1] = 'n';
|
|
modified.country[0] = 'X';
|
|
modified.country[1] = 'A';
|
|
break;
|
|
|
|
case Pseudolocalizer::Method::kBidi:
|
|
modified.language[0] = 'a';
|
|
modified.language[1] = 'r';
|
|
modified.country[0] = 'X';
|
|
modified.country[1] = 'B';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return modified;
|
|
}
|
|
|
|
void pseudolocalizeIfNeeded(const Pseudolocalizer::Method method,
|
|
ResourceConfigValue* originalValue,
|
|
StringPool* pool,
|
|
ResourceEntry* entry) {
|
|
Visitor visitor(pool, method);
|
|
originalValue->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);
|
|
}
|
|
|
|
if (!localizedValue) {
|
|
return;
|
|
}
|
|
|
|
ConfigDescription configWithAccent = modifyConfigForPseudoLocale(
|
|
originalValue->config, method);
|
|
|
|
ResourceConfigValue* newConfigValue = entry->findOrCreateValue(
|
|
configWithAccent, originalValue->product);
|
|
if (!newConfigValue->value) {
|
|
// Only use auto-generated pseudo-localization if none is defined.
|
|
newConfigValue->value = std::move(localizedValue);
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
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->findAllValues(
|
|
ConfigDescription::defaultConfig());
|
|
for (ResourceConfigValue* value : values) {
|
|
pseudolocalizeIfNeeded(Pseudolocalizer::Method::kAccent, value,
|
|
&table->stringPool, entry.get());
|
|
pseudolocalizeIfNeeded(Pseudolocalizer::Method::kBidi, value,
|
|
&table->stringPool, entry.get());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace aapt
|