/* * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /** * # Builtin functions * * The core namespace is not an actual module but refers to the set of * builtin functions and properties available to `ucode` scripts. * * @module core */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "json-c-compat.h" #include "ucode/lexer.h" #include "ucode/compiler.h" #include "ucode/vm.h" #include "ucode/lib.h" #include "ucode/source.h" #include "ucode/program.h" #include "ucode/platform.h" static void format_context_line(uc_stringbuf_t *buf, const char *line, size_t off, bool compact) { unsigned padlen, i; const char *p; for (p = line, padlen = 0; *p != '\n' && *p != '\0'; p++) { if (compact && (p - line) == (ptrdiff_t)off) ucv_stringbuf_append(buf, "\033[22m"); switch (*p) { case '\t': ucv_stringbuf_append(buf, " "); if (p < line + off) padlen += 4; break; case '\r': case '\v': ucv_stringbuf_append(buf, " "); if (p < line + off) padlen++; break; default: ucv_stringbuf_addstr(buf, p, 1); if (p < line + off) padlen++; } } if (compact) { ucv_stringbuf_append(buf, "\033[m\n"); return; } ucv_stringbuf_append(buf, "`\n "); if (padlen < strlen("Near here ^")) { for (i = 0; i < padlen; i++) ucv_stringbuf_append(buf, " "); ucv_stringbuf_append(buf, "^-- Near here\n"); } else { ucv_stringbuf_append(buf, "Near here "); for (i = strlen("Near here "); i < padlen; i++) ucv_stringbuf_append(buf, "-"); ucv_stringbuf_append(buf, "^\n"); } } static char * source_filename(uc_source_t *src, uint32_t line) { const char *name = src->filename ? basename(src->filename) : "[?]"; static char buf[sizeof("xxxxxxxxx.uc:0000000000")]; size_t len = strlen(name); if (len > 12) snprintf(buf, sizeof(buf), "...%s:%u", name + (len - 9), line); else snprintf(buf, sizeof(buf), "%12s:%u", name, line); return buf; } bool uc_source_context_format(uc_stringbuf_t *buf, uc_source_t *src, size_t off, bool compact) { size_t len, rlen; bool truncated; char line[256]; long srcpos; int eline; srcpos = ftell(src->fp); if (srcpos == -1) return false; fseek(src->fp, 0, SEEK_SET); truncated = false; eline = 1; rlen = 0; while (fgets(line, sizeof(line), src->fp)) { len = strlen(line); rlen += len; if (rlen >= off) { if (compact) ucv_stringbuf_printf(buf, "\033[2;40;97m%17s %s", source_filename(src, eline), truncated ? "..." : ""); else ucv_stringbuf_printf(buf, "\n `%s", truncated ? "..." : ""); format_context_line(buf, line, len - (rlen - off) + (truncated ? 3 : 0), compact); break; } truncated = (len > 0 && line[len-1] != '\n'); eline += !truncated; } fseek(src->fp, srcpos, SEEK_SET); return true; } bool uc_error_context_format(uc_stringbuf_t *buf, uc_source_t *src, uc_value_t *stacktrace, size_t off) { uc_value_t *e, *fn, *file, *line, *byte; const char *path; size_t idx; for (idx = 0; idx < (stacktrace ? ucv_array_length(stacktrace) : 0); idx++) { e = ucv_array_get(stacktrace, idx); fn = ucv_object_get(e, "function", NULL); file = ucv_object_get(e, "filename", NULL); if (idx == 0) { path = (file && strcmp(ucv_string_get(file), "[stdin]")) ? ucv_string_get(file) : NULL; if (path && fn) ucv_stringbuf_printf(buf, "In %s(), file %s, ", ucv_string_get(fn), path); else if (fn) ucv_stringbuf_printf(buf, "In %s(), ", ucv_string_get(fn)); else if (path) ucv_stringbuf_printf(buf, "In %s, ", path); else ucv_stringbuf_append(buf, "In "); ucv_stringbuf_printf(buf, "line %" PRId64 ", byte %" PRId64 ":\n", ucv_int64_get(ucv_object_get(e, "line", NULL)), ucv_int64_get(ucv_object_get(e, "byte", NULL))); } else { line = ucv_object_get(e, "line", NULL); byte = ucv_object_get(e, "byte", NULL); ucv_stringbuf_printf(buf, " called from %s%s (%s", fn ? "function " : "anonymous function", fn ? ucv_string_get(fn) : "", file ? ucv_string_get(file) : ""); if (line && byte) ucv_stringbuf_printf(buf, ":%" PRId64 ":%" PRId64 ")\n", ucv_int64_get(line), ucv_int64_get(byte)); else ucv_stringbuf_append(buf, "[C])\n"); } } return uc_source_context_format(buf, src, off, false); } void uc_error_message_indent(char **msg) { uc_stringbuf_t *buf = xprintbuf_new(); char *s, *p, *nl; size_t len; if (!msg || !*msg) return; s = *msg; len = strlen(s); while (len > 0 && s[len-1] == '\n') s[--len] = 0; for (p = s, nl = strchr(p, '\n'); p != NULL; p = nl ? nl + 1 : NULL, nl = p ? strchr(p, '\n') : NULL) { if (!nl) ucv_stringbuf_printf(buf, " | %s", p); else if (nl != p) ucv_stringbuf_printf(buf, " | %.*s\n", (int)(nl - p), p); else ucv_stringbuf_append(buf, " |\n"); } ucv_stringbuf_append(buf, "\n"); *msg = buf->buf; free(buf); free(s); } static char *uc_cast_string(uc_vm_t *vm, uc_value_t **v, bool *freeable) { if (ucv_type(*v) == UC_STRING) { *freeable = false; return _ucv_string_get(v); } *freeable = true; return ucv_to_string(vm, *v); } static void uc_vm_ctx_push(uc_vm_t *vm) { uc_value_t *ctx = NULL; if (vm->callframes.count >= 2) ctx = vm->callframes.entries[vm->callframes.count - 2].ctx; uc_vm_stack_push(vm, ucv_get(ctx)); } static uc_value_t * uc_print_common(uc_vm_t *vm, size_t nargs, FILE *fh) { uc_value_t *item; size_t reslen = 0; size_t len = 0; size_t arridx; char *p; for (arridx = 0; arridx < nargs; arridx++) { item = uc_fn_arg(arridx); if (ucv_type(item) == UC_STRING) { len = ucv_string_length(item); reslen += fwrite(ucv_string_get(item), 1, len, fh); } else if (item != NULL) { p = ucv_to_string(vm, item); len = strlen(p); reslen += fwrite(p, 1, len, fh); free(p); } } return ucv_int64_new(reslen); } /** * Print any of the given values to stdout. * * The `print()` function writes a string representation of each given argument * to stdout and returns the amount of bytes written. * * String values are printed as-is, integer and double values are printed in * decimal notation, boolean values are printed as `true` or `false` while * arrays and objects are converted to their JSON representation before being * written to the standard output. The `null` value is represented by an empty * string so `print(null)` would print nothing. Resource values are printed in * the form ``, e.g. ``. * * If resource, array or object values contain a `tostring()` function in their * prototypes, then this function is invoked to obtain an alternative string * representation of the value. * * Examples: * * ```javascript * print(1 != 2); // Will print 'true' * print(0xff); // Will print '255' * print(2e3); // Will print '2000' * print(null); // Will print nothing * print({ hello: true, world: 123 }); // Will print '{ "hello": true, "world": 123 }' * print([1,2,3]); // Will print '[ 1, 2, 3 ]' * * print(proto({ foo: "bar" }, // Will print 'MyObj' * { tostring: () => "MyObj" })); // instead of '{ "foo": "bar" }' * * ``` * * Returns the amount of bytes printed. * * @function module:core#print * * @param {...*} values * Arbitrary values to print * * @returns {number} */ static uc_value_t * uc_print(uc_vm_t *vm, size_t nargs) { return uc_print_common(vm, nargs, vm->output); } /** * Determine the length of the given object, array or string. * * Returns the length of the given value. * * - For strings, the length is the amount of bytes within the string * - For arrays, the length is the amount of array elements * - For objects, the length is defined as the amount of keys * * Returns `null` if the given argument is not an object, array or string. * * @function module:core#length * * @param {Object|Array|string} x - The input object, array, or string. * * @returns {?number} - The length of the input. * * @example * length("test") // 4 * length([true, false, null, 123, "test"]) // 5 * length({foo: true, bar: 123, baz: "test"}) // 3 * length({}) // 0 * length(true) // null * length(10.0) // null */ static uc_value_t * uc_length(uc_vm_t *vm, size_t nargs) { uc_value_t *arg = uc_fn_arg(0); switch (ucv_type(arg)) { case UC_OBJECT: return ucv_int64_new(ucv_object_length(arg)); case UC_ARRAY: return ucv_int64_new(ucv_array_length(arg)); case UC_STRING: return ucv_int64_new(ucv_string_length(arg)); default: return NULL; } } static int uc_uniq_ucv_equal(const void *k1, const void *k2); static uc_value_t * uc_index(uc_vm_t *vm, size_t nargs, bool right) { uc_value_t *stack = uc_fn_arg(0); uc_value_t *needle = uc_fn_arg(1); const char *sstr, *nstr, *p; size_t arridx, slen, nlen; ssize_t ret = -1; switch (ucv_type(stack)) { case UC_ARRAY: if (right) { for (arridx = ucv_array_length(stack); arridx > 0; arridx--) { if (uc_uniq_ucv_equal(ucv_array_get(stack, arridx - 1), needle)) { ret = (ssize_t)(arridx - 1); break; } } } else { for (arridx = 0, slen = ucv_array_length(stack); arridx < slen; arridx++) { if (uc_uniq_ucv_equal(ucv_array_get(stack, arridx), needle)) { ret = (ssize_t)arridx; break; } } } return ucv_int64_new(ret); case UC_STRING: if (ucv_type(needle) == UC_STRING) { sstr = ucv_string_get(stack); slen = ucv_string_length(stack); nstr = ucv_string_get(needle); nlen = ucv_string_length(needle); if (slen == nlen) { if (memcmp(sstr, nstr, nlen) == 0) ret = 0; } else if (slen > nlen) { if (right) { p = sstr + slen - nlen; do { if (memcmp(p, nstr, nlen) == 0) { ret = (ssize_t)(p - sstr); break; } } while (--p != sstr); } else if (nlen > 0) { p = (const char *)memmem(sstr, slen, nstr, nlen); if (p) ret = (ssize_t)(p - sstr); } else { ret = 0; } } } return ucv_int64_new(ret); default: return NULL; } } /** * Finds the given value passed as the second argument within the array or * string specified in the first argument. * * Returns the first matching array index or first matching string offset or * `-1` if the value was not found. * * Returns `null` if the first argument was neither an array nor a string. * * @function module:core#index * * @param {Array|string} arr_or_str * The array or string to search for the value. * * @param {*} needle * The value to find within the array or string. * * @returns {?number} * * @example * index("Hello hello hello", "ll") // 2 * index([ 1, 2, 3, 1, 2, 3, 1, 2, 3 ], 2) // 1 * index("foo", "bar") // -1 * index(["Red", "Blue", "Green"], "Brown") // -1 * index(123, 2) // null */ static uc_value_t * uc_lindex(uc_vm_t *vm, size_t nargs) { return uc_index(vm, nargs, false); } /** * Finds the given value passed as the second argument within the array or * string specified in the first argument. * * Returns the last matching array index or last matching string offset or * `-1` if the value was not found. * * Returns `null` if the first argument was neither an array nor a string. * * @function module:core#rindex * * @param {Array|string} arr_or_str * The array or string to search for the value. * * @param {*} needle * The value to find within the array or string. * * @returns {?number} * * @example * rindex("Hello hello hello", "ll") // 14 * rindex([ 1, 2, 3, 1, 2, 3, 1, 2, 3 ], 2) // 7 * rindex("foo", "bar") // -1 * rindex(["Red", "Blue", "Green"], "Brown") // -1 * rindex(123, 2) // null */ static uc_value_t * uc_rindex(uc_vm_t *vm, size_t nargs) { return uc_index(vm, nargs, true); } static bool assert_mutable(uc_vm_t *vm, uc_value_t *val) { if (ucv_is_constant(val)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "%s value is immutable", ucv_typename(val)); return false; } return true; } static bool assert_mutable_array(uc_vm_t *vm, uc_value_t *val) { if (ucv_type(val) != UC_ARRAY) return false; return assert_mutable(vm, val); } /** * Pushes the given argument(s) to the given array. * * Returns the last pushed value. * * @function module:core#push * * @param {Array} arr * The array to push values to. * * @param {...*} [values] * The values to push. * * @returns {*} * * @example * let x = [ 1, 2, 3 ]; * push(x, 4, 5, 6); // 6 * print(x, "\n"); // [ 1, 2, 3, 4, 5, 6 ] */ static uc_value_t * uc_push(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); uc_value_t *item = NULL; size_t arridx; if (!assert_mutable_array(vm, arr)) return NULL; for (arridx = 1; arridx < nargs; arridx++) { item = uc_fn_arg(arridx); ucv_array_push(arr, ucv_get(item)); } return ucv_get(item); } /** * Pops the last item from the given array and returns it. * * Returns `null` if the array was empty or if a non-array argument was passed. * * @function module:core#pop * * @param {Array} arr * The input array. * * @returns {*} * * @example * let x = [ 1, 2, 3 ]; * pop(x); // 3 * print(x, "\n"); // [ 1, 2 ] */ static uc_value_t * uc_pop(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); if (!assert_mutable_array(vm, arr)) return NULL; return ucv_array_pop(arr); } /** * Pops the first item from the given array and returns it. * * Returns `null` if the array was empty or if a non-array argument was passed. * * @function module:core#shift * * @param {Array} arr * The array from which to pop the first item. * * @returns {*} * * @example * let x = [ 1, 2, 3 ]; * shift(x); // 1 * print(x, "\n"); // [ 2, 3 ] */ static uc_value_t * uc_shift(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); if (!assert_mutable_array(vm, arr)) return NULL; return ucv_array_shift(arr); } /** * Add the given values to the beginning of the array passed via first argument. * * Returns the last value added to the array. * * @function module:core#unshift * * @param {Array} arr * The array to which the values will be added. * * @param {...*} * Values to add. * * @returns {*} * * @example * let x = [ 3, 4, 5 ]; * unshift(x, 1, 2); // 2 * print(x, "\n"); // [ 1, 2, 3, 4, 5 ] */ static uc_value_t * uc_unshift(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); uc_value_t *item; size_t i; if (!assert_mutable_array(vm, arr)) return NULL; for (i = 1; i < nargs; i++) { item = uc_fn_arg(nargs - i); ucv_array_unshift(arr, ucv_get(item)); } return (nargs > 1) ? ucv_get(uc_fn_arg(nargs - 1)) : NULL; } /** * Converts each given numeric value to a byte and return the resulting string. * Invalid numeric values or values < 0 result in `\0` bytes, values larger than * 255 are truncated to 255. * * Returns a new strings consisting of the given byte values. * * @function module:core#chr * * @param {...number} n1 * The numeric values. * * @returns {string} * * @example * chr(65, 98, 99); // "Abc" * chr(-1, 300); // string consisting of an `0x0` and a `0xff` byte */ static uc_value_t * uc_chr(uc_vm_t *vm, size_t nargs) { uc_value_t *rv = NULL; size_t idx; int64_t n; char *str; if (!nargs) return ucv_string_new_length("", 0); str = xalloc(nargs); for (idx = 0; idx < nargs; idx++) { n = ucv_to_integer(uc_fn_arg(idx)); if (n < 0) n = 0; else if (n > 255) n = 255; str[idx] = (char)n; } rv = ucv_string_new_length(str, nargs); free(str); return rv; } /** * Raise an exception with the given message and abort execution. * * @function module:core#die * * @param {string} msg * The error message. * * @throws {Error} * The error with the given message. * * @example * die(msg); */ static uc_value_t * uc_die(uc_vm_t *vm, size_t nargs) { uc_value_t *msg = uc_fn_arg(0); bool freeable = false; char *s; s = msg ? uc_cast_string(vm, &msg, &freeable) : "Died"; uc_vm_raise_exception(vm, EXCEPTION_USER, "%s", s); if (freeable) free(s); return NULL; } /** * Check whether the given key exists within the given object value. * * Returns `true` if the given key is present within the object passed as the * first argument, otherwise `false`. * * @function module:core#exists * * @param {Object} obj * The input object. * * @param {string} key * The key to check for existence. * * @returns {boolean} * * @example * let x = { foo: true, bar: false, qrx: null }; * exists(x, 'foo'); // true * exists(x, 'qrx'); // true * exists(x, 'baz'); // false */ static uc_value_t * uc_exists(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *key = uc_fn_arg(1); bool found, freeable; char *k; if (ucv_type(obj) != UC_OBJECT) return ucv_boolean_new(false); k = uc_cast_string(vm, &key, &freeable); ucv_object_get(obj, k, &found); if (freeable) free(k); return ucv_boolean_new(found); } /** * Terminate the interpreter with the given exit code. * * This function does not return. * * @function module:core#exit * * @param {number} n * The exit code. * * @example * exit(); * exit(5); */ static uc_value_t * uc_exit(uc_vm_t *vm, size_t nargs) { int64_t n = ucv_to_integer(uc_fn_arg(0)); vm->arg.s32 = (int32_t)n; uc_vm_raise_exception(vm, EXCEPTION_EXIT, "Terminated"); return NULL; } /** * Query an environment variable or then entire environment. * * Returns the value of the given environment variable, or - if omitted - a * dictionary containing all environment variables. * * @function module:core#getenv * * @param {string} [name] * The name of the environment variable. * * @returns {string|Object} */ static uc_value_t * uc_getenv(uc_vm_t *vm, size_t nargs) { uc_value_t *key = uc_fn_arg(0), *rv = NULL; extern char **environ; char *k, *v; if (!key) { rv = ucv_object_new(vm); while (*environ) { v = strchr(*environ, '='); if (v) { xasprintf(&k, "%.*s", (int)(v - *environ), *environ); ucv_object_add(rv, k, ucv_string_new(v + 1)); free(k); } environ++; } } else if (ucv_type(key) == UC_STRING) { k = ucv_string_get(key); v = getenv(k); if (v) rv = ucv_string_new(v); } return rv; } /** * Filter the array passed as the first argument by invoking the function * specified in the second argument for each array item. * * If the invoked function returns a truthy result, the item is retained, * otherwise, it is dropped. The filter function is invoked with three * arguments: * * 1. The array value * 2. The current index * 3. The array being filtered * * Returns a new array containing only retainted items, in the same order as * the input array. * * @function module:core#filter * * @param {Array} arr * The input array. * * @param {Function} fn * The filter function. * * @returns {Array} * * @example * // filter out any empty string: * a = filter(["foo", "", "bar", "", "baz"], length) * // a = ["foo", "bar", "baz"] * * // filter out any non-number type: * a = filter(["foo", 1, true, null, 2.2], function(v) { * return (type(v) == "int" || type(v) == "double"); * }); * // a = [1, 2.2] */ static uc_value_t * uc_filter(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *func = uc_fn_arg(1); uc_value_t *rv, *arr; size_t arridx, arrlen; if (ucv_type(obj) != UC_ARRAY) return NULL; arr = ucv_array_new(vm); for (arrlen = ucv_array_length(obj), arridx = 0; arridx < arrlen; arridx++) { uc_vm_ctx_push(vm); uc_vm_stack_push(vm, ucv_get(func)); uc_vm_stack_push(vm, ucv_get(ucv_array_get(obj, arridx))); uc_vm_stack_push(vm, ucv_int64_new(arridx)); uc_vm_stack_push(vm, ucv_get(obj)); if (uc_vm_call(vm, true, 3)) { ucv_put(arr); return NULL; } rv = uc_vm_stack_pop(vm); if (ucv_is_truish(rv)) ucv_array_push(arr, ucv_get(ucv_array_get(obj, arridx))); ucv_put(rv); } return arr; } /** * Converts the given hexadecimal string into a number. * * Returns the resulting integer value or `NaN` if the input value cannot be * interpreted as hexadecimal number. * * @function module:core#hex * * @param {*} x * The hexadecimal string to be converted. * * @returns {number} */ static uc_value_t * uc_hex(uc_vm_t *vm, size_t nargs) { uc_value_t *val = uc_fn_arg(0); char *e, *v; int64_t n; v = ucv_string_get(val); if (!v || !isxdigit(*v)) return ucv_double_new(NAN); n = strtoll(v, &e, 16); if (e == v || *e) return ucv_double_new(NAN); return ucv_int64_new(n); } /** * Converts the given value to an integer. * * Returns `NaN` if the value is not convertible. * * @function module:core#int * * @param {*} x * The value to be converted to an integer. * * @returns {number} */ static uc_value_t * uc_int(uc_vm_t *vm, size_t nargs) { uc_value_t *val = uc_fn_arg(0); uc_value_t *base = uc_fn_arg(1); char *e, *v; int64_t n; if (ucv_type(val) == UC_STRING) { errno = 0; v = ucv_string_get(val); n = strtoll(v, &e, base ? ucv_int64_get(base) : 10); if (e == v) return ucv_double_new(NAN); } else { n = ucv_to_integer(val); } if (errno == EINVAL || errno == ERANGE) return ucv_double_new(NAN); return ucv_int64_new(n); } /** * Joins the array passed as the second argument into a string, using the * separator passed in the first argument as glue. * * Returns `null` if the second argument is not an array. * * @function module:core#join * * @param {string} sep * The separator to be used in joining the array elements. * * @param {Array} arr * The array to be joined into a string. * * @returns {?string} */ static uc_value_t * uc_join(uc_vm_t *vm, size_t nargs) { uc_value_t *sep = uc_fn_arg(0); uc_value_t *arr = uc_fn_arg(1); size_t arrlen, arridx; uc_stringbuf_t *buf; if (ucv_type(arr) != UC_ARRAY) return NULL; buf = ucv_stringbuf_new(); for (arrlen = ucv_array_length(arr), arridx = 0; arridx < arrlen; arridx++) { if (arridx > 0) ucv_to_stringbuf(vm, buf, sep, false); ucv_to_stringbuf(vm, buf, ucv_array_get(arr, arridx), false); } return ucv_stringbuf_finish(buf); } /** * Enumerates all object key names. * * Returns an array of all key names present in the passed object. * Returns `null` if the given argument is not an object. * * @function module:core#keys * * @param {object} obj * The object from which to retrieve the key names. * * @returns {?Array} */ static uc_value_t * uc_keys(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *arr = NULL; if (ucv_type(obj) != UC_OBJECT) return NULL; arr = ucv_array_new(vm); ucv_object_foreach(obj, key, val) { (void)val; ucv_array_push(arr, ucv_string_new(key)); } return arr; } /** * Convert the given string to lowercase and return the resulting string. * * Returns `null` if the given argument could not be converted to a string. * * @function module:core#lc * * @param {string} s * The input string. * * @returns {?string} * The lowercase string. * * @example * lc("HeLLo WoRLd!"); // "hello world!" */ static uc_value_t * uc_lc(uc_vm_t *vm, size_t nargs) { char *str = ucv_to_string(vm, uc_fn_arg(0)); uc_value_t *rv = NULL; char *p; if (!str) return NULL; for (p = str; *p; p++) if (*p >= 'A' && *p <= 'Z') *p |= 32; rv = ucv_string_new(str); free(str); return rv; } /** * Transform the array passed as the first argument by invoking the function * specified in the second argument for each array item. * * Returns a new array of the same length as the input array containing the * transformed values. * * @function module:core#map * * @param {Array} arr * The input array. * * @param {Function} fn * The mapping function. * * @returns {Array} * * @example * // turn into an array of string lengths: * a = map(["Apple", "Banana", "Bean"], length); * // a = [5, 6, 4] * * // map to type names: * a = map(["foo", 1, true, null, 2.2], type); * // a = ["string", "int", "bool", null, "double"] */ static uc_value_t * uc_map(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *func = uc_fn_arg(1); uc_value_t *arr, *rv; size_t arridx, arrlen; if (ucv_type(obj) != UC_ARRAY) return NULL; arr = ucv_array_new(vm); for (arrlen = ucv_array_length(obj), arridx = 0; arridx < arrlen; arridx++) { uc_vm_ctx_push(vm); uc_vm_stack_push(vm, ucv_get(func)); uc_vm_stack_push(vm, ucv_get(ucv_array_get(obj, arridx))); uc_vm_stack_push(vm, ucv_int64_new(arridx)); uc_vm_stack_push(vm, ucv_get(obj)); if (uc_vm_call(vm, true, 3)) { ucv_put(arr); return NULL; } rv = uc_vm_stack_pop(vm); ucv_array_push(arr, rv); } return arr; } /** * Without further arguments, this function returns the byte value of the first * character in the given string. * * If an offset argument is supplied, the byte value of the character at this * position is returned. If an invalid index is supplied, the function will * return `null`. Negative index entries are counted towards the end of the * string, e.g. `-2` will return the value of the second last character. * * Returns the byte value of the character. * Returns `null` if the offset is invalid or if the input is not a string. * * @function module:core#ord * * @param {string} s * The input string. * * @param {number} [offset] * The offset of the character. * * @returns {?number} * * @example * ord("Abc"); // 65 * ord("Abc", 0); // 65 * ord("Abc", 1); // 98 * ord("Abc", 2); // 99 * ord("Abc", 10); // null * ord("Abc", -10); // null * ord("Abc", "nan"); // null */ static uc_value_t * uc_ord(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); const char *str; int64_t n = 0; size_t len; if (ucv_type(obj) != UC_STRING) return NULL; str = ucv_string_get(obj); len = ucv_string_length(obj); if (nargs > 1) { n = ucv_int64_get(uc_fn_arg(1)); if (errno == EINVAL) return NULL; if (n < 0) n += len; } if (n < 0 || (uint64_t)n >= len) return NULL; return ucv_int64_new((uint8_t)str[n]); } /** * Query the type of the given value. * * Returns the type of the given value as a string which might be one of * `"function"`, `"object"`, `"array"`, `"double"`, `"int"`, or `"bool"`. * * Returns `null` when no value or `null` is passed. * * @function module:core#type * * @param {*} x * The value to determine the type of. * * @returns {?string} */ static uc_value_t * uc_type(uc_vm_t *vm, size_t nargs) { uc_value_t *v = uc_fn_arg(0); uc_type_t t = ucv_type(v); switch (t) { case UC_CFUNCTION: case UC_CLOSURE: return ucv_string_new("function"); case UC_INTEGER: return ucv_string_new("int"); case UC_BOOLEAN: return ucv_string_new("bool"); case UC_NULL: return NULL; default: return ucv_string_new(ucv_typename(v)); } } /** * Reverse the order of the given input array or string. * * If an array is passed, returns the array in reverse order. * If a string is passed, returns the string with the sequence of the characters * reversed. * * Returns the reversed array or string. * Returns `null` if neither an array nor a string were passed. * * @function module:core#reverse * * @param {Array|string} arr_or_str * The input array or string. * * @returns {?(Array|string)} * * @example * reverse([1, 2, 3]); // [ 3, 2, 1 ] * reverse("Abc"); // "cbA" */ static uc_value_t * uc_reverse(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *rv = NULL; size_t len, arridx; const char *str; char *dup, *p; if (ucv_type(obj) == UC_ARRAY) { if (!assert_mutable_array(vm, obj)) return NULL; rv = ucv_array_new(vm); for (arridx = ucv_array_length(obj); arridx > 0; arridx--) ucv_array_push(rv, ucv_get(ucv_array_get(obj, arridx - 1))); } else if (ucv_type(obj) == UC_STRING) { len = ucv_string_length(obj); str = ucv_string_get(obj); p = dup = xalloc(len + 1); while (len > 0) *p++ = str[--len]; rv = ucv_string_new(dup); free(dup); } return rv; } static struct { uc_vm_t *vm; bool ex; uc_value_t *fn; } sort_ctx; static int default_cmp(uc_value_t *v1, uc_value_t *v2) { char *s1, *s2; bool f1, f2; int res; /* when both operands are numeric then compare numerically */ if ((ucv_type(v1) == UC_INTEGER || ucv_type(v1) == UC_DOUBLE) && (ucv_type(v2) == UC_INTEGER || ucv_type(v2) == UC_DOUBLE)) { ucv_compare(0, v1, v2, &res); return res; } /* otherwise convert both operands to strings and compare lexically */ s1 = uc_cast_string(sort_ctx.vm, &v1, &f1); s2 = uc_cast_string(sort_ctx.vm, &v2, &f2); res = strcmp(s1, s2); if (f1) free(s1); if (f2) free(s2); return res; } static int array_sort_fn(const void *k1, const void *k2) { uc_value_t *rv, *null = ucv_int64_new(0); uc_value_t * const *v1 = k1; uc_value_t * const *v2 = k2; int res; if (!sort_ctx.fn) return default_cmp(*v1, *v2); if (sort_ctx.ex) return 0; uc_vm_ctx_push(sort_ctx.vm); uc_vm_stack_push(sort_ctx.vm, ucv_get(sort_ctx.fn)); uc_vm_stack_push(sort_ctx.vm, ucv_get(*v1)); uc_vm_stack_push(sort_ctx.vm, ucv_get(*v2)); if (uc_vm_call(sort_ctx.vm, true, 2)) { sort_ctx.ex = true; return 0; } rv = uc_vm_stack_pop(sort_ctx.vm); ucv_compare(0, rv, null, &res); ucv_put(null); ucv_put(rv); return res; } static int object_sort_fn(const void *k1, const void *k2) { uc_value_t *rv, *null = ucv_int64_new(0); struct lh_entry * const *e1 = k1; struct lh_entry * const *e2 = k2; int res; if (!sort_ctx.fn) return strcmp((char *)lh_entry_k(*e1), (char *)lh_entry_k(*e2)); if (sort_ctx.ex) return 0; uc_vm_ctx_push(sort_ctx.vm); uc_vm_stack_push(sort_ctx.vm, ucv_get(sort_ctx.fn)); uc_vm_stack_push(sort_ctx.vm, ucv_string_new((char *)lh_entry_k(*e1))); uc_vm_stack_push(sort_ctx.vm, ucv_string_new((char *)lh_entry_k(*e2))); uc_vm_stack_push(sort_ctx.vm, ucv_get((uc_value_t *)lh_entry_v(*e1))); uc_vm_stack_push(sort_ctx.vm, ucv_get((uc_value_t *)lh_entry_v(*e2))); if (uc_vm_call(sort_ctx.vm, true, 4)) { sort_ctx.ex = true; return 0; } rv = uc_vm_stack_pop(sort_ctx.vm); ucv_compare(0, rv, null, &res); ucv_put(null); ucv_put(rv); return res; } /** * Sort the given array according to the given sort function. * If no sort function is provided, a default ascending sort order is applied. * * The input array is sorted in-place, no copy is made. * * The custom sort function is repeatedly called until the entire array is * sorted. It will receive two values as arguments and should return a value * lower than, larger than or equal to zero depending on whether the first * argument is smaller, larger or equal to the second argument respectively. * * Returns the sorted input array. * * @function module:core#sort * * @param {Array} arr * The input array to be sorted. * * @param {Function} [fn] * The sort function. * * @returns {Array} * * @example * sort([8, 1, 5, 9]) // [1, 5, 8, 9] * sort(["Bean", "Orange", "Apple"], function(a, b) { * return length(a) - length(b); * }) // ["Bean", "Apple", "Orange"] */ static uc_value_t * uc_sort(uc_vm_t *vm, size_t nargs) { uc_value_t *val = uc_fn_arg(0); uc_value_t *fn = uc_fn_arg(1); if (!assert_mutable(vm, val)) return NULL; sort_ctx.vm = vm; sort_ctx.fn = fn; switch (ucv_type(val)) { case UC_ARRAY: ucv_array_sort(val, array_sort_fn); break; case UC_OBJECT: ucv_object_sort(val, object_sort_fn); break; default: return NULL; } return sort_ctx.ex ? NULL : ucv_get(val); } /** * Removes the elements designated by `off` and `len` from the given array, * and replaces them with the additional arguments passed, if any. * * The array grows or shrinks as necessary. * * Returns the modified input array. * * @function module:core#splice * * @param {Array} arr * The input array to be modified. * * @param {number} off * The index to start removing elements. * * @param {number} [len] * The number of elements to remove. * * @param {...*} [elements] * The elements to insert. * * @returns {*} * * @example * let x = [ 1, 2, 3, 4 ]; * splice(x, 1, 2, "a", "b", "c"); // [ 1, "a", "b", "c", 4 ] * print(x, "\n"); // [ 1, "a", "b", "c", 4 ] */ static uc_value_t * uc_splice(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); int64_t ofs = ucv_to_integer(uc_fn_arg(1)); int64_t remlen = ucv_to_integer(uc_fn_arg(2)); size_t arrlen, addlen, idx; if (!assert_mutable_array(vm, arr)) return NULL; arrlen = ucv_array_length(arr); addlen = nargs; if (addlen == 1) { ofs = 0; addlen = 0; remlen = arrlen; } else if (addlen == 2) { if (ofs < 0) { ofs = arrlen + ofs; if (ofs < 0) ofs = 0; } else if ((uint64_t)ofs > arrlen) { ofs = arrlen; } addlen = 0; remlen = arrlen - ofs; } else { if (ofs < 0) { ofs = arrlen + ofs; if (ofs < 0) ofs = 0; } else if ((uint64_t)ofs > arrlen) { ofs = arrlen; } if (remlen < 0) { remlen = arrlen - ofs + remlen; if (remlen < 0) remlen = 0; } else if ((uint64_t)remlen > arrlen - (uint64_t)ofs) { remlen = arrlen - ofs; } addlen -= 3; } if (addlen < (uint64_t)remlen) { ucv_array_delete(arr, ofs, remlen - addlen); } else if (addlen > (uint64_t)remlen) { for (idx = arrlen; idx > (uint64_t)ofs; idx--) ucv_array_set(arr, idx + addlen - remlen - 1, ucv_get(ucv_array_get(arr, idx - 1))); } for (idx = 0; idx < addlen; idx++) ucv_array_set(arr, ofs + idx, ucv_get(uc_fn_arg(3 + idx))); return ucv_get(arr); } /** * Performs a shallow copy of a portion of the source array, as specified by * the start and end offsets. The original array is not modified. * * Returns a new array containing the copied elements, if any. * Returns `null` if the given source argument is not an array value. * * @function module:core#slice * * @param {Array} arr * The source array to be copied. * * @param {number} [off] * The index of the first element to copy. * * @param {number} [end] * The index of the first element to exclude from the returned array. * * @returns {Array} * * @example * slice([1, 2, 3]) // [1, 2, 3] * slice([1, 2, 3], 1) // [2, 3] * slice([1, 2, 3], -1) // [3] * slice([1, 2, 3], -3, -1) // [1, 2] * slice([1, 2, 3], 10) // [] * slice([1, 2, 3], 2, 1) // [] * slice("invalid", 1, 2) // null */ static uc_value_t * uc_slice(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); uc_value_t *sv = uc_fn_arg(1); uc_value_t *ev = uc_fn_arg(2); uc_value_t *res = NULL; int64_t off, end; size_t len; if (ucv_type(arr) != UC_ARRAY) return NULL; len = ucv_array_length(arr); off = sv ? ucv_to_integer(sv) : 0; end = ev ? ucv_to_integer(ev) : (int64_t)len; if (off < 0) { off = len + off; if (off < 0) off = 0; } else if ((uint64_t)off > len) { off = len; } if (end < 0) { end = len + end; if (end < 0) end = 0; } else if ((uint64_t)end > len) { end = len; } res = ucv_array_new(vm); while (off < end) ucv_array_push(res, ucv_get(ucv_array_get(arr, off++))); return res; } /** * Split the given string using the separator passed as the second argument * and return an array containing the resulting pieces. * * If a limit argument is supplied, the resulting array contains no more than * the given amount of entries, that means the string is split at most * `limit - 1` times total. * * The separator may either be a plain string or a regular expression. * * Returns a new array containing the resulting pieces. * * @function module:core#split * * @param {string} str * The input string to be split. * * @param {string|RegExp} sep * The separator. * * @param {number} [limit] * The limit on the number of splits. * * @returns {Array} * * @example * split("foo,bar,baz", ",") // ["foo", "bar", "baz"] * split("foobar", "") // ["f", "o", "o", "b", "a", "r"] * split("foo,bar,baz", /[ao]/) // ["f", "", ",b", "r,b", "z"] * split("foo=bar=baz", "=", 2) // ["foo", "bar=baz"] */ static uc_value_t * uc_split(uc_vm_t *vm, size_t nargs) { uc_value_t *str = uc_fn_arg(0); uc_value_t *sep = uc_fn_arg(1); uc_value_t *lim = uc_fn_arg(2); uc_value_t *arr = NULL; const char *p, *sepstr, *splitstr; size_t seplen, splitlen, limit; int eflags = 0, res; regmatch_t pmatch; uc_regexp_t *re; if (!sep || ucv_type(str) != UC_STRING) return NULL; arr = ucv_array_new(vm); splitlen = ucv_string_length(str); p = splitstr = ucv_string_get(str); limit = lim ? ucv_uint64_get(lim) : SIZE_MAX; if (limit == 0) goto out; if (ucv_type(sep) == UC_REGEXP) { re = (uc_regexp_t *)sep; while (limit > 1) { res = regexec(&re->regexp, splitstr, 1, &pmatch, eflags); if (res == REG_NOMATCH) break; if (pmatch.rm_so != pmatch.rm_eo) { ucv_array_push(arr, ucv_string_new_length(splitstr, pmatch.rm_so)); splitstr += pmatch.rm_eo; } else if (*splitstr) { ucv_array_push(arr, ucv_string_new_length(splitstr, 1)); splitstr++; } else { goto out; } eflags |= REG_NOTBOL; limit--; } ucv_array_push(arr, ucv_string_new(splitstr)); } else if (ucv_type(sep) == UC_STRING) { sepstr = ucv_string_get(sep); seplen = ucv_string_length(sep); if (splitlen == 0) { ucv_array_push(arr, ucv_string_new_length("", 0)); } else if (seplen == 0) { while (limit > 1 && splitlen > 0) { ucv_array_push(arr, ucv_string_new_length(p, 1)); limit--; splitlen--; p++; } if (splitlen > 0) ucv_array_push(arr, ucv_string_new_length(p, splitlen)); } else { while (limit > 1 && splitlen >= seplen) { if (!memcmp(p, sepstr, seplen)) { ucv_array_push(arr, ucv_string_new_length(splitstr, p - splitstr)); p = splitstr = p + seplen; splitlen -= seplen; limit--; continue; } splitlen--; p++; } ucv_array_push(arr, ucv_string_new_length(splitstr, p - splitstr + splitlen)); } } else { ucv_put(arr); return NULL; } out: return arr; } /** * Extracts a substring out of `str` and returns it. First character is at * offset zero. * * - If `off` is negative, starts that far back from the end of the string. * - If `len` is omitted, returns everything through the end of the string. * - If `len` is negative, leaves that many characters off the string end. * * Returns the extracted substring. * * @function module:core#substr * * @param {string} str * The input string. * * @param {number} off * The starting offset. * * @param {number} [len] * The length of the substring. * * @returns {string} * * @example * s = "The black cat climbed the green tree"; * substr(s, 4, 5); // black * substr(s, 4, -11); // black cat climbed the * substr(s, 14); // climbed the green tree * substr(s, -4); // tree * substr(s, -4, 2); // tr */ static uc_value_t * uc_substr(uc_vm_t *vm, size_t nargs) { uc_value_t *str = uc_fn_arg(0); int64_t ofs = ucv_to_integer(uc_fn_arg(1)); int64_t sublen = ucv_to_integer(uc_fn_arg(2)); const char *p; size_t len; if (ucv_type(str) != UC_STRING) return NULL; p = ucv_string_get(str); len = ucv_string_length(str); switch (nargs) { case 1: ofs = 0; sublen = len; break; case 2: if (ofs < 0) { ofs = len + ofs; if (ofs < 0) ofs = 0; } else if ((uint64_t)ofs > len) { ofs = len; } sublen = len - ofs; break; default: if (ofs < 0) { ofs = len + ofs; if (ofs < 0) ofs = 0; } else if ((uint64_t)ofs > len) { ofs = len; } if (sublen < 0) { sublen = len - ofs + sublen; if (sublen < 0) sublen = 0; } else if ((uint64_t)sublen > len - (uint64_t)ofs) { sublen = len - ofs; } break; } return ucv_string_new_length(p + ofs, sublen); } /** * Returns the current UNIX epoch. * * @function module:core#time * * @returns {number} * * @example * time(); // 1598043054 */ static uc_value_t * uc_time(uc_vm_t *vm, size_t nargs) { time_t t = time(NULL); return ucv_int64_new((int64_t)t); } /** * Converts the given string to uppercase and returns the resulting string. * * Returns null if the given argument could not be converted to a string. * * @function module:core#uc * * @param {*} str * The string to be converted to uppercase. * * @returns {?string} * * @example * uc("hello"); // "HELLO" * uc(123); // null */ static uc_value_t * uc_uc(uc_vm_t *vm, size_t nargs) { char *str = ucv_to_string(vm, uc_fn_arg(0)); uc_value_t *rv = NULL; char *p; if (!str) return NULL; for (p = str; *p; p++) if (*p >= 'a' && *p <= 'z') *p &= ~32; rv = ucv_string_new(str); free(str); return rv; } /** * Converts each given numeric value to an UTF-8 multibyte sequence and returns * the resulting string. * * Invalid numeric values or values outside the range `0`..`0x10FFFF` are * represented by the unicode replacement character `0xFFFD`. * * Returns a new UTF-8 encoded string consisting of unicode characters * corresponding to the given numeric codepoints. * * @function module:core#uchr * * @param {...number} * Numeric values to convert. * * @returns {string} * * @example * uchr(0x2600, 0x26C6, 0x2601); // "☀⛆☁" * uchr(-1, 0x20ffff, "foo"); // "���" */ static uc_value_t * uc_uchr(uc_vm_t *vm, size_t nargs) { uc_value_t *rv = NULL; size_t idx, ulen; char *p, *str; int64_t n; int rem; for (idx = 0, ulen = 0; idx < nargs; idx++) { n = ucv_to_integer(uc_fn_arg(idx)); if (errno == EINVAL || errno == ERANGE || n < 0 || n > 0x10FFFF) ulen += 3; else if (n <= 0x7F) ulen++; else if (n <= 0x7FF) ulen += 2; else if (n <= 0xFFFF) ulen += 3; else ulen += 4; } str = xalloc(ulen); for (idx = 0, p = str, rem = ulen; idx < nargs; idx++) { n = ucv_to_integer(uc_fn_arg(idx)); if (errno == EINVAL || errno == ERANGE || n < 0 || n > 0x10FFFF) n = 0xFFFD; if (!utf8enc(&p, &rem, n)) break; } rv = ucv_string_new_length(str, ulen); free(str); return rv; } /** * Returns an array containing all values of the given object. * * Returns null if no object was passed. * * @function module:core#values * * @param {*} obj * The object from which to extract values. * * @returns {?Array} * * @example * values({ foo: true, bar: false }); // [true, false] */ static uc_value_t * uc_values(uc_vm_t *vm, size_t nargs) { uc_value_t *obj = uc_fn_arg(0); uc_value_t *arr; if (ucv_type(obj) != UC_OBJECT) return NULL; arr = ucv_array_new(vm); ucv_object_foreach(obj, key, val) { (void)key; ucv_array_push(arr, ucv_get(val)); } return arr; } static uc_value_t * uc_trim_common(uc_vm_t *vm, size_t nargs, bool start, bool end) { uc_value_t *str = uc_fn_arg(0); uc_value_t *chr = uc_fn_arg(1); const char *p, *c; size_t len; if (ucv_type(str) != UC_STRING || (chr != NULL && ucv_type(chr) != UC_STRING)) return NULL; c = ucv_string_get(chr); c = c ? c : " \t\r\n"; p = ucv_string_get(str); len = ucv_string_length(str); if (start) { while (*p) { if (!strchr(c, *p)) break; p++; len--; } } if (end) { while (len > 0) { if (!strchr(c, p[len - 1])) break; len--; } } return ucv_string_new_length(p, len); } /** * Trim any of the specified characters in `c` from the start and end of `str`. * If the second argument is omitted, trims the characters, ` ` (space), `\t`, * `\r`, and `\n`. * * Returns the trimmed string. * * @function module:core#trim * * @param {string} str * The string to be trimmed. * * @param {string} [c] * The characters to be trimmed from the start and end of the string. * * @returns {string} */ static uc_value_t * uc_trim(uc_vm_t *vm, size_t nargs) { return uc_trim_common(vm, nargs, true, true); } /** * Trim any of the specified characters from the start of the string. * If the second argument is omitted, trims the characters ` ` (space), '\t', * '\r', and '\n'. * * Returns the left trimmed string. * * @function module:core#ltrim * * @param {string} s * The input string. * * @param {string} [c] * The characters to trim. * * @returns {string} * * @example * ltrim(" foo \n") // "foo \n" * ltrim("--bar--", "-") // "bar--" */ static uc_value_t * uc_ltrim(uc_vm_t *vm, size_t nargs) { return uc_trim_common(vm, nargs, true, false); } /** * Trim any of the specified characters from the end of the string. * If the second argument is omitted, trims the characters ` ` (space), '\t', * '\r', and '\n'. * * Returns the right trimmed string. * * @function module:core#rtrim * * @param {string} str * The input string. * * @param {string} [c] * The characters to trim. * * @returns {string} * * @example * rtrim(" foo \n") // " foo" * rtrim("--bar--", "-") // "--bar" */ static uc_value_t * uc_rtrim(uc_vm_t *vm, size_t nargs) { return uc_trim_common(vm, nargs, false, true); } enum { FMT_F_ALT = (1 << 0), FMT_F_ZERO = (1 << 1), FMT_F_LEFT = (1 << 2), FMT_F_SPACE = (1 << 3), FMT_F_SIGN = (1 << 4), FMT_F_WIDTH = (1 << 5), FMT_F_PREC = (1 << 6), }; enum { FMT_C_NONE = (1 << 0), FMT_C_INT = (1 << 1), FMT_C_UINT = (1 << 2), FMT_C_DBL = (1 << 3), FMT_C_CHR = (1 << 4), FMT_C_STR = (1 << 5), FMT_C_JSON = (1 << 6), }; static void uc_printf_common(uc_vm_t *vm, size_t nargs, uc_stringbuf_t *buf) { char *s, sfmt[sizeof("%#0- +0123456789.0123456789%")]; uint32_t conv, flags, width, precision; uc_value_t *fmt = uc_fn_arg(0), *arg; const char *fstr, *last, *p, *cfmt; size_t argidx = 1, argpos, sfmtlen; uint64_t u; int64_t n; double d; if (ucv_type(fmt) == UC_STRING) fstr = ucv_string_get(fmt); else fstr = ""; for (last = p = fstr; *p; p++) { if (*p == '%') { ucv_stringbuf_addstr(buf, last, p - last); last = p++; flags = 0; width = 0; precision = 0; argpos = argidx; if (*p >= '1' && *p <= '9') { while (isdigit(*p)) width = width * 10 + (*p++ - '0'); /* if a dollar sign follows, this is an argument index */ if (*p == '$') { argpos = width; width = 0; p++; } /* otherwise skip to parsing precision, flags can't possibly follow */ else { flags |= FMT_F_WIDTH; goto parse_precision; } } while (*p != '\0' && strchr("#0- +", *p)) { switch (*p++) { case '#': flags |= FMT_F_ALT; break; case '0': flags |= FMT_F_ZERO; break; case '-': flags |= FMT_F_LEFT; break; case ' ': flags |= FMT_F_SPACE; break; case '+': flags |= FMT_F_SIGN; break; } } if (*p >= '1' && *p <= '9') { while (isdigit(*p)) width = width * 10 + (*p++ - '0'); flags |= FMT_F_WIDTH; } parse_precision: if (*p == '.') { p++; if (*p == '-') { p++; while (isdigit(*p)) p++; } else { while (isdigit(*p)) precision = precision * 10 + (*p++ - '0'); } flags |= FMT_F_PREC; } switch (*p) { case 'd': case 'i': conv = FMT_C_INT; flags &= ~FMT_F_PREC; cfmt = PRId64; break; case 'o': conv = FMT_C_UINT; flags &= ~FMT_F_PREC; cfmt = PRIo64; break; case 'u': conv = FMT_C_UINT; flags &= ~FMT_F_PREC; cfmt = PRIu64; break; case 'x': conv = FMT_C_UINT; flags &= ~FMT_F_PREC; cfmt = PRIx64; break; case 'X': conv = FMT_C_UINT; flags &= ~FMT_F_PREC; cfmt = PRIX64; break; case 'e': conv = FMT_C_DBL; cfmt = "e"; break; case 'E': conv = FMT_C_DBL; cfmt = "E"; break; case 'f': conv = FMT_C_DBL; cfmt = "f"; break; case 'F': conv = FMT_C_DBL; cfmt = "F"; break; case 'g': conv = FMT_C_DBL; cfmt = "g"; break; case 'G': conv = FMT_C_DBL; cfmt = "G"; break; case 'c': conv = FMT_C_CHR; flags &= ~FMT_F_PREC; cfmt = "c"; break; case 's': conv = FMT_C_STR; flags &= ~FMT_F_ZERO; cfmt = "s"; break; case 'J': conv = FMT_C_JSON; if (flags & FMT_F_PREC) { flags &= ~FMT_F_PREC; precision++; } cfmt = "s"; break; case '%': conv = FMT_C_NONE; flags = 0; cfmt = "%"; break; case '\0': p--; /* fall through */ default: continue; } sfmtlen = 0; sfmt[sfmtlen++] = '%'; if (flags & FMT_F_ALT) sfmt[sfmtlen++] = '#'; if (flags & FMT_F_ZERO) sfmt[sfmtlen++] = '0'; if (flags & FMT_F_LEFT) sfmt[sfmtlen++] = '-'; if (flags & FMT_F_SPACE) sfmt[sfmtlen++] = ' '; if (flags & FMT_F_SIGN) sfmt[sfmtlen++] = '+'; if (flags & FMT_F_WIDTH) sfmtlen += snprintf(&sfmt[sfmtlen], sizeof(sfmt) - sfmtlen, "%" PRIu32, width); if (flags & FMT_F_PREC) sfmtlen += snprintf(&sfmt[sfmtlen], sizeof(sfmt) - sfmtlen, ".%" PRIu32, precision); snprintf(&sfmt[sfmtlen], sizeof(sfmt) - sfmtlen, "%s", cfmt); switch (conv) { case FMT_C_NONE: ucv_stringbuf_addstr(buf, cfmt, strlen(cfmt)); break; case FMT_C_INT: argidx++; arg = uc_fn_arg(argpos); n = ucv_to_integer(arg); if (errno == ERANGE) n = (int64_t)ucv_to_unsigned(arg); ucv_stringbuf_printf(buf, sfmt, n); break; case FMT_C_UINT: argidx++; arg = uc_fn_arg(argpos); u = ucv_to_unsigned(arg); if (errno == ERANGE) u = (uint64_t)ucv_to_integer(arg); ucv_stringbuf_printf(buf, sfmt, u); break; case FMT_C_DBL: argidx++; d = ucv_to_double(uc_fn_arg(argpos)); ucv_stringbuf_printf(buf, sfmt, d); break; case FMT_C_CHR: argidx++; n = ucv_to_integer(uc_fn_arg(argpos)); ucv_stringbuf_printf(buf, sfmt, (int)n); break; case FMT_C_STR: argidx++; arg = uc_fn_arg(argpos); switch (ucv_type(arg)) { case UC_STRING: ucv_stringbuf_printf(buf, sfmt, ucv_string_get(arg)); break; case UC_NULL: ucv_stringbuf_append(buf, "(null)"); break; default: s = ucv_to_string(vm, arg); ucv_stringbuf_printf(buf, sfmt, s ? s : "(null)"); free(s); } break; case FMT_C_JSON: argidx++; s = ucv_to_jsonstring_formatted(vm, uc_fn_arg(argpos), precision > 0 ? (precision > 1 ? ' ' : '\t') : '\0', precision > 0 ? (precision > 1 ? precision - 1 : 1) : 0); ucv_stringbuf_printf(buf, sfmt, s ? s : "null"); free(s); break; } last = p + 1; } } ucv_stringbuf_addstr(buf, last, p - last); } /** * Formats the given arguments according to the given format string. * * See `printf()` for details. * * Returns the formatted string. * * @function module:core#sprintf * * @param {string} fmt * The format string. * * @param {...*} * Arguments to be formatted. * * @returns {string} * * @example * sprintf("Hello %s", "world"); // "Hello world" * sprintf("%08x", 123); // "0000007b" * sprintf("%c%c%c", 65, 98, 99); // "Abc" * sprintf("%g", 10 / 3.0); // "3.33333" * sprintf("%2$d %1$d", 12, 34); // "34 12" * sprintf("%J", [1,2,3]); // "[1,2,3]" */ static uc_value_t * uc_sprintf(uc_vm_t *vm, size_t nargs) { uc_stringbuf_t *buf = ucv_stringbuf_new(); uc_printf_common(vm, nargs, buf); return ucv_stringbuf_finish(buf); } /** * Formats the given arguments according to the given format string and outputs * the result to stdout. * * Ucode supports a restricted subset of the formats allowed by the underlying * libc's `printf()` implementation, namely it allows the `d`, `i`, `o`, `u`, * `x`, `X`, `e`, `E`, `f`, `F`, `g`, `G`, `c` and `s` conversions. * * Additionally, an ucode specific `J` format is implemented, which causes the * corresponding value to be formatted as JSON string. By prefixing the `J` * format letter with a precision specifier, the resulting JSON output will be * pretty printed. A precision of `0` will use tabs for indentation, any other * positive precision will use that many spaces for indentation while a negative * or omitted precision specifier will turn off pretty printing. * * Other format specifiers such as `n` or `z` are not accepted and returned * verbatim. Format specifiers including `*` directives are rejected as well. * * Returns the number of bytes written to the standard output. * * @function module:core#printf * * @param {string} fmt * The format string. * * @param {...*} * Arguments to be formatted. * * @returns {number} * * @example * {% * printf("Hello %s\n", "world"); // Hello world * printf("%08x\n", 123); // 0000007b * printf("%c%c%c\n", 65, 98, 99); // Abc * printf("%g\n", 10 / 3.0); // 3.33333 * printf("%2$d %1$d\n", 12, 34); // 34 12 * printf("%J", [1,2,3]); // [ 1, 2, 3 ] * * printf("%.J", [1,2,3]); * // [ * // 1, * // 2, * // 3 * // ] * * printf("%.2J", [1,2,3]); * // [ * // 1, * // 2, * // 3 * // ] * %} */ static uc_value_t * uc_printf(uc_vm_t *vm, size_t nargs) { uc_stringbuf_t *buf = xprintbuf_new(); size_t len; uc_printf_common(vm, nargs, buf); len = fwrite(buf->buf, 1, printbuf_length(buf), vm->output); printbuf_free(buf); return ucv_int64_new(len); } static bool uc_require_so(uc_vm_t *vm, const char *path, uc_value_t **res) { void (*init)(uc_vm_t *, uc_value_t *); uc_value_t *scope; struct stat st; void *dlh; if (stat(path, &st)) return false; dlerror(); dlh = dlopen(path, RTLD_LAZY|RTLD_LOCAL); if (!dlh) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Unable to dlopen file '%s': %s", path, dlerror()); return true; } *(void **)(&init) = dlsym(dlh, "uc_module_entry"); if (!init) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Module '%s' provides no 'uc_module_entry' function", path); return true; } scope = ucv_object_new(vm); init(vm, scope); *res = scope; return true; } static uc_value_t * uc_loadfile(uc_vm_t *vm, size_t nargs); static uc_value_t * uc_callfunc(uc_vm_t *vm, size_t nargs); static bool uc_require_ucode(uc_vm_t *vm, const char *path, uc_value_t *scope, uc_value_t **res, bool raw_mode) { uc_parse_config_t config = *vm->config, *prev_config = vm->config; uc_value_t *closure; struct stat st; if (stat(path, &st)) return false; config.raw_mode = raw_mode; vm->config = &config; uc_vm_stack_push(vm, ucv_string_new(path)); closure = uc_loadfile(vm, 1); ucv_put(uc_vm_stack_pop(vm)); if (closure) { uc_vm_stack_push(vm, closure); uc_vm_stack_push(vm, NULL); uc_vm_stack_push(vm, scope); *res = uc_callfunc(vm, 3); uc_vm_stack_pop(vm); uc_vm_stack_pop(vm); uc_vm_stack_pop(vm); } vm->config = prev_config; return true; } static bool uc_require_path(uc_vm_t *vm, const char *path_template, const char *name, uc_value_t **res, bool so_only) { uc_stringbuf_t *buf = xprintbuf_new(); const char *p, *q, *last; uc_value_t *modtable; bool rv; modtable = ucv_property_get(uc_vm_scope_get(vm), "modules"); *res = ucv_get(ucv_object_get(modtable, name, &rv)); if (rv) goto out; p = strchr(path_template, '*'); if (!p) goto out; ucv_stringbuf_addstr(buf, path_template, p - path_template); for (q = last = name;; q++) { if (*q == '.' || *q == '\0') { ucv_stringbuf_addstr(buf, last, q - last); if (*q) ucv_stringbuf_append(buf, "/"); else ucv_stringbuf_addstr(buf, p + 1, strlen(p + 1)); if (*q == '\0') break; last = q + 1; } else if (!isalnum(*q) && *q != '_') { goto out; } } if (!strcmp(p + 1, ".so")) rv = uc_require_so(vm, buf->buf, res); else if (!strcmp(p + 1, ".uc") && !so_only) rv = uc_require_ucode(vm, buf->buf, NULL, res, true); if (rv) ucv_object_add(modtable, name, ucv_get(*res)); out: printbuf_free(buf); return rv; } uc_value_t * uc_require_library(uc_vm_t *vm, uc_value_t *nameval, bool so_only) { uc_value_t *search, *se, *res; size_t arridx, arrlen; const char *name; if (ucv_type(nameval) != UC_STRING) return NULL; name = ucv_string_get(nameval); search = ucv_property_get(uc_vm_scope_get(vm), "REQUIRE_SEARCH_PATH"); if (ucv_type(search) != UC_ARRAY) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Global require search path not set"); return NULL; } for (arridx = 0, arrlen = ucv_array_length(search); arridx < arrlen; arridx++) { se = ucv_array_get(search, arridx); if (ucv_type(se) != UC_STRING) continue; if (uc_require_path(vm, ucv_string_get(se), name, &res, so_only)) return res; } uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "No module named '%s' could be found", name); return NULL; } /** * Load and evaluate ucode scripts or shared library extensions. * * The `require()` function expands each member of the global * `REQUIRE_SEARCH_PATH` array to a filesystem path by replacing the `*` * placeholder with a slash-separated version of the given dotted module name * and subsequently tries to load a file at the resulting location. * * If a file is found at one of the search path locations, it is compiled and * evaluated or loaded via the C runtime's `dlopen()` function, depending on * whether the found file is a ucode script or a compiled dynamic library. * * The resulting program function of the compiled/loaded module is then * subsequently executed with the current global environment, without a `this` * context and without arguments. * * Finally, the return value of the invoked program function is returned back * by `require()` to the caller. * * By default, modules are cached in the global `modules` dictionary and * subsequent attempts to require the same module will return the cached module * dictionary entry without re-evaluating the module. * * To force reloading a module, the corresponding entry from the global * `modules` dictionary can be deleted. * * To preload a module or to provide a "virtual" module without a corresponding * filesystem resource, an entry can be manually added to the global `modules` * dictionary. * * Summarized, the `require()` function can be roughly described by the * following code: * * ``` * function require(name) { * if (exists(modules, name)) * return modules[name]; * * for (const item in REQUIRE_SEARCH_PATH) { * const modpath = replace(item, '*', replace(name, '.', '/')); * const entryfunc = loadfile(modpath, { raw_mode: true }); * * if (entryfunc) { * const modval = entryfunc(); * modules[name] = modval; * * return modval; * } * } * * die(`Module ${name} not found`); * } * ``` * * Due to the fact that `require()` is a runtime operation, module source code * is only lazily evaluated/loaded upon invoking the first require invocation, * which might lead to situations where errors in module sources are only * reported much later throughout the program execution. Unless runtime loading * of modules is absolutely required, e.g. to conditionally load extensions, the * compile time * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#named_import|`import` syntax} * should be preferred. * * Returns the module value (typically an object) on success. * * Throws an exception if the module function threw an exception. * * Throws an exception if no matching module could be found, if the module * contains syntax errors or upon other I/O related problems. * * @function module:core#require * * @param {string} name * The name of the module to require in dotted notation. * * @returns {*} * * @example * // Require the `example/acme.uc` or `example/acme.so` module * const acme = require('example.acme'); * * // Requiring the same name again will yield the cached instance * const acme2 = require('example.acme'); * assert(acme === acme2); * * // Deleting the module dictionary entry will force a reload * delete modules['example.acme']; * const acme3 = require('example.acme'); * assert(acme !== acme3); * * // Preloading a "virtual" module * modules['example.test'] = { * hello: function() { print("This is the example module\n"); } * }; * * const test = require('example.test'); * test.hello(); // will print "This is the example module" */ static uc_value_t * uc_require(uc_vm_t *vm, size_t nargs) { return uc_require_library(vm, uc_fn_arg(0), false); } /** * Convert the given IP address string to an array of byte values. * * IPv4 addresses result in arrays of 4 integers while IPv6 ones in arrays * containing 16 intergers. The resulting array can be turned back into IP * address strings using the inverse `arrtoip()` function. * * Returns an array containing the address byte values. * Returns `null` if the given argument is not a string or an invalid IP. * * @function module:core#iptoarr * * @param {string} address * The IP address string to convert. * * @returns {?number[]} * * @example * iptoarr("192.168.1.1") // [ 192, 168, 1, 1 ] * iptoarr("fe80::fc54:ff:fe82:abbd") // [ 254, 128, 0, 0, 0, 0, 0, 0, 252, 84, * // 0, 255, 254, 130, 171, 189 ]) * iptoarr("foo") // null (invalid address) * iptoarr(123) // null (not a string) */ static uc_value_t * uc_iptoarr(uc_vm_t *vm, size_t nargs) { uc_value_t *ip = uc_fn_arg(0); uc_value_t *res; union { uint8_t u8[4]; struct in_addr in; struct in6_addr in6; } a; int i; if (ucv_type(ip) != UC_STRING) return NULL; if (inet_pton(AF_INET6, ucv_string_get(ip), &a)) { res = ucv_array_new(vm); for (i = 0; i < 16; i++) ucv_array_push(res, ucv_int64_new(a.in6.s6_addr[i])); return res; } else if (inet_pton(AF_INET, ucv_string_get(ip), &a)) { res = ucv_array_new(vm); ucv_array_push(res, ucv_int64_new(a.u8[0])); ucv_array_push(res, ucv_int64_new(a.u8[1])); ucv_array_push(res, ucv_int64_new(a.u8[2])); ucv_array_push(res, ucv_int64_new(a.u8[3])); return res; } return NULL; } static int check_byte(uc_value_t *v) { int n; if (ucv_type(v) != UC_INTEGER) return -1; n = ucv_int64_get(v); if (n < 0 || n > 255) return -1; return n; } /** * Convert the given input array of byte values to an IP address string. * * Input arrays of length 4 are converted to IPv4 addresses, arrays of length 16 * to IPv6 ones. All other lengths are rejected. If any array element is not an * integer or exceeds the range 0..255 (inclusive), the array is rejected. * * Returns a string containing the formatted IP address. * Returns `null` if the input array was invalid. * * @function module:core#arrtoip * * @param {number[]} arr * The byte array to convert into an IP address string. * * @returns {?string} * * @example * arrtoip([ 192, 168, 1, 1 ]) // "192.168.1.1" * arrtoip([ 254, 128, 0, 0, 0, 0, 0, 0, 252, 84, 0, 255, 254, 130, 171, 189 ]) * // "fe80::fc54:ff:fe82:abbd" * arrtoip([ 1, 2, 3]) // null (invalid length) * arrtoip([ 1, "2", -5, 300 ]) // null (invalid values) * arrtoip("123") // null (not an array) */ static uc_value_t * uc_arrtoip(uc_vm_t *vm, size_t nargs) { uc_value_t *arr = uc_fn_arg(0); union { uint8_t u8[4]; struct in6_addr in6; } a; char buf[INET6_ADDRSTRLEN]; int i, n; if (ucv_type(arr) != UC_ARRAY) return NULL; switch (ucv_array_length(arr)) { case 4: for (i = 0; i < 4; i++) { n = check_byte(ucv_array_get(arr, i)); if (n < 0) return NULL; a.u8[i] = n; } inet_ntop(AF_INET, &a, buf, sizeof(buf)); return ucv_string_new(buf); case 16: for (i = 0; i < 16; i++) { n = check_byte(ucv_array_get(arr, i)); if (n < 0) return NULL; a.in6.s6_addr[i] = n; } inet_ntop(AF_INET6, &a, buf, sizeof(buf)); return ucv_string_new(buf); default: return NULL; } } /** * Match the given string against the regular expression pattern specified as * the second argument. * * If the passed regular expression uses the `g` flag, the return value will be * an array of arrays describing all found occurrences within the string. * * Without the `g` modifier, an array describing the first match is returned. * * Returns `null` if the pattern was not found within the given string. * * @function module:core#match * * @param {string} str * The string to be matched against the pattern. * * @param {RegExp} pattern * The regular expression pattern. * * @returns {?Array} * * @example * match("foobarbaz", /b.(.)/) // ["bar", "r"] * match("foobarbaz", /b.(.)/g) // [["bar", "r"], ["baz", "z"]] */ static uc_value_t * uc_match(uc_vm_t *vm, size_t nargs) { uc_value_t *subject = uc_fn_arg(0); uc_value_t *pattern = uc_fn_arg(1); uc_value_t *rv = NULL, *m; regmatch_t *pmatch = NULL; int eflags = 0, res; uc_regexp_t *re; bool freeable; char *p; size_t i; if (ucv_type(pattern) != UC_REGEXP || !subject) return NULL; re = (uc_regexp_t *)pattern; pmatch = calloc(1 + re->regexp.re_nsub, sizeof(regmatch_t)); if (!pmatch) return NULL; p = uc_cast_string(vm, &subject, &freeable); while (true) { res = regexec(&re->regexp, p, 1 + re->regexp.re_nsub, pmatch, eflags); if (res == REG_NOMATCH) break; m = ucv_array_new(vm); for (i = 0; i < 1 + re->regexp.re_nsub; i++) { if (pmatch[i].rm_so != -1) ucv_array_push(m, ucv_string_new_length(p + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so)); else ucv_array_push(m, NULL); } if (re->global) { if (!rv) rv = ucv_array_new(vm); ucv_array_push(rv, m); if (pmatch[0].rm_so != pmatch[0].rm_eo) p += pmatch[0].rm_eo; else if (*p) p++; else break; eflags |= REG_NOTBOL; } else { rv = m; break; } } free(pmatch); if (freeable) free(p); return rv; } static void uc_replace_cb(uc_vm_t *vm, uc_value_t *func, const char *subject, regmatch_t *pmatch, size_t plen, uc_stringbuf_t *resbuf) { uc_value_t *rv; size_t i; uc_vm_ctx_push(vm); uc_vm_stack_push(vm, ucv_get(func)); for (i = 0; i < plen; i++) { if (pmatch[i].rm_so != -1) uc_vm_stack_push(vm, ucv_string_new_length(subject + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so)); else uc_vm_stack_push(vm, NULL); } if (uc_vm_call(vm, true, i) == EXCEPTION_NONE) { rv = uc_vm_stack_pop(vm); ucv_to_stringbuf(vm, resbuf, rv, false); ucv_put(rv); } } static void uc_replace_str(uc_vm_t *vm, uc_value_t *str, const char *subject, regmatch_t *pmatch, size_t plen, uc_stringbuf_t *resbuf) { bool esc = false; char *p, *r; uint8_t i; for (p = r = ucv_to_string(vm, str); *p; p++) { if (esc) { switch (*p) { case '&': if (pmatch[0].rm_so != -1) ucv_stringbuf_addstr(resbuf, subject + pmatch[0].rm_so, pmatch[0].rm_eo - pmatch[0].rm_so); break; case '`': if (pmatch[0].rm_so != -1) ucv_stringbuf_addstr(resbuf, subject, pmatch[0].rm_so); break; case '\'': if (pmatch[0].rm_so != -1) ucv_stringbuf_addstr(resbuf, subject + pmatch[0].rm_eo, strlen(subject + pmatch[0].rm_eo)); break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': i = *p - '0'; if (i < plen && pmatch[i].rm_so != -1) { ucv_stringbuf_addstr(resbuf, subject + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so); } else { ucv_stringbuf_append(resbuf, "$"); ucv_stringbuf_addstr(resbuf, p, 1); } break; case '$': ucv_stringbuf_append(resbuf, "$"); break; default: ucv_stringbuf_append(resbuf, "$"); ucv_stringbuf_addstr(resbuf, p, 1); } esc = false; } else if (*p == '$') { esc = true; } else { ucv_stringbuf_addstr(resbuf, p, 1); } } free(r); } /** * Replace occurrences of the specified pattern in the string passed as the * first argument. * * - The pattern value may be either a regular expression or a plain string. * - The replace value may be a function which is invoked for each found pattern * or any other value which is converted into a plain string and used as * replacement. * - When an optional limit is specified, substitutions are performed only that * many times. * - If the pattern is a regular expression and not using the `g` flag, then * only the first occurrence in the string is replaced. * - If the `g` flag is used or if the pattern is not a regular expression, all * occurrences are replaced. * - If the replace value is a callback function, it is invoked with the found * substring as the first and any capture group values as subsequent * parameters. * - If the replace value is a string, specific substrings are substituted * before it is inserted into the result. * * Returns a new string with the pattern replaced. * * @function module:core#replace * * @param {string} str * The string in which to replace occurrences. * * @param {RegExp|string} pattern * The pattern to be replaced. * * @param {Function|string} replace * The replacement value. * * @param {number} [limit] * The optional limit of substitutions. * * @returns {string} * * @example * replace("barfoobaz", /(f)(o+)/g, "[$$|$`|$&|$'|$1|$2|$3]") // bar[$|bar|foo|baz|f|oo|$3]baz * replace("barfoobaz", /(f)(o+)/g, uc) // barFOObaz * replace("barfoobaz", "a", "X") // bXrfoobXz * replace("barfoobaz", /(.)(.)(.)/g, function(m, c1, c2, c3) { * return c3 + c2 + c1; * }) // raboofzab * replace("aaaaa", "a", "x", 3) // xxxaa * replace("foo bar baz", /[ao]/g, "x", 3) // fxx bxr baz */ static uc_value_t * uc_replace(uc_vm_t *vm, size_t nargs) { char *sb = NULL, *pt = NULL, *p, *l; uc_value_t *subject = uc_fn_arg(0); uc_value_t *pattern = uc_fn_arg(1); uc_value_t *replace = uc_fn_arg(2); uc_value_t *limitval = uc_fn_arg(3); bool sb_freeable, pt_freeable; regmatch_t *pmatch = NULL; size_t pl, nmatch, limit; uc_regexp_t *re = NULL; uc_stringbuf_t *resbuf; int eflags = 0, res; if (!pattern || !subject || !replace) return NULL; nmatch = 1; if (ucv_type(pattern) == UC_REGEXP) { re = (uc_regexp_t *)pattern; nmatch += re->regexp.re_nsub; } pmatch = calloc(nmatch, sizeof(regmatch_t)); if (!pmatch) return NULL; sb = uc_cast_string(vm, &subject, &sb_freeable); resbuf = ucv_stringbuf_new(); limit = limitval ? ucv_uint64_get(limitval) : SIZE_MAX; if (re) { p = sb; while (limit > 0) { res = regexec(&re->regexp, p, nmatch, pmatch, eflags); if (res == REG_NOMATCH) break; ucv_stringbuf_addstr(resbuf, p, pmatch[0].rm_so); if (ucv_is_callable(replace)) uc_replace_cb(vm, replace, p, pmatch, nmatch, resbuf); else uc_replace_str(vm, replace, p, pmatch, nmatch, resbuf); if (pmatch[0].rm_so != pmatch[0].rm_eo) p += pmatch[0].rm_eo; else if (*p) ucv_stringbuf_addstr(resbuf, p++, 1); else break; if (re->global) eflags |= REG_NOTBOL; else break; limit--; } ucv_stringbuf_addstr(resbuf, p, strlen(p)); } else { pt = uc_cast_string(vm, &pattern, &pt_freeable); pl = strlen(pt); l = p = sb; while (limit > 0) { if (pl == 0 || !strncmp(p, pt, pl)) { ucv_stringbuf_addstr(resbuf, l, p - l); pmatch[0].rm_so = p - l; pmatch[0].rm_eo = pmatch[0].rm_so + pl; if (ucv_is_callable(replace)) uc_replace_cb(vm, replace, l, pmatch, 1, resbuf); else uc_replace_str(vm, replace, l, pmatch, 1, resbuf); if (pl) { l = p + pl; p += pl - 1; } else { l = p; } limit--; } if (!*p++) break; } ucv_stringbuf_addstr(resbuf, l, strlen(l)); if (pt_freeable) free(pt); } free(pmatch); if (sb_freeable) free(sb); return ucv_stringbuf_finish(resbuf); } static struct json_tokener * uc_json_from_object(uc_vm_t *vm, uc_value_t *obj, json_object **jso) { bool trail = false, eof = false; enum json_tokener_error err; struct json_tokener *tok; uc_value_t *rfn, *rbuf; uc_stringbuf_t *buf; rfn = ucv_property_get(obj, "read"); if (!ucv_is_callable(rfn)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Input object does not implement read() method"); return NULL; } tok = xjs_new_tokener(); while (true) { uc_vm_stack_push(vm, ucv_get(obj)); uc_vm_stack_push(vm, ucv_get(rfn)); uc_vm_stack_push(vm, ucv_int64_new(1024)); if (uc_vm_call(vm, true, 1) != EXCEPTION_NONE) { json_tokener_free(tok); return NULL; } rbuf = uc_vm_stack_pop(vm); /* check EOF */ eof = (rbuf == NULL || (ucv_type(rbuf) == UC_STRING && ucv_string_length(rbuf) == 0)); /* on EOF, stop parsing unless trailing garbage was detected which handled below */ if (eof && !trail) { ucv_put(rbuf); /* Didn't parse a complete object yet, possibly a non-delimitted atomic value such as `null`, `true` etc. - nudge parser by sending final zero byte. See json-c issue #681 */ if (json_tokener_get_error(tok) == json_tokener_continue) *jso = json_tokener_parse_ex(tok, "\0", 1); break; } if (trail || *jso) { uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Trailing garbage after JSON data"); json_tokener_free(tok); ucv_put(rbuf); return NULL; } if (ucv_type(rbuf) != UC_STRING) { buf = xprintbuf_new(); ucv_to_stringbuf_formatted(vm, buf, rbuf, 0, '\0', 0); *jso = json_tokener_parse_ex(tok, buf->buf, printbuf_length(buf)); trail = (json_tokener_get_error(tok) == json_tokener_success && json_tokener_get_parse_end(tok) < (size_t)printbuf_length(buf)); printbuf_free(buf); } else { *jso = json_tokener_parse_ex(tok, ucv_string_get(rbuf), ucv_string_length(rbuf)); trail = (json_tokener_get_error(tok) == json_tokener_success && json_tokener_get_parse_end(tok) < ucv_string_length(rbuf)); } ucv_put(rbuf); err = json_tokener_get_error(tok); if (err != json_tokener_success && err != json_tokener_continue) break; } return tok; } static struct json_tokener * uc_json_from_string(uc_vm_t *vm, uc_value_t *str, json_object **jso) { struct json_tokener *tok = xjs_new_tokener(); size_t i; char *p; /* NB: the len + 1 here is intentional to pass the terminating \0 byte * to the json-c parser. This is required to work-around upstream * issue #681 */ *jso = json_tokener_parse_ex(tok, ucv_string_get(str), ucv_string_length(str) + 1); if (json_tokener_get_error(tok) == json_tokener_success) { p = ucv_string_get(str); for (i = json_tokener_get_parse_end(tok); i < ucv_string_length(str); i++) { if (!isspace(p[i])) { uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Trailing garbage after JSON data"); json_tokener_free(tok); return NULL; } } } return tok; } /** * Parse the given string or resource as JSON and return the resulting value. * * If the input argument is a plain string, it is directly parsed as JSON. * * If an array, object or resource value is given, this function will attempt to * invoke a `read()` method on it to read chunks of input text to incrementally * parse as JSON data. Reading will stop if the object's `read()` method returns * either `null` or an empty string. * * Throws an exception on parse errors, trailing garbage, or premature EOF. * * Returns the parsed JSON data. * * @function module:core#json * * @param {string} str_or_resource * The string or resource object to be parsed as JSON. * * @returns {*} * * @example * json('{"a":true, "b":123}') // { "a": true, "b": 123 } * json('[1,2,') // Throws an exception * * import { open } from 'fs'; * let fd = open('example.json', 'r'); * json(fd); // will keep invoking `fd.read()` until EOF and * // incrementally parse each read chunk. * * let x = proto( * [ '{"foo":', 'true, ', '"bar":', 'false}' ], * { read: function() { return shift(this) } } * ); * json(x); // will keep invoking `x.read()` until array * // is empty incrementally parse each piece * */ static uc_value_t * uc_json(uc_vm_t *vm, size_t nargs) { uc_value_t *rv = NULL, *src = uc_fn_arg(0); struct json_tokener *tok = NULL; enum json_tokener_error err; json_object *jso = NULL; switch (ucv_type(src)) { case UC_STRING: tok = uc_json_from_string(vm, src, &jso); break; case UC_RESOURCE: case UC_OBJECT: case UC_ARRAY: tok = uc_json_from_object(vm, src, &jso); break; default: uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Passed value is neither a string nor an object"); } if (!tok) goto out; err = json_tokener_get_error(tok); if (err == json_tokener_continue) { uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Unexpected end of string in JSON data"); goto out; } else if (err != json_tokener_success) { uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "Failed to parse JSON string: %s", json_tokener_error_desc(err)); goto out; } rv = ucv_from_json(vm, jso); out: if (tok) json_tokener_free(tok); json_object_put(jso); return rv; } static char * include_path(const char *curpath, const char *incpath) { char *dup, *res; int len; if (*incpath == '/') return realpath(incpath, NULL); dup = curpath ? strrchr(curpath, '/') : NULL; if (dup) len = asprintf(&res, "%.*s/%s", (int)(dup - curpath), curpath, incpath); else len = asprintf(&res, "./%s", incpath); if (len == -1) return NULL; dup = realpath(res, NULL); free(res); return dup; } static uc_value_t * uc_include_common(uc_vm_t *vm, size_t nargs, bool raw_mode) { uc_value_t *path = uc_fn_arg(0); uc_value_t *scope = uc_fn_arg(1); uc_value_t *rv = NULL, *sc = NULL; uc_closure_t *closure = NULL; size_t i; char *p; if (ucv_type(path) != UC_STRING) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Passed filename is not a string"); return NULL; } if (scope && ucv_type(scope) != UC_OBJECT) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Passed scope value is not an object"); return NULL; } /* find calling closure */ for (i = vm->callframes.count; i > 0; i--) { closure = vm->callframes.entries[i - 1].closure; if (closure) break; } if (!closure) return NULL; p = include_path(uc_program_function_source(closure->function)->runpath, ucv_string_get(path)); if (!p) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Include file not found"); return NULL; } if (ucv_prototype_get(scope)) { sc = ucv_get(scope); } else if (scope) { sc = ucv_object_new(vm); ucv_object_foreach(scope, key, val) ucv_object_add(sc, key, ucv_get(val)); ucv_prototype_set(sc, ucv_get(uc_vm_scope_get(vm))); } else { sc = ucv_get(uc_vm_scope_get(vm)); } if (uc_require_ucode(vm, p, sc, &rv, raw_mode)) ucv_put(rv); ucv_put(sc); free(p); return NULL; } /** * Evaluate and include the file at the given path and optionally override the * execution scope with the given scope object. * * By default, the file is executed within the same scope as the calling * `include()`, but by passing an object as the second argument, it is possible * to extend the scope available to the included file. * * This is useful to supply additional properties as global variables to the * included code. To sandbox included code, that is giving it only access to * explicitly provided properties, the `proto()` function can be used to create * a scope object with an empty prototype. * * @function module:core#include * * @param {string} path * The path to the file to be included. * * @param {Object} [scope] * The optional scope object to override the execution scope. * * @example * // Load and execute "foo.uc" immediately * include("./foo.uc") * * // Execute the "supplemental.ucode" in an extended scope and make the "foo" * // and "bar" properties available as global variables * include("./supplemental.uc", { * foo: true, * bar: 123 * }) * * // Execute the "untrusted.ucode" in a sandboxed scope and make the "foo" and * // "bar" variables as well as the "print" function available to it. * // By assigning an empty prototype object to the scope, included code has no * // access to other global values anymore. * include("./untrusted.uc", proto({ * foo: true, * bar: 123, * print: print * }, {})) */ static uc_value_t * uc_include(uc_vm_t *vm, size_t nargs) { return uc_include_common(vm, nargs, vm->config && vm->config->raw_mode); } /** * When invoked with a string value as the first argument, the function acts * like `include()` but captures the output of the included file as a string and * returns the captured contents. * * The second argument is treated as the scope. * * When invoked with a function value as the first argument, `render()` calls * the given function and passes all subsequent arguments to it. * * Any output produced by the called function is captured and returned as a * string. The return value of the called function is discarded. * * @function module:core#render * * @param {string|Function} path_or_func * The path to the file or the function to be rendered. * * @param {Object|*} [scope_or_fnarg1] * The optional scope or the first argument for the function. * * @param {*} [fnarg2] * The second argument for the function. * * @param {...*} [fnargN] * Additional arguments for the function. * * @returns {string} * * @example * // Renders template file with given scope and captures the output as a string * const output = render("./template.uc", { foo: "bar" }); * * // Calls a function, captures the output, and returns it as a string * const result = render(function(name) { * printf("Hello, %s!\n", name); * }, "Alice"); */ static uc_value_t * uc_render(uc_vm_t *vm, size_t nargs) { uc_string_t hdr = { .header = { .type = UC_STRING, .refcount = 1 } }; uc_string_t *ustr = NULL; FILE *mem, *prev; size_t len = 0; mem = open_memstream((char **)&ustr, &len); if (!mem) goto out; /* reserve space for uc_string_t header... */ if (fwrite(&hdr, 1, sizeof(hdr), mem) != sizeof(hdr)) goto out; /* divert VM output to memory fd */ prev = vm->output; vm->output = mem; /* execute function */ if (ucv_is_callable(uc_fn_arg(0))) (void) uc_vm_call(vm, false, nargs - 1); /* execute include */ else (void) uc_include_common(vm, nargs, false); /* restore previous VM output */ vm->output = prev; fclose(mem); /* update uc_string_t length */ ustr->length = len - sizeof(*ustr); return &ustr->header; out: uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Unable to initialize output memory: %s", strerror(errno)); if (mem) fclose(mem); free(ustr); return NULL; } /** * Print any of the given values to stderr. Arrays and objects are converted to * their JSON representation. * * Returns the amount of bytes printed. * * @function module:core#warn * * @param {...*} x * The values to be printed. * * @returns {number} * * @example * warn("Hello", "world"); // Print "Helloworld" to stderr * warn({ key: "value" }); // Print JSON representation of the object to stderr */ static uc_value_t * uc_warn(uc_vm_t *vm, size_t nargs) { return uc_print_common(vm, nargs, stderr); } /** * Executes the given command, waits for completion, and returns the resulting * exit code. * * The command argument may be either a string, in which case it is passed to * `/bin/sh -c`, or an array, which is directly converted into an `execv()` * argument vector. * * - If the program terminated normally, a positive integer holding the * program's `exit()` code is returned. * - If the program was terminated by an uncaught signal, a negative signal * number is returned. * - If the optional timeout argument is specified, the program is terminated * by `SIGKILL` after that many milliseconds if it doesn't complete within * the timeout. * * Omitting the timeout argument or passing `0` disables the command timeout. * * Returns the program exit code. * * @function module:core#system * * @param {string|Array} command * The command to be executed. * * @param {number} [timeout] * The optional timeout in milliseconds. * * @returns {number} * * @example * // Execute through `/bin/sh` * // prints "Hello world" to stdout and returns 3 * system("echo 'Hello world' && exit 3"); * * // Execute argument vector * // prints the UNIX timestamp to stdout and returns 0 * system(["/usr/bin/date", "+%s"]); * * // Apply a timeout * // returns -9 * system("sleep 3 && echo 'Success'", 1000); */ static uc_value_t * uc_system(uc_vm_t *vm, size_t nargs) { uc_value_t *cmdline = uc_fn_arg(0); uc_value_t *timeout = uc_fn_arg(1); const char **arglist, *fn; sigset_t sigmask, sigomask; struct timespec ts; size_t i, len; int64_t tms; pid_t cld; int rc; if (timeout && (ucv_type(timeout) != UC_INTEGER || ucv_int64_get(timeout) < 0)) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Invalid timeout specified"); return NULL; } switch (ucv_type(cmdline)) { case UC_STRING: arglist = xalloc(sizeof(*arglist) * 4); arglist[0] = xstrdup("/bin/sh"); arglist[1] = xstrdup("-c"); arglist[2] = ucv_to_string(vm, cmdline); arglist[3] = NULL; break; case UC_ARRAY: len = ucv_array_length(cmdline); if (len == 0) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Passed command array is empty"); return NULL; } arglist = xalloc(sizeof(*arglist) * (len + 1)); for (i = 0; i < len; i++) arglist[i] = ucv_to_string(vm, ucv_array_get(cmdline, i)); arglist[i] = NULL; break; default: uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Passed command is neither string nor array"); return NULL; } tms = timeout ? ucv_int64_get(timeout) : 0; if (tms > 0) { sigemptyset(&sigmask); sigaddset(&sigmask, SIGCHLD); if (sigprocmask(SIG_BLOCK, &sigmask, &sigomask) < 0) { fn = "sigprocmask"; goto fail; } } cld = fork(); switch (cld) { case -1: fn = "fork"; goto fail; case 0: execvp(arglist[0], (char * const *)arglist); exit(-1); break; default: if (tms > 0) { ts.tv_sec = tms / 1000; ts.tv_nsec = (tms % 1000) * 1000000; while (1) { if (sigtimedwait(&sigmask, NULL, &ts) < 0) { if (errno == EINTR) continue; if (errno != EAGAIN) { fn = "sigtimedwait"; goto fail; } kill(cld, SIGKILL); } break; } } while (waitpid(cld, &rc, 0) < 0) { if (errno == EINTR) continue; fn = "waitpid"; goto fail; } if (tms > 0) sigprocmask(SIG_SETMASK, &sigomask, NULL); for (i = 0; arglist[i]; i++) free((char *)arglist[i]); free(arglist); if (WIFEXITED(rc)) return ucv_int64_new(WEXITSTATUS(rc)); else if (WIFSIGNALED(rc)) return ucv_int64_new(-WTERMSIG(rc)); else if (WIFSTOPPED(rc)) return ucv_int64_new(-WSTOPSIG(rc)); return NULL; } fail: if (tms > 0) sigprocmask(SIG_SETMASK, &sigomask, NULL); for (i = 0; arglist[i]; i++) free((char *)arglist[i]); free(arglist); uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "%s(): %s", fn, strerror(errno)); return NULL; } /** * Enables or disables VM opcode tracing. * * When invoked with a positive non-zero level, opcode tracing is enabled and * debug information is printed to stderr as the program is executed. * * Invoking `trace()` with zero as an argument turns off opcode tracing. * * @function module:core#trace * * @param {number} level * The level of tracing to enable. * * @example * trace(1); // Enables opcode tracing * trace(0); // Disables opcode tracing */ static uc_value_t * uc_trace(uc_vm_t *vm, size_t nargs) { uc_value_t *level = uc_fn_arg(0); uint8_t prev_level; if (ucv_type(level) != UC_INTEGER) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Invalid level specified"); return NULL; } prev_level = vm->trace; vm->trace = ucv_int64_get(level); return ucv_int64_new(prev_level); } /** * Get or set the prototype of the array or object value `val`. * * When invoked without a second argument, the function returns the current * prototype of the value in `val` or `null` if there is no prototype or if the * given value is neither an object nor an array. * * When invoked with a second prototype argument, the given `proto` value is set * as the prototype on the array or object in `val`. * * Throws an exception if the given prototype value is not an object. * * @function module:core#proto * * @param {Array|Object} val * The array or object value. * * @param {Object} [proto] * The optional prototype object. * * @returns {?Object} * * @example * const arr = [1, 2, 3]; * proto(arr); // Returns the current prototype of the array (null by default) * proto(arr, { foo: true }); // Sets the given object as the prototype of the array */ static uc_value_t * uc_proto(uc_vm_t *vm, size_t nargs) { uc_value_t *val = uc_fn_arg(0); uc_value_t *proto = NULL; if (nargs < 2) return ucv_get(ucv_prototype_get(val)); proto = uc_fn_arg(1); if (!ucv_prototype_set(val, proto)) uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Passed value is neither a prototype, resource or object"); ucv_get(proto); return ucv_get(val); } /** * Pause execution for the given amount of milliseconds. * * @function module:core#sleep * * @param {number} milliseconds * The amount of milliseconds to sleep. * * @returns {boolean} * * @example * sleep(1000); // Sleeps for 1 second */ static uc_value_t * uc_sleep(uc_vm_t *vm, size_t nargs) { uc_value_t *duration = uc_fn_arg(0); struct timeval tv; int64_t ms; ms = ucv_to_integer(duration); if (errno != 0 || ms <= 0) return ucv_boolean_new(false); tv.tv_sec = ms / 1000; tv.tv_usec = (ms % 1000) * 1000; select(0, NULL, NULL, NULL, &tv); return ucv_boolean_new(true); } /** * Raise an exception with the given message parameter when the value in `cond` * is not truish. * * When `message` is omitted, the default value is `Assertion failed`. * * @function module:core#assert * * @param {*} cond * The value to check for truthiness. * * @param {string} [message] * The message to include in the exception. * * @throws {Error} When the condition is falsy. * * @example * assert(true, "This is true"); // No exception is raised * assert(false); // Exception is raised with the default message "Assertion failed" */ static uc_value_t * uc_assert(uc_vm_t *vm, size_t nargs) { uc_value_t *cond = uc_fn_arg(0); uc_value_t *msg = uc_fn_arg(1); bool freeable = false; char *s; if (!ucv_is_truish(cond)) { s = msg ? uc_cast_string(vm, &msg, &freeable) : "Assertion failed"; uc_vm_raise_exception(vm, EXCEPTION_USER, "%s", s); if (freeable) free(s); return NULL; } return ucv_get(cond); } /** * Construct a regular expression instance from the given `source` pattern * string and any flags optionally specified by the `flags` argument. * * - Throws a type error exception if `flags` is not a string or if the string * in `flags` contains unrecognized regular expression flag characters. * - Throws a syntax error when the pattern in `source` cannot be compiled into * a valid regular expression. * * Returns the compiled regular expression value. * * @function module:core#regexp * * @param {string} source * The pattern string. * * @param {string} [flags] * The optional regular expression flags. * * @returns {RegExp} * * @example * regexp('foo.*bar', 'is'); // equivalent to /foo.*bar/is * regexp('foo.*bar', 'x'); // throws a "Type error: Unrecognized flag character 'x'" exception * regexp('foo.*('); // throws a "Syntax error: Unmatched ( or \( exception" */ static uc_value_t * uc_regexp(uc_vm_t *vm, size_t nargs) { bool icase = false, newline = false, global = false, freeable; uc_value_t *source = uc_fn_arg(0); uc_value_t *flags = uc_fn_arg(1); uc_value_t *regex = NULL; char *p, *err = NULL; if (flags) { if (ucv_type(flags) != UC_STRING) { uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Given flags argument is not a string"); return NULL; } for (p = ucv_string_get(flags); *p; p++) { switch (*p) { case 'i': icase = true; break; case 's': newline = true; break; case 'g': global = true; break; default: uc_vm_raise_exception(vm, EXCEPTION_TYPE, "Unrecognized flag character '%c'", *p); return NULL; } } } p = uc_cast_string(vm, &source, &freeable); regex = ucv_regexp_new(p, icase, newline, global, &err); if (freeable) free(p); if (err) { uc_vm_raise_exception(vm, EXCEPTION_SYNTAX, "%s", err); ucv_put(regex); free(err); return NULL; } return regex; } /** * Match the given subject against the supplied wildcard (file glob) pattern. * * - If a truthy value is supplied as the third argument, case-insensitive * matching is performed. * - If a non-string value is supplied as the subject, it is converted into a * string before being matched. * * Returns `true` when the value matched the given pattern, otherwise `false`. * * @function module:core#wildcard * * @param {*} subject * The subject to match against the wildcard pattern. * * @param {string} pattern * The wildcard pattern. * * @param {boolean} [nocase] * Whether to perform case-insensitive matching. * * @returns {boolean} * * @example * wildcard("file.txt", "*.txt"); // Returns true * wildcard("file.txt", "*.TXT", true); // Returns true (case-insensitive match) * wildcard("file.txt", "*.jpg"); // Returns false */ static uc_value_t * uc_wildcard(uc_vm_t *vm, size_t nargs) { uc_value_t *subject = uc_fn_arg(0); uc_value_t *pattern = uc_fn_arg(1); uc_value_t *icase = uc_fn_arg(2); int flags = 0, rv; bool freeable; char *s; if (!subject || ucv_type(pattern) != UC_STRING) return NULL; if (ucv_is_truish(icase)) flags |= FNM_CASEFOLD; s = uc_cast_string(vm, &subject, &freeable); rv = fnmatch(ucv_string_get(pattern), s, flags); if (freeable) free(s); return ucv_boolean_new(rv == 0); } /** * Determine the path of the source file currently being executed by ucode. * * @function module:core#sourcepath * * @param {number} [depth=0] * The depth to walk up the call stack. * * @param {boolean} [dironly] * Whether to return only the directory portion of the source file path. * * @returns {?string} * * @example * sourcepath(); // Returns the path of the currently executed file * sourcepath(1); // Returns the path of the parent source file * sourcepath(2, true); // Returns the directory portion of the grandparent source file path */ static uc_value_t * uc_sourcepath(uc_vm_t *vm, size_t nargs) { uc_value_t *calldepth = uc_fn_arg(0); uc_value_t *dironly = uc_fn_arg(1); uc_value_t *rv = NULL; uc_callframe_t *frame; char *path = NULL; int64_t depth; size_t i; depth = ucv_to_integer(calldepth); if (errno) depth = 0; for (i = vm->callframes.count; i > 0; i--) { frame = &vm->callframes.entries[i - 1]; if (!frame->closure) continue; if (depth > 0) { depth--; continue; } path = realpath(uc_program_function_source(frame->closure->function)->runpath, NULL); break; } if (path) { if (ucv_is_truish(dironly)) rv = ucv_string_new(dirname(path)); else rv = ucv_string_new(path); free(path); } return rv; } static uc_value_t * uc_min_max(uc_vm_t *vm, size_t nargs, int cmp) { uc_value_t *rv = NULL, *val; bool set = false; size_t i; for (i = 0; i < nargs; i++) { val = uc_fn_arg(i); if (!set || ucv_compare(cmp, val, rv, NULL)) { set = true; rv = val; } } return ucv_get(rv); } /** * Return the smallest value among all parameters passed to the function. * * @function module:core#min * * @param {...*} [val] * The values to compare. * * @returns {*} * * @example * min(5, 2.1, 3, "abc", 0.3); // Returns 0.3 * min(1, "abc"); // Returns 1 * min("1", "abc"); // Returns "1" * min("def", "abc", "ghi"); // Returns "abc" * min(true, false); // Returns false */ static uc_value_t * uc_min(uc_vm_t *vm, size_t nargs) { return uc_min_max(vm, nargs, I_LT); } /** * Return the largest value among all parameters passed to the function. * * @function module:core#max * * @param {...*} [val] * The values to compare. * * @returns {*} * * @example * max(5, 2.1, 3, "abc", 0.3); // Returns 5 * max(1, "abc"); // Returns 1 (!) * max("1", "abc"); // Returns "abc" * max("def", "abc", "ghi"); // Returns "ghi" * max(true, false); // Returns true */ static uc_value_t * uc_max(uc_vm_t *vm, size_t nargs) { return uc_min_max(vm, nargs, I_GT); } /* ------------------------------------------------------------------------- * The following base64 encoding and decoding routines are taken from * https://git.openwrt.org/?p=project/libubox.git;a=blob;f=base64.c * and modified for use in ucode. * * Original copyright and license statements below. */ /* * base64 - libubox base64 functions * * Copyright (C) 2015 Felix Fietkau * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* $OpenBSD: base64.c,v 1.7 2013/12/31 02:32:56 tedu Exp $ */ /* * Copyright (c) 1996 by Internet Software Consortium. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ /* * Portions Copyright (c) 1995 by International Business Machines, Inc. * * International Business Machines, Inc. (hereinafter called IBM) grants * permission under its copyrights to use, copy, modify, and distribute this * Software with or without fee, provided that the above copyright notice and * all paragraphs of this notice appear in all copies, and that the name of IBM * not be used in connection with the marketing of any product incorporating * the Software or modifications thereof, without specific, written prior * permission. * * To the extent it has a right to do so, IBM grants an immunity from suit * under its patents, if any, for the use, sale or manufacture of products to * the extent that such products are used for performing Domain Name System * dynamic updates in TCP/IP networks by means of the Software. No immunity is * granted for any product per se or for any other function of any product. * * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. */ /* skips all whitespace anywhere. converts characters, four at a time, starting at (or after) src from base - 64 numbers into three 8 bit bytes in the target area. it returns the number of data bytes stored at the target, or -1 on error. */ /** * Decodes the given base64 encoded string and returns the decoded result. * * - If non-whitespace, non-base64 characters are encountered, if invalid * padding or trailing garbage is found, the function returns `null`. * - If a non-string argument is given, the function returns `null`. * * @function module:core#b64dec * * @param {string} str * The base64 encoded string to decode. * * @returns {?string} * * @example * b64dec("VGhpcyBpcyBhIHRlc3Q="); // Returns "This is a test" * b64dec(123); // Returns null * b64dec("XXX"); // Returns null */ static uc_value_t * uc_b64dec(uc_vm_t *vm, size_t nargs) { enum { BYTE1, BYTE2, BYTE3, BYTE4 } state; uc_value_t *str = uc_fn_arg(0); uc_stringbuf_t *buf; const char *src; unsigned int ch; uint8_t val; size_t off; if (ucv_type(str) != UC_STRING) return NULL; buf = ucv_stringbuf_new(); src = ucv_string_get(str); off = printbuf_length(buf); state = BYTE1; /* memset the last expected output char to pre-grow the output buffer */ printbuf_memset(buf, off + (ucv_string_length(str) / 4) * 3, 0, 1); while ((ch = (unsigned char)*src++) != '\0') { if (isspace(ch)) /* Skip whitespace anywhere. */ continue; if (ch == '=') break; if (ch >= 'A' && ch <= 'Z') val = ch - 'A'; else if (ch >= 'a' && ch <= 'z') val = ch - 'a' + 26; else if (ch >= '0' && ch <= '9') val = ch - '0' + 52; else if (ch == '+') val = 62; else if (ch == '/') val = 63; else goto err; switch (state) { case BYTE1: buf->buf[off] = val << 2; state = BYTE2; break; case BYTE2: buf->buf[off++] |= val >> 4; buf->buf[off] = (val & 0x0f) << 4; state = BYTE3; break; case BYTE3: buf->buf[off++] |= val >> 2; buf->buf[off] = (val & 0x03) << 6; state = BYTE4; break; case BYTE4: buf->buf[off++] |= val; state = BYTE1; break; } } /* * We are done decoding Base-64 chars. Let's see if we ended * on a byte boundary, and/or with erroneous trailing characters. */ if (ch == '=') { /* We got a pad char. */ ch = (unsigned char)*src++; /* Skip it, get next. */ switch (state) { case BYTE1: /* Invalid = in first position */ case BYTE2: /* Invalid = in second position */ goto err; case BYTE3: /* Valid, means one byte of info */ /* Skip any number of spaces. */ for (; ch != '\0'; ch = (unsigned char)*src++) if (!isspace(ch)) break; /* Make sure there is another trailing = sign. */ if (ch != '=') goto err; ch = (unsigned char)*src++; /* Skip the = */ /* Fall through to "single trailing =" case. */ /* FALLTHROUGH */ case BYTE4: /* Valid, means two bytes of info */ /* * We know this char is an =. Is there anything but * whitespace after it? */ for (; ch != '\0'; ch = (unsigned char)*src++) if (!isspace(ch)) goto err; /* * Now make sure for cases BYTE3 and BYTE4 that the "extra" * bits that slopped past the last full byte were * zeros. If we don't check them, they become a * subliminal channel. */ if (buf->buf[off] != 0) goto err; } } else { /* * We ended by seeing the end of the string. Make sure we * have no partial bytes lying around. */ if (state != BYTE1) goto err; } /* Truncate buffer length to actual output length */ buf->bpos = off; return ucv_stringbuf_finish(buf); err: printbuf_free(buf); return NULL; } static const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /** * Encodes the given string into base64 and returns the resulting string. * * - If a non-string argument is given, the function returns `null`. * * @function module:core#b64enc * * @param {string} str * The string to encode. * * @returns {?string} * * @example * b64enc("This is a test"); // Returns "VGhpcyBpcyBhIHRlc3Q=" * b64enc(123); // Returns null */ static uc_value_t * uc_b64enc(uc_vm_t *vm, size_t nargs) { uc_value_t *str = uc_fn_arg(0); unsigned char input[3] = {0}; uc_stringbuf_t *buf; const char *src; char output[4]; size_t len, i; if (ucv_type(str) != UC_STRING) return NULL; buf = ucv_stringbuf_new(); src = ucv_string_get(str); len = ucv_string_length(str); while (2 < len) { input[0] = (unsigned char)*src++; input[1] = (unsigned char)*src++; input[2] = (unsigned char)*src++; len -= 3; output[0] = Base64[input[0] >> 2]; output[1] = Base64[((input[0] & 0x03) << 4) + (input[1] >> 4)]; output[2] = Base64[((input[1] & 0x0f) << 2) + (input[2] >> 6)]; output[3] = Base64[input[2] & 0x3f]; ucv_stringbuf_addstr(buf, output, sizeof(output)); } /* Now we worry about padding. */ if (0 != len) { /* Get what's left. */ input[0] = input[1] = input[2] = '\0'; for (i = 0; i < len; i++) input[i] = *src++; output[0] = Base64[input[0] >> 2]; output[1] = Base64[((input[0] & 0x03) << 4) + (input[1] >> 4)]; output[2] = (len == 1) ? '=' : Base64[((input[1] & 0x0f) << 2) + (input[2] >> 6)]; output[3] = '='; ucv_stringbuf_addstr(buf, output, sizeof(output)); } return ucv_stringbuf_finish(buf); } /* End of base64 code. * ------------------------------------------------------------------------- */ static unsigned long uc_uniq_ucv_hash(const void *k) { union { double d; int64_t i; uint64_t u; } conv; uc_value_t *uv = (uc_value_t *)k; unsigned int h; uint8_t *u8; size_t len; h = ucv_type(uv); switch (h) { case UC_STRING: u8 = (uint8_t *)ucv_string_get(uv); len = ucv_string_length(uv); break; case UC_INTEGER: conv.i = ucv_int64_get(uv); if (errno == ERANGE) { h *= 2; conv.u = ucv_uint64_get(uv); } u8 = (uint8_t *)&conv.u; len = sizeof(conv.u); break; case UC_DOUBLE: conv.d = ucv_double_get(uv); u8 = (uint8_t *)&conv.u; len = sizeof(conv.u); break; default: u8 = (uint8_t *)&uv; len = sizeof(uv); break; } while (len > 0) { h = h * 129 + (*u8++) + LH_PRIME; len--; } return h; } static int uc_uniq_ucv_equal(const void *k1, const void *k2) { uc_value_t *uv1 = (uc_value_t *)k1; uc_value_t *uv2 = (uc_value_t *)k2; if (!ucv_is_scalar(uv1) && !ucv_is_scalar(uv2)) return (uv1 == uv2); /* for the sake of array item uniqueness, treat two NaNs as equal */ if (ucv_type(uv1) == UC_DOUBLE && ucv_type(uv2) == UC_DOUBLE && isnan(ucv_double_get(uv1)) && isnan(ucv_double_get(uv2))) return true; return ucv_is_equal(uv1, uv2); } /** * Returns a new array containing all unique values of the given input array. * * - The order is preserved, and subsequent duplicate values are skipped. * - If a non-array argument is given, the function returns `null`. * * @function module:core#uniq * * @param {Array} array * The input array. * * @returns {?Array} * * @example * uniq([1, true, "foo", 2, true, "bar", "foo"]); // Returns [1, true, "foo", 2, "bar"] * uniq("test"); // Returns null */ static uc_value_t * uc_uniq(uc_vm_t *vm, size_t nargs) { uc_value_t *list = uc_fn_arg(0); uc_value_t *uniq = NULL; struct lh_table *seen; unsigned long hash; uc_value_t *item; size_t i, len; if (ucv_type(list) != UC_ARRAY) return NULL; seen = lh_table_new(16, NULL, uc_uniq_ucv_hash, uc_uniq_ucv_equal); uniq = ucv_array_new(vm); assert(seen && uniq); for (i = 0, len = ucv_array_length(list); i < len; i++) { item = ucv_array_get(list, i); hash = lh_get_hash(seen, item); if (!lh_table_lookup_entry_w_hash(seen, item, hash)) { lh_table_insert_w_hash(seen, item, NULL, hash, 0); ucv_array_push(uniq, ucv_get(item)); } } lh_table_free(seen); return uniq; } /** * A time spec is a plain object describing a point in time, it is returned by * the {@link module:core#gmtime|gmtime()} and * {@link module:core#localtime|localtime()} functions and expected as parameter * by the complementary {@link module:core#timegm|timegm()} and * {@link module:core#timelocal|timelocal()} functions. * * When returned by `gmtime()` or `localtime()`, all members of the object will * be initialized, when passed as argument to `timegm()` or `timelocal()`, most * member values are optional. * * @typedef {Object} module:core.TimeSpec * @property {number} sec - Seconds (0..60) * @property {number} min - Minutes (0..59) * @property {number} hour - Hours (0..23) * @property {number} mday - Day of month (1..31) * @property {number} mon - Month (1..12) * @property {number} year - Year (>= 1900) * @property {number} wday - Day of week (1..7, Sunday = 7) * @property {number} yday - Day of year (1-366, Jan 1st = 1) * @property {number} isdst - Daylight saving time in effect (yes = 1) */ static uc_value_t * uc_gettime_common(uc_vm_t *vm, size_t nargs, bool local) { uc_value_t *ts = uc_fn_arg(0), *res; time_t t = ts ? (time_t)ucv_to_integer(ts) : time(NULL); struct tm *tm = (local ? localtime : gmtime)(&t); if (!tm) return NULL; res = ucv_object_new(vm); ucv_object_add(res, "sec", ucv_int64_new(tm->tm_sec)); ucv_object_add(res, "min", ucv_int64_new(tm->tm_min)); ucv_object_add(res, "hour", ucv_int64_new(tm->tm_hour)); ucv_object_add(res, "mday", ucv_int64_new(tm->tm_mday)); ucv_object_add(res, "mon", ucv_int64_new(tm->tm_mon + 1)); ucv_object_add(res, "year", ucv_int64_new(tm->tm_year + 1900)); ucv_object_add(res, "wday", ucv_int64_new(tm->tm_wday ? tm->tm_wday : 7)); ucv_object_add(res, "yday", ucv_int64_new(tm->tm_yday + 1)); ucv_object_add(res, "isdst", ucv_int64_new(tm->tm_isdst)); return res; } /** * Return the given epoch timestamp (or now, if omitted) as a dictionary * containing broken-down date and time information according to the local * system timezone. * * See {@link module:core.TimeSpec|TimeSpec} for a description of the fields. * * Note that in contrast to the underlying `localtime(3)` C library function, * the values for `mon`, `wday`, and `yday` are 1-based, and the `year` is * 1900-based. * * @function module:core#localtime * * @param {number} [epoch] * The epoch timestamp. * * @returns {module:core.TimeSpec} * * @example * localtime(1647953502); * // Returns: * // { * // sec: 42, * // min: 51, * // hour: 13, * // mday: 22, * // mon: 3, * // year: 2022, * // wday: 2, * // yday: 81, * // isdst: 0 * // } */ static uc_value_t * uc_localtime(uc_vm_t *vm, size_t nargs) { return uc_gettime_common(vm, nargs, true); } /** * Like `localtime()` but interpreting the given epoch value as UTC time. * * See {@link module:core#localtime|localtime()} for details on the return value. * * @function module:core#gmtime * * @param {number} [epoch] * The epoch timestamp. * * @returns {module:core.TimeSpec} * * @example * gmtime(1647953502); * // Returns: * // { * // sec: 42, * // min: 51, * // hour: 13, * // mday: 22, * // mon: 3, * // year: 2022, * // wday: 2, * // yday: 81, * // isdst: 0 * // } */ static uc_value_t * uc_gmtime(uc_vm_t *vm, size_t nargs) { return uc_gettime_common(vm, nargs, false); } static uc_value_t * uc_mktime_common(uc_vm_t *vm, size_t nargs, bool local) { #define FIELD(name, required) \ { #name, required, offsetof(struct tm, tm_##name) } const struct { const char *name; bool required; size_t off; } fields[] = { FIELD(sec, false), FIELD(min, false), FIELD(hour, false), FIELD(mday, true), FIELD(mon, true), FIELD(year, true), FIELD(isdst, false) }; uc_value_t *to = uc_fn_arg(0), *v; struct tm tm = { 0 }; bool exists; time_t t; size_t i; if (ucv_type(to) != UC_OBJECT) return NULL; for (i = 0; i < ARRAY_SIZE(fields); i++) { v = ucv_object_get(to, fields[i].name, &exists); if (!exists && fields[i].required) return NULL; *(int *)((char *)&tm + fields[i].off) = (int)ucv_to_integer(v); } if (tm.tm_mon > 0) tm.tm_mon--; if (tm.tm_year >= 1900) tm.tm_year -= 1900; t = (local ? mktime : timegm)(&tm); return (t != (time_t)-1) ? ucv_int64_new((int64_t)t) : NULL; } /** * Performs the inverse operation of {@link module:core#localtime|localtime()} * by taking a broken-down date and time dictionary and transforming it into an * epoch value according to the local system timezone. * * The `wday` and `yday` fields of the given date time specification are * ignored. Field values outside of their valid range are internally normalized, * e.g. October 40th is interpreted as November 9th. * * Returns the resulting epoch value or null if the input date time dictionary * was invalid or if the date time specification cannot be represented as epoch * value. * * @function module:core#timelocal * * @param {module:core.TimeSpec} datetimespec * The broken-down date and time dictionary. * * @returns {?number} * * @example * timelocal({ "sec": 42, "min": 51, "hour": 13, "mday": 22, "mon": 3, "year": 2022, "isdst": 0 }); * // Returns 1647953502 */ static uc_value_t * uc_timelocal(uc_vm_t *vm, size_t nargs) { return uc_mktime_common(vm, nargs, true); } /** * Like `timelocal()` but interpreting the given date time specification as UTC * time. * * See {@link module:core#timelocal|timelocal()} for details. * * @function module:core#timegm * * @param {module:core.TimeSpec} datetimespec * The broken-down date and time dictionary. * * @returns {?number} * * @example * timegm({ "sec": 42, "min": 51, "hour": 13, "mday": 22, "mon": 3, "year": 2022, "isdst": 0 }); * // Returns 1647953502 */ static uc_value_t * uc_timegm(uc_vm_t *vm, size_t nargs) { return uc_mktime_common(vm, nargs, false); } /** * Reads the current second and microsecond value of the system clock. * * By default, the realtime clock is queried which might skew forwards or * backwards due to NTP changes, system sleep modes etc. If a truish value is * passed as argument, the monotonic system clock is queried instead, which will * return the monotonically increasing time since some arbitrary point in the * past (usually the system boot time). * * Returns a two element array containing the full seconds as the first element * and the nanosecond fraction as the second element. * * Returns `null` if a monotonic clock value is requested and the system does * not implement this clock type. * * @function module:core#clock * * @param {boolean} [monotonic] * Whether to query the monotonic system clock. * * @returns {?number[]} * * @example * clock(); // [ 1647954926, 798269464 ] * clock(true); // [ 474751, 527959975 ] */ static uc_value_t * uc_clock(uc_vm_t *vm, size_t nargs) { clockid_t id = ucv_is_truish(uc_fn_arg(0)) ? CLOCK_MONOTONIC : CLOCK_REALTIME; struct timespec ts; uc_value_t *res; if (clock_gettime(id, &ts) == -1) return NULL; res = ucv_array_new(vm); ucv_array_set(res, 0, ucv_int64_new((int64_t)ts.tv_sec)); ucv_array_set(res, 1, ucv_int64_new((int64_t)ts.tv_nsec)); return res; } /** * Encodes the given byte string into a hexadecimal digit string, converting * the input value to a string if needed. * * @function module:core#hexenc * * @param {string} val * The byte string to encode. * * @returns {string} * * @example * hexenc("Hello world!\n"); // "48656c6c6f20776f726c64210a" */ static uc_value_t * uc_hexenc(uc_vm_t *vm, size_t nargs) { const char *hex = "0123456789abcdef"; uc_value_t *input = uc_fn_arg(0); uc_stringbuf_t *buf; size_t off, len; uint8_t byte; if (!input) return NULL; buf = ucv_stringbuf_new(); off = printbuf_length(buf); ucv_to_stringbuf(vm, buf, input, false); len = printbuf_length(buf) - off; /* memset the last expected output char to grow the output buffer */ printbuf_memset(buf, off + len * 2, 0, 1); /* translate string into hex back to front to reuse the same buffer */ while (len > 0) { byte = buf->buf[--len + off]; buf->buf[off + len * 2 + 0] = hex[byte / 16]; buf->buf[off + len * 2 + 1] = hex[byte % 16]; } /* do not include sentinel `\0` in string length */ buf->bpos--; return ucv_stringbuf_finish(buf); } static inline uint8_t hexval(unsigned char c, bool lo) { return ((c > '9') ? (c - 'a') + 10 : c - '0') << (lo ? 0 : 4); } /** * Decodes the given hexadecimal digit string into a byte string, optionally * skipping specified characters. * * If the characters to skip are not specified, a default of `" \t\n"` is used. * * Returns null if the input string contains invalid characters or an uneven * amount of hex digits. * * Returns the decoded byte string on success. * * @function module:core#hexdec * * @param {string} hexstring * The hexadecimal digit string to decode. * * @param {string} [skipchars] * The characters to skip during decoding. * * @returns {?string} * * @example * hexdec("48656c6c6f20776f726c64210a"); // "Hello world!\n" * hexdec("44:55:66:77:33:44", ":"); // "DUfw3D" */ static uc_value_t * uc_hexdec(uc_vm_t *vm, size_t nargs) { uc_value_t *input = uc_fn_arg(0); uc_value_t *skip = uc_fn_arg(1); size_t len, off, n, i; uc_stringbuf_t *buf; unsigned char *p; const char *s; if (ucv_type(input) != UC_STRING) return NULL; if (skip && ucv_type(skip) != UC_STRING) return NULL; p = (unsigned char *)ucv_string_get(input); len = ucv_string_length(input); s = skip ? (const char *)ucv_string_get(skip) : " \t\n"; for (i = 0, n = 0; i < len; i++) { if (isxdigit(p[i])) n++; else if (!s || !strchr(s, p[i])) return NULL; } if (n & 1) return NULL; buf = ucv_stringbuf_new(); off = printbuf_length(buf); /* preallocate the output buffer */ printbuf_memset(buf, off, 0, n / 2 + 1); for (i = 0, n = 0; i < len; i++) { if (!isxdigit(p[i])) continue; buf->buf[off + (n >> 1)] |= hexval(p[i] | 32, n & 1); n++; } /* do not include sentinel `\0` in string length */ buf->bpos--; return ucv_stringbuf_finish(buf); } /** * Interacts with the mark and sweep garbage collector of the running ucode * virtual machine. * * Depending on the given `operation` string argument, the meaning of `argument` * and the function return value differs. * * The following operations are defined: * * - `collect` - Perform a complete garbage collection cycle, returns `true`. * - `start` - (Re-)start periodic garbage collection, `argument` is an optional * integer in the range `1..65535` specifying the interval. * Defaults to `1000` if omitted. Returns `true` if the periodic GC * was previously stopped and is now started or if the interval * changed. Returns `false` otherwise. * - `stop` - Stop periodic garbage collection. Returns `true` if the periodic * GC was previously started and is now stopped, `false` otherwise. * - `count` - Count the amount of active complex object references in the VM * context, returns the counted amount. * * If the `operation` argument is omitted, the default is `collect`. * * @function module:core#gc * * @param {string} [operation] * The operation to perform. * * @param {*} [argument] * The argument for the operation. * * @returns {?(boolean|number)} * * @example * gc(); // true * gc("start"); // true * gc("count"); // 42 */ static uc_value_t * uc_gc(uc_vm_t *vm, size_t nargs) { uc_value_t *operation = uc_fn_arg(0); uc_value_t *argument = uc_fn_arg(1); const char *op = NULL; uc_weakref_t *ref; int64_t n; if (operation != NULL && ucv_type(operation) != UC_STRING) return NULL; op = ucv_string_get(operation); if (!op || !strcmp(op, "collect")) { ucv_gc(vm); return ucv_boolean_new(true); } else if (!strcmp(op, "start")) { n = argument ? ucv_int64_get(argument) : 0; if (errno || n < 0 || n > 0xFFFF) return NULL; if (n == 0) n = GC_DEFAULT_INTERVAL; return ucv_boolean_new(uc_vm_gc_start(vm, n)); } else if (!strcmp(op, "stop")) { return ucv_boolean_new(uc_vm_gc_stop(vm)); } else if (!strcmp(op, "count")) { for (n = 0, ref = vm->values.next; ref != &vm->values; ref = ref->next) n++; return ucv_uint64_new(n); } return NULL; } /** * A parse configuration is a plain object describing options to use when * compiling ucode at runtime. It is expected as parameter by the * {@link module:core#loadfile|loadfile()} and * {@link module:core#loadstring|loadstring()} functions. * * All members of the parse configuration object are optional and will default * to the state of the running ucode file if omitted. * * @typedef {Object} module:core.ParseConfig * * @property {boolean} lstrip_blocks * Whether to strip whitespace preceeding template directives. * See {@link tutorial-02-syntax.html#whitespace-handling|Whitespace handling}. * * @property {boolean} trim_blocks * Whether to trim trailing newlines following template directives. * See {@link tutorial-02-syntax.html#whitespace-handling|Whitespace handling}. * * @property {boolean} strict_declarations * Whether to compile the code in strict mode (`true`) or not (`false`). * * @property {boolean} raw_mode * Whether to compile the code in plain script mode (`true`) or not (`false`). * * @property {string[]} module_search_path * Override the module search path for compile time imports while compiling the * ucode source. * * @property {string[]} force_dynlink_list * List of module names assumed to be dynamic library extensions, allows * compiling ucode source with import statements referring to `*.so` extensions * not present at compile time. */ static void uc_compile_parse_config(uc_parse_config_t *config, uc_value_t *spec) { uc_value_t *v, *p; size_t i, j; bool found; struct { const char *key; bool *flag; uc_search_path_t *path; } fields[] = { { "lstrip_blocks", &config->lstrip_blocks, NULL }, { "trim_blocks", &config->trim_blocks, NULL }, { "strict_declarations", &config->strict_declarations, NULL }, { "raw_mode", &config->raw_mode, NULL }, { "module_search_path", NULL, &config->module_search_path }, { "force_dynlink_list", NULL, &config->force_dynlink_list } }; for (i = 0; i < ARRAY_SIZE(fields); i++) { v = ucv_object_get(spec, fields[i].key, &found); if (!found) continue; if (fields[i].flag) { *fields[i].flag = ucv_is_truish(v); } else if (fields[i].path) { fields[i].path->count = 0; fields[i].path->entries = NULL; for (j = 0; j < ucv_array_length(v); j++) { p = ucv_array_get(v, j); if (ucv_type(p) != UC_STRING) continue; uc_vector_push(fields[i].path, ucv_string_get(p)); } } } } static uc_value_t * uc_load_common(uc_vm_t *vm, size_t nargs, uc_source_t *source) { uc_parse_config_t conf = *vm->config; uc_program_t *program; uc_value_t *closure; char *err = NULL; uc_compile_parse_config(&conf, uc_fn_arg(1)); program = uc_compile(&conf, source, &err); closure = program ? ucv_closure_new(vm, uc_program_entry(program), false) : NULL; uc_program_put(program); if (!vm->config || conf.module_search_path.entries != vm->config->module_search_path.entries) uc_vector_clear(&conf.module_search_path); if (!vm->config || conf.force_dynlink_list.entries != vm->config->force_dynlink_list.entries) uc_vector_clear(&conf.force_dynlink_list); if (!closure) { uc_error_message_indent(&err); if (source->buffer) uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Unable to compile source string:\n\n%s", err); else uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Unable to compile source file '%s':\n\n%s", source->filename, err); } uc_source_put(source); free(err); return closure; } /** * Compiles the given code string into a ucode program and returns the resulting * program entry function. * * The optional `options` dictionary overrides parse and compile options. * * - If a non-string `code` argument is given, it is implicitly converted to a * string value first. * - If `options` is omitted or a non-object value, the compile options of the * running ucode program are reused. * * See {@link module:core.ParseConfig|ParseConfig} for known keys within the * `options` object. Unrecognized keys are ignored, unspecified options default * to those of the running program. * * Returns the compiled program entry function. * * Throws an exception on compilation errors. * * @function module:core#loadstring * * @param {string} code * The code string to compile. * * @param {module:core.ParseConfig} [options] * The options for compilation. * * @returns {Function} * * @example * let fn1 = loadstring("Hello, {{ name }}", { raw_mode: false }); * * global.name = "Alice"; * fn1(); // prints `Hello, Alice` * * * let fn2 = loadstring("return 1 + 2;", { raw_mode: true }); * fn2(); // 3 */ static uc_value_t * uc_loadstring(uc_vm_t *vm, size_t nargs) { uc_value_t *code = uc_fn_arg(0); uc_source_t *source; size_t len; char *s; if (ucv_type(code) == UC_STRING) { len = ucv_string_length(code); s = xalloc(len); memcpy(s, ucv_string_get(code), len); } else { s = ucv_to_string(vm, code); len = strlen(s); } source = uc_source_new_buffer("[loadstring argument]", s, len); if (!source) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Unable to allocate source buffer: %s", strerror(errno)); return NULL; } return uc_load_common(vm, nargs, source); } /** * Compiles the given file into a ucode program and returns the resulting * program entry function. * * See {@link module:core#loadstring|`loadstring()`} for details. * * Returns the compiled program entry function. * * Throws an exception on compilation or file I/O errors. * * @function module:core#loadfile * * @param {string} path * The path of the file to compile. * * @param {module:core.ParseConfig} [options] * The options for compilation. * * @returns {Function} * * @example * loadfile("./templates/example.uc"); // function main() { ... } */ static uc_value_t * uc_loadfile(uc_vm_t *vm, size_t nargs) { uc_value_t *path = uc_fn_arg(0); uc_source_t *source; if (ucv_type(path) != UC_STRING) return NULL; source = uc_source_new_file(ucv_string_get(path)); if (!source) { uc_vm_raise_exception(vm, EXCEPTION_RUNTIME, "Unable to open source file %s: %s", ucv_string_get(path), strerror(errno)); return NULL; } return uc_load_common(vm, nargs, source); } /** * Calls the given function value with a modified environment. * * The given `ctx` argument is used as `this` context for the invoked function * and the given `scope` value as global environment. Any further arguments are * passed to the invoked function as-is. * * When `ctx` is omitted or `null`, the function will get invoked with `this` * being `null`. * * When `scope` is omitted or `null`, the function will get executed with the * current global environment of the running program. When `scope` is set to a * dictionary, the dictionary is used as global function environment. * * When the `scope` dictionary has no prototype, the current global environment * will be set as prototype, means the scope will inherit from it. * * When a scope prototype is set, it is kept. This allows passing an isolated * (sandboxed) function scope without access to the global environment. * * Any further argument is forwarded as-is to the invoked function as function * call argument. * * Returns `null` if the given function value `fn` is not callable. * * Returns the return value of the invoked function in all other cases. * * Forwards exceptions thrown by the invoked function. * * @function module:core#call * * @param {Function} fn * Function value to call. * * @param {*} [ctx=null] * `this` context for the invoked function. * * @param {Object} [scope=null] * Global environment for the invoked function. * * @param {...*} [arg] * Additional arguments to pass to the invoked function. * * @returns {*} * * @example * // Override this context * call(function() { printf("%J\n", this) }); // null * call(function() { printf("%J\n", this) }, null); // null * call(function() { printf("%J\n", this) }, { x: 1 }); // { "x": 1 } * call(function() { printf("%J\n", this) }, { x: 2 }); // { "x": 2 } * * // Run with default scope * global.a = 1; * call(function() { printf("%J\n", a) }); // 1 * * // Override scope, inherit from current global scope (implicit) * call(function() { printf("%J\n", a) }, null, { a: 2 }); // 2 * * // Override scope, inherit from current global scope (explicit) * call(function() { printf("%J\n", a) }, null, * proto({ a: 2 }, global)); // 2 * * // Override scope, don't inherit (pass `printf()` but not `a`) * call(function() { printf("%J\n", a) }, null, * proto({}, { printf })); // null * * // Forward arguments * x = call((x, y, z) => x * y * z, null, null, 2, 3, 4); // x = 24 */ static uc_value_t * uc_callfunc(uc_vm_t *vm, size_t nargs) { size_t argoff = vm->stack.count - nargs, i; uc_value_t *fn_scope, *prev_scope, *res; uc_value_t *fn = uc_fn_arg(0); uc_value_t *this = uc_fn_arg(1); uc_value_t *scope = uc_fn_arg(2); if (!ucv_is_callable(fn)) return NULL; if (scope && ucv_type(scope) != UC_OBJECT) return NULL; if (ucv_prototype_get(scope)) { fn_scope = ucv_get(scope); } else if (scope) { fn_scope = ucv_object_new(vm); ucv_object_foreach(scope, k, v) ucv_object_add(fn_scope, k, ucv_get(v)); ucv_prototype_set(fn_scope, ucv_get(uc_vm_scope_get(vm))); } else { fn_scope = NULL; } uc_vm_stack_push(vm, ucv_get(this)); uc_vm_stack_push(vm, ucv_get(fn)); for (i = 3; i < nargs; i++) uc_vm_stack_push(vm, ucv_get(vm->stack.entries[3 + argoff++])); if (fn_scope) { prev_scope = ucv_get(uc_vm_scope_get(vm)); uc_vm_scope_set(vm, fn_scope); } if (uc_vm_call(vm, true, i - 3) == EXCEPTION_NONE) res = uc_vm_stack_pop(vm); else res = NULL; if (fn_scope) uc_vm_scope_set(vm, prev_scope); return res; } /** * Set or query process signal handler function. * * When invoked with two arguments, a signal specification and a signal handler * value, this function configures a new process signal handler. * * When invoked with one argument, a signal specification, this function returns * the currently configured handler for the given signal. * * The signal specification might either be an integer signal number or a string * value containing a signal name (with or without "SIG" prefix). Signal names * are treated case-insensitively. * * The signal handler might be either a callable function value or one of the * two special string values `"ignore"` and `"default"`. Passing `"ignore"` will * mask the given process signal while `"default"` will restore the operating * systems default behaviour for the given signal. * * In case a callable handler function is provided, it is invoked at the * earliest opportunity after receiving the corresponding signal from the * operating system. The invoked function will receive a single argument, the * number of the signal it is invoked for. * * Note that within the ucode VM, process signals are not immediately delivered, * instead the VM keeps track of received signals and delivers them to the ucode * script environment at the next opportunity, usually before executing the next * byte code instruction. This means that if a signal is received while * performing a computationally expensive operation in C mode, such as a complex * regexp match, the corresponding ucode signal handler will only be invoked * after that operation concluded and control flow returns to the VM. * * Returns the signal handler function or one of the special values `"ignore"` * or `"default"` corresponding to the given signal specification. * * Returns `null` if an invalid signal spec or signal handler was provided. * * Returns `null` if changing the signal action failed, e.g. due to insufficient * permission, or when attempting to ignore a non-ignorable signal. * * @function module:core#signal * * @param {number|string} signal * The signal to query/set handler for. * * @param {Function|string} [handler] * The signal handler to install for the given signal. * * @returns {Function|string} * * @example * // Ignore signals * signal('INT', 'ignore'); // "ignore" * signal('SIGINT', 'ignore'); // "ignore" (equivalent to 'INT') * signal('sigterm', 'ignore'); // "ignore" (signal names are case insensitive) * signal(9, 'ignore'); // null (SIGKILL cannot be ignored) * * // Restore signal default behavior * signal('INT', 'default'); // "default" * signal('foobar', 'default'); // null (unknown signal name) * signal(-313, 'default'); // null (invalid signal number) * * // Set custom handler function * function intexit(signo) { * printf("I received signal number %d\n", signo); * exit(1); * } * * signal('SIGINT', intexit); // returns intexit * signal('SIGINT') == intexit; // true */ static uc_value_t * uc_signal(uc_vm_t *vm, size_t nargs) { uc_value_t *signame = uc_fn_arg(0); uc_value_t *sighandler = uc_fn_arg(1); struct sigaction sa = { 0 }; char *sigstr; int sig; if (ucv_type(signame) == UC_INTEGER) { sig = (int)ucv_int64_get(signame); if (errno || sig < 0 || sig >= UC_SYSTEM_SIGNAL_COUNT) return NULL; if (!uc_system_signal_names[sig]) return NULL; } else if (ucv_type(signame) == UC_STRING) { sigstr = ucv_string_get(signame); if (!strncasecmp(sigstr, "SIG", 3)) sigstr += 3; for (sig = 0; sig < UC_SYSTEM_SIGNAL_COUNT; sig++) if (uc_system_signal_names[sig] && !strcasecmp(uc_system_signal_names[sig], sigstr)) break; if (sig == UC_SYSTEM_SIGNAL_COUNT) return NULL; } else { return NULL; } /* Query current signal handler state */ if (nargs < 2) { if (sigaction(sig, NULL, &sa) != 0) return NULL; if (sa.sa_handler == SIG_IGN) return ucv_string_new("ignore"); if (sa.sa_handler == SIG_DFL) return ucv_string_new("default"); return ucv_get(ucv_array_get(vm->signal.handler, sig)); } /* Install new signal handler */ if (ucv_type(sighandler) == UC_STRING) { sigstr = ucv_string_get(sighandler); sa.sa_flags = SA_ONSTACK | SA_RESTART; sigemptyset(&sa.sa_mask); if (!strcmp(sigstr, "ignore")) sa.sa_handler = SIG_IGN; else if (!strcmp(sigstr, "default")) sa.sa_handler = SIG_DFL; else return NULL; if (sigaction(sig, &sa, NULL) != 0) return NULL; ucv_array_set(vm->signal.handler, sig, NULL); } else if (ucv_is_callable(sighandler)) { if (sigaction(sig, &vm->signal.sa, NULL) != 0) return NULL; ucv_array_set(vm->signal.handler, sig, ucv_get(sighandler)); } else { return NULL; } return ucv_get(sighandler); } const uc_function_list_t uc_stdlib_functions[] = { { "chr", uc_chr }, { "die", uc_die }, { "exists", uc_exists }, { "exit", uc_exit }, { "filter", uc_filter }, { "getenv", uc_getenv }, { "hex", uc_hex }, { "index", uc_lindex }, { "int", uc_int }, { "join", uc_join }, { "keys", uc_keys }, { "lc", uc_lc }, { "length", uc_length }, { "ltrim", uc_ltrim }, { "map", uc_map }, { "ord", uc_ord }, { "pop", uc_pop }, { "print", uc_print }, { "push", uc_push }, { "reverse", uc_reverse }, { "rindex", uc_rindex }, { "rtrim", uc_rtrim }, { "shift", uc_shift }, { "sort", uc_sort }, { "splice", uc_splice }, { "slice", uc_slice }, { "split", uc_split }, { "substr", uc_substr }, { "time", uc_time }, { "trim", uc_trim }, { "type", uc_type }, { "uchr", uc_uchr }, { "uc", uc_uc }, { "unshift", uc_unshift }, { "values", uc_values }, { "sprintf", uc_sprintf }, { "printf", uc_printf }, { "require", uc_require }, { "iptoarr", uc_iptoarr }, { "arrtoip", uc_arrtoip }, { "match", uc_match }, { "replace", uc_replace }, { "json", uc_json }, { "include", uc_include }, { "warn", uc_warn }, { "system", uc_system }, { "trace", uc_trace }, { "proto", uc_proto }, { "sleep", uc_sleep }, { "assert", uc_assert }, { "render", uc_render }, { "regexp", uc_regexp }, { "wildcard", uc_wildcard }, { "sourcepath", uc_sourcepath }, { "min", uc_min }, { "max", uc_max }, { "b64dec", uc_b64dec }, { "b64enc", uc_b64enc }, { "uniq", uc_uniq }, { "localtime", uc_localtime }, { "gmtime", uc_gmtime }, { "timelocal", uc_timelocal }, { "timegm", uc_timegm }, { "clock", uc_clock }, { "hexdec", uc_hexdec }, { "hexenc", uc_hexenc }, { "gc", uc_gc }, { "loadstring", uc_loadstring }, { "loadfile", uc_loadfile }, { "call", uc_callfunc }, { "signal", uc_signal }, }; void uc_stdlib_load(uc_value_t *scope) { uc_function_list_register(scope, uc_stdlib_functions); } uc_cfn_ptr_t uc_stdlib_function(const char *name) { size_t i; for (i = 0; i < ARRAY_SIZE(uc_stdlib_functions); i++) if (!strcmp(uc_stdlib_functions[i].name, name)) return uc_stdlib_functions[i].func; return NULL; }