quickjs 0.19.0 → 0.20.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63b2c2bd84eaf1dbd09250dc14fc8ba158662f51fb82c1bccb355302f870f451
-  data.tar.gz: 1ad1aa3a1ff28d79fad6fc1d653648e66bf800857872ccecf1858635dadf1c54
+  metadata.gz: e96e8ab31794879d095e585c4d3a56a659743f6dc2b3c86ec192f789cdef0954
+  data.tar.gz: 33934987b758a3536a8f8dc19036bd3aa4aeff183909f38c3095bab6d52691ac
 SHA512:
-  metadata.gz: '08618cb67ac46302c4443851f87d81eafe7b236ddc9dac6a05978ae0eae8e92804a816838bf45f6c42cbd7145d602c9f74f3b375dfae583417eaed7a3418fd42'
-  data.tar.gz: 1ece2015042543a9183c5191f5325a78e6bb40d242b86dfcb98decfaced4d39310ade0347e184413d85d0e521d4515c5b9327a1783989c97d65b4bc652f031e3
+  metadata.gz: 8a33bfbf397a9e08e37870f461a78e4cecfb8de76d99a844c376c3325297295261d3e0f35cfdc58545de58b664dfded9b281f2fe201a85f393096c0eda1e427a
+  data.tar.gz: 638e928150c34f0f2fdf878336f31d6bfe3327faf7cca3f2291b785de320d1bd4b38e28d7908aae5290358244cd5cccaa3325d0b0b4bcbaa534eef150b79848e

data/ext/quickjsrb/quickjs/cutils.c

@@ -100,15 +100,20 @@ void dbuf_init(DynBuf *s)
     dbuf_init2(s, NULL, NULL);
 }
 
-/* return < 0 if error */
-int dbuf_realloc(DynBuf *s, size_t new_size)
+/* Try to allocate 'len' more bytes. return < 0 if error */
+int dbuf_claim(DynBuf *s, size_t len)
 {
-    size_t size;
+    size_t new_size, size;
     uint8_t *new_buf;
+    new_size = s->size + len;
+    if (new_size < len)
+        return -1; /* overflow case */
     if (new_size > s->allocated_size) {
         if (s->error)
             return -1;
-        size = s->allocated_size * 3 / 2;
+        size = s->allocated_size + (s->allocated_size / 2);
+        if (size < s->allocated_size)
+            return -1; /* overflow case */
         if (size > new_size)
             new_size = size;
         new_buf = s->realloc_func(s->opaque, s->buf, new_size);
@@ -122,22 +127,10 @@ int dbuf_realloc(DynBuf *s, size_t new_size)
     return 0;
 }
 
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len)
-{
-    size_t end;
-    end = offset + len;
-    if (dbuf_realloc(s, end))
-        return -1;
-    memcpy(s->buf + offset, data, len);
-    if (end > s->size)
-        s->size = end;
-    return 0;
-}
-
 int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
 {
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
+    if (unlikely((s->allocated_size - s->size) < len)) {
+        if (dbuf_claim(s, len))
             return -1;
     }
     memcpy_no_ub(s->buf + s->size, data, len);
@@ -147,8 +140,8 @@ int dbuf_put(DynBuf *s, const uint8_t *data, size_t len)
 
 int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
 {
-    if (unlikely((s->size + len) > s->allocated_size)) {
-        if (dbuf_realloc(s, s->size + len))
+    if (unlikely((s->allocated_size - s->size) < len)) {
+        if (dbuf_claim(s, len))
             return -1;
     }
     memcpy(s->buf + s->size, s->buf + offset, len);
@@ -156,11 +149,26 @@ int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
     return 0;
 }
 
-int dbuf_putc(DynBuf *s, uint8_t c)
+int __dbuf_putc(DynBuf *s, uint8_t c)
 {
     return dbuf_put(s, &c, 1);
 }
 
+int __dbuf_put_u16(DynBuf *s, uint16_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 2);
+}
+
+int __dbuf_put_u32(DynBuf *s, uint32_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 4);
+}
+
+int __dbuf_put_u64(DynBuf *s, uint64_t val)
+{
+    return dbuf_put(s, (uint8_t *)&val, 8);
+}
+
 int dbuf_putstr(DynBuf *s, const char *str)
 {
     return dbuf_put(s, (const uint8_t *)str, strlen(str));
@@ -182,7 +190,7 @@ int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
         /* fast case */
         return dbuf_put(s, (uint8_t *)buf, len);
     } else {
-        if (dbuf_realloc(s, s->size + len + 1))
+        if (dbuf_claim(s, len + 1))
             return -1;
         va_start(ap, fmt);
         vsnprintf((char *)(s->buf + s->size), s->allocated_size - s->size,
@@ -307,7 +315,7 @@ int unicode_from_utf8(const uint8_t *p, int max_len, const uint8_t **pp)
 
 #if 0
 
-#if defined(EMSCRIPTEN) || defined(__ANDROID__)
+#if defined(__EMSCRIPTEN__) || defined(__ANDROID__)
 
 static void *rqsort_arg;
 static int (*rqsort_cmp)(const void *, const void *, void *);

data/ext/quickjsrb/quickjs/cutils.h

@@ -264,24 +264,58 @@ typedef struct DynBuf {
 
 void dbuf_init(DynBuf *s);
 void dbuf_init2(DynBuf *s, void *opaque, DynBufReallocFunc *realloc_func);
-int dbuf_realloc(DynBuf *s, size_t new_size);
-int dbuf_write(DynBuf *s, size_t offset, const uint8_t *data, size_t len);
+int dbuf_claim(DynBuf *s, size_t len);
 int dbuf_put(DynBuf *s, const uint8_t *data, size_t len);
 int dbuf_put_self(DynBuf *s, size_t offset, size_t len);
-int dbuf_putc(DynBuf *s, uint8_t c);
 int dbuf_putstr(DynBuf *s, const char *str);
+int __dbuf_putc(DynBuf *s, uint8_t c);
+int __dbuf_put_u16(DynBuf *s, uint16_t val);
+int __dbuf_put_u32(DynBuf *s, uint32_t val);
+int __dbuf_put_u64(DynBuf *s, uint64_t val);
+
+static inline int dbuf_putc(DynBuf *s, uint8_t val)
+{
+    if (unlikely((s->allocated_size - s->size) < 1)) {
+        return __dbuf_putc(s, val);
+    } else {
+        s->buf[s->size++] = val;
+        return 0;
+    }
+}
+
 static inline int dbuf_put_u16(DynBuf *s, uint16_t val)
 {
-    return dbuf_put(s, (uint8_t *)&val, 2);
+    if (unlikely((s->allocated_size - s->size) < 2)) {
+        return __dbuf_put_u16(s, val);
+    } else {
+        put_u16(s->buf + s->size, val);
+        s->size += 2;
+        return 0;
+    }
 }
+
 static inline int dbuf_put_u32(DynBuf *s, uint32_t val)
 {
-    return dbuf_put(s, (uint8_t *)&val, 4);
+    if (unlikely((s->allocated_size - s->size) < 4)) {
+        return __dbuf_put_u32(s, val);
+    } else {
+        put_u32(s->buf + s->size, val);
+        s->size += 4;
+        return 0;
+    }
 }
+
 static inline int dbuf_put_u64(DynBuf *s, uint64_t val)
 {
-    return dbuf_put(s, (uint8_t *)&val, 8);
+    if (unlikely((s->allocated_size - s->size) < 8)) {
+        return __dbuf_put_u64(s, val);
+    } else {
+        put_u64(s->buf + s->size, val);
+        s->size += 8;
+        return 0;
+    }
 }
+
 int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
                                                       const char *fmt, ...);
 void dbuf_free(DynBuf *s);

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

@@ -31,6 +31,8 @@ DEF(char32, 5)
 DEF(char32_i, 5)
 DEF(dot, 1)
 DEF(any, 1) /* same as dot but match any character including line terminator */
+DEF(space, 1)
+DEF(not_space, 1) /* must come after */
 DEF(line_start, 1)
 DEF(line_start_m, 1)
 DEF(line_end, 1)
@@ -39,17 +41,22 @@ DEF(goto, 5)
 DEF(split_goto_first, 5)
 DEF(split_next_first, 5)
 DEF(match, 1)
+DEF(lookahead_match, 1)
+DEF(negative_lookahead_match, 1) /* must come after */
 DEF(save_start, 2) /* save start position */
 DEF(save_end, 2) /* save end position, must come after saved_start */
 DEF(save_reset, 3) /* reset save positions */
-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(loop, 6) /* decrement the top the stack and goto if != 0 */
+DEF(loop_split_goto_first, 10) /* loop and then split */
+DEF(loop_split_next_first, 10)
+DEF(loop_check_adv_split_goto_first, 10) /* loop and then check advance and split */
+DEF(loop_check_adv_split_next_first, 10)
+DEF(set_i32, 6) /* store the immediate value to a register */
 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(back_reference, 2) /* variable length */
 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 */
@@ -58,10 +65,9 @@ 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 */
-DEF(check_advance, 1) /* pop one stack element and check that it is different from the character position */
+DEF(negative_lookahead, 5) /* must come after */
+DEF(set_char_pos, 2) /* store the character position to a register */
+DEF(check_advance, 2) /* check that the register is different from the character position */
 DEF(prev, 1) /* go to the previous char */
-DEF(simple_greedy_quant, 17)
 
 #endif /* DEF */