Add RegexSet functionality to C API

These functions implement a C interface to the RegexSet api.

Some notes:
 * These do not include start offsets as the standard regex functions
   do. The reason being is down to how these are implemented in the core
   regex crate. The RegexSet api does not expose a public is_match_at
   whilst the Regex api does.

 * This only tests a complete compile/match mainly for sanity. One or
   two more tests targetting the specific areas would be preferred.

 * Set matches take a mutuable array to fill with results. This is more
   C-like and allows the caller to manage the memory on the stack if
   they want.

Author: tiehuis

regex-capi/ctest/test.c

@@ -331,6 +331,64 @@ bool test_compile_error_size_limit() {
     return passed;
 }
 
+bool test_regex_set_matches() {
+
+#define PAT_COUNT 6
+
+    bool passed = true;
+    const char *patterns[] = {
+        "foo", "barfoo", "\\w+", "\\d+", "foobar", "bar"
+    };
+    const size_t patterns_lengths[] = {
+        3, 6, 3, 3, 6, 3
+    };
+
+    rure_error *err = rure_error_new();
+    rure_set *re = rure_compile_set((const uint8_t **) patterns,
+                                    patterns_lengths,
+                                    PAT_COUNT, err);
+    if (re == NULL) {
+        passed = false;
+        goto done2;
+    }
+
+    if (!rure_set_is_match(re, (const uint8_t *) "foobar", 6)) {
+        passed = false;
+        goto done1;
+    }
+
+    if (rure_set_is_match(re, (const uint8_t *) "", 0)) {
+        passed = false;
+        goto done1;
+    }
+
+    bool matches[PAT_COUNT];
+    if (!rure_set_matches(re, (const uint8_t *) "foobar", 6, matches)) {
+        passed = false;
+        goto done1;
+    }
+
+    const bool match_target[] = {
+        true, false, true, false, true, true
+    };
+
+    int i;
+    for (i = 0; i < PAT_COUNT; ++i) {
+        if (matches[i] != match_target[i]) {
+            passed = false;
+            goto done1;
+        }
+    }
+
+done1:
+    rure_set_free(re);
+done2:
+    rure_error_free(err);
+    return passed;
+
+#undef PAT_COUNT
+}
+
 void run_test(bool (test)(), const char *name, bool *passed) {
     if (!test()) {
         *passed = false;
@@ -353,6 +411,7 @@ int main() {
     run_test(test_compile_error, "test_compile_error", &passed);
     run_test(test_compile_error_size_limit, "test_compile_error_size_limit",
              &passed);
+    run_test(test_regex_set_matches, "test_regex_set_match", &passed);
 
     if (!passed) {
         exit(1);

regex-capi/include/rure.h

@@ -28,6 +28,13 @@ extern "C" {
  */
 typedef struct rure rure;
 
+/*
+ * rure_set is the type of a set of compiled regular expressions.
+ *
+ * A rure can be safely used from multiple threads simultaneously.
+ */
+typedef struct rure_set rure_set;
+
 /*
  * rure_options is the set of non-flag configuration options for compiling
  * a regular expression. Currently, only two options are available: setting
@@ -165,7 +172,7 @@ rure *rure_compile(const uint8_t *pattern, size_t length,
 /*
  * rure_free frees the given compiled regular expression.
  *
- * This must be called at most once.
+ * This must be called at most once for any rure.
  */
 void rure_free(rure *re);
 
@@ -446,6 +453,60 @@ void rure_options_size_limit(rure_options *options, size_t limit);
  */
 void rure_options_dfa_size_limit(rure_options *options, size_t limit);
 
+/*
+ * rure_compile_set compiles the given list of patterns into a single regular
+ * expression which can be matched in a linear-scan. Each pattern in patterns
+ * must be valid UTF-8 and the length of each pattern in patterns corresponds
+ * to a byte length in patterns_lengths.
+ *
+ * The number of patterns to compile is specified by patterns_count. patterns
+ * must contain at least this many entries.
+ *
+ * error is set if there was a problem compiling the pattern.
+ *
+ * The compiled expression set returned may be used from multiple threads.
+ */
+rure_set *rure_compile_set(const uint8_t **patterns,
+                           const size_t *patterns_lengths,
+                           size_t patterns_count, rure_error *error);
+
+/*
+ * rure_set_free frees the given compiled regular expression set.
+ *
+ * This must be called at most once.
+ */
+void rure_set_free(rure_set *re);
+
+/*
+ * rure_is_match returns true if and only if any regexes within the set
+ * match anywhere in the haystack. Once a match has been located, the
+ * matching engine will quit immediately.
+ *
+ * haystack may contain arbitrary bytes, but ASCII compatible text is more
+ * useful. UTF-8 is even more useful. Other text encodings aren't supported.
+ * length should be the number of bytes in haystack.
+ */
+bool rure_set_is_match(rure_set *re, const uint8_t *haystack, size_t length);
+
+/*
+ * rure_set_matches compares each regex in the set against the haystack and
+ * returns an array of bools which correspond to if a match was found for
+ * the specified regex.
+ *
+ * haystack may contain arbitrary bytes, but ASCII compatible text is more
+ * useful. UTF-8 is even more useful. Other text encodings aren't supported.
+ * length should be the number of bytes in haystack.
+ *
+ * matches must be greater than or equal to the number of patterns the
+ * rure_set was compiled with.
+ *
+ * Only use this function if you specifically need to know which regexes
+ * matched within the set. To determine if any of the regexes matched without
+ * caring which, use rure_set_is_match.
+ */
+bool rure_set_matches(rure_set *re, const uint8_t *haystack, size_t length,
+                      const bool *matches);
+
 /*
  * rure_error_new allocates space for an error.
  *

regex-capi/src/rure.rs

@@ -21,6 +21,11 @@ pub struct Options {
     dfa_size_limit: usize,
 }
 
+pub struct RegexSet {
+    re: bytes::RegexSet,
+    pattern_count: usize
+}
+
 const RURE_FLAG_CASEI: u32 = 1 << 0;
 const RURE_FLAG_MULTI: u32 = 1 << 1;
 const RURE_FLAG_DOTNL: u32 = 1 << 2;
@@ -54,6 +59,11 @@ impl Deref for Regex {
     fn deref(&self) -> &bytes::Regex { &self.re }
 }
 
+impl Deref for RegexSet {
+    type Target = bytes::RegexSet;
+    fn deref(&self) -> &bytes::RegexSet { &self.re }
+}
+
 impl Default for Options {
     fn default() -> Options {
         Options {
@@ -280,7 +290,7 @@ ffi_fn! {
         unsafe {
             let cs = match CString::new(cn.as_bytes()) {
                 Result::Ok(val) => val,
-                Result::Err(err) => return false
+                Result::Err(_) => return false
             };
             let ptr = cs.into_raw();
             it.name_ptrs.push(ptr);
@@ -453,3 +463,94 @@ ffi_fn! {
         options.dfa_size_limit = limit;
     }
 }
+
+ffi_fn! {
+    fn rure_compile_set(
+        patterns: *const *const u8,
+        patterns_lengths: *const size_t,
+        patterns_count: size_t,
+        error: *mut Error
+    ) -> *const RegexSet {
+        let (raw_pats, raw_patsl) = unsafe {
+            (
+                slice::from_raw_parts(patterns, patterns_count),
+                slice::from_raw_parts(patterns_lengths, patterns_count)
+            )
+        };
+
+        let mut pats = Vec::with_capacity(patterns_count);
+        for (&raw_pat, &raw_patl) in raw_pats.iter().zip(raw_patsl) {
+            let pat = unsafe { slice::from_raw_parts(raw_pat, raw_patl) };
+            pats.push(match str::from_utf8(pat) {
+                Ok(pat) => pat,
+                Err(err) => {
+                    unsafe {
+                        if !error.is_null() {
+                            *error = Error::new(ErrorKind::Str(err));
+                        }
+                        return ptr::null();
+                    }
+                }
+            });
+        }
+
+        match bytes::RegexSet::new(&pats) {
+            Ok(re) => {
+                let pat_count = re.len();
+                let re = RegexSet {
+                    re: re,
+                    pattern_count: pat_count
+                };
+                Box::into_raw(Box::new(re))
+            }
+            Err(err) => {
+                unsafe {
+                    if !error.is_null() {
+                        *error = Error::new(ErrorKind::Regex(err));
+                    }
+                    ptr::null()
+                }
+            }
+        }
+    }
+}
+
+ffi_fn! {
+    fn rure_set_free(re: *const RegexSet) {
+        unsafe { Box::from_raw(re as *mut RegexSet); }
+    }
+}
+
+ffi_fn! {
+    fn rure_set_is_match(
+        re: *const RegexSet,
+        haystack: *const u8,
+        len: size_t
+    ) -> bool {
+        let re = unsafe { &*re };
+        let haystack = unsafe { slice::from_raw_parts(haystack, len) };
+        re.is_match(haystack)
+    }
+}
+
+ffi_fn! {
+    fn rure_set_matches(
+        re: *const RegexSet,
+        haystack: *const u8,
+        len: size_t,
+        matches: *mut bool
+    ) -> bool {
+        let re = unsafe { &*re };
+        let mut results = unsafe {
+            slice::from_raw_parts_mut(matches, re.pattern_count)
+        };
+        let haystack = unsafe { slice::from_raw_parts(haystack, len) };
+        let matches = re.matches(haystack);
+
+        for i in 0..re.pattern_count {
+            results[i] = matches.matched(i);
+        }
+
+        matches.matched_any()
+    }
+}