re: fix tests

Author: adsharma

native/src/regex_wrapper.cpp

@@ -2,7 +2,9 @@
 #include <regex>
 #include <string>
 #include <unordered_map>
+#include <vector>
 #include <memory>
+#include <cstring>
 
 // A map to store compiled regex objects
 std::unordered_map<int, std::shared_ptr<std::regex>> regex_cache;
@@ -54,32 +56,69 @@ extern "C" {
         std::smatch match;
         std::string str(text);
         if (std::regex_search(str, match, *it->second)) {
-            return match.str().c_str(); // Return the matched substring
+            return strdup(match.str().c_str()); // Return the matched substring
         }
         return nullptr; // Return nullptr if no match is found
     }
 
+
     // Find all matches of a regex pattern in a string
-    const char* findall_pattern(int id, const char* text) {
+    extern "C" char** findall_pattern(int id, const char* text) {
         auto it = regex_cache.find(id);
         if (it == regex_cache.end()) {
             return nullptr; // Return nullptr if the ID is not found
         }
 
         std::string str(text);
         std::smatch match;
-        std::string result;
+        std::vector<std::string> matches;
         std::string::const_iterator searchStart(str.cbegin());
 
+        // Find all matches
         while (std::regex_search(searchStart, str.cend(), match, *it->second)) {
-            result += match.str() + "\n"; // Append each match to the result string
+            matches.push_back(match.str()); // Store each match in the vector
             searchStart = match.suffix().first;
         }
 
-        if (!result.empty()) {
-            return result.c_str(); // Return all matches as a single string separated by newlines
+        if (matches.empty()) {
+            return nullptr; // Return nullptr if no matches are found
+        }
+
+        // Allocate an array of char* to hold the matches
+        char** result = (char**)malloc((matches.size() + 1) * sizeof(char*));
+        if (!result) {
+            return nullptr; // Return nullptr if memory allocation fails
+        }
+
+        // Copy each match into the array
+        for (size_t i = 0; i < matches.size(); ++i) {
+            result[i] = strdup(matches[i].c_str()); // Duplicate the string
+            if (!result[i]) {
+                // Free previously allocated memory if strdup fails
+                for (size_t j = 0; j < i; ++j) {
+                    free(result[j]);
+                }
+                free(result);
+                return nullptr;
+            }
+        }
+
+        // Null-terminate the array
+        result[matches.size()] = nullptr;
+
+        return result;
+    }
+
+    // Function to free the allocated memory for the matches
+    extern "C" void free_matches(char** matches) {
+        if (!matches) {
+            return;
+        }
+
+        for (size_t i = 0; matches[i] != nullptr; ++i) {
+            free(matches[i]); // Free each string
         }
-        return nullptr; // Return nullptr if no matches are found
+        free(matches); // Free the array itself
     }
 
     // Substitute all occurrences of a regex pattern in a string
@@ -91,6 +130,6 @@ extern "C" {
 
         std::string str(text);
         std::string result = std::regex_replace(str, *it->second, replacement);
-        return result.c_str(); // Return the modified string
+        return strdup(result.c_str()); // Return the modified string
     }
 }

src/stdlib/re.py

@@ -1,3 +1,5 @@
+import cffi
+
 from stdlib._cffi_util import load_library
 
 # Define the C interface
@@ -6,9 +8,15 @@
     bool match_compiled(int id, const char* text);
     void release_compiled(int id);
     bool match(const char* pattern, const char* text);
+    const char* search_pattern(int id, const char* text);
+    char** findall_pattern(int id, const char* text);
+    void free_matches(char** matches);
+    const char* substitute_pattern(int id, const char* text, const char* replacement);
+    void free(void *ptr);
 """
 
 # Load the shared library
+ffi = cffi.FFI()
 lib = load_library("regex_wrapper", interface)
 
 
@@ -35,25 +43,42 @@ def search(self, text: str) -> str | None:
         # Search for the compiled regex in the text
         result = lib.search_pattern(self.id, text.encode("utf-8"))  # type: ignore
         if result:
-            return result.decode("utf-8")
+            ptr = result
+            try:
+                result_bytes: bytes = ffi.string(result)
+                return result_bytes.decode("utf-8")
+            finally:
+                lib.free(ptr)
         return None
 
     def findall(self, text: str) -> list[str]:
         # Find all matches of the compiled regex in the text
-        result = lib.search_pattern(self.id, text.encode("utf-8"))  # type: ignore
-        if result:
-            return result.decode("utf-8").split("\n")[
-                :-1
-            ]  # Split by newline and remove the last empty string
-        return []
+        matches_ptr = lib.findall_pattern(self.id, text.encode("utf-8"))  # type: ignore
+        matches = []
+        if matches_ptr:
+            try:
+                # Convert the array of C strings to a Python list
+                i = 0
+                while matches_ptr[i]:
+                    matches.append(ffi.string(matches_ptr[i]).decode("utf-8"))
+                    i += 1
+            finally:
+                # Free the allocated memory
+                lib.free_matches(matches_ptr)
+        return matches
 
     def sub(self, replacement: str, text: str) -> str:
         # Substitute all occurrences of the compiled regex in the text
         result = lib.substitute_pattern(  # type: ignore
             self.id, text.encode("utf-8"), replacement.encode("utf-8")
         )
         if result:
-            return result.decode("utf-8")
+            ptr = result
+            try:
+                result_bytes: bytes = ffi.string(result)
+                return result_bytes.decode("utf-8")
+            finally:
+                lib.free(ptr)
         return text  # Return the original text if substitution fails