Refactoring using MemRef.

ncd/extra/NCDFastNames.c

@@ -79,28 +79,27 @@ static int add_name (NCDFastNames *o, NCDStringIndex *string_index, const char *
     return 1;
 }
 
-int NCDFastNames_Init (NCDFastNames *o, NCDStringIndex *string_index, const char *str, size_t str_len)
+int NCDFastNames_Init (NCDFastNames *o, NCDStringIndex *string_index, MemRef str)
 {
-    ASSERT(str)
+    ASSERT(str.ptr)
     
     o->num_names = 0;
     o->dynamic_names = NULL;
     
     size_t i = 0;
-    while (i < str_len) {
-        if (str[i] == '.') {
-            if (!add_name(o, string_index, str, i, str + (i + 1), str_len - (i + 1))) {
+    while (i < str.len) {
+        if (str.ptr[i] == '.') {
+            if (!add_name(o, string_index, str.ptr, i, str.ptr + (i + 1), str.len - (i + 1))) {
                 goto fail;
             }
-            str += i + 1;
-            str_len -= i + 1;
+            str = MemRef_SubFrom(str, i + 1);
             i = 0;
             continue;
         }
         i++;
     }
     
-    if (!add_name(o, string_index, str, i, NULL, 0)) {
+    if (!add_name(o, string_index, str.ptr, i, NULL, 0)) {
         goto fail;
     }
     

ncd/extra/NCDFastNames.h

@@ -33,6 +33,7 @@
 #include <stddef.h>
 
 #include <misc/debug.h>
+#include <misc/memref.h>
 #include <ncd/NCDStringIndex.h>
 
 #define NCD_NUM_FAST_NAMES 4
@@ -43,7 +44,7 @@ typedef struct {
     NCD_string_id_t static_names[NCD_NUM_FAST_NAMES];
 } NCDFastNames;
 
-int NCDFastNames_Init (NCDFastNames *o, NCDStringIndex *string_index, const char *str, size_t str_len) WARN_UNUSED;
+int NCDFastNames_Init (NCDFastNames *o, NCDStringIndex *string_index, MemRef str) WARN_UNUSED;
 void NCDFastNames_Free (NCDFastNames *o);
 size_t NCDFastNames_GetNumNames (NCDFastNames *o);
 NCD_string_id_t * NCDFastNames_GetNames (NCDFastNames *o);

ncd/modules/alias.c

@@ -71,7 +71,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
     }
     
     // parse name string
-    if (!NCDFastNames_Init(&o->names, i->params->iparams->string_index, NCDVal_StringData(target_arg), NCDVal_StringLength(target_arg))) {
+    if (!NCDFastNames_Init(&o->names, i->params->iparams->string_index, NCDVal_StringMemRef(target_arg))) {
         ModuleLog(i, BLOG_ERROR, "NCDFastNames_Init failed");
         goto fail0;
     }

ncd/modules/call2.c

@@ -355,7 +355,7 @@ static void func_new_call_with_caller_target (void *vo, NCDModuleInst *i, const
     
     struct instance_with_caller_target *o = vo;
     
-    int res = NCDFastNames_Init(&o->names, i->params->iparams->string_index, NCDVal_StringData(caller_target_arg), NCDVal_StringLength(caller_target_arg));
+    int res = NCDFastNames_Init(&o->names, i->params->iparams->string_index, NCDVal_StringMemRef(caller_target_arg));
     if (!res) {
         ModuleLog(i, BLOG_ERROR, "NCDFastNames_Init failed");
         goto fail0;

ncd/modules/explode.c

@@ -117,14 +117,13 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
     }
     o->num = 0;
     
-    const char *data = NCDVal_StringData(input_arg);
-    size_t len = NCDVal_StringLength(input_arg);
+    MemRef data = NCDVal_StringMemRef(input_arg);
     
     while (1) {
         size_t start;
         int is_end = 0;
-        if (limit == 0 || !find_substring(data, len, del.ptr, del.len, table, &start)) {
-            start = len;
+        if (limit == 0 || !find_substring(data.ptr, data.len, del.ptr, del.len, table, &start)) {
+            start = data.len;
             is_end = 1;
         }
         
@@ -140,7 +139,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
             goto fail2;
         }
         
-        memcpy(elem->data, data, start);
+        memcpy(elem->data, data.ptr, start);
         elem->len = start;
         o->num++;
         
@@ -148,8 +147,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
             break;
         }
         
-        data += start + del.len;
-        len -= start + del.len;
+        data = MemRef_SubFrom(data, start + del.len);
         limit--;
     }
     

ncd/modules/parse.c

@@ -87,12 +87,12 @@ static const char *strings[] = {
     "addr", "prefix", NULL
 };
 
-typedef int (*parse_func) (NCDModuleInst *i, const char *str, size_t str_len, NCDValMem *mem, NCDValRef *out);
+typedef int (*parse_func) (NCDModuleInst *i, MemRef str, NCDValMem *mem, NCDValRef *out);
 
-static int parse_number (NCDModuleInst *i, const char *str, size_t str_len, NCDValMem *mem, NCDValRef *out)
+static int parse_number (NCDModuleInst *i, MemRef str, NCDValMem *mem, NCDValRef *out)
 {
     uintmax_t n;
-    if (!parse_unsigned_integer(MemRef_Make(str, str_len), &n)) {
+    if (!parse_unsigned_integer(str, &n)) {
         ModuleLog(i, BLOG_ERROR, "failed to parse number");
         return 0;
     }
@@ -105,9 +105,9 @@ static int parse_number (NCDModuleInst *i, const char *str, size_t str_len, NCDV
     return 1;
 }
 
-static int parse_value (NCDModuleInst *i, const char *str, size_t str_len, NCDValMem *mem, NCDValRef *out)
+static int parse_value (NCDModuleInst *i, MemRef str, NCDValMem *mem, NCDValRef *out)
 {
-    if (!NCDValParser_Parse(str, str_len, mem, out)) {
+    if (!NCDValParser_Parse(str.ptr, str.len, mem, out)) {
         ModuleLog(i, BLOG_ERROR, "failed to parse value");
         return 0;
     }
@@ -115,10 +115,10 @@ static int parse_value (NCDModuleInst *i, const char *str, size_t str_len, NCDVa
     return 1;
 }
 
-static int parse_ipv4_addr (NCDModuleInst *i, const char *str, size_t str_len, NCDValMem *mem, NCDValRef *out)
+static int parse_ipv4_addr (NCDModuleInst *i, MemRef str, NCDValMem *mem, NCDValRef *out)
 {
     uint32_t addr;
-    if (!ipaddr_parse_ipv4_addr(MemRef_Make(str, str_len), &addr)) {
+    if (!ipaddr_parse_ipv4_addr(str, &addr)) {
         ModuleLog(i, BLOG_ERROR, "failed to parse ipv4 addresss");
         return 0;
     }
@@ -134,10 +134,10 @@ static int parse_ipv4_addr (NCDModuleInst *i, const char *str, size_t str_len, N
     return 1;
 }
 
-static int parse_ipv6_addr (NCDModuleInst *i, const char *str, size_t str_len, NCDValMem *mem, NCDValRef *out)
+static int parse_ipv6_addr (NCDModuleInst *i, MemRef str, NCDValMem *mem, NCDValRef *out)
 {
     struct ipv6_addr addr;
-    if (!ipaddr6_parse_ipv6_addr(MemRef_Make(str, str_len), &addr)) {
+    if (!ipaddr6_parse_ipv6_addr(str, &addr)) {
         ModuleLog(i, BLOG_ERROR, "failed to parse ipv6 addresss");
         return 0;
     }
@@ -173,7 +173,7 @@ static void new_templ (void *vo, NCDModuleInst *i, const struct NCDModuleInst_ne
     NCDValMem_Init(&o->mem);
     
     // parse
-    o->succeeded = pfunc(i, NCDVal_StringData(str_arg), NCDVal_StringLength(str_arg), &o->mem, &o->value);
+    o->succeeded = pfunc(i, NCDVal_StringMemRef(str_arg), &o->mem, &o->value);
     
     // signal up
     NCDModuleInst_Backend_Up(i);

ncd/modules/regex_match.c

@@ -247,12 +247,11 @@ static void replace_func_new (void *vo, NCDModuleInst *i, const struct NCDModule
     }
     
     // input state
-    const char *in = NCDVal_StringData(input_arg);
+    MemRef in = NCDVal_StringMemRef(input_arg);
     size_t in_pos = 0;
-    size_t in_len = NCDVal_StringLength(input_arg);
     
     // process input
-    while (in_pos < in_len) {
+    while (in_pos < in.len) {
         // find first match
         int have_match = 0;
         size_t match_regex = 0; // to remove warning
@@ -260,8 +259,8 @@ static void replace_func_new (void *vo, NCDModuleInst *i, const struct NCDModule
         for (size_t j = 0; j < num_regex; j++) {
             regmatch_t this_match;
             this_match.rm_so = 0;
-            this_match.rm_eo = in_len - in_pos;
-            if (regexec(&regs[j], in + in_pos, 1, &this_match, REG_STARTEND) == 0 && (!have_match || this_match.rm_so < match.rm_so)) {
+            this_match.rm_eo = in.len - in_pos;
+            if (regexec(&regs[j], in.ptr + in_pos, 1, &this_match, REG_STARTEND) == 0 && (!have_match || this_match.rm_so < match.rm_so)) {
                 have_match = 1;
                 match_regex = j;
                 match = this_match;
@@ -270,16 +269,16 @@ static void replace_func_new (void *vo, NCDModuleInst *i, const struct NCDModule
         
         // if no match, append remaining data and finish
         if (!have_match) {
-            if (!ExpString_AppendBinary(&out, (const uint8_t *)in + in_pos, in_len - in_pos)) {
-                ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinary failed");
+            if (!ExpString_AppendBinaryMr(&out, MemRef_SubFrom(in, in_pos))) {
+                ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinaryMr failed");
                 goto fail3;
             }
             break;
         }
         
         // append data before match
-        if (!ExpString_AppendBinary(&out, (const uint8_t *)in + in_pos, match.rm_so)) {
-            ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinary failed");
+        if (!ExpString_AppendBinaryMr(&out, MemRef_Sub(in, in_pos, match.rm_so))) {
+            ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinaryMr failed");
             goto fail3;
         }
         

ncd/modules/value.c

@@ -233,9 +233,9 @@ struct value {
 static const char * get_type_str (int type);
 static void value_cleanup (struct value *v);
 static void value_delete (struct value *v);
-static struct value * value_init_storedstring (NCDModuleInst *i, const char *str, size_t len);
+static struct value * value_init_storedstring (NCDModuleInst *i, MemRef str);
 static struct value * value_init_idstring (NCDModuleInst *i, NCD_string_id_t id, NCDStringIndex *string_index);
-static struct value * value_init_externalstring (NCDModuleInst *i, const char *data, size_t length, BRefTarget *ref_target);
+static struct value * value_init_externalstring (NCDModuleInst *i, MemRef data, BRefTarget *ref_target);
 static int value_is_string (struct value *v);
 static size_t value_string_length (struct value *v);
 static void value_string_copy_out (struct value *v, char *dest);
@@ -388,7 +388,7 @@ static void value_delete (struct value *v)
     free(v);
 }
 
-static struct value * value_init_storedstring (NCDModuleInst *i, const char *str, size_t len)
+static struct value * value_init_storedstring (NCDModuleInst *i, MemRef str)
 {
     struct value *v = malloc(sizeof(*v));
     if (!v) {
@@ -400,16 +400,16 @@ static struct value * value_init_storedstring (NCDModuleInst *i, const char *str
     v->parent = NULL;
     v->type = STOREDSTRING_TYPE;
     
-    if (!(v->storedstring.data = BAlloc(len))) {
+    if (!(v->storedstring.data = BAlloc(str.len))) {
         ModuleLog(i, BLOG_ERROR, "BAlloc failed");
         goto fail1;
     }
     
-    if (str) {
-        memcpy(v->storedstring.data, str, len);
+    if (str.ptr) {
+        memcpy(v->storedstring.data, str.ptr, str.len);
     }
     
-    v->storedstring.length = len;
+    v->storedstring.length = str.len;
     
     return v;
     
@@ -442,7 +442,7 @@ fail0:
     return NULL;
 }
 
-static struct value * value_init_externalstring (NCDModuleInst *i, const char *data, size_t length, BRefTarget *ref_target)
+static struct value * value_init_externalstring (NCDModuleInst *i, MemRef data, BRefTarget *ref_target)
 {
     struct value *v = malloc(sizeof(*v));
     if (!v) {
@@ -461,8 +461,8 @@ static struct value * value_init_externalstring (NCDModuleInst *i, const char *d
     v->parent = NULL;
     v->type = EXTERNALSTRING_TYPE;
     
-    v->externalstring.data = data;
-    v->externalstring.length = length;
+    v->externalstring.data = data.ptr;
+    v->externalstring.length = data.len;
     v->externalstring.ref_target = ref_target;
     
     return v;
@@ -724,14 +724,14 @@ static struct value * value_init_fromvalue (NCDModuleInst *i, NCDValRef value)
     switch (NCDVal_Type(value)) {
         case NCDVAL_STRING: {
             if (NCDVal_IsStoredString(value)) {
-                v = value_init_storedstring(i, NCDVal_StringData(value), NCDVal_StringLength(value));
+                v = value_init_storedstring(i, NCDVal_StringMemRef(value));
             } else if (NCDVal_IsIdString(value)) {
                 v = value_init_idstring(i, NCDVal_IdStringId(value), NCDVal_IdStringStringIndex(value));
             } else if (NCDVal_IsExternalString(value)) {
-                v = value_init_externalstring(i, NCDVal_StringData(value), NCDVal_StringLength(value), NCDVal_ExternalStringTarget(value));
+                v = value_init_externalstring(i, NCDVal_StringMemRef(value), NCDVal_ExternalStringTarget(value));
             } else {
                 size_t length = NCDVal_StringLength(value);
-                v = value_init_storedstring(i, NULL, length);
+                v = value_init_storedstring(i, MemRef_Make(NULL, length));
                 if (v) {
                     NCDVal_StringCopyOut(value, 0, length, v->storedstring.data);
                 }
@@ -1761,13 +1761,13 @@ static void func_new_substr (void *vo, NCDModuleInst *i, const struct NCDModuleI
     struct value *v = NULL;
     switch (mov->type) {
         case STOREDSTRING_TYPE: {
-            v = value_init_storedstring(i, mov->storedstring.data + start, amount);
+            v = value_init_storedstring(i, MemRef_Make(mov->storedstring.data + start, amount));
         } break;
         case IDSTRING_TYPE: {
-            v = value_init_storedstring(i, NCDStringIndex_Value(mov->idstring.string_index, mov->idstring.id) + start, amount);
+            v = value_init_storedstring(i, MemRef_Make(NCDStringIndex_Value(mov->idstring.string_index, mov->idstring.id) + start, amount));
         } break;
         case EXTERNALSTRING_TYPE: {
-            v = value_init_externalstring(i, mov->externalstring.data + start, amount, mov->externalstring.ref_target);
+            v = value_init_externalstring(i, MemRef_Make(mov->externalstring.data + start, amount), mov->externalstring.ref_target);
         } break;
         default:
             ASSERT(0);