njs_ret_t
njs_regexp_constructor(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
njs_string_prop_t string;
njs_regexp_flags_t flags;
flags = 0;
switch (nargs) {
case 1:
string.start = NULL;
string.size = 0;
break;
default:
(void) njs_string_prop(&string, &args[2]);
flags = njs_regexp_flags(&string.start, string.start + string.size, 1);
if (nxt_slow_path(flags < 0)) {
return NXT_ERROR;
}
/* Fall through. */
case 2:
(void) njs_string_prop(&string, &args[1]);
break;
}
return njs_regexp_create(vm, &vm->retval, string.start, string.size, flags);
}
njs_ret_t
njs_regexp_constructor(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
size_t length;
njs_regexp_t *regexp;
njs_string_prop_t string;
njs_regexp_flags_t flags;
njs_regexp_pattern_t *pattern;
flags = 0;
switch (nargs) {
default:
length = njs_string_prop(&string, &args[2]);
flags = njs_regexp_flags(&string.start, string.start + length, 1);
if (nxt_slow_path(flags < 0)) {
return NXT_ERROR;
}
/* Fall through. */
case 2:
string.length = njs_string_prop(&string, &args[1]);
if (string.length != 0) {
break;
}
/* Fall through. */
case 1:
string.start = (u_char *) "(?:)";
string.length = sizeof("(?:)") - 1;
break;
}
pattern = njs_regexp_pattern_create(vm, string.start, string.length, flags);
if (nxt_fast_path(pattern != NULL)) {
regexp = njs_regexp_alloc(vm, pattern);
if (nxt_fast_path(regexp != NULL)) {
vm->retval.data.u.regexp = regexp;
vm->retval.type = NJS_REGEXP;
vm->retval.data.truth = 1;
return NXT_OK;
}
}
return NXT_ERROR;
}
static njs_ret_t
njs_regexp_prototype_test(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
njs_ret_t ret;
nxt_uint_t n;
njs_value_t *value;
const njs_value_t *retval;
njs_string_prop_t string;
njs_regexp_pattern_t *pattern;
if (!njs_is_regexp(&args[0])) {
vm->exception = &njs_exception_type_error;
return NXT_ERROR;
}
retval = &njs_value_false;
if (nargs > 1) {
value = &args[1];
} else {
value = (njs_value_t *) &njs_string_void;
}
(void) njs_string_prop(&string, value);
n = (string.length != 0);
pattern = args[0].data.u.regexp->pattern;
if (nxt_regex_is_valid(&pattern->regex[n])) {
ret = nxt_regex_match(&pattern->regex[n], string.start, string.size,
vm->single_match_data, vm->regex_context);
if (ret >= 0) {
retval = &njs_value_true;
} else if (ret != NGX_REGEX_NOMATCH) {
return njs_regexp_match_error(vm);
}
}
vm->retval = *retval;
return NXT_OK;
}
static njs_ret_t
njs_regexp_prototype_last_index(njs_vm_t *vm, njs_value_t *value)
{
uint32_t index;
njs_regexp_t *regexp;
njs_string_prop_t string;
njs_release(vm, value);
regexp = value->data.u.regexp;
(void) njs_string_prop(&string, ®exp->string);
index = njs_string_index(&string, regexp->last_index);
njs_number_set(&vm->retval, index);
return NXT_OK;
}
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_ret_t
njs_regexp_prototype_exec(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
njs_ret_t ret;
nxt_uint_t n, utf8;
njs_value_t *value;
njs_regexp_t *regexp;
njs_string_prop_t string;
njs_regexp_pattern_t *pattern;
nxt_regex_match_data_t *match_data;
if (!njs_is_regexp(&args[0])) {
vm->exception = &njs_exception_type_error;
return NXT_ERROR;
}
if (nargs > 1) {
value = &args[1];
} else {
value = (njs_value_t *) &njs_string_void;
}
regexp = args[0].data.u.regexp;
regexp->string = *value;
(void) njs_string_prop(&string, value);
/* Byte string. */
utf8 = 0;
n = 0;
if (string.length != 0) {
/* ASCII string. */
utf8 = 1;
n = 1;
if (string.length != string.size) {
/* UTF-8 string. */
utf8 = 2;
}
}
pattern = regexp->pattern;
if (nxt_regex_is_valid(&pattern->regex[n])) {
string.start += regexp->last_index;
string.size -= regexp->last_index;
match_data = nxt_regex_match_data(&pattern->regex[n],
vm->regex_context);
if (nxt_slow_path(match_data == NULL)) {
return NXT_ERROR;
}
ret = nxt_regex_match(&pattern->regex[n], string.start, string.size,
match_data, vm->regex_context);
if (ret >= 0) {
return njs_regexp_exec_result(vm, regexp, string.start, match_data,
utf8);
}
if (nxt_slow_path(ret != NGX_REGEX_NOMATCH)) {
nxt_regex_match_data_free(match_data, vm->regex_context);
return njs_regexp_match_error(vm);
}
}
regexp->last_index = 0;
vm->retval = njs_value_null;
return NXT_OK;
}
njs_ret_t
njs_regexp_prototype_exec(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
njs_ret_t ret;
njs_utf8_t utf8;
njs_value_t *value;
njs_regexp_t *regexp;
njs_string_prop_t string;
njs_regexp_utf8_t type;
njs_regexp_pattern_t *pattern;
nxt_regex_match_data_t *match_data;
if (!njs_is_regexp(&args[0])) {
vm->exception = &njs_exception_type_error;
return NXT_ERROR;
}
if (nargs > 1) {
value = &args[1];
} else {
value = (njs_value_t *) &njs_string_void;
}
regexp = args[0].data.u.regexp;
regexp->string = *value;
(void) njs_string_prop(&string, value);
utf8 = NJS_STRING_BYTE;
type = NJS_REGEXP_BYTE;
if (string.length != 0) {
utf8 = NJS_STRING_ASCII;
type = NJS_REGEXP_UTF8;
if (string.length != string.size) {
utf8 = NJS_STRING_UTF8;
}
}
pattern = regexp->pattern;
if (nxt_regex_is_valid(&pattern->regex[type])) {
string.start += regexp->last_index;
string.size -= regexp->last_index;
match_data = nxt_regex_match_data(&pattern->regex[type],
vm->regex_context);
if (nxt_slow_path(match_data == NULL)) {
return NXT_ERROR;
}
ret = njs_regexp_match(vm, &pattern->regex[type], string.start,
string.size, match_data);
if (ret >= 0) {
return njs_regexp_exec_result(vm, regexp, utf8, string.start,
match_data);
}
if (nxt_slow_path(ret != NXT_REGEX_NOMATCH)) {
nxt_regex_match_data_free(match_data, vm->regex_context);
return NXT_ERROR;
}
}
regexp->last_index = 0;
vm->retval = njs_value_null;
return NXT_OK;
}
