quickjs 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b35606f03fd2d506d2f460873000dcfd75595a2639b4d921ed6f8d76e4fff118
-  data.tar.gz: 3c42d67e4e6d57936a34e5ee93669722e5187f7f8b389fa789798fd3ec37abe8
+  metadata.gz: e79081c82cb9b414f3c77b44883c6e025558aea6c3000f204b7da4df411642e4
+  data.tar.gz: 8d0be576f2b301e793e767f8f3a9c7529856e6694d2655beaf14efeb85aab043
 SHA512:
-  metadata.gz: ff5cc1f531fe2c7c5ecc098a024fd6fe4ca62088565e2d6fe46be77e0aeea7db97eba84c1bfb2e032628e60805346f1f6ffafa885287a5c67e553e790668b7c2
-  data.tar.gz: 1a4c6ae31c835475f4146531e7d19e08d5542331e37541832010a920b6510c27cc6512ef119c70a310d11786b535f2f71891f538e9a80a275afadf52c462bd9e
+  metadata.gz: 12404c2ffe3dbc5021eefbf6b8b42bdb9a74d2aa649b55eeb57ad92dbb9330c2d95834401af7a8a8471bc85db0adeebd3d877c5d46b421bc0320b356671253b3
+  data.tar.gz: 387ef0a683d6169e113a3488208c8a75d7409e574eddecc416c059cf9d0d0282b1c3a0c267c54b5b74a2065bb843da5a90070db9c33b34ddc86b9919e7161990

data/ext/quickjsrb/quickjs/cutils.c

@@ -176,6 +176,8 @@ int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
     va_start(ap, fmt);
     len = vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
+    if (len < 0)
+        return -1;
     if (len < sizeof(buf)) {
         /* fast case */
         return dbuf_put(s, (uint8_t *)buf, len);

data/ext/quickjsrb/quickjs/cutils.h

@@ -364,4 +364,60 @@ static inline double uint64_as_float64(uint64_t u64)
     return u.d;
 }
 
+static inline double fromfp16(uint16_t v)
+{
+    double d;
+    uint32_t v1;
+    v1 = v & 0x7fff;
+    if (unlikely(v1 >= 0x7c00))
+        v1 += 0x1f8000; /* NaN or infinity */
+    d = uint64_as_float64(((uint64_t)(v >> 15) << 63) | ((uint64_t)v1 << (52 - 10)));
+    return d * 0x1p1008;
+}
+
+static inline uint16_t tofp16(double d)
+{
+    uint64_t a, addend;
+    uint32_t v, sgn;
+    int shift;
+    
+    a = float64_as_uint64(d);
+    sgn = a >> 63;
+    a = a & 0x7fffffffffffffff;
+    if (unlikely(a > 0x7ff0000000000000)) {
+        /* nan */
+        v = 0x7c01;
+    } else if (a < 0x3f10000000000000) { /* 0x1p-14 */
+        /* subnormal f16 number or zero */
+        if (a <= 0x3e60000000000000) { /* 0x1p-25 */
+            v = 0x0000; /* zero */
+        } else {
+            shift = 1051 - (a >> 52);
+            a = ((uint64_t)1 << 52) | (a & (((uint64_t)1 << 52) - 1));
+            addend = ((a >> shift) & 1) + (((uint64_t)1 << (shift - 1)) - 1);
+            v = (a + addend) >> shift;
+        }
+    } else {
+        /* normal number or infinity */
+        a -= 0x3f00000000000000; /* adjust the exponent */
+        /* round */
+        addend = ((a >> (52 - 10)) & 1) + (((uint64_t)1 << (52 - 11)) - 1);
+        v = (a + addend) >> (52 - 10);
+        /* overflow ? */
+        if (unlikely(v > 0x7c00))
+            v = 0x7c00;
+    }
+    return v | (sgn << 15);
+}
+
+static inline int isfp16nan(uint16_t v)
+{
+    return (v & 0x7FFF) > 0x7C00;
+}
+
+static inline int isfp16zero(uint16_t v)
+{
+    return (v & 0x7FFF) == 0;
+}
+
 #endif  /* CUTILS_H */

data/ext/quickjsrb/quickjs/dtoa.c

@@ -1147,6 +1147,9 @@ int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
                 P = n_digits + 1;
             else
                 P = n_digits;
+            /* "-0" is displayed as "0" if JS_DTOA_MINUS_ZERO is not present */
+            if (sgn && (flags & JS_DTOA_MINUS_ZERO))
+                *q++ = '-';
             goto output;
         }
         /* denormal number: convert to a normal number */
@@ -1156,6 +1159,8 @@ int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
     } else {
         m |= (uint64_t)1 << 52;
     }
+    if (sgn)
+        *q++ = '-';
     /* remove the bias */
     e -= 1022;
     /* d = 2^(e-53)*m */
@@ -1167,8 +1172,6 @@ int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
         (flags & JS_DTOA_EXP_MASK) != JS_DTOA_EXP_ENABLED) {
         m >>= 53 - e;
         /* 'm' is never zero */
-        if (sgn)
-            *q++ = '-';
         q += u64toa_radix(q, m, radix);
         goto done;
     }
@@ -1244,10 +1247,6 @@ int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
         /* frac is rounded using RNDNA */
         mul_pow_round(tmp1, m, e - 53, radix1, radix_shift, n_digits, JS_RNDNA);
 
-        /* "-0" is displayed as "0" */
-        if (sgn && !(tmp1->tab[0] == 0 && tmp1->len == 1)) {
-            *q++ = '-';
-        }
         /* we add one extra digit on the left and remove it if needed
            to avoid testing if the result is < radix^P */
         len = output_digits(q, tmp1, radix, max_int(E + 1, 1) + n_digits,
@@ -1277,11 +1276,6 @@ int js_dtoa(char *buf, double d, int radix, int n_digits, int flags,
         }
     }
  output:
-    /* "-0" is displayed as "0" if JS_DTOA_MINUS_ZERO is not present */
-    if (sgn && ((flags & JS_DTOA_MINUS_ZERO) ||
-                !(tmp1->tab[0] == 0 && tmp1->len == 1))) {
-        *q++ = '-';
-    }
     if (fmt == JS_DTOA_FORMAT_FIXED)
         E_max = n_digits;
     else

data/ext/quickjsrb/quickjs/libregexp-opcode.h

@@ -26,11 +26,15 @@
 
 DEF(invalid, 1) /* never used */
 DEF(char, 3)
+DEF(char_i, 3)
 DEF(char32, 5)
+DEF(char32_i, 5)
 DEF(dot, 1)
 DEF(any, 1) /* same as dot but match any character including line terminator */
 DEF(line_start, 1)
+DEF(line_start_m, 1)
 DEF(line_end, 1)
+DEF(line_end_m, 1)
 DEF(goto, 5)
 DEF(split_goto_first, 5)
 DEF(split_next_first, 5)
@@ -42,11 +46,17 @@ DEF(loop, 5) /* decrement the top the stack and goto if != 0 */
 DEF(push_i32, 5) /* push integer on the stack */
 DEF(drop, 1)
 DEF(word_boundary, 1)
+DEF(word_boundary_i, 1)
 DEF(not_word_boundary, 1)
+DEF(not_word_boundary_i, 1)
 DEF(back_reference, 2)
-DEF(backward_back_reference, 2) /* must come after back_reference */
+DEF(back_reference_i, 2) /* must come after */
+DEF(backward_back_reference, 2) /* must come after */
+DEF(backward_back_reference_i, 2) /* must come after */
 DEF(range, 3) /* variable length */
+DEF(range_i, 3) /* variable length */
 DEF(range32, 3) /* variable length */
+DEF(range32_i, 3) /* variable length */
 DEF(lookahead, 5)
 DEF(negative_lookahead, 5)
 DEF(push_char_pos, 1) /* push the character position on the stack */