details: https://hg.nginx.org/njs/rev/55f49a991f4f
branches:
changeset: 1191:55f49a991f4f
user: Alexander Borisov <alexander.borisov@nginx.com>
date: Mon Oct 21 16:43:45 2019 +0300
description:
Improved functions for converting value to number.

Added functions:
njs_value_to_number(), njs_value_to_integer(), njs_value_to_length()
njs_value_to_int32(), njs_value_to_uint32(), njs_value_to_uint16().

Removed functions:
njs_primitive_value_to_number(), njs_primitive_value_to_integer(),
njs_primitive_value_to_int32(), njs_primitive_value_to_uint32(),
njs_primitive_value_to_length().

Changed return type for njs_number_to_integer() function from int32_t
to int64_t.

diffstat:

src/njs_array.c | 101 +++++++++++++++++++++++-----------------------
src/njs_builtin.c | 9 +++-
src/njs_number.c | 34 +++++++++++----
src/njs_number.h | 55 ++++++-------------------
src/njs_object.c | 11 +----
src/njs_string.c | 37 ++++++++++++-----
src/njs_value.h | 115 +++++++++++++++++++++++++++++++++++++++++++++++++++--
src/njs_vmcode.c | 16 +++---
8 files changed, 238 insertions(+), 140 deletions(-)

diffs (691 lines):

diff -r f01ee3828b15 -r 55f49a991f4f src/njs_array.c
--- a/src/njs_array.c Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_array.c Mon Oct 21 16:43:45 2019 +0300
@@ -332,14 +332,13 @@ static njs_int_t
njs_array_length(njs_vm_t *vm, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval)
{
- double num;
- int64_t size;
- uint32_t length;
- njs_int_t ret;
- njs_value_t *val;
- njs_array_t *array;
- njs_object_t *proto;
- njs_value_t val_length;
+ double num;
+ int64_t size;
+ uint32_t length;
+ njs_int_t ret;
+ njs_value_t *val;
+ njs_array_t *array;
+ njs_object_t *proto;

proto = njs_object(value);

@@ -369,18 +368,16 @@ njs_array_length(njs_vm_t *vm, njs_value
}

if (njs_slow_path(!njs_is_number(setval))) {
- ret = njs_value_to_numeric(vm, &val_length, setval);
- if (ret != NJS_OK) {
+ ret = njs_value_to_number(vm, setval, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
return ret;
}

- num = njs_number(&val_length);
-
} else {
num = njs_number(setval);
}

- length = njs_number_to_uint32(num);
+ length = njs_number_to_length(num);

if ((double) length != num) {
njs_range_error(vm, "Invalid array length");
@@ -422,28 +419,22 @@ static njs_int_t
njs_array_prototype_slice(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
- int64_t start, end, length;
- njs_int_t ret;
- njs_value_t prop_length;
-
- static const njs_value_t string_length = njs_string("length");
-
- ret = njs_value_property(vm, &args[0], njs_value_arg(&string_length),
- &prop_length);
+ int64_t start, end, length;
+ uint32_t object_length;
+ njs_int_t ret;
+
+ ret = njs_object_length(vm, njs_arg(args, nargs, 0), &object_length);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}

- if (njs_slow_path(!njs_is_primitive(&prop_length))) {
- ret = njs_value_to_numeric(vm, &prop_length, &prop_length);
- if (ret != NJS_OK) {
- return ret;
- }
+ length = object_length;
+
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 1), &start);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
}

- start = njs_primitive_value_to_integer(njs_arg(args, nargs, 1));
- length = njs_primitive_value_to_length(&prop_length);
-
if (start < 0) {
start += length;

@@ -458,7 +449,10 @@ njs_array_prototype_slice(njs_vm_t *vm,

} else {
if (njs_is_defined(njs_arg(args, nargs, 2))) {
- end = njs_primitive_value_to_integer(njs_argument(args, 2));
+ ret = njs_value_to_integer(vm, njs_argument(args, 2), &end);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }

} else {
end = length;
@@ -1724,7 +1718,10 @@ njs_array_prototype_index_of(njs_vm_t *v
return ret;
}

- from = njs_primitive_value_to_integer(njs_arg(args, nargs, 2));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 2), &from);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }

if (length == 0 || from >= (int64_t) length) {
goto not_found;
@@ -1781,7 +1778,10 @@ njs_array_prototype_last_index_of(njs_vm
}

if (nargs > 2) {
- from = njs_primitive_value_to_integer(njs_arg(args, nargs, 2));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 2), &from);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }

} else {
from = length - 1;
@@ -1868,7 +1868,10 @@ njs_array_prototype_includes(njs_vm_t *v
goto not_found;
}

- from = njs_primitive_value_to_integer(njs_arg(args, nargs, 2));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 2), &from);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }

if (from < 0) {
from += length;
@@ -1906,14 +1909,13 @@ static njs_int_t
njs_array_prototype_fill(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
- njs_int_t ret;
- njs_int_t i, start, end, length;
+ int64_t start, end;
+ uint32_t length;
+ njs_int_t i, ret;
njs_array_t *array;
- njs_value_t name, prop_length, *this, *value;
+ njs_value_t name, *this, *value;
njs_object_t *object;

- static const njs_value_t string_length = njs_string("length");
-
this = njs_arg(args, nargs, 0);

if (njs_is_primitive(this)) {
@@ -1940,30 +1942,27 @@ njs_array_prototype_fill(njs_vm_t *vm, n
length = array->length;

} else {
- ret = njs_value_property(vm, this, njs_value_arg(&string_length),
- &prop_length);
+ ret = njs_object_length(vm, this, &length);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
-
- if (njs_slow_path(!njs_is_primitive(&prop_length))) {
- ret = njs_value_to_numeric(vm, &prop_length, &prop_length);
- if (ret != NJS_OK) {
- return ret;
- }
- }
-
- length = njs_primitive_value_to_length(&prop_length);
}

- start = njs_primitive_value_to_integer(njs_arg(args, nargs, 2));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 2), &start);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
start = (start < 0) ? njs_max(length + start, 0) : njs_min(start, length);

if (njs_is_undefined(njs_arg(args, nargs, 3))) {
end = length;

} else {
- end = njs_primitive_value_to_integer(njs_arg(args, nargs, 3));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 3), &end);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
}

end = (end < 0) ? njs_max(length + end, 0) : njs_min(end, length);
diff -r f01ee3828b15 -r 55f49a991f4f src/njs_builtin.c
--- a/src/njs_builtin.c Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_builtin.c Mon Oct 21 16:43:45 2019 +0300
@@ -992,14 +992,19 @@ static njs_int_t
njs_dump_value(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
+ uint32_t n;
+ njs_int_t ret;
njs_str_t str;
- njs_uint_t n;
njs_value_t *value, *indent;

value = njs_arg(args, nargs, 1);
indent = njs_arg(args, nargs, 2);

- n = njs_primitive_value_to_integer(indent);
+ ret = njs_value_to_uint32(vm, indent, &n);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
n = njs_min(n, 5);

if (njs_vm_value_dump(vm, &str, value, 1, n) != NJS_OK) {
diff -r f01ee3828b15 -r 55f49a991f4f src/njs_number.c
--- a/src/njs_number.c Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_number.c Mon Oct 21 16:43:45 2019 +0300
@@ -547,10 +547,10 @@ njs_number_prototype_to_fixed(njs_vm_t *
njs_uint_t nargs, njs_index_t unused)
{
u_char *p;
- int32_t frac;
+ int64_t frac;
double number;
size_t length, size;
- njs_int_t point, prefix, postfix;
+ njs_int_t ret, point, prefix, postfix;
njs_value_t *value;
u_char buf[128], buf2[128];

@@ -569,7 +569,11 @@ njs_number_prototype_to_fixed(njs_vm_t *
}
}

- frac = njs_primitive_value_to_integer(njs_arg(args, nargs, 1));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 1), &frac);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
if (njs_slow_path(frac < 0 || frac > 100)) {
njs_range_error(vm, "digits argument must be between 0 and 100");
return NJS_ERROR;
@@ -582,7 +586,7 @@ njs_number_prototype_to_fixed(njs_vm_t *
}

point = 0;
- length = njs_fixed_dtoa(number, frac, (char *) buf, &point);
+ length = njs_fixed_dtoa(number, (njs_int_t) frac, (char *) buf, &point);

prefix = 0;
postfix = 0;
@@ -643,7 +647,8 @@ njs_number_prototype_to_precision(njs_vm
{
double number;
size_t size;
- int32_t precision;
+ int64_t precision;
+ njs_int_t ret;
njs_value_t *value;
u_char buf[128];

@@ -672,13 +677,17 @@ njs_number_prototype_to_precision(njs_vm
return njs_number_to_string(vm, &vm->retval, value);
}

- precision = njs_primitive_value_to_integer(njs_argument(args, 1));
+ ret = njs_value_to_integer(vm, njs_argument(args, 1), &precision);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
if (njs_slow_path(precision < 1 || precision > 100)) {
njs_range_error(vm, "precision argument must be between 1 and 100");
return NJS_ERROR;
}

- size = njs_dtoa_precision(number, (char *) buf, precision);
+ size = njs_dtoa_precision(number, (char *) buf, (size_t) precision);

return njs_string_new(vm, &vm->retval, buf, size, size);
}
@@ -690,7 +699,8 @@ njs_number_prototype_to_exponential(njs_
{
double number;
size_t size;
- int32_t frac;
+ int64_t frac;
+ njs_int_t ret;
njs_value_t *value;
u_char buf[128];

@@ -714,7 +724,11 @@ njs_number_prototype_to_exponential(njs_
}

if (njs_is_defined(njs_arg(args, nargs, 1))) {
- frac = njs_primitive_value_to_integer(njs_argument(args, 1));
+ ret = njs_value_to_integer(vm, njs_argument(args, 1), &frac);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
if (njs_slow_path(frac < 0 || frac > 100)) {
njs_range_error(vm, "digits argument must be between 0 and 100");
return NJS_ERROR;
@@ -724,7 +738,7 @@ njs_number_prototype_to_exponential(njs_
frac = -1;
}

- size = njs_dtoa_exponential(number, (char *) buf, frac);
+ size = njs_dtoa_exponential(number, (char *) buf, (njs_int_t) frac);

return njs_string_new(vm, &vm->retval, buf, size, size);
}
diff -r f01ee3828b15 -r 55f49a991f4f src/njs_number.h
--- a/src/njs_number.h Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_number.h Mon Oct 21 16:43:45 2019 +0300
@@ -61,10 +61,21 @@ njs_number_to_int64(double num)
}


-njs_inline int32_t
+njs_inline int64_t
njs_number_to_integer(double num)
{
- return (int32_t) njs_number_to_int64(num);
+ if (njs_slow_path(isinf(num))) {
+ if (num < 0) {
+ return INT64_MIN;
+ }
+
+ return INT64_MAX;
+
+ } else if (njs_slow_path(isnan(num))) {
+ return 0;
+ }
+
+ return njs_number_to_int64(num);
}


@@ -131,46 +142,6 @@ njs_char_to_hex(u_char c)
return c;
}

-
-njs_inline double
-njs_primitive_value_to_number(const njs_value_t *value)
-{
- if (njs_fast_path(njs_is_numeric(value))) {
- return njs_number(value);
- }
-
- return njs_string_to_number(value, 0);
-}
-
-
-njs_inline int32_t
-njs_primitive_value_to_integer(const njs_value_t *value)
-{
- return njs_number_to_integer(njs_primitive_value_to_number(value));
-}
-
-
-njs_inline int32_t
-njs_primitive_value_to_int32(const njs_value_t *value)
-{
- return njs_number_to_int32(njs_primitive_value_to_number(value));
-}
-
-
-njs_inline uint32_t
-njs_primitive_value_to_uint32(const njs_value_t *value)
-{
- return njs_number_to_uint32(njs_primitive_value_to_number(value));
-}
-
-
-njs_inline uint32_t
-njs_primitive_value_to_length(const njs_value_t *value)
-{
- return njs_number_to_length(njs_primitive_value_to_number(value));
-}
-
-
njs_inline void
njs_uint32_to_string(njs_value_t *value, uint32_t u32)
{
diff -r f01ee3828b15 -r 55f49a991f4f src/njs_object.c
--- a/src/njs_object.c Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_object.c Mon Oct 21 16:43:45 2019 +0300
@@ -2316,14 +2316,5 @@ njs_object_length(njs_vm_t *vm, njs_valu
return ret;
}

- if (!njs_is_primitive(&value_length)) {
- ret = njs_value_to_numeric(vm, &value_length, &value_length);
- if (njs_slow_path(ret != NJS_OK)) {
- return ret;
- }
- }
-
- *length = njs_primitive_value_to_length(&value_length);
-
- return NJS_OK;
+ return njs_value_to_length(vm, &value_length, length);
}
diff -r f01ee3828b15 -r 55f49a991f4f src/njs_string.c
--- a/src/njs_string.c Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_string.c Mon Oct 21 16:43:45 2019 +0300
@@ -1235,16 +1235,22 @@ static njs_int_t
njs_string_prototype_char_at(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
- ssize_t start, length;
+ size_t length;
+ int64_t start;
+ njs_int_t ret;
njs_slice_prop_t slice;
njs_string_prop_t string;

slice.string_length = njs_string_prop(&string, &args[0]);

- start = njs_primitive_value_to_integer(njs_arg(args, nargs, 1));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 1), &start);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
length = 1;

- if (start < 0 || start >= (ssize_t) slice.string_length) {
+ if (start < 0 || start >= (int64_t) slice.string_length) {
start = 0;
length = 0;
}
@@ -1395,21 +1401,26 @@ njs_string_prototype_char_code_at(njs_vm
njs_uint_t nargs, njs_index_t unused)
{
double num;
- ssize_t index, length;
+ size_t length;
+ int64_t index;
uint32_t code;
+ njs_int_t ret;
const u_char *start, *end;
njs_string_prop_t string;

length = njs_string_prop(&string, &args[0]);

- index = njs_primitive_value_to_integer(njs_arg(args, nargs, 1));
-
- if (njs_slow_path(index < 0 || index >= length)) {
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 1), &index);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
+ if (njs_slow_path(index < 0 || index >= (int64_t) length)) {
num = NAN;
goto done;
}

- if ((uint32_t) length == string.size) {
+ if (length == string.size) {
/* Byte or ASCII string. */
code = string.start[index];

@@ -2501,11 +2512,15 @@ njs_string_prototype_repeat(njs_vm_t *vm
njs_index_t unused)
{
u_char *p, *start;
- int32_t n, max;
- uint32_t size, length;
+ int64_t n, max;
+ uint64_t size, length;
+ njs_int_t ret;
njs_string_prop_t string;

- n = njs_primitive_value_to_integer(njs_arg(args, nargs, 1));
+ ret = njs_value_to_integer(vm, njs_arg(args, nargs, 1), &n);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }

(void) njs_string_prop(&string, &args[0]);

diff -r f01ee3828b15 -r 55f49a991f4f src/njs_value.h
--- a/src/njs_value.h Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_value.h Mon Oct 21 16:43:45 2019 +0300
@@ -845,10 +845,12 @@ njs_int_t njs_value_property_delete(njs_
njs_value_t *key, njs_value_t *removed);


+#include "njs_number.h"
+
+
njs_inline njs_int_t
-njs_value_to_numeric(njs_vm_t *vm, njs_value_t *dst, njs_value_t *value)
+njs_value_to_number(njs_vm_t *vm, njs_value_t *value, double *dst)
{
- double num;
njs_int_t ret;
njs_value_t primitive;

@@ -862,14 +864,30 @@ njs_value_to_numeric(njs_vm_t *vm, njs_v
}

if (njs_slow_path(!njs_is_numeric(value))) {
- num = NAN;
+ *dst = NAN;

if (njs_is_string(value)) {
- num = njs_string_to_number(value, 0);
+ *dst = njs_string_to_number(value, 0);
}

- } else {
- num = njs_number(value);
+ return NJS_OK;
+ }
+
+ *dst = njs_number(value);
+
+ return NJS_OK;
+}
+
+
+njs_inline njs_int_t
+njs_value_to_numeric(njs_vm_t *vm, njs_value_t *value, njs_value_t *dst)
+{
+ double num;
+ njs_int_t ret;
+
+ ret = njs_value_to_number(vm, value, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
}

njs_set_number(dst, num);
@@ -879,6 +897,91 @@ njs_value_to_numeric(njs_vm_t *vm, njs_v


njs_inline njs_int_t
+njs_value_to_integer(njs_vm_t *vm, njs_value_t *value, int64_t *dst)
+{
+ double num;
+ njs_int_t ret;
+
+ ret = njs_value_to_number(vm, value, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
+ *dst = njs_number_to_integer(num);
+
+ return NJS_OK;
+}
+
+
+njs_inline njs_int_t
+njs_value_to_length(njs_vm_t *vm, njs_value_t *value, uint32_t *dst)
+{
+ double num;
+ njs_int_t ret;
+
+ ret = njs_value_to_number(vm, value, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
+ *dst = njs_number_to_length(num);
+
+ return NJS_OK;
+}
+
+
+njs_inline njs_int_t
+njs_value_to_int32(njs_vm_t *vm, njs_value_t *value, int32_t *dst)
+{
+ double num;
+ njs_int_t ret;
+
+ ret = njs_value_to_number(vm, value, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
+ *dst = njs_number_to_int32(num);
+
+ return NJS_OK;
+}
+
+
+njs_inline njs_int_t
+njs_value_to_uint32(njs_vm_t *vm, njs_value_t *value, uint32_t *dst)
+{
+ double num;
+ njs_int_t ret;
+
+ ret = njs_value_to_number(vm, value, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
+ *dst = njs_number_to_uint32(num);
+
+ return NJS_OK;
+}
+
+
+njs_inline njs_int_t
+njs_value_to_uint16(njs_vm_t *vm, njs_value_t *value, uint16_t *dst)
+{
+ double num;
+ njs_int_t ret;
+
+ ret = njs_value_to_number(vm, value, &num);
+ if (njs_slow_path(ret != NJS_OK)) {
+ return ret;
+ }
+
+ *dst = njs_number_to_uint16(num);
+
+ return NJS_OK;
+}
+
+
+njs_inline njs_int_t
njs_value_to_string(njs_vm_t *vm, njs_value_t *dst, njs_value_t *value)
{
njs_int_t ret;
diff -r f01ee3828b15 -r 55f49a991f4f src/njs_vmcode.c
--- a/src/njs_vmcode.c Mon Oct 21 15:10:34 2019 +0300
+++ b/src/njs_vmcode.c Mon Oct 21 16:43:45 2019 +0300
@@ -183,7 +183,7 @@ next:
case NJS_VMCODE_DECREMENT:
case NJS_VMCODE_POST_DECREMENT:
if (njs_slow_path(!njs_is_numeric(value2))) {
- ret = njs_value_to_numeric(vm, &numeric1, value2);
+ ret = njs_value_to_numeric(vm, value2, &numeric1);
if (njs_slow_path(ret != NJS_OK)) {
goto error;
}
@@ -350,8 +350,8 @@ next:
case NJS_VMCODE_RIGHT_SHIFT:
case NJS_VMCODE_UNSIGNED_RIGHT_SHIFT:
if (njs_slow_path(!njs_is_numeric(value1))) {
- ret = njs_value_to_numeric(vm, &numeric1, value1);
- if (ret != NJS_OK) {
+ ret = njs_value_to_numeric(vm, value1, &numeric1);
+ if (njs_slow_path(ret != NJS_OK)) {
goto error;
}

@@ -359,8 +359,8 @@ next:
}

if (njs_slow_path(!njs_is_numeric(value2))) {
- ret = njs_value_to_numeric(vm, &numeric2, value2);
- if (ret != NJS_OK) {
+ ret = njs_value_to_numeric(vm, value2, &numeric2);
+ if (njs_slow_path(ret != NJS_OK)) {
goto error;
}

@@ -517,8 +517,8 @@ next:
case NJS_VMCODE_UNARY_NEGATION:
case NJS_VMCODE_BITWISE_NOT:
if (njs_slow_path(!njs_is_numeric(value1))) {
- ret = njs_value_to_numeric(vm, &numeric1, value1);
- if (ret != NJS_OK) {
+ ret = njs_value_to_numeric(vm, value1, &numeric1);
+ if (njs_slow_path(ret != NJS_OK)) {
goto error;
}

@@ -538,7 +538,7 @@ next:
break;

case NJS_VMCODE_BITWISE_NOT:
- njs_set_int32(retval, ~njs_number_to_integer(num));
+ njs_set_int32(retval, ~njs_number_to_uint32(num));
}

pc += sizeof(njs_vmcode_2addr_t);
_______________________________________________
nginx-devel mailing list
nginx-devel@nginx.org
http://mailman.nginx.org/mailman/listinfo/nginx-devel