misc/substring.h: Refactor with MemRef.

examples/substring_test.c

@@ -89,7 +89,7 @@ static void test_tables (int len, int count)
             word[j] = rand() % 2;
         }
         
-        build_substring_backtrack_table(word, len, table);
+        build_substring_backtrack_table(MemRef_Make(word, len), table);
         
         for (int j = 1; j < len; j++) {
             for (int k = j - 1; k >= 0; k--) {
@@ -126,7 +126,7 @@ static void test_substring (int word_len, int text_len, int word_count, int text
             word[j] = rand() % 2;
         }
         
-        build_substring_backtrack_table(word, word_len, table);
+        build_substring_backtrack_table(MemRef_Make(word, word_len), table);
         
         for (int j = 0; j < text_count; j++) {
             for (int k = 0; k < text_len; k++) {
@@ -134,7 +134,7 @@ static void test_substring (int word_len, int text_len, int word_count, int text
             }
             
             size_t pos = 36; // to remove warning
-            int res = find_substring(text, text_len, word, word_len, table, &pos);
+            int res = find_substring(MemRef_Make(text, text_len), MemRef_Make(word, word_len), table, &pos);
             
             size_t spos = 59; // to remove warning
             int sres = find_substring_slow(text, text_len, word, word_len, &spos);
@@ -180,10 +180,10 @@ int main (int argc, char *argv[])
         char text[] = "aggagaa";
         char word[] = "aga";
         size_t table[sizeof(word) - 1];
-        build_substring_backtrack_table(word, strlen(word), table);
+        build_substring_backtrack_table(MemRef_MakeCstr(word), table);
         
         size_t pos;
-        int res = find_substring(text, strlen(text), word, strlen(word), table, &pos);
+        int res = find_substring(MemRef_MakeCstr(text), MemRef_MakeCstr(word), table, &pos);
         ASSERT_FORCE(res)
         ASSERT_FORCE(pos == 3)
     }
@@ -192,10 +192,10 @@ int main (int argc, char *argv[])
         char text[] = "aagagga";
         char word[] = "aga";
         size_t table[sizeof(word) - 1];
-        build_substring_backtrack_table_reverse(word, strlen(word), table);
+        build_substring_backtrack_table_reverse(MemRef_MakeCstr(word), table);
         
         size_t pos;
-        int res = find_substring_reverse(text, strlen(text), word, strlen(word), table, &pos);
+        int res = find_substring_reverse(MemRef_MakeCstr(text), MemRef_MakeCstr(word), table, &pos);
         ASSERT_FORCE(res)
         ASSERT_FORCE(pos == 1)
     }

misc/substring.h

@@ -1,36 +1,37 @@
 #include <stddef.h>
 
 #include <misc/debug.h>
+#include <misc/memref.h>
 
-static void build_substring_backtrack_table (const char *str, size_t len, size_t *out_table)
+static void build_substring_backtrack_table (MemRef str, size_t *out_table)
 {
-    ASSERT(len > 0)
+    ASSERT(str.len > 0)
     
     size_t x = 0;
     
-    for (size_t i = 1; i < len; i++) {
+    for (size_t i = 1; i < str.len; i++) {
         out_table[i] = x;
-        while (x > 0 && str[i] != str[x]) {
+        while (x > 0 && str.ptr[i] != str.ptr[x]) {
             x = out_table[x];
         }
-        if (str[i] == str[x]) {
+        if (str.ptr[i] == str.ptr[x]) {
             x++;
         }
     }
 }
 
-static int find_substring (const char *text, size_t text_len, const char *word, size_t word_len, const size_t *table, size_t *out_position)
+static int find_substring (MemRef text, MemRef word, const size_t *table, size_t *out_position)
 {
-    ASSERT(word_len > 0)
+    ASSERT(word.len > 0)
     
     size_t x = 0;
     
-    for (size_t i = 0; i < text_len; i++) {
-        while (x > 0 && text[i] != word[x]) {
+    for (size_t i = 0; i < text.len; i++) {
+        while (x > 0 && text.ptr[i] != word.ptr[x]) {
             x = table[x];
         }
-        if (text[i] == word[x]) {
-            if (x + 1 == word_len) {
+        if (text.ptr[i] == word.ptr[x]) {
+            if (x + 1 == word.len) {
                 *out_position = i - x;
                 return 1;
             }
@@ -41,36 +42,36 @@ static int find_substring (const char *text, size_t text_len, const char *word,
     return 0;
 }
 
-static void build_substring_backtrack_table_reverse (const char *str, size_t len, size_t *out_table)
+static void build_substring_backtrack_table_reverse (MemRef str, size_t *out_table)
 {
-    ASSERT(len > 0)
+    ASSERT(str.len > 0)
     
     size_t x = 0;
     
-    for (size_t i = 1; i < len; i++) {
+    for (size_t i = 1; i < str.len; i++) {
         out_table[i] = x;
-        while (x > 0 && str[len - 1 - i] != str[len - 1 - x]) {
+        while (x > 0 && str.ptr[str.len - 1 - i] != str.ptr[str.len - 1 - x]) {
             x = out_table[x];
         }
-        if (str[len - 1 - i] == str[len - 1 - x]) {
+        if (str.ptr[str.len - 1 - i] == str.ptr[str.len - 1 - x]) {
             x++;
         }
     }
 }
 
-static int find_substring_reverse (const char *text, size_t text_len, const char *word, size_t word_len, const size_t *table, size_t *out_position)
+static int find_substring_reverse (MemRef text, MemRef word, const size_t *table, size_t *out_position)
 {
-    ASSERT(word_len > 0)
+    ASSERT(word.len > 0)
     
     size_t x = 0;
     
-    for (size_t i = 0; i < text_len; i++) {
-        while (x > 0 && text[text_len - 1 - i] != word[word_len - 1 - x]) {
+    for (size_t i = 0; i < text.len; i++) {
+        while (x > 0 && text.ptr[text.len - 1 - i] != word.ptr[word.len - 1 - x]) {
             x = table[x];
         }
-        if (text[text_len - 1 - i] == word[word_len - 1 - x]) {
-            if (x + 1 == word_len) {
-                *out_position = (text_len - 1 - i);
+        if (text.ptr[text.len - 1 - i] == word.ptr[word.len - 1 - x]) {
+            if (x + 1 == word.len) {
+                *out_position = (text.len - 1 - i);
                 return 1;
             }
             x++;

ncd/NCDModuleIndex.c

@@ -92,10 +92,10 @@ static int add_method (const char *type, const struct NCDInterpModule *module, N
     size_t search_len = sizeof(search) - 1;
     
     size_t table[sizeof(search) - 1];
-    build_substring_backtrack_table_reverse(search, search_len, table);
+    build_substring_backtrack_table_reverse(MemRef_Make(search, search_len), table);
     
     size_t pos;
-    if (!find_substring_reverse(type, strlen(type), search, search_len, table, &pos)) {
+    if (!find_substring_reverse(MemRef_MakeCstr(type), MemRef_Make(search, search_len), table, &pos)) {
         *out_method_id = -1;
         return 1;
     }

ncd/modules/explode.c

@@ -112,7 +112,7 @@ static void compile_search_new (void *vo, NCDModuleInst *i, const struct NCDModu
         goto fail0;
     }
     
-    build_substring_backtrack_table(o->str.ptr, o->str.len, o->table);
+    build_substring_backtrack_table(o->str, o->table);
     
     NCDModuleInst_Backend_Up(i);
     return;
@@ -167,7 +167,7 @@ static void func_new_common (void *vo, NCDModuleInst *i, const struct NCDModuleI
             goto fail0;
         }
         
-        build_substring_backtrack_table(del.ptr, del.len, (size_t *)table);
+        build_substring_backtrack_table(del, (size_t *)table);
     }
     
     // read arguments
@@ -204,7 +204,7 @@ static void func_new_common (void *vo, NCDModuleInst *i, const struct NCDModuleI
     while (1) {
         size_t start;
         int is_end = 0;
-        if (limit == 0 || !find_substring(data.ptr, data.len, del.ptr, del.len, table, &start)) {
+        if (limit == 0 || !find_substring(data, del, table, &start)) {
             start = data.len;
             is_end = 1;
         }