Using printing and parsing library from QuickJS.

- Number.prototype.toString(radix)
    Improved accuracy for edge cases
    Reimplemented using njs_dtoa2() with JS_DTOA_FORMAT_FREE | JS_DTOA_EXP_DISABLED
- Number.prototype.toFixed(frac)
    Reimplemented using njs_dtoa2() with JS_DTOA_FORMAT_FIXED
    Removed old njs_fixed_dtoa() implementation
- Number.prototype.toPrecision(prec)
    Reimplemented using njs_dtoa2() with precision format
    Removed old njs_dtoa_precision() implementation
- Number.prototype.toExponential(frac)
    Reimplemented using njs_dtoa2() with exponential format
    Removed old njs_dtoa_exponential() implementation
- parseInt()
    Simplified parsing implementation
    Removed custom njs_number_radix_parse() helper
- parseFloat()
    Simplified parsing implementation

Removed custom njs_number_bin_parse(), njs_number_oct_parse(),
njs_number_dec_parse() and njs_strtod.c module Better handling of large
numbers and denormal floats and invalid inputs.

Author: xeioex

auto/clang

@@ -203,16 +203,3 @@ njs_feature_test="#include <sanitizer/msan_interface.h>
                       return 0;
                   }"
 . auto/feature
-
-
-njs_feature="_mm_setcsr()"
-njs_feature_name=NJS_HAVE_DENORMALS_CONTROL
-njs_feature_run=no
-njs_feature_incs=
-njs_feature_libs=
-njs_feature_test="#include <xmmintrin.h>
-                  int main(void) {
-                      _mm_setcsr(_mm_getcsr());
-                      return 0;
-                  }"
-. auto/feature

auto/sources

@@ -1,9 +1,7 @@
 NJS_LIB_SRCS=" \
    src/njs_diyfp.c \
    src/njs_dtoa.c \
-   src/njs_dtoa_fixed.c \
    src/njs_str.c \
-   src/njs_strtod.c \
    src/njs_murmur_hash.c \
    src/njs_djb_hash.c \
    src/njs_utf8.c \

external/njs_shell.c

@@ -412,8 +412,6 @@ njs_main(njs_opts_t *opts)
     njs_int_t     ret;
     njs_engine_t  *engine;
 
-    njs_mm_denormals(opts->denormals);
-
     if (opts->file == NULL) {
         if (opts->command.length != 0) {
             opts->file = (char *) "string";
@@ -637,12 +635,6 @@ njs_options_parse(njs_opts_t *opts, int argc, char **argv)
             return NJS_ERROR;
 
         case 'f':
-
-#if !(NJS_HAVE_DENORMALS_CONTROL)
-            njs_stderror("option \"-f\" is not supported\n");
-            return NJS_ERROR;
-#endif
-
             opts->denormals = 0;
             break;
 

src/njs_clang.h

@@ -209,24 +209,6 @@ njs_unsafe_cast_double_to_int64(double num)
 }
 
 
-#if (NJS_HAVE_DENORMALS_CONTROL)
-#include <xmmintrin.h>
-
-/*
- * 0x8000 Flush to zero
- * 0x0040 Denormals are zeros
- */
-
-#define NJS_MM_DENORMALS_MASK 0x8040
-
-#define njs_mm_denormals(on)                                                  \
-    _mm_setcsr((_mm_getcsr() & ~NJS_MM_DENORMALS_MASK) | (!(on) ? 0x8040: 0x0))
-#else
-
-#define njs_mm_denormals(on)
-#endif
-
-
 #ifndef NJS_MAX_ALIGNMENT
 
 #if (NJS_SOLARIS)

src/njs_cutils.h

@@ -0,0 +1,149 @@
+/*
+ * Selected C utilities adapted from QuickJS cutils.h
+ *
+ * Copyright (c) 2024 Fabrice Bellard
+ */
+
+#ifndef _NJS_CUTILS_H_INCLUDED_
+#define _NJS_CUTILS_H_INCLUDED_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef likely
+#define likely(x)       __builtin_expect(!!(x), 1)
+#endif
+
+#ifndef unlikely
+#define unlikely(x)     __builtin_expect(!!(x), 0)
+#endif
+
+#ifndef no_inline
+#define no_inline __attribute__((noinline))
+#endif
+
+/* compatibility attribute used in dtoa implementation */
+#ifndef __maybe_unused
+#define __maybe_unused __attribute__((unused))
+#endif
+
+typedef int BOOL;
+
+#ifndef FALSE
+#define FALSE 0
+#endif
+
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+static inline int
+max_int(int a, int b)
+{
+    return (a > b) ? a : b;
+}
+
+static inline int
+min_int(int a, int b)
+{
+    return (a < b) ? a : b;
+}
+
+static inline uint32_t
+max_uint32(uint32_t a, uint32_t b)
+{
+    return (a > b) ? a : b;
+}
+
+static inline uint32_t
+min_uint32(uint32_t a, uint32_t b)
+{
+    return (a < b) ? a : b;
+}
+
+static inline int64_t
+max_int64(int64_t a, int64_t b)
+{
+    return (a > b) ? a : b;
+}
+
+static inline int64_t
+min_int64(int64_t a, int64_t b)
+{
+    return (a < b) ? a : b;
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int
+clz32(unsigned int a)
+{
+    return __builtin_clz(a);
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int
+clz64(uint64_t a)
+{
+    return __builtin_clzll(a);
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int
+ctz32(unsigned int a)
+{
+    return __builtin_ctz(a);
+}
+
+/* WARNING: undefined if a = 0 */
+static inline int
+ctz64(uint64_t a)
+{
+    return __builtin_ctzll(a);
+}
+
+static inline uint64_t
+float64_as_uint64(double d)
+{
+    union {
+        double   d;
+        uint64_t u64;
+    } u;
+
+    u.d = d;
+    return u.u64;
+}
+
+static inline double
+uint64_as_float64(uint64_t u64)
+{
+    union {
+        double   d;
+        uint64_t u64;
+    } u;
+
+    u.u64 = u64;
+    return u.d;
+}
+
+static inline int
+strstart(const char *str, const char *val, const char **ptr)
+{
+    const char *p = str;
+    const char *q = val;
+
+    while (*q != '\0') {
+        if (*p != *q) {
+            return 0;
+        }
+        p++;
+        q++;
+    }
+
+    if (ptr != NULL) {
+        *ptr = p;
+    }
+
+    return 1;
+}
+
+#endif /* _NJS_CUTILS_H_INCLUDED_ */