Textractor/extensions/replacer.cpp

143 lines
4.0 KiB
C++
Raw Permalink Normal View History

2019-01-23 16:11:14 -05:00
#include "extension.h"
2020-02-13 02:16:21 -07:00
#include "trie.h"
#include "charstorage.h"
2019-01-23 16:11:14 -05:00
#include <cwctype>
#include <fstream>
2019-01-24 08:32:21 -05:00
#include <filesystem>
#include <process.h>
2019-01-23 16:11:14 -05:00
2019-02-27 11:33:17 -05:00
extern const wchar_t* REPLACER_INSTRUCTIONS;
2019-07-03 18:02:32 +05:30
2019-02-18 23:12:12 -05:00
constexpr auto REPLACE_SAVE_FILE = u8"SavedReplacements.txt";
2019-07-03 18:02:32 +05:30
std::atomic<std::filesystem::file_time_type> replaceFileLastWrite = {};
2019-02-28 01:40:40 -05:00
std::shared_mutex m;
2019-01-23 16:11:14 -05:00
2020-02-13 02:16:21 -07:00
class ReplacementTrie
2019-01-23 16:11:14 -05:00
{
public:
2020-02-13 02:16:21 -07:00
ReplacementTrie(std::vector<std::pair<std::wstring, std::wstring>> replacements)
2019-01-23 16:11:14 -05:00
{
2020-02-13 02:16:21 -07:00
for (auto& [original, replacement] : replacements)
if (!original.empty())
trie.Insert(std::wstring_view(original.c_str(), std::remove_if(original.begin(), original.end(), Ignore) - original.begin()))->SetValue(storage.Store(replacement));
2019-01-23 16:11:14 -05:00
}
2019-07-03 18:02:32 +05:30
std::wstring Replace(const std::wstring& sentence) const
2019-01-23 16:11:14 -05:00
{
2019-07-03 18:02:32 +05:30
std::wstring result;
for (int i = 0; i < sentence.size();)
{
std::wstring_view replacement(sentence.c_str() + i, 1);
2019-07-03 18:02:32 +05:30
int originalLength = 1;
2020-02-13 02:16:21 -07:00
auto current = trie.Root();
for (int j = i; current && j <= sentence.size(); ++j)
{
2020-02-13 02:16:21 -07:00
if (const wchar_t* tail = current->Tail())
for (; j <= sentence.size() && *tail; ++j)
if (Ignore(sentence[j]));
else if (sentence[j] == *tail) ++tail;
else goto doneSearchingTrie;
if (int* value = current->Value())
2019-07-03 18:02:32 +05:30
{
2020-02-13 02:16:21 -07:00
replacement = storage.Retrieve(*value);
2019-07-03 18:02:32 +05:30
originalLength = j - i;
}
2020-02-13 02:16:21 -07:00
if (!Ignore(sentence[j])) current = trie.Next(current, sentence[j]);
}
2020-02-13 02:16:21 -07:00
doneSearchingTrie:
2019-07-03 18:02:32 +05:30
result += replacement;
i += originalLength;
}
return result;
2019-01-23 16:11:14 -05:00
}
bool Empty()
{
2020-02-13 02:16:21 -07:00
return trie.Root()->charMap.empty();
}
2019-01-23 16:11:14 -05:00
private:
2019-02-17 19:14:49 -05:00
static bool Ignore(wchar_t ch)
2019-01-23 16:11:14 -05:00
{
2019-02-17 19:14:49 -05:00
return ch <= 0x20 || std::iswspace(ch);
2019-01-23 16:11:14 -05:00
}
2020-02-13 02:16:21 -07:00
CharStorage<wchar_t> storage;
Trie<wchar_t, int> trie;
2019-07-03 18:02:32 +05:30
} trie = { {} };
2019-01-23 16:11:14 -05:00
2020-02-13 02:16:21 -07:00
std::vector<std::pair<std::wstring, std::wstring>> Parse(std::wstring_view replacementScript)
2019-01-23 16:11:14 -05:00
{
2020-02-13 02:16:21 -07:00
std::vector<std::pair<std::wstring, std::wstring>> replacements;
for (size_t end = 0; ;)
2019-01-23 16:11:14 -05:00
{
2019-07-03 18:02:32 +05:30
size_t original = replacementScript.find(L"|ORIG|", end);
size_t becomes = replacementScript.find(L"|BECOMES|", original);
if ((end = replacementScript.find(L"|END|", becomes)) == std::wstring::npos) break;
2020-02-13 02:16:21 -07:00
replacements.emplace_back(replacementScript.substr(original + 6, becomes - original - 6), replacementScript.substr(becomes + 9, end - becomes - 9));
2019-02-20 22:14:32 -05:00
}
2019-07-03 18:02:32 +05:30
return replacements;
2019-01-23 16:11:14 -05:00
}
void UpdateReplacements()
{
try
{
if (replaceFileLastWrite.exchange(std::filesystem::last_write_time(REPLACE_SAVE_FILE)) == std::filesystem::last_write_time(REPLACE_SAVE_FILE)) return;
std::vector<BYTE> file(std::istreambuf_iterator(std::ifstream(REPLACE_SAVE_FILE, std::ios::binary)), {});
std::scoped_lock l(m);
2020-02-13 02:16:21 -07:00
trie = ReplacementTrie(Parse({ (wchar_t*)file.data(), file.size() / sizeof(wchar_t) }));
}
catch (std::filesystem::filesystem_error) { replaceFileLastWrite.store({}); }
}
2019-01-23 16:11:14 -05:00
BOOL WINAPI DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
UpdateReplacements();
if (trie.Empty())
2019-01-24 08:32:21 -05:00
{
2019-09-09 22:08:24 -04:00
auto file = std::ofstream(REPLACE_SAVE_FILE, std::ios::binary) << "\xff\xfe";
for (auto ch : std::wstring_view(REPLACER_INSTRUCTIONS)) file << (ch == L'\n' ? std::string_view("\r\0\n", 4) : std::string_view((char*)&ch, 2));
2019-01-24 08:32:21 -05:00
_spawnlp(_P_DETACH, "notepad", "notepad", REPLACE_SAVE_FILE, NULL); // show file to user
}
2019-01-23 16:11:14 -05:00
}
break;
case DLL_PROCESS_DETACH:
{
}
break;
}
return TRUE;
}
bool ProcessSentence(std::wstring& sentence, SentenceInfo)
{
UpdateReplacements();
2019-01-24 08:32:21 -05:00
2019-07-03 18:02:32 +05:30
std::shared_lock l(m);
sentence = trie.Replace(sentence);
return true;
2019-01-23 16:11:14 -05:00
}
2019-07-03 18:02:32 +05:30
TEST(
2019-01-23 16:11:14 -05:00
{
2019-07-03 18:02:32 +05:30
auto replacements = Parse(LR"(
|ORIG||BECOMES|goodbye |END|Ignore this text
And this text   
2019-01-23 16:11:14 -05:00
|ORIG||BECOMES|idiot|END|
2019-07-03 18:02:32 +05:30
|ORIG| |BECOMES| hello|END||ORIG|delete this|BECOMES||END|)");
assert(replacements.size() == 4);
std::wstring original = LR"(Don't replace this 
delete this)";
2020-02-13 02:16:21 -07:00
std::wstring replaced = ReplacementTrie(std::move(replacements)).Replace(original);
2019-07-03 18:02:32 +05:30
assert(replaced == L"Don't replace thisgoodbye idiot hello");
2019-01-23 16:11:14 -05:00
}
);