fixed id cschimg in LanguageManager; limited Stack in UndoRedoManager

Author: daddel80

src/LanguageManager.cpp

@@ -24,6 +24,31 @@
 #include <windows.h>
 #include <map>
 
+namespace {
+
+    // Build a cache key from id + placeholders.
+    static std::wstring makeKey(const std::wstring& id,
+        const std::vector<std::wstring>& repl)
+    {
+        // Use a rarely used unit separator as delimiter.
+        std::wstring key = id;
+        key.push_back(L'\x1F');
+        for (const auto& r : repl) {
+            key += r;
+            key.push_back(L'\x1F');
+        }
+        return key;
+    }
+
+    // Global cache holder for getLPCW(); single instance per process.
+    static std::unordered_map<std::wstring, std::wstring>& lpcwCache()
+    {
+        static std::unordered_map<std::wstring, std::wstring> cache;
+        return cache;
+    }
+
+}
+
 // -----------------------------------------------------------------
 // Singleton
 // -----------------------------------------------------------------
@@ -59,69 +84,99 @@ bool LanguageManager::loadFromIni(const std::wstring& iniFile,
         return false;
 
     const auto& data = _cache.raw();
-    // 2) override with requested language
     if (auto it = data.find(languageCode); it != data.end())
         for (const auto& kv : it->second)
             _table[kv.first] = kv.second;
 
+    invalidateCaches(); // Clear derived caches after language change
     return true;
 }
 
+void LanguageManager::invalidateCaches()
+{
+    lpcwCache().clear();
+}
+
 // -----------------------------------------------------------------
 // String getters
 // -----------------------------------------------------------------
+// Replace <br/>, then $REPLACE_n (descending), then $REPLACE.
 std::wstring LanguageManager::get(const std::wstring& id,
     const std::vector<std::wstring>& repl) const
 {
     auto it = _table.find(id);
-    if (it == _table.end()) return L"Text not found";
+    if (it == _table.end())
+        return id; // developer-friendly fallback: show missing key
 
     std::wstring result = it->second;
     const std::wstring base = L"$REPLACE_STRING";
 
-    // <br/>  →  CRLF
+    // 1) Replace <br/> with CRLF (all occurrences)
     for (size_t p = result.find(L"<br/>");
         p != std::wstring::npos;
         p = result.find(L"<br/>", p))
+    {
         result.replace(p, 5, L"\r\n");
+        p += 2; // advance beyond inserted CRLF to avoid re-scan at same spot
+    }
+
+    // 2) Numbered placeholders: $REPLACE_STRING1, $REPLACE_STRING2, ... (highest index first)
+    for (size_t i = repl.size(); i > 0; --i)
+    {
+        const std::wstring ph = base + std::to_wstring(i);
+        const std::wstring& val = repl[i - 1];
 
-    // numbered placeholders (highest first)
-    for (size_t i = repl.size(); i > 0; --i) {
-        std::wstring ph = base + std::to_wstring(i);
         for (size_t p = result.find(ph);
             p != std::wstring::npos;
             p = result.find(ph, p))
-            result.replace(p, ph.size(), repl[i - 1]);
+        {
+            result.replace(p, ph.size(), val);
+            p += val.size(); // skip over inserted text
+        }
     }
 
-    // plain $REPLACE_STRING
-    for (size_t p = result.find(base);
-        p != std::wstring::npos;
-        p = result.find(base, p))
-        result.replace(p, base.size(),
-            repl.empty() ? L"" : repl[0]);
+    // 3) Plain $REPLACE_STRING -> repl[0] (empty if not provided)
+    {
+        const std::wstring& val = repl.empty() ? std::wstring() : repl[0];
+
+        for (size_t p = result.find(base);
+            p != std::wstring::npos;
+            p = result.find(base, p))
+        {
+            result.replace(p, base.size(), val);
+            p += val.size(); // skip over inserted text
+        }
+    }
 
     return result;
 }
 
+
 LPCWSTR LanguageManager::getLPCW(const std::wstring& id,
     const std::vector<std::wstring>& repl) const
 {
-    static std::map<std::wstring, std::wstring> cache;
-    auto& ref = cache[id];
-    if (ref.empty())
-        ref = get(id, repl);
-    return ref.c_str();
+    // Cache per (id + repl) to avoid wrong reuse for different placeholders.
+    auto& cache = lpcwCache();
+    const std::wstring key = makeKey(id, repl);
+
+    auto it = cache.find(key);
+    if (it == cache.end())
+        it = cache.emplace(key, get(id, repl)).first;
+
+    return it->second.c_str();
 }
 
+
 LPWSTR LanguageManager::getLPW(const std::wstring& id,
     const std::vector<std::wstring>& repl) const
 {
-    static std::wstring buf;
+    // Use a thread-local buffer to avoid data races and overwrite issues.
+    thread_local std::wstring buf;
     buf = get(id, repl);
-    return &buf[0];
+    return buf.empty() ? nullptr : &buf[0];
 }
 
+
 // -----------------------------------------------------------------
 // Detect active language from Notepad++ nativeLang.xml
 // -----------------------------------------------------------------

src/LanguageManager.h

@@ -69,6 +69,7 @@ class LanguageManager
     LanguageManager& operator=(const LanguageManager&) = delete;
 
     static std::wstring detectLanguage(const std::wstring& nativeLangXmlPath);
+    void invalidateCaches();
 
     IniFileCache _cache;                               // languages.ini only
     std::unordered_map<std::wstring, std::wstring> _table;   // id → text

src/ResultDock.cpp

@@ -614,7 +614,6 @@ void ResultDock::applyTheme()
     S(SCI_SETCARETLINEBACK, theme.caretLineBg, 0);
     S(SCI_SETCARETLINEBACKALPHA, theme.caretLineAlpha);
 
-
     // Line background indicator
     S(SCI_INDICSETSTYLE, INDIC_LINE_BACKGROUND, INDIC_HIDDEN);
 

src/UndoRedoManager.cpp

@@ -39,6 +39,7 @@ void UndoRedoManager::push(Action undoAction,
                       std::move(redoAction),
                       label });
     _redo.clear();
+    trim();
 }
 
 // -----------------------------------------------------------------------------

src/UndoRedoManager.h

@@ -39,7 +39,6 @@ class UndoRedoManager
 
     bool undo();          // returns false if nothing to undo
     bool redo();          // returns false if nothing to redo
-
     void clear();
 
     [[nodiscard]] bool   canUndo()   const { return !_undo.empty(); }
@@ -50,6 +49,9 @@ class UndoRedoManager
     [[nodiscard]] std::wstring peekUndoLabel() const;
     [[nodiscard]] std::wstring peekRedoLabel() const;
 
+    void setCapacity(size_t cap) { _capacity = cap; trim(); }
+    size_t capacity() const { return _capacity; }
+
 private:
     UndoRedoManager() = default;
     ~UndoRedoManager() = default;
@@ -64,4 +66,11 @@ class UndoRedoManager
 
     std::vector<Item> _undo;
     std::vector<Item> _redo;
+
+    size_t _capacity = 200;    // limited stps
+    void trim() {
+        if (_capacity == 0) return;
+        while (_undo.size() > _capacity) _undo.erase(_undo.begin());
+        while (_redo.size() > _capacity) _redo.erase(_redo.begin());
+    }
 };