Claude
e782d24e32
RegexEngine.h/.cc wrap the regex engine for search, regex replace-all and the terminal and ImGui renderers' match highlighting: - With KTE_USE_PCRE2 (default ON; used when pkg-config finds libpcre2-8, linked as -lpcre2-8) patterns are compiled by PCRE2 with its JIT and matched under a match limit: catastrophic backtracking stops with a status note instead of hanging the editor, and matching does not recurse on the C stack (no large-stack thread; the per-keystroke and per-frame line limit is 1 MiB instead of 2,000 bytes). Otherwise std::regex is used as before. - Replacement strings follow std::regex_replace (ECMAScript as libstdc++ reads it) with either engine: the PCRE2 path expands $&, $n, $`, $', $$ itself and steps over empty matches the same way. - Regex search walks lines over the materialized text instead of calling GetLineView per row. The terminal renderer compiles the pattern once per frame (it compiled it for every row). - Only one checkpoint per journal is queued at a time: whole-file edits in a row on a large buffer each queued a full copy of the buffer. - default.nix and the Dockerfile add pcre2 and pkg-config. On 26 MB: regex keystroke 1.6 -> 0.14 ms, next 62 -> 6 ms, replace-all 929 -> 438 ms; a rarely matching regex over 105 MB: 1.55 s -> 0.10 s. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015rcVQiiWyTzoNrsvLSaAfB
37 lines
1.7 KiB
C++
37 lines
1.7 KiB
C++
// RegexGuard.h - keep std::regex from overflowing the stack
|
|
//
|
|
// libstdc++'s std::regex matcher recurses roughly once per character of a
|
|
// match, so a pattern such as ".*" or "a+" on a line of a few tens of
|
|
// thousands of characters (minified JS/JSON) overflows a default 8 MiB
|
|
// stack and crashes the editor.
|
|
#pragma once
|
|
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <regex>
|
|
#include <string>
|
|
|
|
namespace kte {
|
|
// Used where std::regex is still called directly (the Qt frontend's match
|
|
// highlighting; search and the other renderers use RegexEngine.h, whose
|
|
// Regex::IncrementalLineLimit() applies the same limits for std::regex).
|
|
// Regex matches are highlighted only on lines up to this many bytes:
|
|
// std::regex can take time quadratic in line length even for ordinary
|
|
// patterns (".*q" on a 20 KB line: 12 s), with no way to interrupt it, and
|
|
// these run on every frame or keystroke.
|
|
constexpr std::size_t kRegexRenderLineLimit = 2000;
|
|
|
|
// Run fn to completion on a thread with a large stack (address space is
|
|
// reserved, pages are committed only as used), so regex work over long lines
|
|
// cannot overflow. If such a thread cannot be created, fn runs on the calling
|
|
// thread. Exceptions thrown by fn are rethrown to the caller.
|
|
void RunWithLargeStack(const std::function<void()> &fn);
|
|
|
|
// Call on_match(position, length) for each match of rx in line. Lines short
|
|
// enough to be safe on any stack are matched inline; longer ones on a large
|
|
// stack (a 10,000-byte line already overflowed 8 MiB for some patterns).
|
|
// Throws what std::regex throws.
|
|
void ForEachRegexMatch(const std::string &line, const std::regex &rx,
|
|
const std::function<void(std::size_t, std::size_t)> &on_match);
|
|
} // namespace kte
|