perf: replace std::regex with POSIX regex_t in grep and sed

std::regex is known to be 5-10x slower than POSIX regex. Replace with
regex_t via the existing scoped_regex RAII wrapper. Also removes the
<regex> header dependency, reducing compile time and binary size.

Author: Charliechen114514

src/applets/grep.cpp

@@ -2,19 +2,17 @@
 // Supported flags: -E (extended regex), -i (ignore case), -v (invert match),
 //                  -n (line numbers), -r (recursive), -c (count only),
 //                  -l (files with matches), -q (quiet)
-// Known differences from GNU grep: uses std::regex (slower on large files),
-// no PCRE2, no color, no context lines.
 
 #include <cstdio>
 #include <filesystem>
-#include <regex>
 #include <string>
 #include <string_view>
 #include <vector>
 
 #include <cfbox/args.hpp>
 #include <cfbox/help.hpp>
 #include <cfbox/io.hpp>
+#include <cfbox/regex.hpp>
 
 namespace {
 
@@ -55,15 +53,12 @@ auto grep_file(const std::string& pattern, const GrepOptions& opts,
 
     auto lines = cfbox::io::split_lines(result.value());
 
-    auto flags = std::regex::ECMAScript;
-    if (opts.extended) flags = std::regex::egrep;
-    if (opts.ignore_case) flags |= std::regex::icase;
+    int cflags = opts.extended ? REG_EXTENDED : 0;
+    if (opts.ignore_case) cflags |= REG_ICASE;
 
-    std::regex re;
-    try {
-        re = std::regex(pattern, flags);
-    } catch (const std::regex_error& e) {
-        std::fprintf(stderr, "cfbox grep: invalid regex: %s\n", e.what());
+    cfbox::util::scoped_regex re;
+    if (re.compile(pattern.c_str(), cflags) != 0) {
+        std::fprintf(stderr, "cfbox grep: invalid regex: %s\n", pattern.c_str());
         return 2;
     }
 
@@ -72,7 +67,7 @@ auto grep_file(const std::string& pattern, const GrepOptions& opts,
 
     for (std::size_t i = 0; i < lines.size(); ++i) {
         const auto& line = lines[i];
-        bool matched = std::regex_search(line, re);
+        bool matched = re.exec(line.c_str(), 0, nullptr, 0) == 0;
         if (opts.invert) matched = !matched;
 
         if (matched) {

src/applets/sed.cpp

@@ -5,14 +5,15 @@
 // no a/i/c commands, no hold space, no multi-line pattern space.
 
 #include <cstdio>
-#include <regex>
+#include <cstring>
 #include <string>
 #include <string_view>
 #include <vector>
 
 #include <cfbox/args.hpp>
 #include <cfbox/help.hpp>
 #include <cfbox/io.hpp>
+#include <cfbox/regex.hpp>
 
 namespace {
 
@@ -225,20 +226,38 @@ auto address_matches(const Address& addr, std::size_t line, std::size_t total_li
 }
 
 auto apply_substitute(std::string& line, const SedCommand& cmd) -> bool {
-    try {
-        std::regex re(cmd.pattern);
-        if (!std::regex_search(line, re)) return false;
-
-        if (cmd.global) {
-            line = std::regex_replace(line, re, cmd.replacement);
-        } else {
-            line = std::regex_replace(line, re, cmd.replacement,
-                                      std::regex_constants::format_first_only);
+    cfbox::util::scoped_regex re;
+    if (re.compile(cmd.pattern.c_str(), REG_EXTENDED) != 0) return false;
+
+    regmatch_t m;
+    if (re.exec(line.c_str(), 1, &m, 0) != 0) return false;
+
+    if (!cmd.global) {
+        // Single replacement
+        std::string result;
+        auto* p = line.c_str();
+        result.append(p, static_cast<std::size_t>(m.rm_so));
+        result.append(cmd.replacement);
+        result.append(p + m.rm_eo);
+        line = result;
+    } else {
+        // Global replacement
+        std::string result;
+        auto* p = line.c_str();
+        auto offset = p;
+        while (re.exec(offset, 1, &m, 0) == 0 && m.rm_so >= 0) {
+            result.append(offset, static_cast<std::size_t>(m.rm_so));
+            result.append(cmd.replacement);
+            offset += m.rm_eo;
+            if (m.rm_so == m.rm_eo) {
+                if (*offset) result += *offset++;
+                else break;
+            }
         }
-        return true;
-    } catch (const std::regex_error&) {
-        return false;
+        result.append(offset);
+        line = result;
     }
+    return true;
 }
 
 auto process_lines(const std::vector<std::string>& lines,