Storing regex match data

yeshjho · yeshjho · commit 1f458b14d23d · 2024-06-06T22:44:20.000+09:00
diff --git a/Typoon/match/trigger_tree.cpp b/Typoon/match/trigger_tree.cpp
@@ -79,6 +79,12 @@ std::strong_ordering Letter::operator<=>(const Letter& other) const
 }
 
 
+RegexPattern::~RegexPattern()
+{
+    pcre2_code_free(mPattern);
+}
+
+
 TriggerTree::TriggerTree(std::filesystem::path matchFile, std::vector<std::filesystem::path> includes, std::vector<std::filesystem::path> excludes)
     : mMatchFile(std::move(matchFile))
     , mIncludes(std::move(includes))
@@ -166,7 +172,10 @@ void TriggerTree::Reconstruct(std::string_view matchesString, std::function<void
         };
         // TODO: Warn about empty triggers or replaces
 
+        mRegexMatches.clear();
+
         /// First iteration. Construct the tree, preprocessing the data to be easy to use.
+        /// Regex matches will be fully processed here.
         TempNode root;
         std::vector<std::pair<const Match*, const std::wstring*>> triggersOverwritten;
         for (const Match& match : matchesFiltered)
@@ -293,14 +302,14 @@ void TriggerTree::Reconstruct(std::string_view matchesString, std::function<void
                     logger.Log(ELogLevel::ERROR, std::format(L"Regex compilation failed: {}\n"
                                                                 "File: {}, Original Trigger: {}, After Preprocess: {}, Error Offset: {}",
                         errMsg, mMatchFile.generic_wstring(), regexTrigger, triggerStr, errOffset));
-
+                    // TODO: Notification
                     pcre2_code_free(pattern);
                     continue;
                 }
 
                 pcre2_jit_compile(pattern, PCRE2_JIT_COMPLETE);  // Don't care if it failed or not. It'll automatically fallback to non-jit if so.
 
-                // TODO: Store
+                mRegexMatches.emplace_back(pattern, doNeedFullComposite, replaceType, replaceStr, doKeepComposite);
 
                 STOP
                 continue;
@@ -479,6 +488,7 @@ void TriggerTree::Reconstruct(std::string_view matchesString, std::function<void
             STOP
         }
 
+        mHasRegexMatches = !mRegexMatches.empty();
         mTreeHeight = height;
         mIsConstructingTriggerTree.store(false);
         if (onFinish && !didCallOnFinish)
@@ -545,6 +555,11 @@ void TriggerTree::OnInput(const InputMessage(&inputs)[MAX_INPUT_COUNT], int leng
         mAgents.reserve(mTreeHeight);
         mNextIterationAgents.reserve(mTreeHeight);
         mStroke.resize(std::max(mTreeHeight, 1U), 0);
+        if (mHasRegexMatches)
+        {
+            mStrokeForRegex.clear();
+            mStrokeForRegex.resize(std::max(get_config().maxStrokeLengthForRegex, 1), 0);
+        }
         mRootAgent = { &mTree.front(), static_cast<int>(mTreeHeight) };
     }
 
@@ -562,6 +577,7 @@ void TriggerTree::OnInput(const InputMessage(&inputs)[MAX_INPUT_COUNT], int leng
     if (length >= 0 && inputs[0].letter == L'\b')
     {
         std::ranges::shift_right(mStroke, 1);
+        std::ranges::shift_right(mStrokeForRegex, 1);
 
         // The input size is bigger than 1 only if letters are composed in the imm simulator.
         // But a backspace can't be used to finish composing(other than clearing one completely),
@@ -645,6 +661,15 @@ void TriggerTree::OnInput(const InputMessage(&inputs)[MAX_INPUT_COUNT], int leng
             return false;
         };
 
+    const auto lambdaCheckRegexMatches = [this, length, inputs](wchar_t inputLetter, bool isBeingComposed, int inputIndex)
+        {
+            for (const auto& [pattern, doNeedFullComposite, replaceType, replaceStr, doKeepComposite] : mRegexMatches)
+            {
+            }
+
+            return false;
+        };
+
     for (int i = 0; i < length; i++)
     {
         const auto [inputLetter, isBeingComposed] = inputs[i];
@@ -653,6 +678,22 @@ void TriggerTree::OnInput(const InputMessage(&inputs)[MAX_INPUT_COUNT], int leng
         {
             std::ranges::shift_left(mStroke, 1);
             mStroke.back() = inputLetter;
+
+            if (mHasRegexMatches)
+            {
+                if (L'가' <= inputLetter && inputLetter <= L'힣')
+                {
+                    std::wstring normalized = Letter::COMPOSITE_ENCLOSURE + normalize_hangeul(std::wstring_view{ &inputLetter, 1 }) + Letter::COMPOSITE_ENCLOSURE;
+                    const size_t size = normalized.size();
+                    std::ranges::shift_left(mStrokeForRegex, size);
+                    normalized.copy(&*(mStrokeForRegex.end() - size), size);
+                }
+                else
+                {
+                    std::ranges::shift_left(mStrokeForRegex, 1);
+                    mStrokeForRegex.back() = inputLetter;
+                }
+            }
         }
 
         // Check for triggers in the root node first.
@@ -669,6 +710,11 @@ void TriggerTree::OnInput(const InputMessage(&inputs)[MAX_INPUT_COUNT], int leng
             }
         }
 
+        if (!isTriggerFound)
+        {
+            isTriggerFound = lambdaCheckRegexMatches(inputLetter, isBeingComposed, i);
+        }
+
         if (isTriggerFound)
         {
             mNextIterationAgents.clear();
@@ -692,7 +738,7 @@ void TriggerTree::OnInput(const InputMessage(&inputs)[MAX_INPUT_COUNT], int leng
 void TriggerTree::replaceString(const Ending& ending, const Agent& agent, std::wstring_view stroke, 
     const InputMessage(&inputs)[MAX_INPUT_COUNT], int inputLength, int inputIndex, bool doNeedFullComposite)
 {
-    const auto& [replaceStringIndex, replaceType, replaceStringLength, backspaceCount, cursorMoveCount,
+    const auto& [replaceType, replaceStringIndex, replaceStringLength, backspaceCount, cursorMoveCount,
         propagateCase, uppercaseStyle, keepComposite] = ending;
 
     const std::wstring_view originalReplaceString{ mReplaceStrings.data() + replaceStringIndex, replaceStringLength };
diff --git a/Typoon/match/trigger_tree.h b/Typoon/match/trigger_tree.h
@@ -70,17 +70,48 @@ struct Ending
         COMMAND,
     };
 
-    int replaceStringIndex = -1;
     EReplaceType type = EReplaceType::TEXT;
+    int replaceStringIndex = -1;
     unsigned int replaceStringLength = 0;
-    unsigned int backspaceCount = 0;  // If it's a regex match, need to calculate this after substitution.
-    unsigned int cursorMoveCount = 0;  // If it's a regex match, need to calculate this after substitution.
+    unsigned int backspaceCount = 0;
+    unsigned int cursorMoveCount = 0;
     bool propagateCase = false;  // Won't be true if the first letter is not cased.
     Match::EUppercaseStyle uppercaseStyle = Match::EUppercaseStyle::FIRST_LETTER;  // Only used if `propagateCase` is true.
     bool keepComposite = false;  // Won't be true if the letter is not Korean or need full composite.
 };
 
 
+class pcre2_real_code_16;
+
+class RegexPattern
+{
+public:
+    RegexPattern(pcre2_real_code_16* pattern) : mPattern(pattern) {}
+    ~RegexPattern();
+    RegexPattern(const RegexPattern& other) = default;
+    RegexPattern(RegexPattern&& other) noexcept = default;
+    RegexPattern& operator=(const RegexPattern& other) = default;
+    RegexPattern& operator=(RegexPattern&& other) noexcept = default;
+
+    operator pcre2_real_code_16* () const noexcept { return mPattern; }
+
+
+private:
+    pcre2_real_code_16* mPattern = nullptr;
+};
+
+
+struct RegexMatch
+{
+    RegexPattern pattern = nullptr;
+    bool needFullComposite = false;
+
+    Ending::EReplaceType type = Ending::EReplaceType::TEXT;
+    std::wstring replaceString;
+    bool keepComposite = false;
+};
+
+
 // The agents for tracking the current possible triggers.
 struct Agent
 {
@@ -131,13 +162,17 @@ class TriggerTree
     std::vector<Ending> mEndings;
     std::wstring mReplaceStrings;
 
-    std::vector<Agent> mAgents{};
-    std::vector<Agent> mNextIterationAgents{};
-    std::deque<DeadAgent> mDeadAgents{};
-    std::wstring mStroke{};
+    std::vector<Agent> mAgents;
+    std::vector<Agent> mNextIterationAgents;
+    std::deque<DeadAgent> mDeadAgents;
+    std::wstring mStroke;
     bool mShouldResetAgents = false;
     Agent mRootAgent;
 
+    bool mHasRegexMatches = false;
+    std::vector<RegexMatch> mRegexMatches;
+    std::wstring mStrokeForRegex;
+
     std::atomic<bool> mIsTriggerTreeOutdated = true;
     std::atomic<bool> mIsConstructingTriggerTree = false;
 
diff --git a/Typoon/utils/config.cpp b/Typoon/utils/config.cpp
@@ -68,6 +68,7 @@ struct ConfigForParse
     std::string cursor_placeholder = "|_|";
     std::string regex_composite_start = ">>";
     std::string regex_composite_end = "<<";
+    int max_stroke_length_for_regex = 50;
 
     bool notify_config_load = true;
     bool notify_match_load = true;
@@ -86,6 +87,7 @@ struct ConfigForParse
             { cursor_placeholder.begin(), cursor_placeholder.end() },
             { regex_composite_start.begin(), regex_composite_start.end() },
             { regex_composite_end.begin(), regex_composite_end.end() },
+            max_stroke_length_for_regex,
             notify_config_load,
             notify_match_load,
             notify_on_off,
@@ -104,7 +106,7 @@ struct ConfigForParse
 };
 
 
-JSON5_CLASS(ConfigForParse, match_file_path, max_backspace_count, cursor_placeholder, regex_composite_start, regex_composite_end,
+JSON5_CLASS(ConfigForParse, match_file_path, max_backspace_count, cursor_placeholder, regex_composite_start, regex_composite_end, max_stroke_length_for_regex,
     notify_config_load, notify_match_load, notify_on_off, hotkey_toggle_on_off, hotkey_get_program_name, program_overrides)
 
 Config config;
diff --git a/Typoon/utils/config.h b/Typoon/utils/config.h
@@ -23,6 +23,7 @@ struct Config
     std::wstring cursorPlaceholder;
     std::wstring regexCompositeStart;
     std::wstring regexCompositeEnd;
+    int maxStrokeLengthForRegex;
 
     bool notifyConfigLoad;
     bool notifyMatchLoad;
