@port-labs/jq-node-bindings 0.0.13 → 0.0.15-dev1

package/deps/jq/src/builtin.c

@@ -1,5 +1,3 @@
-#define _BSD_SOURCE
-#define _GNU_SOURCE
 #ifndef __sun__
 # define _XOPEN_SOURCE
 # define _XOPEN_SOURCE_EXTENDED 1
@@ -34,6 +32,9 @@ void *alloca (size_t);
 #endif
 #include <string.h>
 #include <time.h>
+#ifdef WIN32
+#include <windows.h>
+#endif
 #include "builtin.h"
 #include "compile.h"
 #include "jq_parser.h"
@@ -42,28 +43,40 @@ void *alloca (size_t);
 #include "locfile.h"
 #include "jv_unicode.h"
 #include "jv_alloc.h"
+#include "jv_dtoa.h"
+#include "jv_dtoa_tsd.h"
+#include "jv_private.h"
+#include "util.h"
+
+
+#define BINOP(name) \
+static jv f_ ## name(jq_state *jq, jv input, jv a, jv b) { \
+  jv_free(input); \
+  return binop_ ## name(a, b); \
+}
+BINOPS
+#undef BINOP
 
 
 static jv type_error(jv bad, const char* msg) {
   char errbuf[15];
-  jv err = jv_invalid_with_msg(jv_string_fmt("%s (%s) %s",
-                                             jv_kind_name(jv_get_kind(bad)),
-                                             jv_dump_string_trunc(jv_copy(bad), errbuf, sizeof(errbuf)),
+  const char *badkind = jv_kind_name(jv_get_kind(bad));
+  jv err = jv_invalid_with_msg(jv_string_fmt("%s (%s) %s", badkind,
+                                             jv_dump_string_trunc(bad, errbuf, sizeof(errbuf)),
                                              msg));
-  jv_free(bad);
   return err;
 }
 
 static jv type_error2(jv bad1, jv bad2, const char* msg) {
   char errbuf1[15],errbuf2[15];
+  const char *badkind1 = jv_kind_name(jv_get_kind(bad1));
+  const char *badkind2 = jv_kind_name(jv_get_kind(bad2));
   jv err = jv_invalid_with_msg(jv_string_fmt("%s (%s) and %s (%s) %s",
-                                             jv_kind_name(jv_get_kind(bad1)),
-                                             jv_dump_string_trunc(jv_copy(bad1), errbuf1, sizeof(errbuf1)),
-                                             jv_kind_name(jv_get_kind(bad2)),
-                                             jv_dump_string_trunc(jv_copy(bad2), errbuf2, sizeof(errbuf2)),
+                                             badkind1,
+                                             jv_dump_string_trunc(bad1, errbuf1, sizeof(errbuf1)),
+                                             badkind2,
+                                             jv_dump_string_trunc(bad2, errbuf2, sizeof(errbuf2)),
                                              msg));
-  jv_free(bad1);
-  jv_free(bad2);
   return err;
 }
 
@@ -78,8 +91,7 @@ static inline jv ret_error2(jv bad1, jv bad2, jv msg) {
   return jv_invalid_with_msg(msg);
 }
 
-static jv f_plus(jq_state *jq, jv input, jv a, jv b) {
-  jv_free(input);
+jv binop_plus(jv a, jv b) {
   if (jv_get_kind(a) == JV_KIND_NULL) {
     jv_free(a);
     return b;
@@ -87,8 +99,11 @@ static jv f_plus(jq_state *jq, jv input, jv a, jv b) {
     jv_free(b);
     return a;
   } else if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    return jv_number(jv_number_value(a) +
+    jv r = jv_number(jv_number_value(a) +
                      jv_number_value(b));
+    jv_free(a);
+    jv_free(b);
+    return r;
   } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
     return jv_string_concat(a, b);
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
@@ -100,6 +115,39 @@ static jv f_plus(jq_state *jq, jv input, jv a, jv b) {
   }
 }
 
+#ifdef __APPLE__
+// macOS has a bunch of libm deprecation warnings, so let's clean those up
+#ifdef HAVE_TGAMMA
+#define HAVE_GAMMA
+#define gamma tgamma
+#endif
+#ifdef HAVE___EXP10
+#define HAVE_EXP10
+#define exp10 __exp10
+#endif
+#ifdef HAVE_REMAINDER
+#define HAVE_DREM
+#define drem remainder
+#endif
+
+// We replace significand with our own, since there's not a rename-replacement
+#ifdef HAVE_FREXP
+static double __jq_significand(double x) {
+  int z;
+  return 2*frexp(x, &z);
+}
+#define HAVE_SIGNIFICAND
+#define significand __jq_significand
+#elif defined(HAVE_SCALBN) && defined(HAVE_ILOGB)
+static double __jq_significand(double x) {
+  return scalbn(x, -ilogb(x));
+}
+#define HAVE_SIGNIFICAND
+#define significand __jq_significand
+#endif
+
+#endif // ifdef __APPLE__
+
 #define LIBM_DD(name) \
 static jv f_ ## name(jq_state *jq, jv input) { \
   if (jv_get_kind(input) != JV_KIND_NUMBER) { \
@@ -109,7 +157,11 @@ static jv f_ ## name(jq_state *jq, jv input) { \
   jv_free(input); \
   return ret; \
 }
-#define LIBM_DD_NO(name)
+#define LIBM_DD_NO(name) \
+static jv f_ ## name(jq_state *jq, jv input) { \
+  jv error = jv_string("Error: " #name "/0 not found at build time"); \
+  return ret_error(input, error); \
+}
 
 #define LIBM_DDD(name) \
 static jv f_ ## name(jq_state *jq, jv input, jv a, jv b) { \
@@ -127,7 +179,12 @@ static jv f_ ## name(jq_state *jq, jv input, jv a, jv b) { \
   jv_free(b); \
   return ret; \
 }
-#define LIBM_DDD_NO(name)
+#define LIBM_DDD_NO(name) \
+static jv f_ ## name(jq_state *jq, jv input, jv a, jv b) { \
+  jv_free(b); \
+  jv error = jv_string("Error: " #name "/2 not found at build time"); \
+  return ret_error2(input, a, error); \
+}
 
 #define LIBM_DDDD(name) \
 static jv f_ ## name(jq_state *jq, jv input, jv a, jv b, jv c) { \
@@ -153,48 +210,46 @@ static jv f_ ## name(jq_state *jq, jv input, jv a, jv b, jv c) { \
   jv_free(c); \
   return ret; \
 }
-#define LIBM_DDDD_NO(name)
+#define LIBM_DDDD_NO(name) \
+static jv f_ ## name(jq_state *jq, jv input, jv a, jv b, jv c) { \
+  jv_free(c); \
+  jv_free(b); \
+  jv error = jv_string("Error: " #name "/3 not found at build time"); \
+  return ret_error2(input, a, error); \
+}
+
+#define LIBM_DA(name, type) \
+static jv f_ ## name(jq_state *jq, jv input) { \
+  if (jv_get_kind(input) != JV_KIND_NUMBER) { \
+    return type_error(input, "number required"); \
+  } \
+  type value; \
+  double d = name(jv_number_value(input), &value); \
+  jv ret = JV_ARRAY(jv_number(d), jv_number(value)); \
+  jv_free(input); \
+  return ret; \
+}
+#define LIBM_DA_NO(name, type) \
+static jv f_ ## name(jq_state *jq, jv input) { \
+  jv error = jv_string("Error: " #name "/0 not found at build time"); \
+  return ret_error(input, error); \
+}
+
 #include "libm.h"
 #undef LIBM_DDDD_NO
 #undef LIBM_DDD_NO
 #undef LIBM_DD_NO
+#undef LIBM_DA_NO
 #undef LIBM_DDDD
 #undef LIBM_DDD
 #undef LIBM_DD
+#undef LIBM_DA
 
-#ifdef HAVE_FREXP
-static jv f_frexp(jq_state *jq, jv input) {
-  if (jv_get_kind(input) != JV_KIND_NUMBER) {
-    return type_error(input, "number required");
-  }
-  int exp;
-  double d = frexp(jv_number_value(input), &exp);
-  jv ret = JV_ARRAY(jv_number(d), jv_number(exp));
-  jv_free(input);
-  return ret;
-}
-#endif
-#ifdef HAVE_MODF
-static jv f_modf(jq_state *jq, jv input) {
-  if (jv_get_kind(input) != JV_KIND_NUMBER) {
-    return type_error(input, "number required");
-  }
-  double i;
-  jv ret = JV_ARRAY(jv_number(modf(jv_number_value(input), &i)));
-  jv_free(input);
-  return jv_array_append(ret, jv_number(i));
-}
-#endif
-#ifdef HAVE_LGAMMA_R
-static jv f_lgamma_r(jq_state *jq, jv input) {
-  if (jv_get_kind(input) != JV_KIND_NUMBER) {
-    return type_error(input, "number required");
-  }
-  int sign;
-  jv ret = JV_ARRAY(jv_number(lgamma_r(jv_number_value(input), &sign)));
-  jv_free(input);
-  return jv_array_append(ret, jv_number(sign));
-}
+#ifdef __APPLE__
+#undef gamma
+#undef drem
+#undef significand
+#undef exp10
 #endif
 
 static jv f_negate(jq_state *jq, jv input) {
@@ -229,7 +284,7 @@ static jv f_endswith(jq_state *jq, jv a, jv b) {
   const char *bstr = jv_string_value(b);
   size_t alen = jv_string_length_bytes(jv_copy(a));
   size_t blen = jv_string_length_bytes(jv_copy(b));
-  jv ret;;
+  jv ret;
 
   if (alen < blen ||
      memcmp(astr + (alen - blen), bstr, blen) != 0)
@@ -241,37 +296,12 @@ static jv f_endswith(jq_state *jq, jv a, jv b) {
   return ret;
 }
 
-static jv f_ltrimstr(jq_state *jq, jv input, jv left) {
-  if (jv_get_kind(f_startswith(jq, jv_copy(input), jv_copy(left))) != JV_KIND_TRUE) {
-    jv_free(left);
-    return input;
-  }
-  /*
-   * FIXME It'd be better to share the suffix with the original input --
-   * that we could do, we just can't share prefixes.
-   */
-  int prefixlen = jv_string_length_bytes(left);
-  jv res = jv_string_sized(jv_string_value(input) + prefixlen,
-                           jv_string_length_bytes(jv_copy(input)) - prefixlen);
-  jv_free(input);
-  return res;
-}
-
-static jv f_rtrimstr(jq_state *jq, jv input, jv right) {
-  if (jv_get_kind(f_endswith(jq, jv_copy(input), jv_copy(right))) == JV_KIND_TRUE) {
-    jv res = jv_string_sized(jv_string_value(input),
-                             jv_string_length_bytes(jv_copy(input)) - jv_string_length_bytes(right));
-    jv_free(input);
-    return res;
-  }
-  jv_free(right);
-  return input;
-}
-
-static jv f_minus(jq_state *jq, jv input, jv a, jv b) {
-  jv_free(input);
+jv binop_minus(jv a, jv b) {
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    return jv_number(jv_number_value(a) - jv_number_value(b));
+    jv r = jv_number(jv_number_value(a) - jv_number_value(b));
+    jv_free(a);
+    jv_free(b);
+    return r;
   } else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
     jv out = jv_array();
     jv_array_foreach(a, i, x) {
@@ -294,12 +324,14 @@ static jv f_minus(jq_state *jq, jv input, jv a, jv b) {
   }
 }
 
-static jv f_multiply(jq_state *jq, jv input, jv a, jv b) {
+jv binop_multiply(jv a, jv b) {
   jv_kind ak = jv_get_kind(a);
   jv_kind bk = jv_get_kind(b);
-  jv_free(input);
   if (ak == JV_KIND_NUMBER && bk == JV_KIND_NUMBER) {
-    return jv_number(jv_number_value(a) * jv_number_value(b));
+    jv r = jv_number(jv_number_value(a) * jv_number_value(b));
+    jv_free(a);
+    jv_free(b);
+    return r;
   } else if ((ak == JV_KIND_STRING && bk == JV_KIND_NUMBER) ||
              (ak == JV_KIND_NUMBER && bk == JV_KIND_STRING)) {
     jv str = a;
@@ -308,18 +340,20 @@ static jv f_multiply(jq_state *jq, jv input, jv a, jv b) {
       str = b;
       num = a;
     }
-    int n;
-    size_t alen = jv_string_length_bytes(jv_copy(str));
-    jv res = str;
-
-    for (n = jv_number_value(num) - 1; n > 0; n--)
-      res = jv_string_append_buf(res, jv_string_value(str), alen);
-
-    jv_free(num);
-    if (n < 0) {
-      jv_free(str);
-      return jv_null();
+    jv res;
+    double d = jv_number_value(num);
+    if (d < 0 || isnan(d)) {
+      res = jv_null();
+    } else {
+      int n = d;
+      size_t alen = jv_string_length_bytes(jv_copy(str));
+      res = jv_string_empty(alen * n);
+      for (; n > 0; n--) {
+        res = jv_string_append_buf(res, jv_string_value(str), alen);
+      }
     }
+    jv_free(str);
+    jv_free(num);
     return res;
   } else if (ak == JV_KIND_OBJECT && bk == JV_KIND_OBJECT) {
     return jv_object_merge_recursive(a, b);
@@ -328,12 +362,14 @@ static jv f_multiply(jq_state *jq, jv input, jv a, jv b) {
   }
 }
 
-static jv f_divide(jq_state *jq, jv input, jv a, jv b) {
-  jv_free(input);
+jv binop_divide(jv a, jv b) {
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
     if (jv_number_value(b) == 0.0)
       return type_error2(a, b, "cannot be divided because the divisor is zero");
-    return jv_number(jv_number_value(a) / jv_number_value(b));
+    jv r = jv_number(jv_number_value(a) / jv_number_value(b));
+    jv_free(a);
+    jv_free(b);
+    return r;
   } else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
     return jv_string_split(a, b);
   } else {
@@ -341,24 +377,35 @@ static jv f_divide(jq_state *jq, jv input, jv a, jv b) {
   }
 }
 
-static jv f_mod(jq_state *jq, jv input, jv a, jv b) {
-  jv_free(input);
+#define dtoi(n) ((n) < INTMAX_MIN ? INTMAX_MIN : -(n) < INTMAX_MIN ? INTMAX_MAX : (intmax_t)(n))
+jv binop_mod(jv a, jv b) {
   if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
-    if ((intmax_t)jv_number_value(b) == 0)
+    double na = jv_number_value(a);
+    double nb = jv_number_value(b);
+    if (isnan(na) || isnan(nb)) {
+      jv_free(a);
+      jv_free(b);
+      return jv_number(NAN);
+    }
+    intmax_t bi = dtoi(nb);
+    if (bi == 0)
       return type_error2(a, b, "cannot be divided (remainder) because the divisor is zero");
-    return jv_number((intmax_t)jv_number_value(a) % (intmax_t)jv_number_value(b));
+    // Check if the divisor is -1 to avoid overflow when the dividend is INTMAX_MIN.
+    jv r = jv_number(bi == -1 ? 0 : dtoi(na) % bi);
+    jv_free(a);
+    jv_free(b);
+    return r;
   } else {
     return type_error2(a, b, "cannot be divided (remainder)");
   }
 }
+#undef dtoi
 
-static jv f_equal(jq_state *jq, jv input, jv a, jv b) {
-  jv_free(input);
+jv binop_equal(jv a, jv b) {
   return jv_bool(jv_equal(a, b));
 }
 
-static jv f_notequal(jq_state *jq, jv input, jv a, jv b) {
-  jv_free(input);
+jv binop_notequal(jv a, jv b) {
   return jv_bool(!jv_equal(a, b));
 }
 
@@ -369,8 +416,7 @@ enum cmp_op {
   CMP_OP_GREATEREQ
 };
 
-static jv order_cmp(jv input, jv a, jv b, enum cmp_op op) {
-  jv_free(input);
+static jv order_cmp(jv a, jv b, enum cmp_op op) {
   int r = jv_cmp(a, b);
   return jv_bool((op == CMP_OP_LESS && r < 0) ||
                  (op == CMP_OP_LESSEQ && r <= 0) ||
@@ -378,20 +424,20 @@ static jv order_cmp(jv input, jv a, jv b, enum cmp_op op) {
                  (op == CMP_OP_GREATER && r > 0));
 }
 
-static jv f_less(jq_state *jq, jv input, jv a, jv b) {
-  return order_cmp(input, a, b, CMP_OP_LESS);
+jv binop_less(jv a, jv b) {
+  return order_cmp(a, b, CMP_OP_LESS);
 }
 
-static jv f_greater(jq_state *jq, jv input, jv a, jv b) {
-  return order_cmp(input, a, b, CMP_OP_GREATER);
+jv binop_greater(jv a, jv b) {
+  return order_cmp(a, b, CMP_OP_GREATER);
 }
 
-static jv f_lesseq(jq_state *jq, jv input, jv a, jv b) {
-  return order_cmp(input, a, b, CMP_OP_LESSEQ);
+jv binop_lesseq(jv a, jv b) {
+  return order_cmp(a, b, CMP_OP_LESSEQ);
 }
 
-static jv f_greatereq(jq_state *jq, jv input, jv a, jv b) {
-  return order_cmp(input, a, b, CMP_OP_GREATEREQ);
+jv binop_greatereq(jv a, jv b) {
+  return order_cmp(a, b, CMP_OP_GREATEREQ);
 }
 
 static jv f_contains(jq_state *jq, jv a, jv b) {
@@ -420,11 +466,22 @@ static jv f_tonumber(jq_state *jq, jv input) {
     return input;
   }
   if (jv_get_kind(input) == JV_KIND_STRING) {
-    jv parsed = jv_parse(jv_string_value(input));
-    if (!jv_is_valid(parsed) || jv_get_kind(parsed) == JV_KIND_NUMBER) {
-      jv_free(input);
-      return parsed;
+    const char* s = jv_string_value(input);
+#ifdef USE_DECNUM
+    jv number = jv_number_with_literal(s);
+    if (jv_get_kind(number) == JV_KIND_INVALID) {
+      return type_error(input, "cannot be parsed as a number");
     }
+#else
+    char *end = 0;
+    double d = jvp_strtod(tsd_dtoa_context_get(), s, &end);
+    if (end == 0 || *end != 0) {
+      return type_error(input, "cannot be parsed as a number");
+    }
+    jv number = jv_number(d);
+#endif
+    jv_free(input);
+    return number;
   }
   return type_error(input, "cannot be parsed as a number");
 }
@@ -437,7 +494,9 @@ static jv f_length(jq_state *jq, jv input) {
   } else if (jv_get_kind(input) == JV_KIND_STRING) {
     return jv_number(jv_string_length_codepoints(input));
   } else if (jv_get_kind(input) == JV_KIND_NUMBER) {
-    return jv_number(fabs(jv_number_value(input)));
+    jv r = jv_number(fabs(jv_number_value(input)));
+    jv_free(input);
+    return r;
   } else if (jv_get_kind(input) == JV_KIND_NULL) {
     jv_free(input);
     return jv_number(0);
@@ -582,7 +641,7 @@ static jv f_format(jq_state *jq, jv input, jv fmt) {
     input = f_tostring(jq, input);
 
     int unreserved[128] = {0};
-    const char* p = CHARS_ALPHANUM "-_.!~*'()";
+    const char* p = CHARS_ALPHANUM "-_.~";
     while (*p) unreserved[(int)*p++] = 1;
 
     jv line = jv_string("");
@@ -598,6 +657,48 @@ static jv f_format(jq_state *jq, jv input, jv fmt) {
     }
     jv_free(input);
     return line;
+  } else if (!strcmp(fmt_s, "urid")) {
+    jv_free(fmt);
+    input = f_tostring(jq, input);
+
+    jv line = jv_string("");
+    const char *errmsg =  "is not a valid uri encoding";
+    const char *s = jv_string_value(input);
+    while (*s) {
+      if (*s != '%') {
+        line = jv_string_append_buf(line, s++, 1);
+      } else {
+        unsigned char unicode[4] = {0};
+        int b = 0;
+        // check leading bits of first octet to determine length of unicode character
+        // (https://datatracker.ietf.org/doc/html/rfc3629#section-3)
+        while (b == 0 || (b < 4 && unicode[0] >> 7 & 1 && unicode[0] >> (7-b) & 1)) {
+          if (*(s++) != '%') {
+            jv_free(line);
+            return type_error(input, errmsg);
+          }
+          for (int i=0; i<2; i++) {
+            unicode[b] <<= 4;
+            char c = *(s++);
+            if ('0' <= c && c <= '9') unicode[b] |= c - '0';
+            else if ('a' <= c && c <= 'f') unicode[b] |= c - 'a' + 10;
+            else if ('A' <= c && c <= 'F') unicode[b] |= c - 'A' + 10;
+            else {
+              jv_free(line);
+              return type_error(input, errmsg);
+            }
+          }
+          b++;
+        }
+        if (!jvp_utf8_is_valid((const char *)unicode, (const char *)unicode+b)) {
+          jv_free(line);
+          return type_error(input, errmsg);
+        }
+        line = jv_string_append_buf(line, (const char *)unicode, b);
+      }
+    }
+    jv_free(input);
+    return line;
   } else if (!strcmp(fmt_s, "sh")) {
     jv_free(fmt);
     if (jv_get_kind(input) != JV_KIND_ARRAY)
@@ -656,7 +757,7 @@ static jv f_format(jq_state *jq, jv input, jv fmt) {
     input = f_tostring(jq, input);
     const unsigned char* data = (const unsigned char*)jv_string_value(input);
     int len = jv_string_length_bytes(jv_copy(input));
-    size_t decoded_len = (3 * len) / 4; // 3 usable bytes for every 4 bytes of input
+    size_t decoded_len = (3 * (size_t)len) / 4; // 3 usable bytes for every 4 bytes of input
     char *result = jv_mem_calloc(decoded_len, sizeof(char));
     memset(result, 0, decoded_len * sizeof(char));
     uint32_t ri = 0;
@@ -862,15 +963,26 @@ static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) {
       if (region->end[0] == region->beg[0]) {
         unsigned long idx;
         const char *fr = (const char*)input_string;
-        for (idx = 0; fr != input_string+region->beg[0]; idx++) {
+        for (idx = 0; fr < input_string+region->beg[0]; idx++) {
           fr += jvp_utf8_decode_length(*fr);
         }
         jv match = jv_object_set(jv_object(), jv_string("offset"), jv_number(idx));
         match = jv_object_set(match, jv_string("length"), jv_number(0));
         match = jv_object_set(match, jv_string("string"), jv_string(""));
-        match = jv_object_set(match, jv_string("captures"), jv_array());
+        jv captures = jv_array();
+        for (int i = 1; i < region->num_regs; ++i) {
+          jv cap = jv_object();
+          cap = jv_object_set(cap, jv_string("offset"), jv_number(idx));
+          cap = jv_object_set(cap, jv_string("string"), jv_string(""));
+          cap = jv_object_set(cap, jv_string("length"), jv_number(0));
+          cap = jv_object_set(cap, jv_string("name"), jv_null());
+          captures = jv_array_append(captures, cap);
+        }
+        onig_foreach_name(reg, f_match_name_iter, &captures);
+        match = jv_object_set(match, jv_string("captures"), captures);
         result = jv_array_append(result, match);
-        start += 1;
+        // ensure '"qux" | match("(?=u)"; "g")' matches just once
+        start = (const UChar*)(input_string+region->end[0]+1);
         continue;
       }
 
@@ -899,7 +1011,7 @@ static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) {
             cap = jv_object_set(cap, jv_string("string"), jv_null());
           } else {
             fr = input_string;
-            for (idx = 0; fr != input_string+region->beg[i]; idx++) {
+            for (idx = 0; fr < input_string+region->beg[i]; idx++) {
               fr += jvp_utf8_decode_length(*fr);
             }
             cap = jv_object_set(jv_object(), jv_string("offset"), jv_number(idx));
@@ -911,7 +1023,7 @@ static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) {
           continue;
         }
         fr = input_string;
-        for (idx = len = 0; fr != input_string+region->end[i]; len++) {
+        for (idx = len = 0; fr < input_string+region->end[i]; len++) {
           if (fr == input_string+region->beg[i]) idx = len, len=0;
           fr += jvp_utf8_decode_length(*fr);
         }
@@ -932,17 +1044,15 @@ static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) {
       break;
     } else { /* Error */
       UChar ebuf[ONIG_MAX_ERROR_MESSAGE_LEN];
-      onig_error_code_to_str(ebuf, onigret, einfo);
+      onig_error_code_to_str(ebuf, onigret, &einfo);
       jv_free(result);
       result = jv_invalid_with_msg(jv_string_concat(jv_string("Regex failure: "),
             jv_string((char*)ebuf)));
       break;
     }
-  } while (global && start != end);
+  } while (global && start <= end);
   onig_region_free(region,1);
   region = NULL;
-  if (region)
-    onig_region_free(region,1);
   onig_free(reg);
   jv_free(input);
   jv_free(regex);
@@ -950,7 +1060,11 @@ static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) {
 }
 #else /* !HAVE_LIBONIG */
 static jv f_match(jq_state *jq, jv input, jv regex, jv modifiers, jv testmode) {
-  return jv_invalid_with_msg(jv_string("jq was compiled without ONIGURUMA regex libary. match/test/sub and related functions are not available."));
+  jv_free(input);
+  jv_free(regex);
+  jv_free(modifiers);
+  jv_free(testmode);
+  return jv_invalid_with_msg(jv_string("jq was compiled without ONIGURUMA regex library. match/test/sub and related functions are not available."));
 }
 #endif /* HAVE_LIBONIG */
 
@@ -1053,9 +1167,8 @@ static jv f_nan(jq_state *jq, jv input) {
   return jv_number(NAN);
 }
 
-static jv f_error(jq_state *jq, jv input, jv msg) {
-  jv_free(input);
-  return jv_invalid_with_msg(msg);
+static jv f_error(jq_state *jq, jv input) {
+  return jv_invalid_with_msg(input);
 }
 
 // FIXME Should autoconf check for this!
@@ -1126,11 +1239,84 @@ static jv f_string_indexes(jq_state *jq, jv a, jv b) {
   return jv_string_indexes(a, b);
 }
 
+enum trim_op {
+  TRIM_LEFT  = 1 << 0,
+  TRIM_RIGHT = 1 << 1
+};
+
+static jv string_trim(jv a, int op) {
+  if (jv_get_kind(a) != JV_KIND_STRING) {
+    return ret_error(a, jv_string("trim input must be a string"));
+  }
+
+  int len = jv_string_length_bytes(jv_copy(a));
+  const char *start = jv_string_value(a);
+  const char *trim_start = start;
+  const char *end = trim_start + len;
+  const char *trim_end = end;
+  int c;
+
+  if (op & TRIM_LEFT) {
+    for (;;) {
+      const char *ns = jvp_utf8_next(trim_start, end, &c);
+      if (!ns || !jvp_codepoint_is_whitespace(c))
+        break;
+      trim_start = ns;
+    }
+  }
+
+  // make sure not empty string or start trim has trimmed everything
+  if ((op & TRIM_RIGHT) && trim_end > trim_start) {
+    for (;;) {
+      const char *ns = jvp_utf8_backtrack(trim_end-1, trim_start, NULL);
+      jvp_utf8_next(ns, trim_end, &c);
+      if (!jvp_codepoint_is_whitespace(c))
+        break;
+      trim_end = ns;
+      if (ns == trim_start)
+        break;
+    }
+  }
+
+  // no new string needed if there is nothing to trim
+  if (trim_start == start && trim_end == end)
+    return a;
+
+  jv ts = jv_string_sized(trim_start, trim_end - trim_start);
+  jv_free(a);
+  return ts;
+}
+
+static jv f_string_trim(jq_state *jq, jv a)  { return string_trim(a, TRIM_LEFT | TRIM_RIGHT); }
+static jv f_string_ltrim(jq_state *jq, jv a) { return string_trim(a, TRIM_LEFT); }
+static jv f_string_rtrim(jq_state *jq, jv a) { return string_trim(a, TRIM_RIGHT); }
+
 static jv f_string_implode(jq_state *jq, jv a) {
   if (jv_get_kind(a) != JV_KIND_ARRAY) {
     return ret_error(a, jv_string("implode input must be an array"));
   }
-  return jv_string_implode(a);
+
+  int len = jv_array_length(jv_copy(a));
+  jv s = jv_string_empty(len);
+
+  for (int i = 0; i < len; i++) {
+    jv n = jv_array_get(jv_copy(a), i);
+    if (jv_get_kind(n) != JV_KIND_NUMBER || jvp_number_is_nan(n)) {
+      jv_free(a);
+      jv_free(s);
+      return type_error(n, "can't be imploded, unicode codepoint needs to be numeric");
+    }
+
+    int nv = jv_number_value(n);
+    jv_free(n);
+    // outside codepoint range or in utf16 surrogate pair range
+    if (nv < 0 || nv > 0x10FFFF || (nv >= 0xD800 && nv <= 0xDFFF))
+      nv = 0xFFFD; // U+FFFD REPLACEMENT CHARACTER
+    s = jv_string_append_codepoint(s, nv);
+  }
+
+  jv_free(a);
+  return s;
 }
 
 static jv f_setpath(jq_state *jq, jv a, jv b, jv c) { return jv_setpath(a, b, c); }
@@ -1171,7 +1357,11 @@ static jv f_debug(jq_state *jq, jv input) {
 }
 
 static jv f_stderr(jq_state *jq, jv input) {
-  jv_dumpf(jv_copy(input), stderr, 0);
+  jq_msg_cb cb;
+  void *data;
+  jq_get_stderr_cb(jq, &cb, &data);
+  if (cb != NULL)
+    cb(data, jv_copy(input));
   return input;
 }
 
@@ -1186,6 +1376,27 @@ static jv tm2jv(struct tm *tm) {
                   jv_number(tm->tm_yday));
 }
 
+#if defined(WIN32) && !defined(HAVE_SETENV)
+static int setenv(const char *var, const char *val, int ovr)
+{
+  BOOL b;
+  char c[2];
+  if (!ovr)
+  {
+    DWORD d;
+    d = GetEnvironmentVariableA (var, c, 2);
+    if (0 != d && GetLastError () != ERROR_ENVVAR_NOT_FOUND) {
+      return d;
+    }
+  }
+  b = SetEnvironmentVariableA (var, val);
+  if (b) {
+    return 0;
+  }
+  return 1;
+}
+#endif
+
 /*
  * mktime() has side-effects and anyways, returns time in the local
  * timezone, not UTC.  We want timegm(), which isn't standard.
@@ -1201,10 +1412,23 @@ static jv tm2jv(struct tm *tm) {
  *
  * Returns (time_t)-2 if mktime()'s side-effects cannot be corrected.
  */
-static time_t my_timegm(struct tm *tm) {
+static time_t my_mktime(struct tm *tm) {
 #ifdef HAVE_TIMEGM
   return timegm(tm);
-#else /* HAVE_TIMEGM */
+#elif HAVE_TM_TM_GMT_OFF
+
+  time_t t = mktime(tm);
+  if (t == (time_t)-1)
+    return t;
+  return t + tm->tm_gmtoff;
+#elif HAVE_TM___TM_GMT_OFF
+  time_t t = mktime(tm);
+  if (t == (time_t)-1)
+    return t;
+  return t + tm->__tm_gmtoff;
+#elif WIN32
+  return _mkgmtime(tm);
+#else
   char *tz;
 
   tz = (tz = getenv("TZ")) != NULL ? strdup(tz) : NULL;
@@ -1214,18 +1438,6 @@ static time_t my_timegm(struct tm *tm) {
   if (tz != NULL)
     setenv("TZ", tz, 1);
   return t;
-#endif /* !HAVE_TIMEGM */
-}
-static time_t my_mktime(struct tm *tm) {
-  time_t t = mktime(tm);
-  if (t == (time_t)-1)
-    return t;
-#ifdef HAVE_TM_TM_GMT_OFF
-  return t + tm->tm_gmtoff;
-#elif HAVE_TM___TM_GMT_OFF
-  return t + tm->__tm_gmtoff;
-#else
-  return (time_t)-2; /* Not supported */
 #endif
 }
 
@@ -1286,7 +1498,6 @@ static void set_tm_yday(struct tm *tm) {
   tm->tm_yday = yday;
 }
 
-#ifdef HAVE_STRPTIME
 static jv f_strptime(jq_state *jq, jv a, jv b) {
   if (jv_get_kind(a) != JV_KIND_STRING || jv_get_kind(b) != JV_KIND_STRING) {
     return ret_error2(a, b, jv_string("strptime/1 requires string inputs and arguments"));
@@ -1298,9 +1509,14 @@ static jv f_strptime(jq_state *jq, jv a, jv b) {
   tm.tm_yday = 367; // sentinel
   const char *input = jv_string_value(a);
   const char *fmt = jv_string_value(b);
-  const char *end = strptime(input, fmt, &tm);
 
-  if (end == NULL || (*end != '\0' && !isspace(*end))) {
+#ifndef HAVE_STRPTIME
+  if (strcmp(fmt, "%Y-%m-%dT%H:%M:%SZ")) {
+    return ret_error2(a, b, jv_string("strptime/1 only supports ISO 8601 on this platform"));
+  }
+#endif
+  const char *end = strptime(input, fmt, &tm);
+  if (end == NULL || (*end != '\0' && !isspace((unsigned char)*end))) {
     return ret_error2(a, b, jv_string_fmt("date \"%s\" does not match format \"%s\"", input, fmt));
   }
   jv_free(b);
@@ -1324,6 +1540,8 @@ static jv f_strptime(jq_state *jq, jv a, jv b) {
    */
   set_tm_wday(&tm);
   set_tm_yday(&tm);
+#elif defined(WIN32) || !defined(HAVE_STRPTIME)
+  set_tm_wday(&tm);
 #else
   if (tm.tm_wday == 8 && tm.tm_mday != 0 && tm.tm_mon >= 0 && tm.tm_mon <= 11)
     set_tm_wday(&tm);
@@ -1336,37 +1554,36 @@ static jv f_strptime(jq_state *jq, jv a, jv b) {
   jv_free(a); // must come after `*end` because `end` is a pointer into `a`'s string
   return r;
 }
-#else
-static jv f_strptime(jq_state *jq, jv a, jv b) {
-  jv_free(a);
-  jv_free(b);
-  return jv_invalid_with_msg(jv_string("strptime/1 not implemented on this platform"));
-}
-#endif
-
-#define TO_TM_FIELD(t, j, i)                    \
-    do {                                        \
-      jv n = jv_array_get(jv_copy(j), (i));     \
-      if (jv_get_kind(n) != (JV_KIND_NUMBER)) { \
-        jv_free(j);                             \
-        return 0;                               \
-      }                                         \
-      t = jv_number_value(n);                   \
-      jv_free(n);                               \
-    } while (0)
 
 static int jv2tm(jv a, struct tm *tm) {
   memset(tm, 0, sizeof(*tm));
-  TO_TM_FIELD(tm->tm_year, a, 0);
-  tm->tm_year -= 1900;
-  TO_TM_FIELD(tm->tm_mon,  a, 1);
-  TO_TM_FIELD(tm->tm_mday, a, 2);
-  TO_TM_FIELD(tm->tm_hour, a, 3);
-  TO_TM_FIELD(tm->tm_min,  a, 4);
-  TO_TM_FIELD(tm->tm_sec,  a, 5);
-  TO_TM_FIELD(tm->tm_wday, a, 6);
-  TO_TM_FIELD(tm->tm_yday, a, 7);
-  jv_free(a);
+  static const size_t offsets[] = {
+    offsetof(struct tm, tm_year),
+    offsetof(struct tm, tm_mon),
+    offsetof(struct tm, tm_mday),
+    offsetof(struct tm, tm_hour),
+    offsetof(struct tm, tm_min),
+    offsetof(struct tm, tm_sec),
+    offsetof(struct tm, tm_wday),
+    offsetof(struct tm, tm_yday),
+  };
+
+  for (size_t i = 0; i < (sizeof offsets / sizeof *offsets); ++i) {
+    jv n = jv_array_get(jv_copy(a), i);
+    if (!jv_is_valid(n))
+      break;
+    if (jv_get_kind(n) != JV_KIND_NUMBER || jvp_number_is_nan(n)) {
+      jv_free(a);
+      jv_free(n);
+      return 0;
+    }
+    double d = jv_number_value(n);
+    if (i == 0) /* year */
+      d -= 1900;
+    *(int *)((void *)tm + offsets[i]) = d < INT_MIN ? INT_MIN :
+                                        d > INT_MAX ? INT_MAX : (int)d;
+    jv_free(n);
+  }
 
   // We use UTC everywhere (gettimeofday, gmtime) and UTC does not do DST.
   // Setting tm_isdst to 0 is done by the memset.
@@ -1376,6 +1593,7 @@ static int jv2tm(jv a, struct tm *tm) {
   // hope it is okay to initialize them to zero, because the standard does not
   // provide an alternative.
 
+  jv_free(a);
   return 1;
 }
 
@@ -1384,8 +1602,6 @@ static int jv2tm(jv a, struct tm *tm) {
 static jv f_mktime(jq_state *jq, jv a) {
   if (jv_get_kind(a) != JV_KIND_ARRAY)
     return ret_error(a, jv_string("mktime requires array inputs"));
-  if (jv_array_length(jv_copy(a)) < 6)
-    return ret_error(a, jv_string("mktime requires parsed datetime inputs"));
   struct tm tm;
   if (!jv2tm(a, &tm))
     return jv_invalid_with_msg(jv_string("mktime requires parsed datetime inputs"));
@@ -1408,7 +1624,7 @@ static jv f_gmtime(jq_state *jq, jv a) {
   jv_free(a);
   tmp = gmtime_r(&secs, &tm);
   if (tmp == NULL)
-    return jv_invalid_with_msg(jv_string("errror converting number of seconds since epoch to datetime"));
+    return jv_invalid_with_msg(jv_string("error converting number of seconds since epoch to datetime"));
   a = tm2jv(tmp);
   return jv_array_set(a, 5, jv_number(jv_number_value(jv_array_get(jv_copy(a), 5)) + (fsecs - floor(fsecs))));
 }
@@ -1423,7 +1639,7 @@ static jv f_gmtime(jq_state *jq, jv a) {
   jv_free(a);
   tmp = gmtime(&secs);
   if (tmp == NULL)
-    return jv_invalid_with_msg(jv_string("errror converting number of seconds since epoch to datetime"));
+    return jv_invalid_with_msg(jv_string("error converting number of seconds since epoch to datetime"));
   a = tm2jv(tmp);
   return jv_array_set(a, 5, jv_number(jv_number_value(jv_array_get(jv_copy(a), 5)) + (fsecs - floor(fsecs))));
 }
@@ -1475,11 +1691,15 @@ static jv f_localtime(jq_state *jq, jv a) {
 static jv f_strftime(jq_state *jq, jv a, jv b) {
   if (jv_get_kind(a) == JV_KIND_NUMBER) {
     a = f_gmtime(jq, a);
+    if (!jv_is_valid(a)) {
+      jv_free(b);
+      return a;
+    }
   } else if (jv_get_kind(a) != JV_KIND_ARRAY) {
     return ret_error2(a, b, jv_string("strftime/1 requires parsed datetime inputs"));
-  } else if (jv_get_kind(b) != JV_KIND_STRING) {
-    return ret_error2(a, b, jv_string("strftime/1 requires a string format"));
   }
+  if (jv_get_kind(b) != JV_KIND_STRING)
+    return ret_error2(a, b, jv_string("strftime/1 requires a string format"));
   struct tm tm;
   if (!jv2tm(a, &tm))
     return ret_error(b, jv_string("strftime/1 requires parsed datetime inputs"));
@@ -1508,12 +1728,12 @@ static jv f_strflocaltime(jq_state *jq, jv a, jv b) {
     a = f_localtime(jq, a);
   } else if (jv_get_kind(a) != JV_KIND_ARRAY) {
     return ret_error2(a, b, jv_string("strflocaltime/1 requires parsed datetime inputs"));
-  } else if (jv_get_kind(b) != JV_KIND_STRING) {
-    return ret_error2(a, b, jv_string("strflocaltime/1 requires a string format"));
   }
+  if (jv_get_kind(b) != JV_KIND_STRING)
+    return ret_error2(a, b, jv_string("strflocaltime/1 requires a string format"));
   struct tm tm;
   if (!jv2tm(a, &tm))
-    return jv_invalid_with_msg(jv_string("strflocaltime/1 requires parsed datetime inputs"));
+    return ret_error(b, jv_string("strflocaltime/1 requires parsed datetime inputs"));
   const char *fmt = jv_string_value(b);
   size_t alloced = strlen(fmt) + 100;
   char *buf = alloca(alloced);
@@ -1561,104 +1781,133 @@ static jv f_current_line(jq_state *jq, jv a) {
   return jq_util_input_get_current_line(jq);
 }
 
+static jv f_have_decnum(jq_state *jq, jv a) {
+  jv_free(a);
+#ifdef USE_DECNUM
+  return jv_true();
+#else
+  return jv_false();
+#endif
+}
+
+#define CFUNC(func, name, arity) \
+  {.fptr = { .a ## arity = func }, name, arity}
+
 #define LIBM_DD(name) \
-  {(cfunction_ptr)f_ ## name,  #name, 1},
-#define LIBM_DD_NO(name)
+  CFUNC(f_ ## name, #name, 1),
+#define LIBM_DD_NO(name) LIBM_DD(name)
+#define LIBM_DA(name, type) LIBM_DD(name)
+#define LIBM_DA_NO(name, type) LIBM_DD(name)
 
 #define LIBM_DDD(name) \
-  {(cfunction_ptr)f_ ## name, #name, 3},
-#define LIBM_DDD_NO(name)
+  CFUNC(f_ ## name, #name, 3),
+#define LIBM_DDD_NO(name) LIBM_DDD(name)
 
 #define LIBM_DDDD(name) \
-  {(cfunction_ptr)f_ ## name, #name, 4},
-#define LIBM_DDDD_NO(name)
+  CFUNC(f_ ## name, #name, 4),
+#define LIBM_DDDD_NO(name) LIBM_DDDD(name)
 
 static const struct cfunction function_list[] = {
 #include "libm.h"
-#ifdef HAVE_FREXP
-  {(cfunction_ptr)f_frexp,"frexp", 1},
-#endif
-#ifdef HAVE_MODF
-  {(cfunction_ptr)f_modf,"modf", 1},
-#endif
-#ifdef HAVE_LGAMMA_R
-  {(cfunction_ptr)f_lgamma_r,"lgamma_r", 1},
-#endif
-  {(cfunction_ptr)f_plus, "_plus", 3},
-  {(cfunction_ptr)f_negate, "_negate", 1},
-  {(cfunction_ptr)f_minus, "_minus", 3},
-  {(cfunction_ptr)f_multiply, "_multiply", 3},
-  {(cfunction_ptr)f_divide, "_divide", 3},
-  {(cfunction_ptr)f_mod, "_mod", 3},
-  {(cfunction_ptr)f_dump, "tojson", 1},
-  {(cfunction_ptr)f_json_parse, "fromjson", 1},
-  {(cfunction_ptr)f_tonumber, "tonumber", 1},
-  {(cfunction_ptr)f_tostring, "tostring", 1},
-  {(cfunction_ptr)f_keys, "keys", 1},
-  {(cfunction_ptr)f_keys_unsorted, "keys_unsorted", 1},
-  {(cfunction_ptr)f_startswith, "startswith", 2},
-  {(cfunction_ptr)f_endswith, "endswith", 2},
-  {(cfunction_ptr)f_ltrimstr, "ltrimstr", 2},
-  {(cfunction_ptr)f_rtrimstr, "rtrimstr", 2},
-  {(cfunction_ptr)f_string_split, "split", 2},
-  {(cfunction_ptr)f_string_explode, "explode", 1},
-  {(cfunction_ptr)f_string_implode, "implode", 1},
-  {(cfunction_ptr)f_string_indexes, "_strindices", 2},
-  {(cfunction_ptr)f_setpath, "setpath", 3}, // FIXME typechecking
-  {(cfunction_ptr)f_getpath, "getpath", 2},
-  {(cfunction_ptr)f_delpaths, "delpaths", 2},
-  {(cfunction_ptr)f_has, "has", 2},
-  {(cfunction_ptr)f_equal, "_equal", 3},
-  {(cfunction_ptr)f_notequal, "_notequal", 3},
-  {(cfunction_ptr)f_less, "_less", 3},
-  {(cfunction_ptr)f_greater, "_greater", 3},
-  {(cfunction_ptr)f_lesseq, "_lesseq", 3},
-  {(cfunction_ptr)f_greatereq, "_greatereq", 3},
-  {(cfunction_ptr)f_contains, "contains", 2},
-  {(cfunction_ptr)f_length, "length", 1},
-  {(cfunction_ptr)f_utf8bytelength, "utf8bytelength", 1},
-  {(cfunction_ptr)f_type, "type", 1},
-  {(cfunction_ptr)f_isinfinite, "isinfinite", 1},
-  {(cfunction_ptr)f_isnan, "isnan", 1},
-  {(cfunction_ptr)f_isnormal, "isnormal", 1},
-  {(cfunction_ptr)f_infinite, "infinite", 1},
-  {(cfunction_ptr)f_nan, "nan", 1},
-  {(cfunction_ptr)f_sort, "sort", 1},
-  {(cfunction_ptr)f_sort_by_impl, "_sort_by_impl", 2},
-  {(cfunction_ptr)f_group_by_impl, "_group_by_impl", 2},
-  {(cfunction_ptr)f_min, "min", 1},
-  {(cfunction_ptr)f_max, "max", 1},
-  {(cfunction_ptr)f_min_by_impl, "_min_by_impl", 2},
-  {(cfunction_ptr)f_max_by_impl, "_max_by_impl", 2},
-  {(cfunction_ptr)f_error, "error", 2},
-  {(cfunction_ptr)f_format, "format", 2},
-  {(cfunction_ptr)f_env, "env", 1},
-  {(cfunction_ptr)f_halt, "halt", 1},
-  {(cfunction_ptr)f_halt_error, "halt_error", 2},
-  {(cfunction_ptr)f_get_search_list, "get_search_list", 1},
-  {(cfunction_ptr)f_get_prog_origin, "get_prog_origin", 1},
-  {(cfunction_ptr)f_get_jq_origin, "get_jq_origin", 1},
-  {(cfunction_ptr)f_match, "_match_impl", 4},
-  {(cfunction_ptr)f_modulemeta, "modulemeta", 1},
-  {(cfunction_ptr)f_input, "_input", 1},
-  {(cfunction_ptr)f_debug, "debug", 1},
-  {(cfunction_ptr)f_stderr, "stderr", 1},
-  {(cfunction_ptr)f_strptime, "strptime", 2},
-  {(cfunction_ptr)f_strftime, "strftime", 2},
-  {(cfunction_ptr)f_strflocaltime, "strflocaltime", 2},
-  {(cfunction_ptr)f_mktime, "mktime", 1},
-  {(cfunction_ptr)f_gmtime, "gmtime", 1},
-  {(cfunction_ptr)f_localtime, "localtime", 1},
-  {(cfunction_ptr)f_now, "now", 1},
-  {(cfunction_ptr)f_current_filename, "input_filename", 1},
-  {(cfunction_ptr)f_current_line, "input_line_number", 1},
+  CFUNC(f_negate, "_negate", 1),
+#define BINOP(name) CFUNC(f_ ## name, "_" #name, 3),
+BINOPS
+#undef BINOP
+  CFUNC(f_dump, "tojson", 1),
+  CFUNC(f_json_parse, "fromjson", 1),
+  CFUNC(f_tonumber, "tonumber", 1),
+  CFUNC(f_tostring, "tostring", 1),
+  CFUNC(f_keys, "keys", 1),
+  CFUNC(f_keys_unsorted, "keys_unsorted", 1),
+  CFUNC(f_startswith, "startswith", 2),
+  CFUNC(f_endswith, "endswith", 2),
+  CFUNC(f_string_split, "split", 2),
+  CFUNC(f_string_explode, "explode", 1),
+  CFUNC(f_string_implode, "implode", 1),
+  CFUNC(f_string_indexes, "_strindices", 2),
+  CFUNC(f_string_trim, "trim", 1),
+  CFUNC(f_string_ltrim, "ltrim", 1),
+  CFUNC(f_string_rtrim, "rtrim", 1),
+  CFUNC(f_setpath, "setpath", 3),
+  CFUNC(f_getpath, "getpath", 2),
+  CFUNC(f_delpaths, "delpaths", 2),
+  CFUNC(f_has, "has", 2),
+  CFUNC(f_contains, "contains", 2),
+  CFUNC(f_length, "length", 1),
+  CFUNC(f_utf8bytelength, "utf8bytelength", 1),
+  CFUNC(f_type, "type", 1),
+  CFUNC(f_isinfinite, "isinfinite", 1),
+  CFUNC(f_isnan, "isnan", 1),
+  CFUNC(f_isnormal, "isnormal", 1),
+  CFUNC(f_infinite, "infinite", 1),
+  CFUNC(f_nan, "nan", 1),
+  CFUNC(f_sort, "sort", 1),
+  CFUNC(f_sort_by_impl, "_sort_by_impl", 2),
+  CFUNC(f_group_by_impl, "_group_by_impl", 2),
+  CFUNC(f_min, "min", 1),
+  CFUNC(f_max, "max", 1),
+  CFUNC(f_min_by_impl, "_min_by_impl", 2),
+  CFUNC(f_max_by_impl, "_max_by_impl", 2),
+  CFUNC(f_error, "error", 1),
+  CFUNC(f_format, "format", 2),
+  CFUNC(f_env, "env", 1),
+  CFUNC(f_halt, "halt", 1),
+  CFUNC(f_halt_error, "halt_error", 2),
+  CFUNC(f_get_search_list, "get_search_list", 1),
+  CFUNC(f_get_prog_origin, "get_prog_origin", 1),
+  CFUNC(f_get_jq_origin, "get_jq_origin", 1),
+  CFUNC(f_match, "_match_impl", 4),
+  CFUNC(f_modulemeta, "modulemeta", 1),
+  CFUNC(f_input, "input", 1),
+  CFUNC(f_debug, "debug", 1),
+  CFUNC(f_stderr, "stderr", 1),
+  CFUNC(f_strptime, "strptime", 2),
+  CFUNC(f_strftime, "strftime", 2),
+  CFUNC(f_strflocaltime, "strflocaltime", 2),
+  CFUNC(f_mktime, "mktime", 1),
+  CFUNC(f_gmtime, "gmtime", 1),
+  CFUNC(f_localtime, "localtime", 1),
+  CFUNC(f_now, "now", 1),
+  CFUNC(f_current_filename, "input_filename", 1),
+  CFUNC(f_current_line, "input_line_number", 1),
+  CFUNC(f_have_decnum, "have_decnum", 1),
+  CFUNC(f_have_decnum, "have_literal_numbers", 1),
 };
 #undef LIBM_DDDD_NO
 #undef LIBM_DDD_NO
 #undef LIBM_DD_NO
+#undef LIBM_DA_NO
 #undef LIBM_DDDD
 #undef LIBM_DDD
 #undef LIBM_DD
+#undef LIBM_DA
+
+// This is a hack to make last(g) yield no output values,
+// if g yields no output values, without using boxing.
+static block gen_last_1() {
+  block last_var = gen_op_var_fresh(STOREV, "last");
+  block is_empty_var = gen_op_var_fresh(STOREV, "is_empty");
+  block init = BLOCK(gen_op_simple(DUP),
+                     gen_const(jv_null()),
+                     last_var,
+                     gen_op_simple(DUP),
+                     gen_const(jv_true()),
+                     is_empty_var);
+  block call_arg = BLOCK(gen_call("arg", gen_noop()),
+                         gen_op_simple(DUP),
+                         gen_op_bound(STOREV, last_var),
+                         gen_const(jv_false()),
+                         gen_op_bound(STOREV, is_empty_var),
+                         gen_op_simple(BACKTRACK));
+  block if_empty = gen_op_simple(BACKTRACK);
+  return BLOCK(init,
+               gen_op_target(FORK, call_arg),
+               call_arg,
+               BLOCK(gen_op_bound(LOADVN, is_empty_var),
+                     gen_op_target(JUMP_F, if_empty),
+                     if_empty,
+                     gen_op_bound(LOADVN, last_var)));
+}
 
 struct bytecoded_builtin { const char* name; block code; };
 static block bind_bytecoded_builtins(block b) {
@@ -1679,6 +1928,7 @@ static block bind_bytecoded_builtins(block b) {
       {"path", BLOCK(gen_op_simple(PATH_BEGIN),
                      gen_call("arg", gen_noop()),
                      gen_op_simple(PATH_END))},
+      {"last", gen_last_1()},
     };
     for (unsigned i=0; i<sizeof(builtin_def_1arg)/sizeof(builtin_def_1arg[0]); i++) {
       builtins = BLOCK(builtins, gen_function(builtin_def_1arg[i].name,
@@ -1703,87 +1953,31 @@ static block bind_bytecoded_builtins(block b) {
                                             BLOCK(gen_param("start"), gen_param("end")),
                                             range));
   }
-  return block_bind(builtins, b, OP_IS_CALL_PSEUDO);
+  return BLOCK(builtins, b);
 }
 
-
-
-static const char* const jq_builtins =
+static const char jq_builtins[] = {
 /* Include jq-coded builtins */
 #include "src/builtin.inc"
-
-/* Include unsupported math functions next */
-#define LIBM_DD(name)
-#define LIBM_DDD(name)
-#define LIBM_DDDD(name)
-#define LIBM_DD_NO(name) "def " #name ": \"Error: " #name "/0 not found at build time\"|error;"
-#define LIBM_DDD_NO(name) "def " #name "(a;b): \"Error: " #name "/2 not found at build time\"|error;"
-#define LIBM_DDDD_NO(name) "def " #name "(a;b;c): \"Error: " #name "/3 not found at build time\"|error;"
-#include "libm.h"
-#ifndef HAVE_FREXP
-  "def frexp: \"Error: frexp/0 not found found at build time\"|error;"
-#endif
-#ifndef HAVE_MODF
-  "def modf: \"Error: modf/0 not found found at build time\"|error;"
-#endif
-#ifndef HAVE_LGAMMA_R
-  "def lgamma_r: \"Error: lgamma_r/0 not found found at build time\"|error;"
-#endif
-;
-
-#undef LIBM_DDDD_NO
-#undef LIBM_DDD_NO
-#undef LIBM_DD_NO
-#undef LIBM_DDDD
-#undef LIBM_DDD
-#undef LIBM_DD
-
+  '\0',
+};
 
 static block gen_builtin_list(block builtins) {
   jv list = jv_array_append(block_list_funcs(builtins, 1), jv_string("builtins/0"));
   return BLOCK(builtins, gen_function("builtins", gen_noop(), gen_const(list)));
 }
 
-static int builtins_bind_one(jq_state *jq, block* bb, const char* code) {
-  struct locfile* src;
-  src = locfile_init(jq, "<builtin>", code, strlen(code));
-  block funcs;
-  int nerrors = jq_parse_library(src, &funcs);
-  if (nerrors == 0) {
-    *bb = block_bind(funcs, *bb, OP_IS_CALL_PSEUDO);
-  }
-  locfile_free(src);
-  return nerrors;
-}
-
-static int slurp_lib(jq_state *jq, block* bb) {
-  int nerrors = 0;
-  char* home = getenv("HOME");
-  if (home) {    // silently ignore no $HOME
-    jv filename = jv_string_append_str(jv_string(home), "/.jq");
-    jv data = jv_load_file(jv_string_value(filename), 1);
-    if (jv_is_valid(data)) {
-      nerrors = builtins_bind_one(jq, bb, jv_string_value(data) );
-    }
-    jv_free(filename);
-    jv_free(data);
-  }
-  return nerrors;
-}
-
 int builtins_bind(jq_state *jq, block* bb) {
-  block builtins = gen_noop();
-  int nerrors = slurp_lib(jq, bb);
-  if (nerrors) {
-    block_free(*bb);
-    return nerrors;
-  }
-  nerrors = builtins_bind_one(jq, &builtins, jq_builtins);
+  block builtins;
+  struct locfile* src = locfile_init(jq, "<builtin>", jq_builtins, sizeof(jq_builtins)-1);
+  int nerrors = jq_parse_library(src, &builtins);
   assert(!nerrors);
+  locfile_free(src);
+
   builtins = bind_bytecoded_builtins(builtins);
   builtins = gen_cbinding(function_list, sizeof(function_list)/sizeof(function_list[0]), builtins);
   builtins = gen_builtin_list(builtins);
-  *bb = block_bind(builtins, *bb, OP_IS_CALL_PSEUDO);
-  *bb = block_drop_unreferenced(*bb);
+
+  *bb = block_bind_referenced(builtins, *bb, OP_IS_CALL_PSEUDO);
   return nerrors;
 }