}
-nxt_noinline njs_value_t *
+njs_value_t *
njs_vm_retval(njs_vm_t *vm)
{
return &vm->retval;
}
-nxt_noinline void
+void
njs_vm_retval_set(njs_vm_t *vm, const njs_value_t *value)
{
vm->retval = *value;
}
+void
+njs_value_undefined_set(njs_value_t *value)
+{
+ njs_set_undefined(value);
+}
+
+
+void
+njs_value_boolean_set(njs_value_t *value, int yn)
+{
+ njs_set_boolean(value, yn);
+}
+
+
+void
+njs_value_number_set(njs_value_t *value, double num)
+{
+ njs_set_number(value, num);
+}
+
+
+void
+njs_value_data_set(njs_value_t *value, void *data)
+{
+ njs_set_data(value, data);
+}
+
+
+njs_ret_t
+njs_vm_value_string_set(njs_vm_t *vm, njs_value_t *value, const u_char *start,
+ uint32_t size)
+{
+ return njs_string_set(vm, value, start, size);
+}
+
+
+u_char *
+njs_vm_value_string_alloc(njs_vm_t *vm, njs_value_t *value, uint32_t size)
+{
+ return njs_string_alloc(vm, value, size, 0);
+}
+
+
+nxt_noinline void
+njs_vm_value_error_set(njs_vm_t *vm, njs_value_t *value, const char *fmt, ...)
+{
+ va_list args;
+ u_char buf[NXT_MAX_ERROR_STR], *p;
+
+ p = buf;
+
+ if (fmt != NULL) {
+ va_start(args, fmt);
+ p = nxt_vsprintf(buf, buf + sizeof(buf), fmt, args);
+ va_end(args);
+ }
+
+ njs_error_new(vm, value, NJS_OBJECT_ERROR, buf, p - buf);
+}
+
+
+uint8_t
+njs_value_bool(const njs_value_t *value)
+{
+ return njs_bool(value);
+}
+
+
+double
+njs_value_number(const njs_value_t *value)
+{
+ return njs_number(value);
+}
+
+
+void *
+njs_value_data(const njs_value_t *value)
+{
+ return njs_data(value);
+}
+
+
+njs_function_t *
+njs_value_function(const njs_value_t *value)
+{
+ return njs_function(value);
+}
+
+
+nxt_int_t
+njs_value_is_null(const njs_value_t *value)
+{
+ return njs_is_null(value);
+}
+
+
+nxt_int_t
+njs_value_is_undefined(const njs_value_t *value)
+{
+ return njs_is_undefined(value);
+}
+
+
+nxt_int_t
+njs_value_is_null_or_undefined(const njs_value_t *value)
+{
+ return njs_is_null_or_undefined(value);
+}
+
+
+nxt_int_t
+njs_value_is_boolean(const njs_value_t *value)
+{
+ return njs_is_boolean(value);
+}
+
+
+nxt_int_t
+njs_value_is_number(const njs_value_t *value)
+{
+ return njs_is_number(value);
+}
+
+
+nxt_int_t
+njs_value_is_valid_number(const njs_value_t *value)
+{
+ return njs_is_number(value)
+ && !isnan(value->data.u.number)
+ && !isinf(value->data.u.number);
+}
+
+
+nxt_int_t
+njs_value_is_string(const njs_value_t *value)
+{
+ return njs_is_string(value);
+}
+
+
+nxt_int_t
+njs_value_is_object(const njs_value_t *value)
+{
+ return njs_is_object(value);
+}
+
+
+nxt_int_t
+njs_value_is_function(const njs_value_t *value)
+{
+ return njs_is_function(value);
+}
+
+
nxt_noinline void
njs_vm_memory_error(njs_vm_t *vm)
{
rc = NJS_OK;
- retval->data.u.object = object;
- retval->type = NJS_OBJECT;
- retval->data.truth = 1;
+ njs_set_object(retval, object);
done:
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&value->data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(value), &lhq);
if (nxt_slow_path(ret != NXT_OK)) {
return NULL;
}
njs_value_t *args, nxt_uint_t nargs, njs_index_t unused);
static njs_ret_t njs_array_prototype_map_continuation(njs_vm_t *vm,
njs_value_t *args, nxt_uint_t nargs, njs_index_t unused);
-static nxt_noinline uint32_t njs_array_prototype_map_index(njs_array_t *array,
+static uint32_t njs_array_prototype_map_index(njs_array_t *array,
njs_array_map_t *map);
-static nxt_noinline njs_ret_t njs_array_iterator_args(njs_vm_t *vm,
+static njs_ret_t njs_array_iterator_args(njs_vm_t *vm,
njs_value_t *args, nxt_uint_t nargs);
-static nxt_noinline uint32_t njs_array_iterator_index(njs_array_t *array,
+static uint32_t njs_array_iterator_index(njs_array_t *array,
njs_array_iter_t *iter);
-static nxt_noinline njs_ret_t njs_array_iterator_apply(njs_vm_t *vm,
+static njs_ret_t njs_array_iterator_apply(njs_vm_t *vm,
njs_array_iter_t *iter, njs_value_t *args, nxt_uint_t nargs);
-static nxt_noinline njs_ret_t njs_array_prototype_find_apply(njs_vm_t *vm,
+static njs_ret_t njs_array_prototype_find_apply(njs_vm_t *vm,
njs_array_iter_t *iter, njs_value_t *args, nxt_uint_t nargs);
static njs_ret_t njs_array_prototype_reduce_continuation(njs_vm_t *vm,
njs_value_t *args, nxt_uint_t nargs, njs_index_t unused);
njs_value_t *args, nxt_uint_t nargs, njs_index_t unused);
-nxt_noinline njs_array_t *
+njs_array_t *
njs_array_alloc(njs_vm_t *vm, uint64_t length, uint32_t spare)
{
uint64_t size;
if (nxt_fast_path(array != NULL)) {
- vm->retval.data.u.array = array;
value = array->start;
if (args == NULL) {
}
}
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+
+ njs_set_array(&vm->retval, array);
return NXT_OK;
}
return NXT_ERROR;
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
for (i = 0; i < length; i++) {
array->start[i] = args[i + 1];
array = (njs_array_t *) proto;
- njs_value_number_set(retval, array->length);
+ njs_set_number(retval, array->length);
return NJS_OK;
}
array->length = length;
- njs_value_number_set(retval, length);
+ njs_set_number(retval, length);
return NJS_OK;
}
return NXT_ERROR;
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
if (length != 0) {
n = 0;
if (nxt_fast_path(njs_is_array(this))) {
- value = this->data.u.array->start;
+ value = njs_array_start(this);
do {
/* GC: retain long string and object in values[start]. */
njs_array_t *array;
if (njs_is_array(&args[0])) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
if (nargs != 0) {
ret = njs_array_expand(vm, array, 0, nargs);
}
}
- njs_value_number_set(&vm->retval, array->length);
+ njs_set_number(&vm->retval, array->length);
}
return NXT_OK;
retval = &njs_value_undefined;
if (njs_is_array(&args[0])) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
if (array->length != 0) {
array->length--;
njs_array_t *array;
if (njs_is_array(&args[0])) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
n = nargs - 1;
if (n != 0) {
} while (n > 1);
}
- njs_value_number_set(&vm->retval, array->length);
+ njs_set_number(&vm->retval, array->length);
}
return NXT_OK;
retval = &njs_value_undefined;
if (njs_is_array(&args[0])) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
if (array->length != 0) {
array->length--;
delete = 0;
if (njs_is_array(&args[0])) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
length = array->length;
if (nargs > 1) {
}
}
- vm->retval.data.u.array = deleted;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, deleted);
return NXT_OK;
}
njs_array_t *array;
if (njs_is_array(&args[0])) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
length = array->length;
if (length > 1) {
}
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
} else {
/* STUB */
goto empty;
}
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
if (array->length == 0) {
goto empty;
n = 0;
mask = -1;
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
for (i = 0; i < array->length; i++) {
value = &array->start[i];
for (i = 0; i < nargs; i++) {
if (njs_is_array(&args[i])) {
- length += args[i].data.u.array->length;
+ length += njs_array_len(&args[i]);
} else {
length++;
return NXT_ERROR;
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
value = array->start;
n = 1;
if (njs_is_array(src)) {
- n = src->data.u.array->length;
- src = src->data.u.array->start;
+ n = njs_array_len(src);
+ src = njs_array_start(src);
}
while (n != 0) {
goto done;
}
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
length = array->length;
if (length == 0) {
done:
- njs_value_number_set(&vm->retval, index);
+ njs_set_number(&vm->retval, index);
return NXT_OK;
}
goto done;
}
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
length = array->length;
if (length == 0) {
done:
- njs_value_number_set(&vm->retval, index);
+ njs_set_number(&vm->retval, index);
return NXT_OK;
}
goto done;
}
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
length = array->length;
if (length == 0) {
fill = njs_vm_continuation(vm);
if (njs_is_array(this)) {
- array = this->data.u.array;
+ array = njs_array(this);
length = array->length;
} else {
iter = njs_vm_continuation(vm);
- index = njs_array_iterator_index(args[0].data.u.array, iter);
+ index = njs_array_iterator_index(njs_array(&args[0]), iter);
if (index == NJS_ARRAY_INVALID_INDEX) {
vm->retval = njs_value_undefined;
retval = &njs_value_true;
} else {
- index = njs_array_iterator_index(args[0].data.u.array, iter);
+ index = njs_array_iterator_index(njs_array(&args[0]), iter);
if (index == NJS_ARRAY_INVALID_INDEX) {
retval = &njs_value_false;
retval = &njs_value_false;
} else {
- index = njs_array_iterator_index(args[0].data.u.array, iter);
+ index = njs_array_iterator_index(njs_array(&args[0]), iter);
if (index == NJS_ARRAY_INVALID_INDEX) {
retval = &njs_value_true;
}
}
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
index = njs_array_iterator_index(array, &filter->iter);
if (index == NJS_ARRAY_INVALID_INDEX) {
- vm->retval.data.u.array = filter->array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, filter->array);
return NXT_OK;
}
iter = &find->iter;
if (!njs_is_true(&iter->retval)) {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
iter->index++;
if (iter->index < iter->length && iter->index < array->length) {
iter->index++;
if (iter->index < iter->length
- && iter->index < args[0].data.u.array->length)
+ && iter->index < njs_array_len(&args[0]))
{
return njs_array_prototype_find_apply(vm, iter, args, nargs);
}
index = -1;
}
- njs_value_number_set(&vm->retval, index);
+ njs_set_number(&vm->retval, index);
return NXT_OK;
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_array_prototype_find_apply(njs_vm_t *vm, njs_array_iter_t *iter,
njs_value_t *args, nxt_uint_t nargs)
{
arguments[0] = *value;
n = iter->index;
- value = &args[0].data.u.array->start[n];
+ value = &njs_array_start(&args[0])[n];
if (!njs_is_valid(value)) {
value = &njs_value_undefined;
arguments[1] = *value;
- njs_value_number_set(&arguments[2], n);
+ njs_set_number(&arguments[2], n);
arguments[3] = args[0];
map->iter.u.cont.function = njs_array_prototype_map_continuation;
njs_set_invalid(&map->iter.retval);
- map->array = njs_array_alloc(vm, args[0].data.u.array->length, 0);
+ map->array = njs_array_alloc(vm, njs_array_len(&args[0]), 0);
if (nxt_slow_path(map->array == NULL)) {
return NXT_ERROR;
}
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_array_prototype_map_continuation(njs_vm_t *vm, njs_value_t *args,
nxt_uint_t nargs, njs_index_t unused)
{
map->array->start[map->iter.index] = map->iter.retval;
}
- index = njs_array_prototype_map_index(args[0].data.u.array, map);
+ index = njs_array_prototype_map_index(njs_array(&args[0]), map);
if (index == NJS_ARRAY_INVALID_INDEX) {
- vm->retval.data.u.array = map->array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, map->array);
return NXT_OK;
}
iter->retval = args[2];
} else {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
n = njs_array_iterator_index(array, iter);
if (n == NJS_ARRAY_INVALID_INDEX) {
njs_array_iter_t *iter;
iter = njs_vm_continuation(vm);
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
n = njs_array_iterator_index(array, iter);
arguments[2] = array->start[n];
- njs_value_number_set(&arguments[3], n);
+ njs_set_number(&arguments[3], n);
arguments[4] = args[0];
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_array_iterator_args(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs)
{
njs_array_iter_t *iter;
if (nargs > 1 && njs_is_array(&args[0]) && njs_is_function(&args[1])) {
iter = njs_vm_continuation(vm);
- iter->length = args[0].data.u.array->length;
+ iter->length = njs_array_len(&args[0]);
iter->retval.data.truth = 0;
iter->index = NJS_ARRAY_INVALID_INDEX;
}
-static nxt_noinline uint32_t
+static uint32_t
njs_array_iterator_index(njs_array_t *array, njs_array_iter_t *iter)
{
uint32_t i, length;
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_array_iterator_apply(njs_vm_t *vm, njs_array_iter_t *iter,
njs_value_t *args, nxt_uint_t nargs)
{
arguments[0] = *value;
n = iter->index;
- arguments[1] = args[0].data.u.array->start[n];
+ arguments[1] = njs_array_start(&args[0])[n];
- njs_value_number_set(&arguments[2], n);
+ njs_set_number(&arguments[2], n);
arguments[3] = args[0];
iter->retval = args[2];
} else {
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
n = njs_array_reduce_right_index(array, iter);
if (n == NJS_ARRAY_INVALID_INDEX) {
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_array_prototype_reduce_right_continuation(njs_vm_t *vm, njs_value_t *args,
nxt_uint_t nargs, njs_index_t unused)
{
njs_array_iter_t *iter;
iter = njs_vm_continuation(vm);
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
n = njs_array_reduce_right_index(array, iter);
arguments[2] = array->start[n];
- njs_value_number_set(&arguments[3], n);
+ njs_set_number(&arguments[3], n);
arguments[4] = args[0];
}
-static nxt_noinline uint32_t
+static uint32_t
njs_array_reduce_right_index(njs_array_t *array, njs_array_iter_t *iter)
{
uint32_t n;
ret = njs_string_cmp(&args[1], &args[2]);
- njs_value_number_set(&vm->retval, ret);
+ njs_set_number(&vm->retval, ret);
return NXT_OK;
}
{
njs_array_sort_t *sort;
- if (njs_is_array(&args[0]) && args[0].data.u.array->length > 1) {
+ if (njs_is_array(&args[0]) && njs_array_len(&args[0]) > 1) {
sort = njs_vm_continuation(vm);
sort->u.cont.function = njs_array_prototype_sort_continuation;
njs_value_t value, *start, arguments[3];
njs_array_sort_t *sort;
- array = args[0].data.u.array;
+ array = njs_array(&args[0]);
start = array->start;
sort = njs_vm_continuation(vm);
lhq.key.length = p - lhq.key.start;
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
- ret = nxt_lvlhsh_find(&value->data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(value), &lhq);
if (nxt_slow_path(ret != NXT_OK)) {
return NULL;
}
return NJS_ERROR;
}
- prop->value.data.u.array = argv;
- prop->value.type = NJS_ARRAY;
- prop->value.data.truth = 1;
+ njs_set_array(&prop->value, argv);
lhq.value = prop;
lhq.key_hash = NJS_ARGV_HASH;
lhq.pool = vm->mem_pool;
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_insert(&process->data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_insert(njs_object_hash(process), &lhq);
if (nxt_fast_path(ret == NXT_OK)) {
*retval = prop->value;
return NXT_ERROR;
}
- prop->value.data.u.object = env;
- prop->value.type = NJS_OBJECT;
- prop->value.data.truth = 1;
+ njs_set_object(&prop->value, env);
lhq.replace = 0;
lhq.pool = vm->mem_pool;
lhq.key = nxt_string_value("env");
lhq.key_hash = NJS_ENV_HASH;
- ret = nxt_lvlhsh_insert(&process->data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_insert(njs_object_hash(process), &lhq);
if (nxt_fast_path(ret == NXT_OK)) {
*retval = prop->value;
alg->init(&dgst->u);
- njs_value_data_set(&hash->value, dgst);
+ njs_set_data(&hash->value, dgst);
vm->retval.data.u.object_value = hash;
vm->retval.type = NJS_OBJECT_VALUE;
return NJS_ERROR;
}
- njs_value_data_set(&hmac->value, ctx);
+ njs_set_data(&hmac->value, ctx);
vm->retval.data.u.object_value = hmac;
vm->retval.type = NJS_OBJECT_VALUE;
sizeof("Mon Sep 28 1970 12:00:00 GMT+0600 (XXXXX)")
-static nxt_noinline double njs_date_string_parse(njs_value_t *date);
+static double njs_date_string_parse(njs_value_t *date);
static double njs_date_rfc2822_string_parse(struct tm *tm, const u_char *p,
const u_char *end);
static double njs_date_js_string_parse(struct tm *tm, const u_char *p,
const u_char *end);
static const u_char *njs_date_skip_week_day(const u_char *p, const u_char *end);
static const u_char *njs_date_skip_spaces(const u_char *p, const u_char *end);
-static nxt_noinline nxt_int_t njs_date_month_parse(const u_char *p,
+static nxt_int_t njs_date_month_parse(const u_char *p, const u_char *end);
+static const u_char *njs_date_time_parse(struct tm *tm, const u_char *p,
const u_char *end);
-static nxt_noinline const u_char *njs_date_time_parse(struct tm *tm,
- const u_char *p, const u_char *end);
-static nxt_noinline nxt_int_t njs_date_gmtoff_parse(const u_char *start,
- const u_char *end);
-static nxt_noinline const u_char *njs_date_number_parse(int *value,
- const u_char *p, const u_char *end, size_t size);
+static nxt_int_t njs_date_gmtoff_parse(const u_char *start, const u_char *end);
+static const u_char *njs_date_number_parse(int *value, const u_char *p,
+ const u_char *end, size_t size);
static int64_t njs_timegm(struct tm *tm);
-static nxt_noinline njs_ret_t njs_date_string(njs_vm_t *vm, const char *fmt,
- double time);
-static nxt_noinline double njs_date_time(struct tm *tm, int64_t ms);
+static njs_ret_t njs_date_string(njs_vm_t *vm, const char *fmt, double time);
+static double njs_date_time(struct tm *tm, int64_t ms);
static double njs_date_utc_time(struct tm *tm, double time);
static const njs_value_t njs_string_invalid_date = njs_string("Invalid Date");
-static nxt_noinline uint64_t
+static uint64_t
njs_gettime(void)
{
struct timeval tv;
}
-static nxt_noinline double
+static double
njs_timeclip(double time)
{
if (isinf(time) || isnan(time) || fabs(time) > 8.64e15) {
done:
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
njs_date_now(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
- njs_value_number_set(&vm->retval, njs_gettime());
+ njs_set_number(&vm->retval, njs_gettime());
return NXT_OK;
}
time = NAN;
}
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
-static nxt_noinline double
+static double
njs_date_string_parse(njs_value_t *date)
{
int ext, ms, ms_length, skipped;
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_date_month_parse(const u_char *p, const u_char *end)
{
if (p + 2 < end) {
}
-static nxt_noinline const u_char *
+static const u_char *
njs_date_time_parse(struct tm *tm, const u_char *p, const u_char *end)
{
p = njs_date_number_parse(&tm->tm_hour, p, end, 2);
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_date_gmtoff_parse(const u_char *start, const u_char *end)
{
int gmtoff, hour, min;
}
-static nxt_noinline const u_char *
+static const u_char *
njs_date_number_parse(int *value, const u_char *p, const u_char *end,
size_t size)
{
njs_date_prototype_value_of(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
- njs_value_number_set(&vm->retval, args[0].data.u.date->time);
+ njs_set_number(&vm->retval, args[0].data.u.date->time);
return NXT_OK;
}
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_date_string(njs_vm_t *vm, const char *fmt, double time)
{
size_t size;
value = tm.tm_year + 1900;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_year + 1900;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_mon;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_mon;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_mday;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_mday;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_wday;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_wday;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_hour;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_hour;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_min;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = tm.tm_min;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = (int64_t) (value / 1000) % 60;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = (int64_t) value % 1000;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
value = - nxt_timezone(&tm) / 60;
}
- njs_value_number_set(&vm->retval, value);
+ njs_set_number(&vm->retval, value);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
}
args[0].data.u.date->time = time;
- njs_value_number_set(&vm->retval, time);
+ njs_set_number(&vm->retval, time);
return NXT_OK;
}
-static nxt_noinline double
+static double
njs_date_time(struct tm *tm, int64_t ms)
{
double time;
}
-nxt_noinline njs_object_t *
+njs_object_t *
njs_error_alloc(njs_vm_t *vm, njs_value_type_t type, const njs_value_t *name,
const njs_value_t *message)
{
void njs_error_new(njs_vm_t *vm, njs_value_t *dst, njs_value_type_t type,
u_char *start, size_t size);
-void njs_error_fmt_new(njs_vm_t *vm, njs_value_t *dst, njs_value_type_t type,
- const char *fmt, ...);
+void nxt_noinline njs_error_fmt_new(njs_vm_t *vm, njs_value_t *dst,
+ njs_value_type_t type, const char *fmt, ...);
void njs_memory_error(njs_vm_t *vm);
void njs_memory_error_set(njs_vm_t *vm, njs_value_t *value);
return NJS_ERROR;
}
- njs_value_number_set(&vm->retval, vm->event_id - 1);
+ njs_set_number(&vm->retval, vm->event_id - 1);
return NJS_OK;
}
}
-nxt_noinline njs_external_ptr_t
+njs_external_ptr_t
njs_vm_external(njs_vm_t *vm, const njs_value_t *value)
{
if (nxt_fast_path(njs_is_external(value))) {
lhq.key = nxt_string_value("flag");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[2].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[2]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &flag);
lhq.key = nxt_string_value("encoding");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[2].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[2]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &encoding);
lhq.key = nxt_string_value("flag");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[2].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[2]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &flag);
lhq.key = nxt_string_value("encoding");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[2].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[2]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &encoding);
lhq.key = nxt_string_value("flag");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[3].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[3]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &flag);
lhq.key = nxt_string_value("encoding");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[3].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[3]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &encoding);
lhq.key = nxt_string_value("mode");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[3].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[3]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
mode = &prop->value;
lhq.key = nxt_string_value("flag");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[3].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[3]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &flag);
lhq.key = nxt_string_value("encoding");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[3].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[3]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
njs_string_get(&prop->value, &encoding);
lhq.key = nxt_string_value("mode");
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&args[3].data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&args[3]), &lhq);
if (ret == NXT_OK) {
prop = lhq.value;
mode = &prop->value;
nargs = frame->nargs;
- njs_value_number_set(&value, nargs);
+ njs_set_number(&value, nargs);
prop = njs_object_prop_alloc(vm, &njs_string_length, &value, 1);
if (nxt_slow_path(prop == NULL)) {
rest_arguments = &frame->arguments[frame->function->u.lambda->nargs];
/* GC: retain. */
- rest_arguments->type = NJS_ARRAY;
- rest_arguments->data.u.array = array;
- rest_arguments->data.truth = 1;
+ njs_set_array(rest_arguments, array);
return NXT_OK;
}
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_function_lambda_frame(njs_vm_t *vm, njs_function_t *function,
const njs_value_t *this, const njs_value_t *args, nxt_uint_t nargs,
nxt_bool_t ctor)
}
-nxt_noinline njs_native_frame_t *
+njs_native_frame_t *
njs_function_frame_alloc(njs_vm_t *vm, size_t size)
{
size_t spare_size, chunk_size;
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_function_lambda_call(njs_vm_t *vm, njs_index_t retval,
u_char *return_address)
{
n = 0;
}
- njs_value_number_set(retval, n);
+ njs_set_number(retval, n);
return NXT_OK;
}
njs_generator_t *generator, njs_parser_node_t *node);
static nxt_int_t njs_generate_for_in_statement(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline nxt_int_t njs_generate_start_block(njs_vm_t *vm,
+static nxt_int_t njs_generate_start_block(njs_vm_t *vm,
njs_generator_t *generator, njs_generator_block_type_t type,
const nxt_str_t *label);
static njs_generator_block_t *njs_generate_lookup_block(
njs_generator_block_t *block, uint32_t mask, const nxt_str_t *label);
static njs_generator_block_t *njs_generate_find_block(
njs_generator_block_t *block, uint32_t mask, const nxt_str_t *label);
-static nxt_noinline void njs_generate_patch_block(njs_vm_t *vm,
- njs_generator_t *generator, njs_generator_patch_t *list);
+static void njs_generate_patch_block(njs_vm_t *vm, njs_generator_t *generator,
+ njs_generator_patch_t *list);
static njs_generator_patch_t *njs_generate_make_continuation_patch(njs_vm_t *vm,
njs_generator_block_t *block, const nxt_str_t *label, njs_ret_t offset);
static njs_generator_patch_t *njs_generate_make_exit_patch(njs_vm_t *vm,
njs_generator_block_t *block, const nxt_str_t *label, njs_ret_t offset);
-static nxt_noinline void njs_generate_patch_block_exit(njs_vm_t *vm,
+static void njs_generate_patch_block_exit(njs_vm_t *vm,
njs_generator_t *generator);
static const nxt_str_t *njs_generate_jump_destination(njs_vm_t *vm,
njs_generator_block_t *block, const char *inst_type, uint32_t mask,
njs_generator_t *generator, njs_parser_node_t *node);
static nxt_int_t njs_generate_method_call(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline nxt_int_t njs_generate_call(njs_vm_t *vm,
- njs_generator_t *generator, njs_parser_node_t *node);
+static nxt_int_t njs_generate_call(njs_vm_t *vm, njs_generator_t *generator,
+ njs_parser_node_t *node);
static nxt_int_t njs_generate_try_statement(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
static nxt_int_t njs_generate_throw_statement(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
static nxt_int_t njs_generate_export_statement(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline njs_index_t njs_generate_dest_index(njs_vm_t *vm,
+static njs_index_t njs_generate_dest_index(njs_vm_t *vm,
+ njs_generator_t *generator, njs_parser_node_t *node);
+static njs_index_t njs_generate_object_dest_index(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline njs_index_t
- njs_generate_object_dest_index(njs_vm_t *vm, njs_generator_t *generator,
- njs_parser_node_t *node);
static njs_index_t njs_generate_node_temp_index_get(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline njs_index_t njs_generate_temp_index_get(njs_vm_t *vm,
+static njs_index_t njs_generate_temp_index_get(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline nxt_int_t
- njs_generate_children_indexes_release(njs_vm_t *vm,
+static nxt_int_t njs_generate_children_indexes_release(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline nxt_int_t njs_generate_node_index_release(njs_vm_t *vm,
+static nxt_int_t njs_generate_node_index_release(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
-static nxt_noinline nxt_int_t njs_generate_index_release(njs_vm_t *vm,
+static nxt_int_t njs_generate_index_release(njs_vm_t *vm,
njs_generator_t *generator, njs_index_t index);
static nxt_int_t njs_generate_reference_error(njs_vm_t *vm,
njs_generator_t *generator, njs_parser_node_t *node);
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_generate_start_block(njs_vm_t *vm, njs_generator_t *generator,
njs_generator_block_type_t type, const nxt_str_t *label)
{
}
-static nxt_noinline void
+static void
njs_generate_patch_block(njs_vm_t *vm, njs_generator_t *generator,
njs_generator_patch_t *list)
{
}
-static nxt_noinline void
+static void
njs_generate_patch_block_exit(njs_vm_t *vm, njs_generator_t *generator)
{
njs_generator_block_t *block;
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_generate_call(njs_vm_t *vm, njs_generator_t *generator,
njs_parser_node_t *node)
{
}
-static nxt_noinline njs_index_t
+static njs_index_t
njs_generate_dest_index(njs_vm_t *vm, njs_generator_t *generator,
njs_parser_node_t *node)
{
}
-static nxt_noinline njs_index_t
+static njs_index_t
njs_generate_object_dest_index(njs_vm_t *vm, njs_generator_t *generator,
njs_parser_node_t *node)
{
}
-static nxt_noinline njs_index_t
+static njs_index_t
njs_generate_temp_index_get(njs_vm_t *vm, njs_generator_t *generator,
njs_parser_node_t *node)
{
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_generate_children_indexes_release(njs_vm_t *vm, njs_generator_t *generator,
njs_parser_node_t *node)
{
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_generate_node_index_release(njs_vm_t *vm, njs_generator_t *generator,
njs_parser_node_t *node)
{
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_generate_index_release(njs_vm_t *vm, njs_generator_t *generator,
njs_index_t index)
{
}
}
- value->data.u.object = object;
- value->type = NJS_OBJECT;
- value->data.truth = 1;
+ njs_set_object(value, object);
ctx->depth++;
}
}
- value->data.u.array = array;
- value->type = NJS_ARRAY;
- value->data.truth = 1;
+ njs_set_array(value, array);
ctx->depth++;
#define njs_json_is_non_empty(_value) \
(((_value)->type == NJS_OBJECT) \
- && !nxt_lvlhsh_is_empty(&(_value)->data.u.object->hash)) \
- || (((_value)->type == NJS_ARRAY) && (_value)->data.u.array->length != 0)
+ && !nxt_lvlhsh_is_empty(njs_object_hash(_value))) \
+ || (((_value)->type == NJS_ARRAY) && njs_array_len(_value) != 0)
static njs_ret_t
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&state->value.data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&state->value), &lhq);
if (nxt_slow_path(ret == NXT_DECLINED)) {
state->index++;
break;
lhq.pool = vm->mem_pool;
if (njs_is_undefined(&parse->retval)) {
- ret = nxt_lvlhsh_delete(&state->value.data.u.object->hash,
- &lhq);
+ ret = nxt_lvlhsh_delete(njs_object_hash(&state->value), &lhq);
} else {
prop = njs_object_prop_alloc(vm, key, &parse->retval, 1);
}
lhq.value = prop;
- ret = nxt_lvlhsh_insert(&state->value.data.u.object->hash,
- &lhq);
+ ret = nxt_lvlhsh_insert(njs_object_hash(&state->value), &lhq);
}
if (nxt_slow_path(ret != NXT_OK)) {
break;
case NJS_JSON_ARRAY_START:
- if (state->index < state->value.data.u.array->length) {
- value = &state->value.data.u.array->start[state->index];
+ if (state->index < njs_array_len(&state->value)) {
+ value = &njs_array_start(&state->value)[state->index];
if (njs_json_is_non_empty(value)) {
state = njs_json_push_parse_state(vm, parse, value);
return njs_json_parse_continuation_apply(vm, parse);
case NJS_JSON_ARRAY_REPLACED:
- value = &state->value.data.u.array->start[state->index];
+ value = &njs_array_start(&state->value)[state->index];
*value = parse->retval;
state->index++;
case NJS_JSON_ARRAY_START:
njs_uint32_to_string(&arguments[1], state->index);
- arguments[2] = state->value.data.u.array->start[state->index];
+ arguments[2] = njs_array_start(&state->value)[state->index];
state->type = NJS_JSON_ARRAY_REPLACED;
break;
lhq.key_hash = nxt_djb_hash(lhq.key.start, lhq.key.length);
lhq.proto = &njs_object_hash_proto;
- ret = nxt_lvlhsh_find(&state->value.data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_find(njs_object_hash(&state->value), &lhq);
if (nxt_slow_path(ret == NXT_DECLINED)) {
break;
}
/* Fall through. */
case NJS_JSON_ARRAY_CONTINUE:
- if (state->index >= state->value.data.u.array->length) {
+ if (state->index >= njs_array_len(&state->value)) {
njs_json_stringify_indent(stringify->stack.items - 1);
njs_json_stringify_append("]", 1);
njs_json_stringify_indent(stringify->stack.items);
}
- value = &state->value.data.u.array->start[state->index++];
+ value = &njs_array_start(&state->value)[state->index++];
if (njs_is_object(value)) {
to_json = njs_object_to_json_function(vm, value);
njs_array_t *properties, *array;
properties_length = 1;
- array = stringify->replacer.data.u.array;
+ array = njs_array(&stringify->replacer);
array_length = array->length;
for (i = 0; i < array_length; i++) {
state->prop_value = NULL;
if (njs_is_array(&stringify->replacer)) {
- state->keys = stringify->replacer.data.u.array;
+ state->keys = njs_array(&stringify->replacer);
} else {
if (njs_is_external(value)) {
lhq.value = prop;
- ret = nxt_lvlhsh_insert(&wrapper->data.u.object->hash, &lhq);
+ ret = nxt_lvlhsh_insert(njs_object_hash(wrapper), &lhq);
if (nxt_slow_path(ret != NXT_OK)) {
return NULL;
}
/* Fall through. */
case NJS_JSON_ARRAY_CONTINUE:
- if (state->index >= state->value.data.u.array->length) {
+ if (state->index >= njs_array_len(&state->value)) {
njs_json_stringify_indent(stringify->stack.items);
njs_json_stringify_append("]", 1);
njs_json_stringify_indent(stringify->stack.items + 1);
}
- val = &state->value.data.u.array->start[state->index++];
+ val = &njs_array_start(&state->value)[state->index++];
if (njs_dump_is_object(val)) {
state = njs_json_push_stringify_state(vm, stringify, val);
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = 32;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
}
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = 0;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
done:
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = INFINITY;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = nxt_random(&vm->random) / 4294967296.0;
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
static nxt_int_t njs_module_lookup(njs_vm_t *vm, const nxt_str_t *cwd,
njs_module_info_t *info);
-static nxt_noinline nxt_int_t njs_module_relative_path(njs_vm_t *vm,
+static nxt_int_t njs_module_relative_path(njs_vm_t *vm,
const nxt_str_t *dir, njs_module_info_t *info);
static nxt_int_t njs_module_absolute_path(njs_vm_t *vm,
njs_module_info_t *info);
if (module->function.native) {
value = njs_vmcode_operand(vm, module->index);
- value->data.u.object = &module->object;
- value->type = NJS_OBJECT;
- value->data.truth = 1;
+ njs_set_object(value, &module->object);
} else {
ret = njs_vm_invoke(vm, &module->function, NULL, 0, module->index);
}
-static nxt_noinline nxt_int_t
+static nxt_int_t
njs_module_relative_path(njs_vm_t *vm, const nxt_str_t *dir,
njs_module_info_t *info)
{
module = lhq.value;
module->object.__proto__ = &vm->prototypes[NJS_PROTOTYPE_OBJECT].object;
- vm->retval.data.u.object = &module->object;
- vm->retval.type = NJS_OBJECT;
- vm->retval.data.truth = 1;
+ njs_set_object(&vm->retval, &module->object);
return NXT_OK;
}
} else if (njs_is_array(value)) {
- array = value->data.u.array;
+ array = njs_array(value);
if (nxt_lvlhsh_is_empty(&array->object.hash)) {
}
-double
-njs_primitive_value_to_number(const njs_value_t *value)
-{
- if (nxt_fast_path(njs_is_numeric(value))) {
- return value->data.u.number;
- }
-
- return njs_string_to_number(value, 1);
-}
-
-
-int32_t
-njs_primitive_value_to_integer(const njs_value_t *value)
-{
- return njs_number_to_integer(njs_primitive_value_to_number(value));
-}
-
-
-int32_t
-njs_primitive_value_to_int32(const njs_value_t *value)
-{
- return njs_number_to_int32(njs_primitive_value_to_number(value));
-}
-
-
-uint32_t
-njs_primitive_value_to_uint32(const njs_value_t *value)
-{
- return njs_number_to_uint32(njs_primitive_value_to_number(value));
-}
-
-
-uint32_t
-njs_primitive_value_to_length(const njs_value_t *value)
-{
- return njs_number_to_length(njs_primitive_value_to_number(value));
-}
-
-
double
njs_number_dec_parse(const u_char **start, const u_char *end)
{
vm->retval.data.truth = 1;
} else {
- njs_value_number_set(&vm->retval, value->data.u.number);
+ njs_set_number(&vm->retval, value->data.u.number);
}
return NXT_OK;
done:
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
num = njs_string_to_number(&args[1], 1);
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
-int64_t
-njs_number_to_int64(double num)
-{
-#if (NXT_NAN_TO_UINT_CONVERSION != 0)
- /*
- * PPC32: NaN and Inf are converted to 0x8000000080000000
- * and become non-zero after truncation.
- */
-
- if (isnan(num) || isinf(num)) {
- return 0;
- }
-#endif
-
- /*
- * ES5.1: integer must be modulo 2^32.
- * 2^53 is the largest integer number which can be stored safely
- * in the IEEE-754 format and numbers less than 2^53 can be just
- * converted to int64_t eliding more expensive fmod() operation.
- * Then the int64 integer is truncated to uint32_t. The NaN is
- * converted to 0x8000000000000000 and becomes 0 after truncation.
- * fmod() of the Infinity returns NaN.
- */
-
- if (fabs(num) > 9007199254740992.0) {
- return (int64_t) fmod(num, 4294967296.0);
- }
-
- return (int64_t) num;
-}
-
-
-nxt_noinline int32_t
-njs_number_to_integer(double num)
-{
- return (int32_t) njs_number_to_int64(num);
-}
-
-
-nxt_noinline int32_t
-njs_number_to_int32(double num)
-{
- return (int32_t) njs_number_to_int64(num);
-}
-
-
-nxt_noinline uint32_t
-njs_number_to_uint32(double num)
-{
- return (uint32_t) njs_number_to_int64(num);
-}
-
-
-nxt_noinline uint32_t
-njs_number_to_length(double num)
-{
-#if (NXT_NAN_TO_UINT_CONVERSION != 0)
- if (isnan(num)) {
- return 0;
- }
-#endif
-
- if (num > UINT32_MAX) {
- return UINT32_MAX;
-
- } else if (num < 0.0) {
- return 0;
- }
-
- return (uint32_t) (int64_t) num;
-}
-
-
-
static const njs_object_prop_t njs_is_nan_function_properties[] =
{
/* isNaN.name == "isNaN". */
#define _NJS_NUMBER_H_INCLUDED_
+#include <njs_string.h>
#include <math.h>
uint32_t njs_value_to_index(const njs_value_t *value);
-double njs_primitive_value_to_number(const njs_value_t *value);
-int32_t njs_primitive_value_to_integer(const njs_value_t *value);
-int32_t njs_primitive_value_to_int32(const njs_value_t *value);
-uint32_t njs_primitive_value_to_uint32(const njs_value_t *value);
-uint32_t njs_primitive_value_to_length(const njs_value_t *value);
double njs_number_dec_parse(const u_char **start, const u_char *end);
uint64_t njs_number_oct_parse(const u_char **start, const u_char *end);
uint64_t njs_number_bin_parse(const u_char **start, const u_char *end);
nxt_uint_t nargs, njs_index_t unused);
njs_ret_t njs_number_parse_float(njs_vm_t *vm, njs_value_t *args,
nxt_uint_t nargs, njs_index_t unused);
-int64_t njs_number_to_int64(double num);
-nxt_noinline int32_t njs_number_to_integer(double num);
-nxt_noinline int32_t njs_number_to_int32(double num);
-nxt_noinline uint32_t njs_number_to_uint32(double num);
-nxt_noinline uint32_t njs_number_to_length(double num);
+
+
+nxt_inline int64_t
+njs_number_to_int64(double num)
+{
+#if (NXT_NAN_TO_UINT_CONVERSION != 0)
+ /*
+ * PPC32: NaN and Inf are converted to 0x8000000080000000
+ * and become non-zero after truncation.
+ */
+
+ if (isnan(num) || isinf(num)) {
+ return 0;
+ }
+#endif
+
+ /*
+ * ES5.1: integer must be modulo 2^32.
+ * 2^53 is the largest integer number which can be stored safely
+ * in the IEEE-754 format and numbers less than 2^53 can be just
+ * converted to int64_t eliding more expensive fmod() operation.
+ * Then the int64 integer is truncated to uint32_t. The NaN is
+ * converted to 0x8000000000000000 and becomes 0 after truncation.
+ * fmod() of the Infinity returns NaN.
+ */
+
+ if (fabs(num) > 9007199254740992.0) {
+ return (int64_t) fmod(num, 4294967296.0);
+ }
+
+ return (int64_t) num;
+}
+
+
+nxt_inline int32_t
+njs_number_to_integer(double num)
+{
+ return (int32_t) njs_number_to_int64(num);
+}
+
+
+nxt_inline int32_t
+njs_number_to_int32(double num)
+{
+ return (int32_t) njs_number_to_int64(num);
+}
+
+
+nxt_inline uint32_t
+njs_number_to_uint32(double num)
+{
+ return (uint32_t) njs_number_to_int64(num);
+}
+
+
+nxt_inline uint32_t
+njs_number_to_length(double num)
+{
+#if (NXT_NAN_TO_UINT_CONVERSION != 0)
+ if (isnan(num)) {
+ return 0;
+ }
+#endif
+
+ if (num > UINT32_MAX) {
+ return UINT32_MAX;
+
+ } else if (num < 0.0) {
+ return 0;
+ }
+
+ return (uint32_t) (int64_t) num;
+}
+
nxt_inline nxt_int_t
njs_char_to_hex(u_char c)
}
+nxt_inline double
+njs_primitive_value_to_number(const njs_value_t *value)
+{
+ if (nxt_fast_path(njs_is_numeric(value))) {
+ return value->data.u.number;
+ }
+
+ return njs_string_to_number(value, 1);
+}
+
+
+nxt_inline int32_t
+njs_primitive_value_to_integer(const njs_value_t *value)
+{
+ return njs_number_to_integer(njs_primitive_value_to_number(value));
+}
+
+
+nxt_inline int32_t
+njs_primitive_value_to_int32(const njs_value_t *value)
+{
+ return njs_number_to_int32(njs_primitive_value_to_number(value));
+}
+
+
+nxt_inline uint32_t
+njs_primitive_value_to_uint32(const njs_value_t *value)
+{
+ return njs_number_to_uint32(njs_primitive_value_to_number(value));
+}
+
+
+nxt_inline uint32_t
+njs_primitive_value_to_length(const njs_value_t *value)
+{
+ return njs_number_to_length(njs_primitive_value_to_number(value));
+}
+
+
nxt_inline void
njs_uint32_to_string(njs_value_t *value, uint32_t u32)
{
njs_object_enum_t kind, nxt_bool_t all);
-nxt_noinline njs_object_t *
+njs_object_t *
njs_object_alloc(njs_vm_t *vm)
{
njs_object_t *object;
}
-nxt_noinline njs_object_t *
+njs_object_t *
njs_object_value_alloc(njs_vm_t *vm, const njs_value_t *value, nxt_uint_t type)
{
nxt_uint_t index;
object->__proto__ = NULL;
}
- vm->retval.data.u.object = object;
- vm->retval.type = NJS_OBJECT;
- vm->retval.data.truth = 1;
+ njs_set_object(&vm->retval, object);
return NXT_OK;
}
return NXT_ERROR;
}
- vm->retval.data.u.array = keys;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, keys);
return NXT_OK;
}
return NXT_ERROR;
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
return NXT_OK;
}
return NXT_ERROR;
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
return NXT_OK;
}
/* GC: retain. */
entry->start[1] = array->start[i];
- item->data.u.array = entry;
- item->type = NJS_ARRAY;
- item->data.truth = 1;
+ njs_set_array(item, entry);
item++;
}
njs_string_short_set(string, 1, 1);
- item->data.u.array = entry;
- item->type = NJS_ARRAY;
- item->data.truth = 1;
+ njs_set_array(item, entry);
item++;
}
njs_string_short_set(string, size, 1);
- item->data.u.array = entry;
- item->type = NJS_ARRAY;
- item->data.truth = 1;
+ njs_set_array(item, entry);
item++;
/* GC: retain. */
entry->start[1] = prop->value;
- item->data.u.array = entry;
- item->type = NJS_ARRAY;
- item->data.truth = 1;
+ njs_set_array(item, entry);
item++;
}
/* GC: retain. */
entry->start[1] = prop->value;
- item->data.u.array = entry;
- item->type = NJS_ARRAY;
- item->data.truth = 1;
+ njs_set_array(item, entry);
item++;
}
nxt_lvlhsh_each_init(&lhe, &njs_object_hash_proto);
- hash = &desc->data.u.object->hash;
+ hash = njs_object_hash(desc);
for ( ;; ) {
prop = nxt_lvlhsh_each(hash, &lhe);
}
}
- vm->retval.data.u.object = descriptors;
- vm->retval.type = NJS_OBJECT;
- vm->retval.data.truth = 1;
+ njs_set_object(&vm->retval, descriptors);
return NXT_OK;
}
return NXT_ERROR;
}
- vm->retval.data.u.array = names;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, names);
return NXT_OK;
}
pq.lhq.value = prop;
pq.lhq.pool = vm->mem_pool;
- ret = nxt_lvlhsh_insert(&object->data.u.object->hash, &pq.lhq);
+ ret = nxt_lvlhsh_insert(njs_object_hash(object), &pq.lhq);
if (nxt_slow_path(ret != NXT_OK)) {
njs_internal_error(vm, "lvlhsh insert failed");
return NXT_ERROR;
}
-nxt_noinline njs_object_prop_t *
+njs_object_prop_t *
njs_object_prop_alloc(njs_vm_t *vm, const njs_value_t *name,
const njs_value_t *value, uint8_t attributes)
{
}
-nxt_noinline njs_object_prop_t *
+njs_object_prop_t *
njs_object_property(njs_vm_t *vm, const njs_object_t *object,
nxt_lvlhsh_query_t *lhq)
{
pq.lhq.replace = 0;
pq.lhq.pool = vm->mem_pool;
- ret = nxt_lvlhsh_insert(&object->data.u.object->hash, &pq.lhq);
+ ret = nxt_lvlhsh_insert(njs_object_hash(object), &pq.lhq);
if (nxt_slow_path(ret != NXT_OK)) {
njs_internal_error(vm, "lvlhsh insert failed");
return NXT_ERROR;
return NXT_ERROR;
}
- dest->data.u.object = desc;
- dest->type = NJS_OBJECT;
- dest->data.truth = 1;
+ njs_set_object(dest, desc);
return NXT_OK;
}
} while (n != pattern->ngroups);
}
- njs_value_undefined_set(&vm->retval);
+ njs_set_undefined(&vm->retval);
return pattern;
(void) njs_string_prop(&string, ®exp->string);
index = njs_string_index(&string, regexp->last_index);
- njs_value_number_set(retval, index);
+ njs_set_number(retval, index);
return NXT_OK;
}
/* TODO: Non UTF-8 position */
- njs_value_number_set(&prop->value, regexp->last_index + captures[0]);
+ njs_set_number(&prop->value, regexp->last_index + captures[0]);
if (regexp->pattern->global) {
regexp->last_index += captures[1];
goto fail;
}
- prop->value.data.u.object = groups;
- prop->value.type = NJS_OBJECT;
- prop->value.data.truth = 1;
+ njs_set_object(&prop->value, groups);
i = 0;
} while (i < regexp->pattern->ngroups);
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
ret = NXT_OK;
goto done;
const u_char *basis, nxt_uint_t padding);
static njs_ret_t njs_decode_base64_core(njs_vm_t *vm,
njs_value_t *value, const nxt_str_t *src, const u_char *basis);
-static nxt_noinline void njs_string_slice_prop(njs_string_prop_t *string,
+static void njs_string_slice_prop(njs_string_prop_t *string,
njs_slice_prop_t *slice, njs_value_t *args, nxt_uint_t nargs);
-static nxt_noinline void njs_string_slice_args(njs_slice_prop_t *slice,
- njs_value_t *args, nxt_uint_t nargs);
+static void njs_string_slice_args(njs_slice_prop_t *slice, njs_value_t *args,
+ nxt_uint_t nargs);
static njs_ret_t njs_string_from_char_code(njs_vm_t *vm,
njs_value_t *args, nxt_uint_t nargs, njs_index_t unused);
static njs_ret_t njs_string_bytes_from(njs_vm_t *vm, njs_value_t *args,
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_new(njs_vm_t *vm, njs_value_t *value, const u_char *start,
uint32_t size, uint32_t length)
{
}
-nxt_noinline u_char *
+u_char *
njs_string_alloc(njs_vm_t *vm, njs_value_t *value, uint64_t size,
uint64_t length)
{
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_hex(njs_vm_t *vm, njs_value_t *value, const nxt_str_t *src)
{
u_char *p, c;
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_base64(njs_vm_t *vm, njs_value_t *value, const nxt_str_t *src)
{
nxt_str_t dst;
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_base64url(njs_vm_t *vm, njs_value_t *value, const nxt_str_t *src)
{
size_t padding;
* sets njs_string_prop_t struct.
*/
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_validate(njs_vm_t *vm, njs_string_prop_t *string, njs_value_t *value)
{
u_char *start;
}
-nxt_noinline size_t
+size_t
njs_string_prop(njs_string_prop_t *string, const njs_value_t *value)
{
size_t size;
length = (length == 0) ? size : length;
}
- njs_value_number_set(retval, length);
+ njs_set_number(retval, length);
njs_release(vm, value);
* JavaScript 1.2, ECMAScript 3.
*/
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_string_prototype_slice(njs_vm_t *vm, njs_value_t *args, nxt_uint_t nargs,
njs_index_t unused)
{
}
-static nxt_noinline void
+static void
njs_string_slice_prop(njs_string_prop_t *string, njs_slice_prop_t *slice,
njs_value_t *args, nxt_uint_t nargs)
{
}
-static nxt_noinline void
+static void
njs_string_slice_args(njs_slice_prop_t *slice, njs_value_t *args,
nxt_uint_t nargs)
{
}
-nxt_noinline void
+void
njs_string_slice_string_prop(njs_string_prop_t *dst,
const njs_string_prop_t *string, const njs_slice_prop_t *slice)
{
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_slice(njs_vm_t *vm, njs_value_t *dst,
const njs_string_prop_t *string, const njs_slice_prop_t *slice)
{
done:
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return NXT_OK;
}
njs_array_t *array;
njs_value_t *octet;
- array = value->data.u.array;
+ array = njs_array(value);
length = array->length;
for (i = 0; i < length; i++) {
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_decode_hex(njs_vm_t *vm, njs_value_t *value, const nxt_str_t *src)
{
u_char *p, *dst;
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_decode_base64(njs_vm_t *vm, njs_value_t *value, const nxt_str_t *src)
{
static u_char basis64[] = {
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_string_decode_base64url(njs_vm_t *vm, njs_value_t *value,
const nxt_str_t *src)
{
done:
- njs_value_number_set(&vm->retval, index);
+ njs_set_number(&vm->retval, index);
return NXT_OK;
}
done:
- njs_value_number_set(&vm->retval, index);
+ njs_set_number(&vm->retval, index);
return NXT_OK;
}
* njs_string_offset() assumes that index is correct.
*/
-nxt_noinline const u_char *
+const u_char *
njs_string_offset(const u_char *start, const u_char *end, size_t index)
{
uint32_t *map;
* njs_string_index() assumes that offset is correct.
*/
-nxt_noinline uint32_t
+uint32_t
njs_string_index(njs_string_prop_t *string, uint32_t offset)
{
uint32_t *map, last, index;
}
-nxt_noinline void
+void
njs_string_offset_map_init(const u_char *start, size_t size)
{
size_t offset;
done:
- njs_value_number_set(&vm->retval, index);
+ njs_set_number(&vm->retval, index);
return NXT_OK;
}
} while (p <= end);
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
}
return NXT_OK;
done:
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
return NXT_OK;
}
r->empty = (captures[0] == captures[1]);
/* The offset of the matched substring. */
- njs_value_number_set(&arguments[n + 1], captures[0]);
+ njs_set_number(&arguments[n + 1], captures[0]);
/* The whole string being examined. */
length = njs_string_calc_length(r->utf8, r->part[0].start, r->part[0].size);
arguments[1] = args[1];
/* The offset of the matched substring. */
- njs_value_number_set(&arguments[2], r->part[0].size);
+ njs_set_number(&arguments[2], r->part[0].size);
/* The whole string being examined. */
arguments[3] = args[0];
void njs_string_copy(njs_value_t *dst, njs_value_t *src);
njs_ret_t njs_string_validate(njs_vm_t *vm, njs_string_prop_t *string,
njs_value_t *value);
-nxt_noinline size_t njs_string_prop(njs_string_prop_t *string,
- const njs_value_t *value);
+size_t njs_string_prop(njs_string_prop_t *string, const njs_value_t *value);
njs_ret_t njs_string_constructor(njs_vm_t *vm, njs_value_t *args,
nxt_uint_t nargs, njs_index_t unused);
nxt_bool_t njs_string_eq(const njs_value_t *val1, const njs_value_t *val2);
nxt_int_t njs_string_cmp(const njs_value_t *val1, const njs_value_t *val2);
-nxt_noinline void njs_string_slice_string_prop(njs_string_prop_t *dst,
+void njs_string_slice_string_prop(njs_string_prop_t *dst,
const njs_string_prop_t *string, const njs_slice_prop_t *slice);
njs_ret_t njs_string_slice(njs_vm_t *vm, njs_value_t *dst,
const njs_string_prop_t *string, const njs_slice_prop_t *slice);
const u_char *njs_string_offset(const u_char *start, const u_char *end,
size_t index);
-nxt_noinline uint32_t njs_string_index(njs_string_prop_t *string,
- uint32_t offset);
+uint32_t njs_string_index(njs_string_prop_t *string, uint32_t offset);
void njs_string_offset_map_init(const u_char *start, size_t size);
njs_ret_t njs_primitive_value_to_string(njs_vm_t *vm, njs_value_t *dst,
const njs_value_t *src);
* and should fit in CPU L1 instruction cache.
*/
-static nxt_noinline njs_ret_t njs_string_concat(njs_vm_t *vm,
- njs_value_t *val1, njs_value_t *val2);
-static nxt_noinline njs_ret_t njs_values_equal(njs_vm_t *vm,
- const njs_value_t *val1, const njs_value_t *val2);
-static nxt_noinline njs_ret_t njs_values_compare(njs_vm_t *vm,
- const njs_value_t *val1, const njs_value_t *val2);
+static njs_ret_t njs_string_concat(njs_vm_t *vm, njs_value_t *val1,
+ njs_value_t *val2);
+static njs_ret_t njs_values_equal(njs_vm_t *vm, const njs_value_t *val1,
+ const njs_value_t *val2);
+static njs_ret_t njs_values_compare(njs_vm_t *vm, const njs_value_t *val1,
+ const njs_value_t *val2);
static njs_ret_t njs_function_frame_create(njs_vm_t *vm, njs_value_t *value,
const njs_value_t *this, uintptr_t nargs, nxt_bool_t ctor);
static njs_object_t *njs_function_new_object(njs_vm_t *vm, njs_value_t *value);
* values is passed as arguments although they are not always used.
*/
-nxt_noinline nxt_int_t
+nxt_int_t
njs_vmcode_interpreter(njs_vm_t *vm)
{
u_char *catch;
}
-nxt_noinline void
+void
njs_value_retain(njs_value_t *value)
{
njs_string_t *string;
}
-nxt_noinline void
+void
njs_value_release(njs_vm_t *vm, njs_value_t *value)
{
njs_string_t *string;
object = njs_object_alloc(vm);
if (nxt_fast_path(object != NULL)) {
- vm->retval.data.u.object = object;
- vm->retval.type = NJS_OBJECT;
- vm->retval.data.truth = 1;
+ njs_set_object(&vm->retval, object);
return sizeof(njs_vmcode_object_t);
}
array->length = 0;
}
- vm->retval.data.u.array = array;
- vm->retval.type = NJS_ARRAY;
- vm->retval.data.truth = 1;
+ njs_set_array(&vm->retval, array);
return sizeof(njs_vmcode_array_t);
}
code = (njs_vmcode_arguments_t *) vm->current;
value = njs_vmcode_operand(vm, code->dst);
- value->data.u.object = frame->native.arguments_object;
- value->type = NJS_OBJECT;
- value->data.truth = 1;
+ njs_set_object(value, frame->native.arguments_object);
return sizeof(njs_vmcode_arguments_t);
}
value = njs_vmcode_operand(vm, retval);
if (!njs_is_primitive(value)) {
- array = value->data.u.array;
+ array = njs_array(value);
ret = njs_function_activate(vm, (njs_function_t *) &concat,
&njs_string_empty, array->start,
njs_release(vm, reference);
- njs_value_number_set(reference, num);
+ njs_set_number(reference, num);
vm->retval = *reference;
return sizeof(njs_vmcode_3addr_t);
njs_release(vm, reference);
- njs_value_number_set(reference, num);
+ njs_set_number(reference, num);
vm->retval = *reference;
return sizeof(njs_vmcode_3addr_t);
njs_release(vm, reference);
- njs_value_number_set(reference, num + 1.0);
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(reference, num + 1.0);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
njs_release(vm, reference);
- njs_value_number_set(reference, num - 1.0);
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(reference, num - 1.0);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
njs_vmcode_unary_plus(njs_vm_t *vm, njs_value_t *value, njs_value_t *invld)
{
if (nxt_fast_path(njs_is_numeric(value))) {
- njs_value_number_set(&vm->retval, value->data.u.number);
+ njs_set_number(&vm->retval, value->data.u.number);
return sizeof(njs_vmcode_2addr_t);
}
njs_vmcode_unary_negation(njs_vm_t *vm, njs_value_t *value, njs_value_t *invld)
{
if (nxt_fast_path(njs_is_numeric(value))) {
- njs_value_number_set(&vm->retval, - value->data.u.number);
+ njs_set_number(&vm->retval, - value->data.u.number);
return sizeof(njs_vmcode_2addr_t);
}
if (nxt_fast_path(njs_is_numeric(val1) && njs_is_numeric(val2))) {
num = val1->data.u.number + val2->data.u.number;
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_string_concat(njs_vm_t *vm, njs_value_t *val1, njs_value_t *val2)
{
u_char *start;
if (nxt_fast_path(njs_is_numeric(val1) && njs_is_numeric(val2))) {
num = val1->data.u.number - val2->data.u.number;
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
if (nxt_fast_path(njs_is_numeric(val1) && njs_is_numeric(val2))) {
num = val1->data.u.number * val2->data.u.number;
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
num = NAN;
}
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
if (nxt_fast_path(njs_is_numeric(val1) && njs_is_numeric(val2))) {
num = val1->data.u.number / val2->data.u.number;
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
if (nxt_fast_path(njs_is_numeric(val1) && njs_is_numeric(val2))) {
num = fmod(val1->data.u.number, val2->data.u.number);
- njs_value_number_set(&vm->retval, num);
+ njs_set_number(&vm->retval, num);
return sizeof(njs_vmcode_3addr_t);
}
num1 = njs_number_to_int32(val1->data.u.number);
num2 = njs_number_to_uint32(val2->data.u.number);
- njs_value_number_set(&vm->retval, num1 << (num2 & 0x1f));
+ njs_set_number(&vm->retval, num1 << (num2 & 0x1f));
return sizeof(njs_vmcode_3addr_t);
}
num1 = njs_number_to_int32(val1->data.u.number);
num2 = njs_number_to_uint32(val2->data.u.number);
- njs_value_number_set(&vm->retval, num1 >> (num2 & 0x1f));
+ njs_set_number(&vm->retval, num1 >> (num2 & 0x1f));
return sizeof(njs_vmcode_3addr_t);
}
num1 = njs_number_to_uint32(val1->data.u.number);
num2 = njs_number_to_uint32(val2->data.u.number);
- njs_value_number_set(&vm->retval, num1 >> (num2 & 0x1f));
+ njs_set_number(&vm->retval, num1 >> (num2 & 0x1f));
return sizeof(njs_vmcode_3addr_t);
}
if (nxt_fast_path(njs_is_numeric(value))) {
num = njs_number_to_integer(value->data.u.number);
- njs_value_number_set(&vm->retval, ~num);
+ njs_set_number(&vm->retval, ~num);
return sizeof(njs_vmcode_2addr_t);
}
num1 = njs_number_to_integer(val1->data.u.number);
num2 = njs_number_to_integer(val2->data.u.number);
- njs_value_number_set(&vm->retval, num1 & num2);
+ njs_set_number(&vm->retval, num1 & num2);
return sizeof(njs_vmcode_3addr_t);
}
num1 = njs_number_to_integer(val1->data.u.number);
num2 = njs_number_to_integer(val2->data.u.number);
- njs_value_number_set(&vm->retval, num1 ^ num2);
+ njs_set_number(&vm->retval, num1 ^ num2);
return sizeof(njs_vmcode_3addr_t);
}
num1 = njs_number_to_uint32(val1->data.u.number);
num2 = njs_number_to_uint32(val2->data.u.number);
- njs_value_number_set(&vm->retval, num1 | num2);
+ njs_set_number(&vm->retval, num1 | num2);
return sizeof(njs_vmcode_3addr_t);
}
}
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_values_equal(njs_vm_t *vm, const njs_value_t *val1, const njs_value_t *val2)
{
nxt_bool_t nv1, nv2;
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_vmcode_less(njs_vm_t *vm, njs_value_t *val1, njs_value_t *val2)
{
njs_ret_t ret;
}
-nxt_noinline njs_ret_t
+njs_ret_t
njs_vmcode_greater_or_equal(njs_vm_t *vm, njs_value_t *val1, njs_value_t *val2)
{
njs_ret_t ret;
* or negative trap number if convertion to primitive is required.
*/
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_values_compare(njs_vm_t *vm, const njs_value_t *val1,
const njs_value_t *val2)
{
}
-nxt_noinline nxt_bool_t
+nxt_bool_t
njs_values_strict_equal(const njs_value_t *val1, const njs_value_t *val2)
{
size_t size, length1, length2;
return NXT_ERROR;
}
- val.data.u.object = object;
- val.type = NJS_OBJECT;
- val.data.truth = 1;
+ njs_set_object(&val, object);
this = &val;
}
}
* the nearest try_end block. The exit_value is checked by njs_vmcode_finally().
*/
-nxt_noinline njs_ret_t
+njs_ret_t
njs_vmcode_try_break(njs_vm_t *vm, njs_value_t *exit_value,
njs_value_t *offset)
{
* the nearest try_end block. The exit_value is checked by njs_vmcode_finally().
*/
-nxt_noinline njs_ret_t
+njs_ret_t
njs_vmcode_try_continue(njs_vm_t *vm, njs_value_t *exit_value,
njs_value_t *offset)
{
* njs_vmcode_finally(), and jumps to the nearest try_break block.
*/
-nxt_noinline njs_ret_t
+njs_ret_t
njs_vmcode_try_return(njs_vm_t *vm, njs_value_t *value, njs_value_t *invld)
{
njs_vmcode_try_return_t *try_return;
* It is also set on the end of a "catch" block followed by a "finally" block.
*/
-nxt_noinline njs_ret_t
+njs_ret_t
njs_vmcode_try_end(njs_vm_t *vm, njs_value_t *invld, njs_value_t *offset)
{
njs_exception_t *e;
num = njs_string_to_number(value, 0);
}
- njs_value_number_set(value, num);
+ njs_set_number(value, num);
}
ret = sizeof(njs_vmcode_1addr_t);
num = njs_string_to_number(value, 0);
}
- njs_value_number_set(value, num);
+ njs_set_number(value, num);
}
*vm->top_frame->trap_values[1].data.u.value = *value;
* for numbers and "toString", "valueOf" for strings.
*/
-static nxt_noinline njs_ret_t
+static njs_ret_t
njs_primitive_value(njs_vm_t *vm, njs_value_t *value, nxt_uint_t hint)
{
njs_ret_t ret;
}
-nxt_noinline void
-njs_value_undefined_set(njs_value_t *value)
-{
- *value = njs_value_undefined;
-}
-
-
-nxt_noinline void
-njs_value_boolean_set(njs_value_t *value, int yn)
-{
- *value = yn ? njs_value_true : njs_value_false;
-}
-
-
-nxt_noinline void
-njs_value_number_set(njs_value_t *value, double num)
-{
- value->data.u.number = num;
- value->type = NJS_NUMBER;
- value->data.truth = njs_is_number_true(num);
-}
-
-
-nxt_noinline void
-njs_value_data_set(njs_value_t *value, void *data)
-{
- value->data.u.data = data;
- value->type = NJS_DATA;
- value->data.truth = 1;
-}
-
-
-nxt_noinline njs_ret_t
-njs_vm_value_string_set(njs_vm_t *vm, njs_value_t *value, const u_char *start,
- uint32_t size)
-{
- return njs_string_set(vm, value, start, size);
-}
-
-
-nxt_noinline u_char *
-njs_vm_value_string_alloc(njs_vm_t *vm, njs_value_t *value, uint32_t size)
-{
- return njs_string_alloc(vm, value, size, 0);
-}
-
-
-void
-njs_vm_value_error_set(njs_vm_t *vm, njs_value_t *value, const char *fmt, ...)
-{
- va_list args;
- u_char buf[NXT_MAX_ERROR_STR], *p;
-
- p = buf;
-
- if (fmt != NULL) {
- va_start(args, fmt);
- p = nxt_vsprintf(buf, buf + sizeof(buf), fmt, args);
- va_end(args);
- }
-
- njs_error_new(vm, value, NJS_OBJECT_ERROR, buf, p - buf);
-}
-
-
-nxt_noinline uint8_t
-njs_value_bool(const njs_value_t *value)
-{
- return value->data.truth;
-}
-
-
-nxt_noinline double
-njs_value_number(const njs_value_t *value)
-{
- return value->data.u.number;
-}
-
-
-nxt_noinline void *
-njs_value_data(const njs_value_t *value)
-{
- return value->data.u.data;
-}
-
-
-nxt_noinline njs_function_t *
-njs_value_function(const njs_value_t *value)
-{
- return value->data.u.function;
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_null(const njs_value_t *value)
-{
- return njs_is_null(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_undefined(const njs_value_t *value)
-{
- return njs_is_undefined(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_null_or_undefined(const njs_value_t *value)
-{
- return njs_is_null_or_undefined(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_boolean(const njs_value_t *value)
-{
- return njs_is_boolean(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_number(const njs_value_t *value)
-{
- return njs_is_number(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_valid_number(const njs_value_t *value)
-{
- return njs_is_number(value)
- && !isnan(value->data.u.number)
- && !isinf(value->data.u.number);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_string(const njs_value_t *value)
-{
- return njs_is_string(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_object(const njs_value_t *value)
-{
- return njs_is_object(value);
-}
-
-
-nxt_noinline nxt_int_t
-njs_value_is_function(const njs_value_t *value)
-{
- return njs_is_function(value);
-}
-
-
nxt_int_t
njs_vm_value_string_copy(njs_vm_t *vm, nxt_str_t *retval,
const njs_value_t *value, uintptr_t *next)
break;
case NJS_ARRAY:
- array = value->data.u.array;
+ array = njs_array(value);
do {
n = (*next)++;
#include <nxt_djb_hash.h>
#include <nxt_mp.h>
+#include <math.h>
+
#define NJS_MAX_STACK_SIZE (16 * 1024 * 1024)
((value)->type != NJS_INVALID)
+#define njs_bool(value) \
+ ((value)->data.truth)
+
+
+#define njs_number(value) \
+ ((value)->data.u.number)
+
+
+#define njs_data(value) \
+ ((value)->data.u.data)
+
+
+#define njs_function(value) \
+ ((value)->data.u.function)
+
+
+#define njs_object(value) \
+ ((value)->data.u.object)
+
+
+#define njs_object_hash(value) \
+ (&(value)->data.u.object->hash)
+
+
+#define njs_array(value) \
+ ((value)->data.u.array)
+
+
+#define njs_array_len(value) \
+ ((value)->data.u.array->length)
+
+
+#define njs_array_start(value) \
+ ((value)->data.u.array->start)
+
+
+#define njs_set_undefined(value) \
+ *(value) = njs_value_undefined
+
+
+#define njs_set_boolean(value, yn) \
+ *(value) = yn ? njs_value_true : njs_value_false
+
+
+#define njs_set_true(value) \
+ *(value) = njs_value_true
+
+
+#define njs_set_false(value) \
+ *(value) = njs_value_false
+
+
+nxt_inline void
+njs_set_number(njs_value_t *value, double num)
+{
+ value->data.u.number = num;
+ value->type = NJS_NUMBER;
+ value->data.truth = njs_is_number_true(num);
+}
+
+
+nxt_inline void
+njs_set_data(njs_value_t *value, void *data)
+{
+ value->data.u.data = data;
+ value->type = NJS_DATA;
+ value->data.truth = 1;
+}
+
+
+nxt_inline void
+njs_set_object(njs_value_t *value, njs_object_t *object)
+{
+ value->data.u.object = object;
+ value->type = NJS_OBJECT;
+ value->data.truth = 1;
+}
+
+
+nxt_inline void
+njs_set_array(njs_value_t *value, njs_array_t *array)
+{
+ value->data.u.array = array;
+ value->type = NJS_ARRAY;
+ value->data.truth = 1;
+}
+
+
#define njs_set_invalid(value) \
(value)->type = NJS_INVALID
}
-static nxt_noinline void *
+static void *
nxt_lvlhsh_bucket_each(nxt_lvlhsh_each_t *lhe)
{
void *value, **next;
projects / njs.git / commitdiff