184 lines
7.2 KiB
C++
184 lines
7.2 KiB
C++
/*
|
|
Copyright 2015-2018 Amebis
|
|
|
|
This file is part of ZRCola.
|
|
|
|
ZRCola is free software: you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
ZRCola is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with ZRCola. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
|
|
void ZRCola::translation_db::Translate(_In_ transetid_t set, _In_z_count_(inputMax) const wchar_t* input, _In_ size_t inputMax, _Out_ std::wstring &output, _Out_opt_ std::vector<mapping>* map) const
|
|
{
|
|
assert(input || inputMax == 0);
|
|
|
|
// Trim inputMax to actual length.
|
|
inputMax = inputMax != (size_t)-1 ? wcsnlen(input, inputMax) : wcslen(input);
|
|
|
|
// Clear the output.
|
|
output.clear();
|
|
output.reserve(inputMax);
|
|
if (map)
|
|
map->clear();
|
|
|
|
// Limit search to the given set first.
|
|
indexSrc::size_type l_set, r_set;
|
|
idxSrc.find(translation(set ), l_set);
|
|
idxSrc.find(translation(set + 1), r_set);
|
|
|
|
for (size_t i = 0; i < inputMax;) {
|
|
// Find the longest matching translation at i-th character.
|
|
size_t l_match = (size_t)-1;
|
|
for (size_t l = l_set, r = r_set, ii = i, j = 0; ii < inputMax && l < r; ii++, j++) {
|
|
wchar_t c = input[ii];
|
|
while (l < r) {
|
|
// Test the translation in the middle of the search area.
|
|
size_t m = (l + r) / 2;
|
|
|
|
// Get the j-th character of the translation.
|
|
// All translations that get short on characters are lexically ordered before.
|
|
// Thus the j-th character is considered 0.
|
|
wchar_t s = idxSrc[m].src_at(j);
|
|
|
|
// Do the bisection test.
|
|
if (c < s) r = m;
|
|
else if (s < c) l = m + 1;
|
|
else {
|
|
// Character found.
|
|
|
|
// Narrow the search area on the left to start at the first translation in the run.
|
|
for (size_t r2 = m; l < r2;) {
|
|
size_t m2 = (l + r2) / 2;
|
|
if (c <= idxSrc[m2].src_at(j)) r2 = m2; else l = m2 + 1;
|
|
}
|
|
|
|
// Narrow the search area on the right to end at the first translation not in the run.
|
|
for (size_t l2 = m + 1; l2 < r;) {
|
|
size_t m2 = (l2 + r) / 2;
|
|
if (idxSrc[m2].src_at(j) <= c) l2 = m2 + 1; else r = m2;
|
|
}
|
|
|
|
if (j + 1 == idxSrc[l].src_len()) {
|
|
// The first translation of the run was a match (thus far). Save it.
|
|
l_match = l;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (l_match < r_set) {
|
|
// The saved translation was an exact match.
|
|
const translation &trans = idxSrc[l_match];
|
|
output.append(trans.dst(), trans.dst_end());
|
|
i += trans.src_len();
|
|
if (trans.src_len() != trans.dst_len() && map) {
|
|
// Mapping changed.
|
|
map->push_back(ZRCola::mapping(i, output.length()));
|
|
}
|
|
} else {
|
|
// The match was not found.
|
|
output += input[i];
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ZRCola::translation_db::TranslateInv(_In_ transetid_t set, _In_z_count_(inputMax) const wchar_t* input, _In_ size_t inputMax, _In_ const langchar_db *lc_db, _In_ langid_t lang, _Out_ std::wstring &output, _Out_opt_ std::vector<mapping>* map) const
|
|
{
|
|
assert(input || inputMax == 0);
|
|
|
|
// Trim inputMax to actual length.
|
|
inputMax = inputMax != (size_t)-1 ? wcsnlen(input, inputMax) : wcslen(input);
|
|
|
|
// Clear the output.
|
|
output.clear();
|
|
output.reserve(inputMax);
|
|
if (map)
|
|
map->clear();
|
|
|
|
// Limit search to the given set first.
|
|
indexDst::size_type l_set, r_set;
|
|
idxDst.find(translation(set ), l_set);
|
|
idxDst.find(translation(set + 1), r_set);
|
|
|
|
for (size_t i = 0; i < inputMax;) {
|
|
// Find the longest matching inverse translation at i-th character.
|
|
size_t l_match = (size_t)-1;
|
|
for (size_t l = l_set, r = r_set, ii = i, j = 0; ii < inputMax && l < r; ii++, j++) {
|
|
wchar_t c = input[ii];
|
|
while (l < r) {
|
|
// Test the inverse translation in the middle of the search area.
|
|
size_t m = (l + r) / 2;
|
|
|
|
// Get the j-th character of the inverse translation.
|
|
// All inverse translations that get short on characters are lexically ordered before.
|
|
// Thus the j-th character is considered 0.
|
|
wchar_t s = idxDst[m].dst_at(j);
|
|
|
|
// Do the bisection test.
|
|
if (c < s) r = m;
|
|
else if (s < c) l = m + 1;
|
|
else {
|
|
// Character found.
|
|
|
|
// Narrow the search area on the left to start at the first inverse translation in the run.
|
|
for (size_t r2 = m; l < r2;) {
|
|
size_t m2 = (l + r2) / 2;
|
|
if (c <= idxDst[m2].dst_at(j)) r2 = m2; else l = m2 + 1;
|
|
}
|
|
|
|
// Narrow the search area on the right to end at the first inverse translation not in the run.
|
|
for (size_t l2 = m + 1; l2 < r;) {
|
|
size_t m2 = (l2 + r) / 2;
|
|
if (idxDst[m2].dst_at(j) <= c) l2 = m2 + 1; else r = m2;
|
|
}
|
|
|
|
if (j + 1 == idxDst[l].dst_len()) {
|
|
// The first inverse translation of the run was a match (thus far). Save it.
|
|
l_match = l;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (l_match < r_set) {
|
|
// The saved inverse translation was an exact match.
|
|
const translation &trans = idxDst[l_match];
|
|
if (trans.src_len() && trans.src()[0] != L'#' && (!lc_db || !lc_db->IsLocalCharacter(trans.dst(), trans.dst_end(), lang))) {
|
|
// Append source sequence.
|
|
output.append(trans.src(), trans.src_end());
|
|
i += trans.dst_len();
|
|
if (trans.dst_len() != trans.src_len() && map) {
|
|
// Mapping changed.
|
|
map->push_back(ZRCola::mapping(i, output.length()));
|
|
}
|
|
} else {
|
|
// Character is inhibited to inverse translate.
|
|
output.append(trans.dst(), trans.dst_end());
|
|
i += trans.dst_len();
|
|
}
|
|
} else {
|
|
// The match was not found.
|
|
output += input[i];
|
|
i++;
|
|
}
|
|
}
|
|
}
|