Update prototypes with mock values

Author: tiehuis

regex-capi/README.md

@@ -99,7 +99,5 @@ There are a few things missing from the C API that are present in the Rust API.
 There's no particular (known) reason why they don't, they just haven't been
 implemented yet.
 
-* RegexSet, which permits matching multiple regular expressions simultaneously
-  in a single linear time search.
 * Splitting a string by a regex.
 * Replacing regex matches in a string with some other text.

regex-capi/ctest/test.c

@@ -346,7 +346,10 @@ bool test_regex_set_matches() {
     rure_error *err = rure_error_new();
     rure_set *re = rure_compile_set((const uint8_t **) patterns,
                                     patterns_lengths,
-                                    PAT_COUNT, err);
+                                    PAT_COUNT,
+                                    0,
+                                    NULL,
+                                    err);
     if (re == NULL) {
         passed = false;
         goto done2;
@@ -357,18 +360,18 @@ bool test_regex_set_matches() {
         goto done1;
     }
 
-    if (!rure_set_is_match(re, (const uint8_t *) "foobar", 6)) {
+    if (!rure_set_is_match(re, (const uint8_t *) "foobar", 6, 0)) {
         passed = false;
         goto done1;
     }
 
-    if (rure_set_is_match(re, (const uint8_t *) "", 0)) {
+    if (rure_set_is_match(re, (const uint8_t *) "", 0, 0)) {
         passed = false;
         goto done1;
     }
 
     bool matches[PAT_COUNT];
-    if (!rure_set_matches(re, (const uint8_t *) "foobar", 6, matches)) {
+    if (!rure_set_matches(re, (const uint8_t *) "foobar", 6, 0, matches)) {
         passed = false;
         goto done1;
     }

regex-capi/include/rure.h

@@ -468,7 +468,10 @@ void rure_options_dfa_size_limit(rure_options *options, size_t limit);
  */
 rure_set *rure_compile_set(const uint8_t **patterns,
                            const size_t *patterns_lengths,
-                           size_t patterns_count, rure_error *error);
+                           size_t patterns_count,
+                           uint32_t flags,
+                           rure_options *options,
+                           rure_error *error);
 
 /*
  * rure_set_free frees the given compiled regular expression set.
@@ -486,7 +489,8 @@ void rure_set_free(rure_set *re);
  * 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);
+bool rure_set_is_match(rure_set *re, const uint8_t *haystack, size_t length,
+                       size_t start);
 
 /*
  * rure_set_matches compares each regex in the set against the haystack and
@@ -507,7 +511,7 @@ bool rure_set_is_match(rure_set *re, const uint8_t *haystack, size_t length);
  * caring which, use rure_set_is_match.
  */
 bool rure_set_matches(rure_set *re, const uint8_t *haystack, size_t length,
-                      bool *matches);
+                      size_t start, bool *matches);
 
 /*
  * rure_set_len returns the number of patterns rure_set was compiled with.

regex-capi/src/rure.rs

@@ -1,6 +1,7 @@
 use ::error::{Error, ErrorKind};
 
 use ::regex::bytes;
+use ::regex::internal::{Exec, ExecBuilder, RegexOptions};
 use ::libc::{c_char, size_t};
 
 use ::std::collections::HashMap;
@@ -469,6 +470,8 @@ ffi_fn! {
         patterns: *const *const u8,
         patterns_lengths: *const size_t,
         patterns_count: size_t,
+        flags: u32,
+        options: *const Options,
         error: *mut Error
     ) -> *const RegexSet {
         let (raw_pats, raw_patsl) = unsafe {
@@ -525,7 +528,8 @@ ffi_fn! {
     fn rure_set_is_match(
         re: *const RegexSet,
         haystack: *const u8,
-        len: size_t
+        len: size_t,
+        start: size_t
     ) -> bool {
         let re = unsafe { &*re };
         let haystack = unsafe { slice::from_raw_parts(haystack, len) };
@@ -538,6 +542,7 @@ ffi_fn! {
         re: *const RegexSet,
         haystack: *const u8,
         len: size_t,
+        start: size_t,
         matches: *mut bool
     ) -> bool {
         let re = unsafe { &*re };

src/lib.rs

@@ -603,4 +603,5 @@ pub mod internal {
     pub use prog::{Program, Inst, EmptyLook, InstRanges};
     pub use re_plugin::Plugin;
     pub use re_unicode::_Regex;
+    pub use re_builder::RegexOptions;
 }

src/re_builder.rs

@@ -7,6 +7,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
+#![allow(missing_docs)]
 
 /// The set of user configurable options for compiling zero or more regexes.
 #[derive(Clone, Debug)]