feat: add scoped_regex RAII wrapper for regex_t management

Add scoped_regex class in regex.hpp that automatically calls regfree()
on destruction. Replace all manual regcomp/regfree pairs in
awk_executor.cpp (4 sites) and expr.cpp (1 site), eliminating
potential resource leaks on early return paths.

Author: Charliechen114514

include/cfbox/regex.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <regex.h>
+
+namespace cfbox::util {
+
+class scoped_regex {
+    regex_t regex_{};
+    bool valid_ = false;
+
+public:
+    scoped_regex() = default;
+    ~scoped_regex() {
+        if (valid_) regfree(&regex_);
+    }
+    scoped_regex(const scoped_regex&) = delete;
+    scoped_regex& operator=(const scoped_regex&) = delete;
+
+    auto compile(const char* pattern, int flags) -> int {
+        if (valid_) { regfree(&regex_); valid_ = false; }
+        int rc = regcomp(&regex_, pattern, flags);
+        valid_ = (rc == 0);
+        return rc;
+    }
+
+    auto exec(const char* str, std::size_t nmatch, regmatch_t* matches, int flags) const -> int {
+        return regexec(&regex_, str, nmatch, matches, flags);
+    }
+
+    auto get() const -> const regex_t* { return &regex_; }
+    auto valid() const -> bool { return valid_; }
+};
+
+} // namespace cfbox::util

src/applets/awk/awk_executor.cpp

@@ -2,9 +2,10 @@
 #include <cmath>
 #include <cstdio>
 #include <cstring>
-#include <regex.h>
 #include <sstream>
 
+#include <cfbox/regex.hpp>
+
 namespace cfbox::awk {
 
 class Executor {
@@ -200,11 +201,9 @@ class Executor {
     }
 
     auto regex_match(const std::string& str, const std::string& pat) -> bool {
-        regex_t regex;
-        if (regcomp(&regex, pat.c_str(), REG_EXTENDED | REG_NOSUB) != 0) return false;
-        auto ret = regexec(&regex, str.c_str(), 0, nullptr, 0);
-        regfree(&regex);
-        return ret == 0;
+        util::scoped_regex regex;
+        if (regex.compile(pat.c_str(), REG_EXTENDED | REG_NOSUB) != 0) return false;
+        return regex.exec(str.c_str(), 0, nullptr, 0) == 0;
     }
 
     auto eval_func_call(NodePtr node) -> std::string {
@@ -244,20 +243,19 @@ class Executor {
                 if (!tok.empty()) parts.push_back(tok);
             } else {
                 // regex split
-                regex_t regex;
-                if (regcomp(&regex, sep.c_str(), REG_EXTENDED) == 0) {
+                util::scoped_regex regex;
+                if (regex.compile(sep.c_str(), REG_EXTENDED) == 0) {
                     auto* p = args[0].c_str();
                     while (*p) {
                         regmatch_t m;
-                        if (regexec(&regex, p, 1, &m, 0) == 0 && m.rm_so >= 0) {
+                        if (regex.exec(p, 1, &m, 0) == 0 && m.rm_so >= 0) {
                             parts.emplace_back(p, static_cast<std::size_t>(m.rm_so));
                             p += m.rm_eo;
                         } else {
                             parts.push_back(p);
                             break;
                         }
                     }
-                    regfree(&regex);
                 }
             }
             for (std::size_t i = 0; i < parts.size(); ++i) {
@@ -272,13 +270,13 @@ class Executor {
             auto pat = args[0], repl = args[1];
             auto& str = st_.fields.empty() ? st_.record : st_.fields[0];
             int count = 0;
-            regex_t regex;
-            if (regcomp(&regex, pat.c_str(), REG_EXTENDED) == 0) {
+            util::scoped_regex regex;
+            if (regex.compile(pat.c_str(), REG_EXTENDED) == 0) {
                 regmatch_t m;
                 auto* p = str.c_str();
                 std::string result;
                 while (*p) {
-                    if (regexec(&regex, p, 1, &m, 0) == 0 && m.rm_so >= 0) {
+                    if (regex.exec(p, 1, &m, 0) == 0 && m.rm_so >= 0) {
                         result.append(p, static_cast<std::size_t>(m.rm_so));
                         result.append(repl);
                         p += m.rm_eo;
@@ -289,20 +287,18 @@ class Executor {
                         break;
                     }
                 }
-                regfree(&regex);
                 str = result;
             }
             return to_string(static_cast<double>(count));
         }
         if (name == "match") {
             if (args.size() < 2) return "0";
-            regex_t regex;
-            if (regcomp(&regex, args[1].c_str(), REG_EXTENDED) != 0) return "0";
+            util::scoped_regex regex;
+            if (regex.compile(args[1].c_str(), REG_EXTENDED) != 0) return "0";
             regmatch_t m;
-            if (regexec(&regex, args[0].c_str(), 1, &m, 0) != 0) { regfree(&regex); return "0"; }
+            if (regex.exec(args[0].c_str(), 1, &m, 0) != 0) return "0";
             st_.vars["RSTART"] = to_string(static_cast<double>(m.rm_so + 1));
             st_.vars["RLENGTH"] = to_string(static_cast<double>(m.rm_eo - m.rm_so));
-            regfree(&regex);
             return st_.vars["RSTART"];
         }
         if (name == "sprintf") {

src/applets/expr.cpp

@@ -1,12 +1,12 @@
 #include <cstdio>
 #include <cstring>
 #include <optional>
-#include <regex.h>
 #include <string>
 #include <vector>
 
 #include <cfbox/args.hpp>
 #include <cfbox/help.hpp>
+#include <cfbox/regex.hpp>
 
 namespace {
 constexpr cfbox::help::HelpEntry HELP = {
@@ -99,22 +99,19 @@ static auto eval_compare(std::vector<std::string>::iterator& it,
             ++it;
             auto pattern = eval_primary(it, end).to_str();
             auto str = left.to_str();
-            regex_t regex;
-            if (regcomp(&regex, pattern.c_str(), REG_EXTENDED) != 0) {
+            cfbox::util::scoped_regex regex;
+            if (regex.compile(pattern.c_str(), REG_EXTENDED) != 0) {
                 return Value::integer(0);
             }
             regmatch_t match;
-            if (regexec(&regex, str.c_str(), 1, &match, 0) == 0) {
+            if (regex.exec(str.c_str(), 1, &match, 0) == 0) {
                 if (match.rm_so >= 0 && match.rm_eo > match.rm_so) {
-                    regfree(&regex);
                     return Value::str(str.substr(
                         static_cast<std::size_t>(match.rm_so),
                         static_cast<std::size_t>(match.rm_eo - match.rm_so)));
                 }
-                regfree(&regex);
                 return Value::integer(static_cast<long>(match.rm_eo - match.rm_so));
             }
-            regfree(&regex);
             return Value::integer(0);
         }
         if ((op == "<" || op == "<=" || op == "=" || op == "==" ||