Make sorted serialization faster

Redbean Lua and JSON serialization now goes faster because we're now
inserting object entries into tree data structure rather than making
an array and sorting it at the end. For example, when serializing an
object with 10,000 entries this goes twice as fast. However it still
goes slower than saying EncodeJson(x, {sorted=false}).

libc/alg/critbit0.h

@@ -13,14 +13,14 @@ struct critbit0 {
 
 bool critbit0_contains(struct critbit0 *, const char *) dontthrow nosideeffect
     paramsnonnull();
-bool critbit0_insert(struct critbit0 *, const char *) paramsnonnull();
+int critbit0_insert(struct critbit0 *, const char *) paramsnonnull();
 bool critbit0_delete(struct critbit0 *, const char *) dontthrow paramsnonnull();
 void critbit0_clear(struct critbit0 *) dontthrow paramsnonnull();
 char *critbit0_get(struct critbit0 *, const char *);
 intptr_t critbit0_allprefixed(struct critbit0 *, const char *,
                               intptr_t (*)(const char *, void *), void *)
     paramsnonnull((1, 2, 3)) dontthrow;
-bool critbit0_emplace(struct critbit0 *, char *, size_t) paramsnonnull();
+int critbit0_emplace(struct critbit0 *, char *, size_t) paramsnonnull();
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */

libc/alg/critbit0_allprefixed.c

@@ -58,7 +58,9 @@ intptr_t critbit0_allprefixed(struct critbit0 *t, const char *prefix,
     if (q->byte < ulen) top = p;
   }
   for (size_t i = 0; i < ulen; ++i) {
-    if (p[i] != ubytes[i]) return 0;
+    if (p[i] != ubytes[i]) {
+      return 0;
+    }
   }
   return allprefixed_traverse(top, callback, arg);
 }

libc/alg/critbit0_emplace.c

@@ -23,18 +23,19 @@
 
 /**
  * Inserts 𝑢 into 𝑡 without copying.
- * @param t tree
- * @param u NUL-terminated string which must be 8+ byte aligned and
- *     becomes owned by the tree afterwards
- * @return true if 𝑡 was mutated
+ *
+ * @param t is critical bit tree
+ * @param u is nul-terminated string which must be 8+ byte aligned
+ *     and becomes owned by the tree afterwards
+ * @return true if 𝑡 was mutated, or -1 w/ errno
  * @note h/t djb and agl
  */
-bool critbit0_emplace(struct critbit0 *t, char *u, size_t ulen) {
+int critbit0_emplace(struct critbit0 *t, char *u, size_t ulen) {
   unsigned char *p = t->root;
   if (!p) {
     t->root = u;
     t->count = 1;
-    return true;
+    return 1;
   }
   const unsigned char *const ubytes = (void *)u;
   while (1 & (intptr_t)p) {
@@ -49,39 +50,43 @@ bool critbit0_emplace(struct critbit0 *t, char *u, size_t ulen) {
   for (newbyte = 0; newbyte < ulen; ++newbyte) {
     if (p[newbyte] != ubytes[newbyte]) {
       newotherbits = p[newbyte] ^ ubytes[newbyte];
-      goto different_byte_found;
+      goto DifferentByteFound;
     }
   }
   if (p[newbyte] != 0) {
     newotherbits = p[newbyte];
-    goto different_byte_found;
+    goto DifferentByteFound;
   }
-  return false;
-different_byte_found:
+  return 0;
+DifferentByteFound:
   newotherbits |= newotherbits >> 1;
   newotherbits |= newotherbits >> 2;
   newotherbits |= newotherbits >> 4;
   newotherbits = (newotherbits & ~(newotherbits >> 1)) ^ 255;
   unsigned char c = p[newbyte];
   int newdirection = (1 + (newotherbits | c)) >> 8;
-  struct CritbitNode *newnode = malloc(sizeof(struct CritbitNode));
-  newnode->byte = newbyte;
-  newnode->otherbits = newotherbits;
-  newnode->child[1 - newdirection] = (void*)ubytes;
-  void **wherep = &t->root;
-  for (;;) {
-    unsigned char *wp = *wherep;
-    if (!(1 & (intptr_t)wp)) break;
-    struct CritbitNode *q = (void *)(wp - 1);
-    if (q->byte > newbyte) break;
-    if (q->byte == newbyte && q->otherbits > newotherbits) break;
-    unsigned char c2 = 0;
-    if (q->byte < ulen) c2 = ubytes[q->byte];
-    const int direction = (1 + (q->otherbits | c2)) >> 8;
-    wherep = q->child + direction;
+  struct CritbitNode *newnode;
+  if ((newnode = malloc(sizeof(struct CritbitNode)))) {
+    newnode->byte = newbyte;
+    newnode->otherbits = newotherbits;
+    newnode->child[1 - newdirection] = (void *)ubytes;
+    void **wherep = &t->root;
+    for (;;) {
+      unsigned char *wp = *wherep;
+      if (!(1 & (intptr_t)wp)) break;
+      struct CritbitNode *q = (void *)(wp - 1);
+      if (q->byte > newbyte) break;
+      if (q->byte == newbyte && q->otherbits > newotherbits) break;
+      unsigned char c2 = 0;
+      if (q->byte < ulen) c2 = ubytes[q->byte];
+      const int direction = (1 + (q->otherbits | c2)) >> 8;
+      wherep = q->child + direction;
+    }
+    newnode->child[newdirection] = *wherep;
+    *wherep = (void *)(1 + (char *)newnode);
+    t->count++;
+    return 1;
+  } else {
+    return -1;
   }
-  newnode->child[newdirection] = *wherep;
-  *wherep = (void *)(1 + (char *)newnode);
-  t->count++;
-  return true;
 }

libc/alg/critbit0_insert.c

@@ -25,10 +25,15 @@
  * Inserts 𝑢 into 𝑡.
  * @param t tree
  * @param u NUL-terminated string
- * @return true if 𝑡 was mutated
+ * @return true if 𝑡 was mutated, or -1 w/ errno
  * @note h/t djb and agl
  */
-bool critbit0_insert(struct critbit0 *t, const char *u) {
-  size_t ulen = strlen(u);
-  return critbit0_emplace(t, memcpy(malloc(ulen + 1), u, ulen + 1), ulen);
+int critbit0_insert(struct critbit0 *t, const char *u) {
+  char *p;
+  size_t n;
+  if ((p = malloc((n = strlen(u)) + 1))) {
+    return critbit0_emplace(t, memcpy(p, u, n + 1), n);
+  } else {
+    return -1;
+  }
 }