static njs_ret_t
njs_array_prototype_join(njs_vm_t *vm, njs_param_t *param)
{
u_char *p;
size_t size, length;
nxt_int_t ret;
nxt_uint_t i, n, max;
njs_array_t *array;
njs_value_t *value, *values;
njs_string_prop_t separator, string;
if (!njs_is_array(param->object)) {
goto empty;
}
array = param->object->data.u.array;
if (array->length == 0) {
goto empty;
}
if (param->nargs != 0) {
value = ¶m->args[0];
} else {
value = (njs_value_t *) &njs_string_comma;
}
(void) njs_string_prop(&separator, value);
max = 0;
for (i = 0; i < array->length; i++) {
value = &array->start[i];
if (njs_is_valid(value) && !njs_is_string(value)) {
max++;
}
}
values = nxt_mem_cache_align(vm->mem_cache_pool, sizeof(njs_value_t),
sizeof(njs_value_t) * max);
if (nxt_slow_path(values == NULL)) {
return NXT_ERROR;
}
size = separator.size * (array->length - 1);
length = separator.length * (array->length - 1);
n = 0;
for (i = 0; i < array->length; i++) {
value = &array->start[i];
if (njs_is_valid(value)) {
if (!njs_is_string(value)) {
ret = njs_value_to_string(vm, &values[n], value);
if (nxt_slow_path(ret != NXT_OK)) {
return NXT_ERROR;
}
value = &values[n++];
}
(void) njs_string_prop(&string, value);
size += string.size;
length += string.length;
}
}
p = njs_string_alloc(vm, &vm->retval, size, length);
if (nxt_slow_path(p == NULL)) {
return NXT_ERROR;
}
n = 0;
for (i = 0; i < array->length; i++) {
value = &array->start[i];
if (njs_is_valid(value)) {
if (!njs_is_string(value)) {
value = &values[n++];
}
(void) njs_string_prop(&string, value);
p = memcpy(p, string.start, string.size);
p += string.size;
}
if (i < array->length - 1) {
p = memcpy(p, separator.start, separator.size);
p += separator.size;
}
}
for (i = 0; i < max; i++) {
njs_release(vm, &values[i]);
}
nxt_mem_cache_free(vm->mem_cache_pool, values);
return NXT_OK;
empty:
vm->retval = njs_string_empty;
return NXT_OK;
}
njs_regexp_pattern_t *
njs_regexp_pattern_create(njs_vm_t *vm, u_char *start, size_t length,
njs_regexp_flags_t flags)
{
int options, ret;
u_char *p, *end;
size_t size;
njs_regexp_pattern_t *pattern;
size = 1; /* A trailing "/". */
size += ((flags & NJS_REGEXP_GLOBAL) != 0);
size += ((flags & NJS_REGEXP_IGNORE_CASE) != 0);
size += ((flags & NJS_REGEXP_MULTILINE) != 0);
pattern = nxt_mem_cache_zalloc(vm->mem_cache_pool,
sizeof(njs_regexp_pattern_t)
+ 1 + length + size + 1);
if (nxt_slow_path(pattern == NULL)) {
return NULL;
}
pattern->flags = size;
pattern->next = NULL;
p = (u_char *) pattern + sizeof(njs_regexp_pattern_t);
pattern->source = p;
*p++ = '/';
p = memcpy(p, start, length);
p += length;
end = p;
*p++ = '\0';
pattern->global = ((flags & NJS_REGEXP_GLOBAL) != 0);
if (pattern->global) {
*p++ = 'g';
}
#ifdef PCRE_JAVASCRIPT_COMPAT
/* JavaScript compatibility has been introduced in PCRE-7.7. */
options = PCRE_JAVASCRIPT_COMPAT;
#else
options = 0;
#endif
pattern->ignore_case = ((flags & NJS_REGEXP_IGNORE_CASE) != 0);
if (pattern->ignore_case) {
*p++ = 'i';
options |= PCRE_CASELESS;
}
pattern->multiline = ((flags & NJS_REGEXP_MULTILINE) != 0);
if (pattern->multiline) {
*p++ = 'm';
options |= PCRE_MULTILINE;
}
*p++ = '\0';
ret = njs_regexp_pattern_compile(vm, &pattern->regex[0],
&pattern->source[1], options);
if (nxt_slow_path(ret < 0)) {
return NULL;
}
pattern->ncaptures = ret;
ret = njs_regexp_pattern_compile(vm, &pattern->regex[1],
&pattern->source[1], options | PCRE_UTF8);
if (nxt_fast_path(ret >= 0)) {
if (nxt_slow_path((u_int) ret != pattern->ncaptures)) {
vm->exception = &njs_exception_internal_error;
nxt_mem_cache_free(vm->mem_cache_pool, pattern);
return NULL;
}
} else if (ret != NXT_DECLINED) {
nxt_mem_cache_free(vm->mem_cache_pool, pattern);
return NULL;
}
*end = '/';
return pattern;
}
static void
njs_regexp_free(void *p, void *memory_data)
{
nxt_mem_cache_free(memory_data, p);
}
static void
lvlhsh_unit_test_pool_free(void *pool, void *p, size_t size)
{
nxt_mem_cache_free(pool, p);
}
