Refactored njs_arr_t API.

1) const njs_mem_proto_t *proto is removed from arguments.
2) njs_mp_t *mp is passed during array creation.

diff --git a/src/njs.h b/src/njs.h
index 9a163bf143b4681b7a1f01d27f785926db83c435..deb06f7d5a4eb4c4afbe8fdce48eaac9cb5773bc 100644 (file)
--- a/src/njs.h
+++ b/src/njs.h
@@ -18,7 +18,6 @@
 #include <njs_clang.h>
 #include <njs_str.h>
 #include <njs_stub.h>
-#include <njs_arr.h>
 #include <njs_lvlhsh.h>
 
 
@@ -225,7 +224,6 @@ NJS_EXPORT njs_external_ptr_t njs_vm_external(njs_vm_t *vm,
     const njs_value_t *value);
 
 NJS_EXPORT void njs_disassembler(njs_vm_t *vm);
-NJS_EXPORT njs_arr_t *njs_vm_completions(njs_vm_t *vm, njs_str_t *expression);
 
 NJS_EXPORT const njs_value_t *njs_vm_value(njs_vm_t *vm, const njs_str_t *name);
 NJS_EXPORT njs_function_t *njs_vm_function(njs_vm_t *vm, const njs_str_t *name);

diff --git a/src/njs_arr.c b/src/njs_arr.c
index 04f4da682ea5fc4641da98ae9a914a4a967f473e..3a55c9df913e3f7620472e83a831579e9f0a9ee6 100644 (file)
--- a/src/njs_arr.c
+++ b/src/njs_arr.c
@@ -7,98 +7,99 @@
 #include <njs_auto_config.h>
 #include <njs_types.h>
 #include <njs_clang.h>
-#include <njs_stub.h>
+#include <njs_mp.h>
 #include <njs_arr.h>
 #include <njs_str.h>
 #include <string.h>
 
 
 njs_arr_t *
-njs_arr_create(uint32_t items, uint32_t item_size,
-    const njs_mem_proto_t *proto, void *pool)
+njs_arr_create(njs_mp_t *mp, njs_uint_t n, size_t size)
 {
-    njs_arr_t  *array;
+    njs_arr_t  *arr;
 
-    array = proto->alloc(pool, sizeof(njs_arr_t) + items * item_size);
-
-    if (njs_fast_path(array != NULL)) {
-        array->start = (char *) array + sizeof(njs_arr_t);
-        array->items = 0;
-        array->item_size = item_size;
-        array->avalaible = items;
-        array->pointer = 1;
-        array->separate = 1;
+    arr = njs_mp_alloc(mp, sizeof(njs_arr_t) + n * size);
+    if (njs_slow_path(arr == NULL)) {
+        return NULL;
     }
 
-    return array;
+    arr->start = (char *) arr + sizeof(njs_arr_t);
+    arr->items = 0;
+    arr->item_size = size;
+    arr->avalaible = n;
+    arr->pointer = 1;
+    arr->separate = 1;
+    arr->mem_pool = mp;
+
+    return arr;
 }
 
 
 void *
-njs_arr_init(njs_arr_t *array, void *start, uint32_t items,
-    uint32_t item_size, const njs_mem_proto_t *proto, void *pool)
+njs_arr_init(njs_mp_t *mp, njs_arr_t *arr, void *start, njs_uint_t n,
+    size_t size)
 {
-    array->start = start;
-    array->items = items;
-    array->item_size = item_size;
-    array->avalaible = items;
-    array->pointer = 0;
-    array->separate = 0;
-
-    if (array->start == NULL) {
-        array->separate = 1;
-        array->items = 0;
-
-        array->start = proto->alloc(pool, items * item_size);
+    arr->start = start;
+    arr->items = n;
+    arr->item_size = size;
+    arr->avalaible = n;
+    arr->pointer = 0;
+    arr->separate = 0;
+    arr->mem_pool = mp;
+
+    if (arr->start == NULL) {
+        arr->separate = 1;
+        arr->items = 0;
+
+        arr->start = njs_mp_alloc(mp, n * size);
     }
 
-    return array->start;
+    return arr->start;
 }
 
 
 void
-njs_arr_destroy(njs_arr_t *array, const njs_mem_proto_t *proto, void *pool)
+njs_arr_destroy(njs_arr_t *arr)
 {
-    if (array->separate) {
-        proto->free(pool, array->start);
+    if (arr->separate) {
+        njs_mp_free(arr->mem_pool, arr->start);
 #if (NJS_DEBUG)
-        array->start = NULL;
-        array->items = 0;
-        array->avalaible = 0;
+        arr->start = NULL;
+        arr->items = 0;
+        arr->avalaible = 0;
 #endif
     }
 
-    if (array->pointer) {
-        proto->free(pool, array);
+    if (arr->pointer) {
+        njs_mp_free(arr->mem_pool, arr);
     }
 }
 
 
 void *
-njs_arr_add(njs_arr_t *array, const njs_mem_proto_t *proto, void *pool)
+njs_arr_add(njs_arr_t *arr)
 {
-    return njs_arr_add_multiple(array, proto, pool, 1);
+    return njs_arr_add_multiple(arr, 1);
 }
 
 
 void *
-njs_arr_add_multiple(njs_arr_t *array, const njs_mem_proto_t *proto,
-    void *pool, uint32_t items)
+njs_arr_add_multiple(njs_arr_t *arr, njs_uint_t items)
 {
     void      *item, *start, *old;
     uint32_t  n;
 
-    n = array->avalaible;
-    items += array->items;
+    n = arr->avalaible;
+    items += arr->items;
 
     if (items >= n) {
 
         if (n < 16) {
-            /* Allocate new array twice as much as current. */
+            /* Allocate new arr twice as much as current. */
             n *= 2;
 
         } else {
-            /* Allocate new array half as much as current. */
+            /* Allocate new arr half as much as current. */
             n += n / 2;
         }
 
@@ -106,42 +107,42 @@ njs_arr_add_multiple(njs_arr_t *array, const njs_mem_proto_t *proto,
             n = items;
         }
 
-        start = proto->alloc(pool, n * array->item_size);
+        start = njs_mp_alloc(arr->mem_pool, n * arr->item_size);
         if (njs_slow_path(start == NULL)) {
             return NULL;
         }
 
-        array->avalaible = n;
-        old = array->start;
-        array->start = start;
+        arr->avalaible = n;
+        old = arr->start;
+        arr->start = start;
 
-        memcpy(start, old, (uint32_t) array->items * array->item_size);
+        memcpy(start, old, (uint32_t) arr->items * arr->item_size);
 
-        if (array->separate == 0) {
-            array->separate = 1;
+        if (arr->separate == 0) {
+            arr->separate = 1;
 
         } else {
-            proto->free(pool, old);
+            njs_mp_free(arr->mem_pool, old);
         }
     }
 
-    item = (char *) array->start + (uint32_t) array->items * array->item_size;
+    item = (char *) arr->start + (uint32_t) arr->items * arr->item_size;
 
-    array->items = items;
+    arr->items = items;
 
     return item;
 }
 
 
 void *
-njs_arr_zero_add(njs_arr_t *array, const njs_mem_proto_t *proto, void *pool)
+njs_arr_zero_add(njs_arr_t *arr)
 {
     void  *item;
 
-    item = njs_arr_add(array, proto, pool);
+    item = njs_arr_add(arr);
 
     if (njs_fast_path(item != NULL)) {
-        njs_memzero(item, array->item_size);
+        njs_memzero(item, arr->item_size);
     }
 
     return item;
@@ -149,13 +150,13 @@ njs_arr_zero_add(njs_arr_t *array, const njs_mem_proto_t *proto, void *pool)
 
 
 void
-njs_arr_remove(njs_arr_t *array, void *item)
+njs_arr_remove(njs_arr_t *arr, void *item)
 {
     u_char    *next, *last, *end;
     uint32_t  item_size;
 
-    item_size = array->item_size;
-    end = (u_char *) array->start + item_size * array->items;
+    item_size = arr->item_size;
+    end = (u_char *) arr->start + item_size * arr->items;
     last = end - item_size;
 
     if (item != last) {
@@ -164,5 +165,5 @@ njs_arr_remove(njs_arr_t *array, void *item)
         memmove(item, next, end - next);
     }
 
-    array->items--;
+    arr->items--;
 }

diff --git a/src/njs_arr.h b/src/njs_arr.h
index 5c81b33853d5974aac6082683550f468fd9a719c..ad062e90bae136b59b62512f17acf6d70318404a 100644 (file)
--- a/src/njs_arr.h
+++ b/src/njs_arr.h
@@ -20,47 +20,44 @@ typedef struct {
 
     uint8_t           pointer;
     uint8_t           separate;
+    njs_mp_t          *mem_pool;
 } njs_arr_t;
 
 
-NJS_EXPORT njs_arr_t *njs_arr_create(uint32_t items, uint32_t item_size,
-    const njs_mem_proto_t *proto, void *pool);
-NJS_EXPORT void *njs_arr_init(njs_arr_t *array, void *start, uint32_t items,
-    uint32_t item_size, const njs_mem_proto_t *proto, void *pool);
-NJS_EXPORT void njs_arr_destroy(njs_arr_t *array,
-    const njs_mem_proto_t *proto, void *pool);
-NJS_EXPORT void *njs_arr_add(njs_arr_t *array, const njs_mem_proto_t *proto,
-    void *pool);
-NJS_EXPORT void *njs_arr_add_multiple(njs_arr_t *array,
-    const njs_mem_proto_t *proto, void *pool, uint32_t items);
-NJS_EXPORT void *njs_arr_zero_add(njs_arr_t *array,
-    const njs_mem_proto_t *proto, void *pool);
-NJS_EXPORT void njs_arr_remove(njs_arr_t *array, void *item);
+NJS_EXPORT njs_arr_t *njs_arr_create(njs_mp_t *mp, njs_uint_t n,
+    size_t size);
+NJS_EXPORT void *njs_arr_init(njs_mp_t *mp, njs_arr_t *arr, void *start,
+    njs_uint_t n, size_t size);
+NJS_EXPORT void njs_arr_destroy(njs_arr_t *arr);
+NJS_EXPORT void *njs_arr_add(njs_arr_t *arr);
+NJS_EXPORT void *njs_arr_add_multiple(njs_arr_t *arr, njs_uint_t n);
+NJS_EXPORT void *njs_arr_zero_add(njs_arr_t *arr);
+NJS_EXPORT void njs_arr_remove(njs_arr_t *arr, void *item);
 
 
-#define njs_arr_item(array, i)                                              \
-    ((void *) ((char *) (array)->start + (array)->item_size * (i)))
+#define njs_arr_item(arr, i)                                                \
+    ((void *) ((char *) (arr)->start + (arr)->item_size * (i)))
 
 
-#define njs_arr_last(array)                                                 \
-    ((void *)                                                                 \
-        ((char *) (array)->start                                              \
-                      + (array)->item_size * ((array)->items - 1)))
+#define njs_arr_last(arr)                                                   \
+    ((void *)                                                               \
+        ((char *) (arr)->start                                              \
+                      + (arr)->item_size * ((arr)->items - 1)))
 
 
-#define njs_arr_reset(array)                                                \
-    (array)->items = 0;
+#define njs_arr_reset(arr)                                                  \
+    (arr)->items = 0;
 
 
-#define njs_arr_is_empty(array)                                             \
-    ((array)->items == 0)
+#define njs_arr_is_empty(arr)                                               \
+    ((arr)->items == 0)
 
 
 njs_inline void *
-njs_arr_remove_last(njs_arr_t *array)
+njs_arr_remove_last(njs_arr_t *arr)
 {
-    array->items--;
-    return (char *) array->start + array->item_size * array->items;
+    arr->items--;
+    return (char *) arr->start + arr->item_size * arr->items;
 }
 
 

diff --git a/src/njs_builtin.c b/src/njs_builtin.c
index d3033a5600e593e25ea3cc422ecff967fdd3cbb1..a4bc5e4917958b9c1ce43cd1f533314040431ac6 100644 (file)
--- a/src/njs_builtin.c
+++ b/src/njs_builtin.c
@@ -772,9 +772,7 @@ njs_vm_completions(njs_vm_t *vm, njs_str_t *expression)
     if (expression == NULL) {
         size = njs_builtin_completions_size(vm);
 
-        completions = njs_arr_create(size, sizeof(njs_str_t),
-                                     &njs_array_mem_proto, vm->mem_pool);
-
+        completions = njs_arr_create(vm->mem_pool, size, sizeof(njs_str_t));
         if (njs_slow_path(completions == NULL)) {
             return NULL;
         }
@@ -897,9 +895,7 @@ njs_object_completions(njs_vm_t *vm, njs_object_t *object)
 
     } while (o != NULL);
 
-    completions = njs_arr_create(size, sizeof(njs_str_t),
-                                 &njs_array_mem_proto, vm->mem_pool);
-
+    completions = njs_arr_create(vm->mem_pool, size, sizeof(njs_str_t));
     if (njs_slow_path(completions == NULL)) {
         return NULL;
     }

diff --git a/src/njs_extern.c b/src/njs_extern.c
index c9a65a66065d4c59a82763427b83398a7ac3ce20..9e835512166e64939369a878e67e9b3f6137ca88 100644 (file)
--- a/src/njs_extern.c
+++ b/src/njs_extern.c
@@ -178,8 +178,7 @@ njs_vm_external_create(njs_vm_t *vm, njs_value_t *ext_val,
         return NJS_ERROR;
     }
 
-    obj = njs_arr_add(vm->external_objects, &njs_array_mem_proto,
-                      vm->mem_pool);
+    obj = njs_arr_add(vm->external_objects);
     if (njs_slow_path(obj == NULL)) {
         return NJS_ERROR;
     }

diff --git a/src/njs_generator.c b/src/njs_generator.c
index dec4d13d9f20b78cb228d4f1a552b37b48ffc188..57dd56cb6f9c580c72153ec8547a242226f58733 100644 (file)
--- a/src/njs_generator.c
+++ b/src/njs_generator.c
@@ -2432,14 +2432,13 @@ njs_generate_scope(njs_vm_t *vm, njs_generator_t *generator,
     }
 
     if (vm->codes == NULL) {
-        vm->codes = njs_arr_create(4, sizeof(njs_vm_code_t),
-                                   &njs_array_mem_proto, vm->mem_pool);
+        vm->codes = njs_arr_create(vm->mem_pool, 4, sizeof(njs_vm_code_t));
         if (njs_slow_path(vm->codes == NULL)) {
             return NJS_ERROR;
         }
     }
 
-    code = njs_arr_add(vm->codes, &njs_array_mem_proto, vm->mem_pool);
+    code = njs_arr_add(vm->codes);
     if (njs_slow_path(code == NULL)) {
         return NJS_ERROR;
     }
@@ -3265,8 +3264,7 @@ njs_generate_index_release(njs_vm_t *vm, njs_generator_t *generator,
     cache = generator->index_cache;
 
     if (cache == NULL) {
-        cache = njs_arr_create(4, sizeof(njs_value_t *),
-                               &njs_array_mem_proto, vm->mem_pool);
+        cache = njs_arr_create(vm->mem_pool, 4, sizeof(njs_value_t *));
         if (njs_slow_path(cache == NULL)) {
             return NJS_ERROR;
         }
@@ -3274,7 +3272,7 @@ njs_generate_index_release(njs_vm_t *vm, njs_generator_t *generator,
         generator->index_cache = cache;
     }
 
-    last = njs_arr_add(cache, &njs_array_mem_proto, vm->mem_pool);
+    last = njs_arr_add(cache);
     if (njs_fast_path(last != NULL)) {
         *last = index;
         return NJS_OK;
@@ -3317,7 +3315,7 @@ njs_generate_function_debug(njs_vm_t *vm, const njs_str_t *name,
 {
     njs_function_debug_t  *debug;
 
-    debug = njs_arr_add(vm->debug, &njs_array_mem_proto, vm->mem_pool);
+    debug = njs_arr_add(vm->debug);
     if (njs_slow_path(debug == NULL)) {
         return NJS_ERROR;
     }

diff --git a/src/njs_json.c b/src/njs_json.c
index 7756bc84e8d49d59e78dc8d039e6a9c1c7ba11a4..2219c2727e1afc7c451e6f9ce971d047e4fd5ac6 100644 (file)
--- a/src/njs_json.c
+++ b/src/njs_json.c
@@ -208,8 +208,8 @@ njs_json_parse(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
 
         parse->function = njs_function(reviver);
 
-        if (njs_arr_init(&parse->stack, NULL, 4, sizeof(njs_json_state_t),
-                         &njs_array_mem_proto, vm->mem_pool)
+        if (njs_arr_init(vm->mem_pool, &parse->stack, NULL, 4,
+                         sizeof(njs_json_state_t))
             == NULL)
         {
             goto memory_error;
@@ -305,8 +305,8 @@ njs_json_stringify(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
         }
     }
 
-    if (njs_arr_init(&stringify->stack, NULL, 4, sizeof(njs_json_state_t),
-                     &njs_array_mem_proto, vm->mem_pool)
+    if (njs_arr_init(vm->mem_pool, &stringify->stack, NULL, 4,
+                     sizeof(njs_json_state_t))
         == NULL)
     {
         goto memory_error;
@@ -1103,7 +1103,7 @@ njs_json_push_parse_state(njs_vm_t *vm, njs_json_parse_t *parse,
 {
     njs_json_state_t  *state;
 
-    state = njs_arr_add(&parse->stack, &njs_array_mem_proto, vm->mem_pool);
+    state = njs_arr_add(&parse->stack);
     if (state != NULL) {
         state = njs_arr_last(&parse->stack);
         state->value = *value;
@@ -1693,8 +1693,7 @@ njs_json_push_stringify_state(njs_vm_t *vm, njs_json_stringify_t *stringify,
         return NULL;
     }
 
-    state = njs_arr_add(&stringify->stack, &njs_array_mem_proto,
-                        vm->mem_pool);
+    state = njs_arr_add(&stringify->stack);
     if (njs_slow_path(state == NULL)) {
         njs_memory_error(vm);
         return NULL;
@@ -2419,8 +2418,8 @@ njs_vm_value_dump(njs_vm_t *vm, njs_str_t *retval, const njs_value_t *value,
 
     njs_memset(stringify->space.start, ' ', indent);
 
-    if (njs_arr_init(&stringify->stack, NULL, 4, sizeof(njs_json_state_t),
-                     &njs_array_mem_proto, vm->mem_pool)
+    if (njs_arr_init(vm->mem_pool, &stringify->stack, NULL, 4,
+                     sizeof(njs_json_state_t))
         == NULL)
     {
         goto memory_error;

diff --git a/src/njs_main.h b/src/njs_main.h
index 499683b90535b3213cfe38f2d226bc52bb10bfa8..55a13113c5f9a9c76229fbf2db2b81a02d34a506 100644 (file)
--- a/src/njs_main.h
+++ b/src/njs_main.h
@@ -20,7 +20,6 @@
 #include <njs_strtod.h>
 #include <njs_djb_hash.h>
 #include <njs_trace.h>
-#include <njs_arr.h>
 #include <njs_queue.h>
 #include <njs_lvlhsh.h>
 #include <njs_random.h>
@@ -28,6 +27,7 @@
 #include <njs_file.h>
 #include <njs_malloc.h>
 #include <njs_mp.h>
+#include <njs_arr.h>
 #include <njs_sprintf.h>
 
 #include <njs.h>

diff --git a/src/njs_module.c b/src/njs_module.c
index 40348f410bb8941145932a7d78f2b1c84b04edb3..bd6d9084a3e58d7c1c1092dec0f77e39a811fb70 100644 (file)
--- a/src/njs_module.c
+++ b/src/njs_module.c
@@ -492,14 +492,13 @@ njs_module_insert(njs_vm_t *vm, njs_module_t *module)
     }
 
     if (vm->modules == NULL) {
-        vm->modules = njs_arr_create(4, sizeof(njs_module_t *),
-                                     &njs_array_mem_proto, vm->mem_pool);
+        vm->modules = njs_arr_create(vm->mem_pool, 4, sizeof(njs_module_t *));
         if (njs_slow_path(vm->modules == NULL)) {
             return NJS_ERROR;
         }
     }
 
-    value = njs_arr_add(vm->modules, &njs_array_mem_proto, vm->mem_pool);
+    value = njs_arr_add(vm->modules);
     if (njs_slow_path(value == NULL)) {
         return NJS_ERROR;
     }

diff --git a/src/njs_parser.c b/src/njs_parser.c
index a49e956fd40a7ef371e3497259273c1a4c38c98e..118c7af97853ccc1788e9b306d58660c51d2f6db 100644 (file)
--- a/src/njs_parser.c
+++ b/src/njs_parser.c
@@ -218,8 +218,7 @@ njs_parser_scope_begin(njs_vm_t *vm, njs_parser_t *parser, njs_scope_t type)
     values = NULL;
 
     if (scope->type < NJS_SCOPE_BLOCK) {
-        values = njs_arr_create(4, sizeof(njs_value_t), &njs_array_mem_proto,
-                                vm->mem_pool);
+        values = njs_arr_create(vm->mem_pool, 4, sizeof(njs_value_t));
         if (njs_slow_path(values == NULL)) {
             return NJS_ERROR;
         }

diff --git a/src/njs_string.c b/src/njs_string.c
index 7e266551ca356fa8164a57a000f62e97f4c9a884..053d4407ce51911e2d00dd5af00e723071d28f69 100644 (file)
--- a/src/njs_string.c
+++ b/src/njs_string.c
@@ -3112,9 +3112,8 @@ njs_string_prototype_replace(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
     }
 
     /* This cannot fail. */
-    r->part = njs_arr_init(&r->parts, &r->array,
-                           3, sizeof(njs_string_replace_part_t),
-                           &njs_array_mem_proto, vm->mem_pool);
+    r->part = njs_arr_init(vm->mem_pool, &r->parts, &r->array,
+                           3, sizeof(njs_string_replace_part_t));
 
     r->substitutions = NULL;
     r->function = NULL;
@@ -3222,14 +3221,12 @@ njs_string_replace_regexp(njs_vm_t *vm, njs_value_t *args,
         }
 
         if (r->part != r->parts.start) {
-            r->part = njs_arr_add(&r->parts, &njs_array_mem_proto,
-                                  vm->mem_pool);
+            r->part = njs_arr_add(&r->parts);
             if (njs_slow_path(r->part == NULL)) {
                 return NJS_ERROR;
             }
 
-            r->part = njs_arr_add(&r->parts, &njs_array_mem_proto,
-                                  vm->mem_pool);
+            r->part = njs_arr_add(&r->parts);
             if (njs_slow_path(r->part == NULL)) {
                 return NJS_ERROR;
             }
@@ -3297,7 +3294,7 @@ njs_string_replace_regexp(njs_vm_t *vm, njs_value_t *args,
 
     njs_regex_match_data_free(r->match_data, vm->regex_context);
 
-    njs_arr_destroy(&r->parts, &njs_array_mem_proto, vm->mem_pool);
+    njs_arr_destroy(&r->parts);
 
     njs_string_copy(&vm->retval, &args[0]);
 
@@ -3513,8 +3510,8 @@ njs_string_replace_parse(njs_vm_t *vm, njs_string_replace_t *r, u_char *p,
     uint32_t            type;
     njs_string_subst_t  *s;
 
-    r->substitutions = njs_arr_create(4, sizeof(njs_string_subst_t),
-                                      &njs_array_mem_proto, vm->mem_pool);
+    r->substitutions = njs_arr_create(vm->mem_pool, 4,
+                                      sizeof(njs_string_subst_t));
 
     if (njs_slow_path(r->substitutions == NULL)) {
         return NJS_ERROR;
@@ -3529,7 +3526,7 @@ njs_string_replace_parse(njs_vm_t *vm, njs_string_replace_t *r, u_char *p,
 copy:
 
     if (s == NULL) {
-        s = njs_arr_add(r->substitutions, &njs_array_mem_proto, vm->mem_pool);
+        s = njs_arr_add(r->substitutions);
         if (njs_slow_path(s == NULL)) {
             return NJS_ERROR;
         }
@@ -3593,7 +3590,7 @@ skip:
             goto copy;
         }
 
-        s = njs_arr_add(r->substitutions, &njs_array_mem_proto, vm->mem_pool);
+        s = njs_arr_add(r->substitutions);
         if (njs_slow_path(s == NULL)) {
             return NJS_ERROR;
         }
@@ -3621,8 +3618,7 @@ njs_string_replace_substitute(njs_vm_t *vm, njs_string_replace_t *r,
     last = r->substitutions->items;
     end = r->part[0].start + r->part[0].size;
 
-    part = njs_arr_add_multiple(&r->parts, &njs_array_mem_proto, vm->mem_pool,
-                                last + 1);
+    part = njs_arr_add_multiple(&r->parts, last + 1);
     if (njs_slow_path(part == NULL)) {
         return NJS_ERROR;
     }
@@ -3801,7 +3797,7 @@ njs_string_replace_join(njs_vm_t *vm, njs_string_replace_t *r)
         /* GC: release valid values. */
     }
 
-    njs_arr_destroy(&r->parts, &njs_array_mem_proto, vm->mem_pool);
+    njs_arr_destroy(&r->parts);
 
     return NJS_OK;
 }

diff --git a/src/njs_stub.h b/src/njs_stub.h
index f114ab6a31ac0a0ea4d40ed8c82f7b1d643453a4..f4f4149e260def4da2359310d96981f6d3b58e6d 100644 (file)
--- a/src/njs_stub.h
+++ b/src/njs_stub.h
@@ -22,17 +22,6 @@
 #define NJS_DONE           (-4)
 
 
-typedef struct {
-    void           *(*alloc)(void *mem, size_t size);
-    void           *(*zalloc)(void *mem, size_t size);
-    void           *(*align)(void *mem, size_t alignment, size_t size);
-    void           *(*zalign)(void *mem, size_t alignment, size_t size);
-    void           (*free)(void *mem, void *p);
-    void           (*alert)(void *trace, const char *fmt, ...);
-    void njs_cdecl  (*trace)(void *trace, const char *fmt, ...);
-} njs_mem_proto_t;
-
-
 #define njs_thread_log_alert(...)
 #define njs_thread_log_error(...)
 #define njs_log_error(...)

diff --git a/src/njs_variable.c b/src/njs_variable.c
index d61c84c8f2002d1834de72b5471e7d699c108019..1de625990dcf7c5638fcb6be2811c420eb492342 100644 (file)
--- a/src/njs_variable.c
+++ b/src/njs_variable.c
@@ -564,8 +564,7 @@ njs_scope_next_index(njs_vm_t *vm, njs_parser_scope_t *scope,
         values = scope->values[scope_index];
 
         if (values == NULL) {
-            values = njs_arr_create(4, sizeof(njs_value_t),
-                                    &njs_array_mem_proto, vm->mem_pool);
+            values = njs_arr_create(vm->mem_pool, 4, sizeof(njs_value_t));
             if (njs_slow_path(values == NULL)) {
                 return NJS_INDEX_ERROR;
             }
@@ -573,7 +572,7 @@ njs_scope_next_index(njs_vm_t *vm, njs_parser_scope_t *scope,
             scope->values[scope_index] = values;
         }
 
-        value = njs_arr_add(values, &njs_array_mem_proto, vm->mem_pool);
+        value = njs_arr_add(values);
         if (njs_slow_path(value == NULL)) {
             return NJS_INDEX_ERROR;
         }

diff --git a/src/njs_vm.c b/src/njs_vm.c
index 649404cb4d7afeeae5382c363a19045519f4f6ef..e923f5b21db0f364453156955e32ae519d3e551c 100644 (file)
--- a/src/njs_vm.c
+++ b/src/njs_vm.c
@@ -20,31 +20,6 @@ const njs_str_t  njs_entry_unknown =        njs_str("unknown");
 const njs_str_t  njs_entry_anonymous =      njs_str("anonymous");
 
 
-static void *
-njs_array_mem_alloc(void *mem, size_t size)
-{
-    return njs_mp_alloc(mem, size);
-}
-
-
-static void
-njs_array_mem_free(void *mem, void *p)
-{
-    njs_mp_free(mem, p);
-}
-
-
-const njs_mem_proto_t  njs_array_mem_proto = {
-    njs_array_mem_alloc,
-    NULL,
-    NULL,
-    NULL,
-    njs_array_mem_free,
-    NULL,
-    NULL,
-};
-
-
 njs_vm_t *
 njs_vm_create(njs_vm_opt_t *options)
 {
@@ -111,9 +86,7 @@ njs_vm_create(njs_vm_opt_t *options)
 
         vm->external = options->external;
 
-        vm->external_objects = njs_arr_create(4, sizeof(void *),
-                                              &njs_array_mem_proto,
-                                              vm->mem_pool);
+        vm->external_objects = njs_arr_create(vm->mem_pool, 4, sizeof(void *));
         if (njs_slow_path(vm->external_objects == NULL)) {
             return NULL;
         }
@@ -127,8 +100,8 @@ njs_vm_create(njs_vm_opt_t *options)
         vm->trace.data = vm;
 
         if (options->backtrace) {
-            debug = njs_arr_create(4, sizeof(njs_function_debug_t),
-                                   &njs_array_mem_proto, vm->mem_pool);
+            debug = njs_arr_create(vm->mem_pool, 4,
+                                   sizeof(njs_function_debug_t));
             if (njs_slow_path(debug == NULL)) {
                 return NULL;
             }
@@ -302,9 +275,8 @@ njs_vm_clone(njs_vm_t *vm, njs_external_ptr_t external)
         nvm->external_prototypes_hash = vm->external_prototypes_hash;
 
         items = vm->external_objects->items;
-        externals = njs_arr_create(items + 4, sizeof(void *),
-                                   &njs_array_mem_proto, nvm->mem_pool);
 
+        externals = njs_arr_create(nvm->mem_pool, items + 4, sizeof(void *));
         if (njs_slow_path(externals == NULL)) {
             return NULL;
         }
@@ -393,8 +365,8 @@ njs_vm_init(njs_vm_t *vm)
     njs_queue_init(&vm->posted_events);
 
     if (vm->debug != NULL) {
-        backtrace = njs_arr_create(4, sizeof(njs_backtrace_entry_t),
-                                   &njs_array_mem_proto, vm->mem_pool);
+        backtrace = njs_arr_create(vm->mem_pool, 4,
+                                   sizeof(njs_backtrace_entry_t));
         if (njs_slow_path(backtrace == NULL)) {
             return NJS_ERROR;
         }
@@ -634,14 +606,13 @@ njs_vm_add_path(njs_vm_t *vm, const njs_str_t *path)
     njs_str_t  *item;
 
     if (vm->paths == NULL) {
-        vm->paths = njs_arr_create(4, sizeof(njs_str_t),
-                                   &njs_array_mem_proto, vm->mem_pool);
+        vm->paths = njs_arr_create(vm->mem_pool, 4, sizeof(njs_str_t));
         if (njs_slow_path(vm->paths == NULL)) {
             return NJS_ERROR;
         }
     }
 
-    item = njs_arr_add(vm->paths, &njs_array_mem_proto, vm->mem_pool);
+    item = njs_arr_add(vm->paths);
     if (njs_slow_path(item == NULL)) {
         return NJS_ERROR;
     }
@@ -1088,7 +1059,7 @@ njs_vm_add_backtrace_entry(njs_vm_t *vm, njs_frame_t *frame)
     native_frame = &frame->native;
     function = native_frame->function;
 
-    be = njs_arr_add(vm->backtrace, &njs_array_mem_proto, vm->mem_pool);
+    be = njs_arr_add(vm->backtrace);
     if (njs_slow_path(be == NULL)) {
         return NJS_ERROR;
     }

diff --git a/src/njs_vm.h b/src/njs_vm.h
index 59128ce7e9e27a42198ba9d5beea44d8510ae6f7..4b377cf7582cb4c612258b0b7f7259f7c2bd9f96 100644 (file)
--- a/src/njs_vm.h
+++ b/src/njs_vm.h
@@ -348,6 +348,7 @@ njs_int_t njs_builtin_match_native_function(njs_vm_t *vm,
     njs_function_t *function, njs_str_t *name);
 
 njs_arr_t *njs_vm_backtrace(njs_vm_t *vm);
+njs_arr_t *njs_vm_completions(njs_vm_t *vm, njs_str_t *expression);
 
 void *njs_lvlhsh_alloc(void *data, size_t size);
 void njs_lvlhsh_free(void *data, void *p, size_t size);
@@ -359,7 +360,6 @@ extern const njs_str_t    njs_entry_native;
 extern const njs_str_t    njs_entry_unknown;
 extern const njs_str_t    njs_entry_anonymous;
 
-extern const njs_mem_proto_t     njs_array_mem_proto;
 extern const njs_lvlhsh_proto_t  njs_object_hash_proto;