mirror of
https://github.com/stedolan/jq.git
synced 2024-05-11 05:55:39 +00:00
612 lines
19 KiB
C
612 lines
19 KiB
C
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "builtin.h"
|
|
#include "compile.h"
|
|
#include "jq_parser.h"
|
|
#include "locfile.h"
|
|
#include "jv_aux.h"
|
|
#include "jv_unicode.h"
|
|
#include "main.h"
|
|
|
|
|
|
|
|
typedef jv (*func_1)(jv);
|
|
typedef jv (*func_2)(jv,jv);
|
|
typedef jv (*func_3)(jv,jv,jv);
|
|
typedef jv (*func_4)(jv,jv,jv,jv);
|
|
typedef jv (*func_5)(jv,jv,jv,jv,jv);
|
|
jv cfunction_invoke(struct cfunction* function, jv input[]) {
|
|
switch (function->nargs) {
|
|
case 1: return ((func_1)function->fptr)(input[0]);
|
|
case 2: return ((func_2)function->fptr)(input[0], input[1]);
|
|
case 3: return ((func_3)function->fptr)(input[0], input[1], input[2]);
|
|
case 4: return ((func_4)function->fptr)(input[0], input[1], input[2], input[3]);
|
|
case 5: return ((func_5)function->fptr)(input[0], input[1], input[2], input[3], input[4]);
|
|
default: return jv_invalid_with_msg(jv_string("Function takes too many arguments"));
|
|
}
|
|
}
|
|
|
|
static jv type_error(jv bad, const char* msg) {
|
|
jv err = jv_invalid_with_msg(jv_string_fmt("%s %s",
|
|
jv_kind_name(jv_get_kind(bad)),
|
|
msg));
|
|
jv_free(bad);
|
|
return err;
|
|
}
|
|
|
|
static jv type_error2(jv bad1, jv bad2, const char* msg) {
|
|
jv err = jv_invalid_with_msg(jv_string_fmt("%s and %s %s",
|
|
jv_kind_name(jv_get_kind(bad1)),
|
|
jv_kind_name(jv_get_kind(bad2)),
|
|
msg));
|
|
jv_free(bad1);
|
|
jv_free(bad2);
|
|
return err;
|
|
}
|
|
|
|
static jv f_plus(jv input, jv a, jv b) {
|
|
jv_free(input);
|
|
if (jv_get_kind(a) == JV_KIND_NULL) {
|
|
jv_free(a);
|
|
return b;
|
|
} else if (jv_get_kind(b) == JV_KIND_NULL) {
|
|
jv_free(b);
|
|
return a;
|
|
} else if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
|
return jv_number(jv_number_value(a) +
|
|
jv_number_value(b));
|
|
} else if (jv_get_kind(a) == JV_KIND_STRING && jv_get_kind(b) == JV_KIND_STRING) {
|
|
return jv_string_concat(a, b);
|
|
} else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
|
|
return jv_array_concat(a, b);
|
|
} else if (jv_get_kind(a) == JV_KIND_OBJECT && jv_get_kind(b) == JV_KIND_OBJECT) {
|
|
return jv_object_merge(a, b);
|
|
} else {
|
|
return type_error2(a, b, "cannot be added");
|
|
}
|
|
}
|
|
|
|
static jv f_negate(jv input) {
|
|
if (jv_get_kind(input) != JV_KIND_NUMBER) {
|
|
return type_error(input, "cannot be negated");
|
|
}
|
|
jv ret = jv_number(-jv_number_value(input));
|
|
jv_free(input);
|
|
return ret;
|
|
}
|
|
|
|
static jv f_minus(jv input, jv a, jv b) {
|
|
jv_free(input);
|
|
if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
|
return jv_number(jv_number_value(a) - jv_number_value(b));
|
|
} else if (jv_get_kind(a) == JV_KIND_ARRAY && jv_get_kind(b) == JV_KIND_ARRAY) {
|
|
jv out = jv_array();
|
|
jv_array_foreach(a, i, x) {
|
|
int include = 1;
|
|
jv_array_foreach(b, j, y) {
|
|
if (jv_equal(jv_copy(x), y)) {
|
|
include = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (include)
|
|
out = jv_array_append(out, jv_copy(x));
|
|
jv_free(x);
|
|
}
|
|
jv_free(a);
|
|
jv_free(b);
|
|
return out;
|
|
} else {
|
|
return type_error2(a, b, "cannot be subtracted");
|
|
}
|
|
}
|
|
|
|
static jv f_multiply(jv input, jv a, jv b) {
|
|
jv_free(input);
|
|
if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
|
return jv_number(jv_number_value(a) * jv_number_value(b));
|
|
} else {
|
|
return type_error2(a, b, "cannot be multiplied");
|
|
}
|
|
}
|
|
|
|
static jv f_divide(jv input, jv a, jv b) {
|
|
jv_free(input);
|
|
if (jv_get_kind(a) == JV_KIND_NUMBER && jv_get_kind(b) == JV_KIND_NUMBER) {
|
|
return jv_number(jv_number_value(a) / jv_number_value(b));
|
|
} else {
|
|
return type_error2(a, b, "cannot be divided");
|
|
}
|
|
}
|
|
|
|
static jv f_equal(jv input, jv a, jv b) {
|
|
jv_free(input);
|
|
return jv_bool(jv_equal(a, b));
|
|
}
|
|
|
|
static jv f_notequal(jv input, jv a, jv b) {
|
|
jv_free(input);
|
|
return jv_bool(!jv_equal(a, b));
|
|
}
|
|
|
|
enum cmp_op {
|
|
CMP_OP_LESS,
|
|
CMP_OP_GREATER,
|
|
CMP_OP_LESSEQ,
|
|
CMP_OP_GREATEREQ
|
|
};
|
|
|
|
static jv order_cmp(jv input, jv a, jv b, enum cmp_op op) {
|
|
jv_free(input);
|
|
int r = jv_cmp(a, b);
|
|
return jv_bool((op == CMP_OP_LESS && r < 0) ||
|
|
(op == CMP_OP_LESSEQ && r <= 0) ||
|
|
(op == CMP_OP_GREATEREQ && r >= 0) ||
|
|
(op == CMP_OP_GREATER && r > 0));
|
|
}
|
|
|
|
static jv f_less(jv input, jv a, jv b) {
|
|
return order_cmp(input, a, b, CMP_OP_LESS);
|
|
}
|
|
|
|
static jv f_greater(jv input, jv a, jv b) {
|
|
return order_cmp(input, a, b, CMP_OP_GREATER);
|
|
}
|
|
|
|
static jv f_lesseq(jv input, jv a, jv b) {
|
|
return order_cmp(input, a, b, CMP_OP_LESSEQ);
|
|
}
|
|
|
|
static jv f_greatereq(jv input, jv a, jv b) {
|
|
return order_cmp(input, a, b, CMP_OP_GREATEREQ);
|
|
}
|
|
|
|
static jv f_contains(jv a, jv b) {
|
|
if (jv_get_kind(a) == jv_get_kind(b)) {
|
|
return jv_bool(jv_contains(a, b));
|
|
} else {
|
|
return type_error2(a, b, "cannot have their containment checked");
|
|
}
|
|
}
|
|
|
|
static jv f_tonumber(jv input) {
|
|
if (jv_get_kind(input) == JV_KIND_NUMBER) {
|
|
return input;
|
|
}
|
|
if (jv_get_kind(input) == JV_KIND_STRING) {
|
|
jv parsed = jv_parse(jv_string_value(input));
|
|
if (!jv_is_valid(parsed) || jv_get_kind(parsed) == JV_KIND_NUMBER) {
|
|
jv_free(input);
|
|
return parsed;
|
|
}
|
|
}
|
|
return type_error(input, "cannot be parsed as a number");
|
|
}
|
|
|
|
static jv f_length(jv input) {
|
|
if (jv_get_kind(input) == JV_KIND_ARRAY) {
|
|
return jv_number(jv_array_length(input));
|
|
} else if (jv_get_kind(input) == JV_KIND_OBJECT) {
|
|
return jv_number(jv_object_length(input));
|
|
} else if (jv_get_kind(input) == JV_KIND_STRING) {
|
|
return jv_number(jv_string_length_codepoints(input));
|
|
} else if (jv_get_kind(input) == JV_KIND_NULL) {
|
|
jv_free(input);
|
|
return jv_number(0);
|
|
} else {
|
|
return type_error(input, "has no length");
|
|
}
|
|
}
|
|
|
|
static jv f_tostring(jv input) {
|
|
if (jv_get_kind(input) == JV_KIND_STRING) {
|
|
return input;
|
|
} else {
|
|
return jv_dump_string(input, 0);
|
|
}
|
|
}
|
|
|
|
#define CHARS_ALPHANUM "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
|
|
|
|
static jv escape_string(jv input, const char* escapings) {
|
|
|
|
assert(jv_get_kind(input) == JV_KIND_STRING);
|
|
const char* lookup[128] = {0};
|
|
const char* p = escapings;
|
|
while (*p) {
|
|
lookup[(int)*p] = p+1;
|
|
p++;
|
|
p += strlen(p);
|
|
p++;
|
|
}
|
|
|
|
jv ret = jv_string("");
|
|
const char* i = jv_string_value(input);
|
|
const char* end = i + jv_string_length_bytes(jv_copy(input));
|
|
const char* cstart;
|
|
int c = 0;
|
|
while ((i = jvp_utf8_next((cstart = i), end, &c))) {
|
|
assert(c != -1);
|
|
if (c < 128 && lookup[c]) {
|
|
ret = jv_string_append_str(ret, lookup[c]);
|
|
} else {
|
|
ret = jv_string_append_buf(ret, cstart, i - cstart);
|
|
}
|
|
}
|
|
jv_free(input);
|
|
return ret;
|
|
|
|
}
|
|
|
|
static jv f_format(jv input, jv fmt) {
|
|
if (jv_get_kind(fmt) != JV_KIND_STRING) {
|
|
jv_free(input);
|
|
return type_error(fmt, "is not a valid format");
|
|
}
|
|
const char* fmt_s = jv_string_value(fmt);
|
|
if (!strcmp(fmt_s, "json")) {
|
|
jv_free(fmt);
|
|
return jv_dump_string(input, 0);
|
|
} else if (!strcmp(fmt_s, "text")) {
|
|
jv_free(fmt);
|
|
return f_tostring(input);
|
|
} else if (!strcmp(fmt_s, "csv")) {
|
|
jv_free(fmt);
|
|
if (jv_get_kind(input) != JV_KIND_ARRAY)
|
|
return type_error(input, "cannot be csv-formatted, only array");
|
|
jv line = jv_string("");
|
|
jv_array_foreach(input, i, x) {
|
|
if (i) line = jv_string_append_str(line, ",");
|
|
switch (jv_get_kind(x)) {
|
|
case JV_KIND_NULL:
|
|
/* null rendered as empty string */
|
|
jv_free(x);
|
|
break;
|
|
case JV_KIND_TRUE:
|
|
case JV_KIND_FALSE:
|
|
line = jv_string_concat(line, jv_dump_string(x, 0));
|
|
break;
|
|
case JV_KIND_NUMBER:
|
|
if (jv_number_value(x) != jv_number_value(x)) {
|
|
/* NaN, render as empty string */
|
|
jv_free(x);
|
|
} else {
|
|
line = jv_string_concat(line, jv_dump_string(x, 0));
|
|
}
|
|
break;
|
|
case JV_KIND_STRING: {
|
|
line = jv_string_append_str(line, "\"");
|
|
line = jv_string_concat(line, escape_string(x, "\"\"\"\0"));
|
|
line = jv_string_append_str(line, "\"");
|
|
break;
|
|
}
|
|
default:
|
|
jv_free(input);
|
|
jv_free(line);
|
|
return type_error(x, "is not valid in a csv row");
|
|
}
|
|
}
|
|
jv_free(input);
|
|
return line;
|
|
} else if (!strcmp(fmt_s, "html")) {
|
|
jv_free(fmt);
|
|
return escape_string(f_tostring(input), "&&\0<<\0>>\0''\0\""\0");
|
|
} else if (!strcmp(fmt_s, "uri")) {
|
|
jv_free(fmt);
|
|
input = f_tostring(input);
|
|
|
|
int unreserved[128] = {0};
|
|
const char* p = CHARS_ALPHANUM "-_.!~*'()";
|
|
while (*p) unreserved[(int)*p++] = 1;
|
|
|
|
jv line = jv_string("");
|
|
const char* s = jv_string_value(input);
|
|
for (int i=0; i<jv_string_length_bytes(jv_copy(input)); i++) {
|
|
unsigned ch = (unsigned)(unsigned char)*s;
|
|
if (ch < 128 && unreserved[ch]) {
|
|
line = jv_string_append_buf(line, s, 1);
|
|
} else {
|
|
line = jv_string_concat(line, jv_string_fmt("%%%02x", ch));
|
|
}
|
|
s++;
|
|
}
|
|
jv_free(input);
|
|
return line;
|
|
} else if (!strcmp(fmt_s, "sh")) {
|
|
jv_free(fmt);
|
|
if (jv_get_kind(input) != JV_KIND_ARRAY)
|
|
input = jv_array_set(jv_array(), 0, input);
|
|
jv line = jv_string("");
|
|
jv_array_foreach(input, i, x) {
|
|
if (i) line = jv_string_append_str(line, " ");
|
|
switch (jv_get_kind(x)) {
|
|
case JV_KIND_NULL:
|
|
case JV_KIND_TRUE:
|
|
case JV_KIND_FALSE:
|
|
case JV_KIND_NUMBER:
|
|
line = jv_string_concat(line, jv_dump_string(x, 0));
|
|
break;
|
|
|
|
case JV_KIND_STRING: {
|
|
line = jv_string_append_str(line, "'");
|
|
line = jv_string_concat(line, escape_string(x, "''\\''\0"));
|
|
line = jv_string_append_str(line, "'");
|
|
break;
|
|
}
|
|
|
|
default:
|
|
jv_free(input);
|
|
jv_free(line);
|
|
return type_error(x, "can not be escaped for shell");
|
|
}
|
|
}
|
|
jv_free(input);
|
|
return line;
|
|
} else if (!strcmp(fmt_s, "base64")) {
|
|
jv_free(fmt);
|
|
input = f_tostring(input);
|
|
jv line = jv_string("");
|
|
const char b64[64 + 1] = CHARS_ALPHANUM "+/";
|
|
const char* data = jv_string_value(input);
|
|
int len = jv_string_length_bytes(jv_copy(input));
|
|
for (int i=0; i<len; i+=3) {
|
|
uint32_t code = 0;
|
|
int n = len - i >= 3 ? 3 : len-i;
|
|
for (int j=0; j<3; j++) {
|
|
code <<= 8;
|
|
code |= j < n ? (unsigned)data[i+j] : 0;
|
|
}
|
|
char buf[4];
|
|
for (int j=0; j<4; j++) {
|
|
buf[j] = b64[(code >> (18 - j*6)) & 0x3f];
|
|
}
|
|
if (n < 3) buf[3] = '=';
|
|
if (n < 2) buf[2] = '=';
|
|
line = jv_string_append_buf(line, buf, sizeof(buf));
|
|
}
|
|
jv_free(input);
|
|
return line;
|
|
} else {
|
|
jv_free(input);
|
|
return jv_invalid_with_msg(jv_string_concat(fmt, jv_string(" is not a valid format")));
|
|
}
|
|
}
|
|
|
|
static jv f_keys(jv input) {
|
|
if (jv_get_kind(input) == JV_KIND_OBJECT || jv_get_kind(input) == JV_KIND_ARRAY) {
|
|
return jv_keys(input);
|
|
} else {
|
|
return type_error(input, "has no keys");
|
|
}
|
|
}
|
|
|
|
static jv f_sort(jv input){
|
|
if (jv_get_kind(input) == JV_KIND_ARRAY) {
|
|
return jv_sort(input, jv_copy(input));
|
|
} else {
|
|
return type_error(input, "cannot be sorted, as it is not an array");
|
|
}
|
|
}
|
|
|
|
static jv f_sort_by_impl(jv input, jv keys) {
|
|
if (jv_get_kind(input) == JV_KIND_ARRAY &&
|
|
jv_get_kind(keys) == JV_KIND_ARRAY &&
|
|
jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) {
|
|
return jv_sort(input, keys);
|
|
} else {
|
|
return type_error2(input, keys, "cannot be sorted, as they are not both arrays");
|
|
}
|
|
}
|
|
|
|
static jv f_group_by_impl(jv input, jv keys) {
|
|
if (jv_get_kind(input) == JV_KIND_ARRAY &&
|
|
jv_get_kind(keys) == JV_KIND_ARRAY &&
|
|
jv_array_length(jv_copy(input)) == jv_array_length(jv_copy(keys))) {
|
|
return jv_group(input, keys);
|
|
} else {
|
|
return type_error2(input, keys, "cannot be sorted, as they are not both arrays");
|
|
}
|
|
}
|
|
|
|
static jv minmax_by(jv values, jv keys, int is_min) {
|
|
if (jv_get_kind(values) != JV_KIND_ARRAY)
|
|
return type_error2(values, keys, "cannot be iterated over");
|
|
if (jv_get_kind(keys) != JV_KIND_ARRAY)
|
|
return type_error2(values, keys, "cannot be iterated over");
|
|
if (jv_array_length(jv_copy(values)) != jv_array_length(jv_copy(keys)))
|
|
return type_error2(values, keys, "have wrong length");
|
|
|
|
if (jv_array_length(jv_copy(values)) == 0) {
|
|
jv_free(values);
|
|
jv_free(keys);
|
|
return jv_null();
|
|
}
|
|
jv ret = jv_array_get(jv_copy(values), 0);
|
|
jv retkey = jv_array_get(jv_copy(keys), 0);
|
|
for (int i=1; i<jv_array_length(jv_copy(values)); i++) {
|
|
jv item = jv_array_get(jv_copy(keys), i);
|
|
int cmp = jv_cmp(jv_copy(item), jv_copy(retkey));
|
|
if ((cmp < 0) == (is_min == 1)) {
|
|
jv_free(retkey);
|
|
retkey = item;
|
|
jv_free(ret);
|
|
ret = jv_array_get(jv_copy(values), i);
|
|
} else {
|
|
jv_free(item);
|
|
}
|
|
}
|
|
jv_free(values);
|
|
jv_free(keys);
|
|
jv_free(retkey);
|
|
return ret;
|
|
}
|
|
|
|
static jv f_min(jv x) {
|
|
return minmax_by(x, jv_copy(x), 1);
|
|
}
|
|
|
|
static jv f_max(jv x) {
|
|
return minmax_by(x, jv_copy(x), 0);
|
|
}
|
|
|
|
static jv f_min_by_impl(jv x, jv y) {
|
|
return minmax_by(x, y, 1);
|
|
}
|
|
|
|
static jv f_max_by_impl(jv x, jv y) {
|
|
return minmax_by(x, y, 0);
|
|
}
|
|
|
|
|
|
static jv f_type(jv input) {
|
|
jv out = jv_string(jv_kind_name(jv_get_kind(input)));
|
|
jv_free(input);
|
|
return out;
|
|
}
|
|
|
|
static jv f_error(jv input, jv msg) {
|
|
jv_free(input);
|
|
msg = f_tostring(msg);
|
|
return jv_invalid_with_msg(msg);
|
|
}
|
|
|
|
static const struct cfunction function_list[] = {
|
|
{(cfunction_ptr)f_plus, "_plus", 3},
|
|
{(cfunction_ptr)f_negate, "_negate", 1},
|
|
{(cfunction_ptr)f_minus, "_minus", 3},
|
|
{(cfunction_ptr)f_multiply, "_multiply", 3},
|
|
{(cfunction_ptr)f_divide, "_divide", 3},
|
|
{(cfunction_ptr)f_tonumber, "tonumber", 1},
|
|
{(cfunction_ptr)f_tostring, "tostring", 1},
|
|
{(cfunction_ptr)f_keys, "keys", 1},
|
|
{(cfunction_ptr)jv_setpath, "setpath", 3}, // FIXME typechecking
|
|
{(cfunction_ptr)jv_getpath, "getpath", 2},
|
|
{(cfunction_ptr)jv_delpaths, "delpaths", 2},
|
|
{(cfunction_ptr)jv_has, "has", 2},
|
|
{(cfunction_ptr)f_equal, "_equal", 3},
|
|
{(cfunction_ptr)f_notequal, "_notequal", 3},
|
|
{(cfunction_ptr)f_less, "_less", 3},
|
|
{(cfunction_ptr)f_greater, "_greater", 3},
|
|
{(cfunction_ptr)f_lesseq, "_lesseq", 3},
|
|
{(cfunction_ptr)f_greatereq, "_greatereq", 3},
|
|
{(cfunction_ptr)f_contains, "contains", 2},
|
|
{(cfunction_ptr)f_length, "length", 1},
|
|
{(cfunction_ptr)f_type, "type", 1},
|
|
{(cfunction_ptr)f_sort, "sort", 1},
|
|
{(cfunction_ptr)f_sort_by_impl, "_sort_by_impl", 2},
|
|
{(cfunction_ptr)f_group_by_impl, "_group_by_impl", 2},
|
|
{(cfunction_ptr)f_min, "min", 1},
|
|
{(cfunction_ptr)f_max, "max", 1},
|
|
{(cfunction_ptr)f_min_by_impl, "_min_by_impl", 2},
|
|
{(cfunction_ptr)f_max_by_impl, "_max_by_impl", 2},
|
|
{(cfunction_ptr)f_error, "error", 2},
|
|
{(cfunction_ptr)f_format, "format", 2},
|
|
};
|
|
|
|
struct bytecoded_builtin { const char* name; block code; };
|
|
static block bind_bytecoded_builtins(block b) {
|
|
block builtins = gen_noop();
|
|
{
|
|
struct bytecoded_builtin builtin_defs[] = {
|
|
{"empty", gen_op_simple(BACKTRACK)},
|
|
{"false", gen_const(jv_false())},
|
|
{"true", gen_const(jv_true())},
|
|
{"null", gen_const(jv_null())},
|
|
{"not", gen_condbranch(gen_const(jv_false()),
|
|
gen_const(jv_true()))}
|
|
};
|
|
for (unsigned i=0; i<sizeof(builtin_defs)/sizeof(builtin_defs[0]); i++) {
|
|
builtins = BLOCK(builtins, gen_function(builtin_defs[i].name, gen_noop(),
|
|
builtin_defs[i].code));
|
|
}
|
|
}
|
|
{
|
|
struct bytecoded_builtin builtin_def_1arg[] = {
|
|
{"path", BLOCK(gen_op_simple(PATH_BEGIN),
|
|
gen_call("arg", gen_noop()),
|
|
gen_op_simple(PATH_END))},
|
|
};
|
|
for (unsigned i=0; i<sizeof(builtin_def_1arg)/sizeof(builtin_def_1arg[0]); i++) {
|
|
builtins = BLOCK(builtins, gen_function(builtin_def_1arg[i].name,
|
|
gen_op_block_unbound(CLOSURE_PARAM, "arg"),
|
|
builtin_def_1arg[i].code));
|
|
}
|
|
}
|
|
{
|
|
block rangevar = block_bind(gen_op_var_unbound(STOREV, "rangevar"),
|
|
gen_noop(), OP_HAS_VARIABLE);
|
|
block init = BLOCK(gen_op_simple(DUP), gen_call("start", gen_noop()), rangevar);
|
|
block range = BLOCK(init,
|
|
gen_call("end", gen_noop()),
|
|
gen_op_var_bound(RANGE, rangevar));
|
|
builtins = BLOCK(builtins, gen_function("range",
|
|
BLOCK(gen_op_block_unbound(CLOSURE_PARAM, "start"),
|
|
gen_op_block_unbound(CLOSURE_PARAM, "end")),
|
|
range));
|
|
}
|
|
|
|
return block_bind_referenced(builtins, b, OP_IS_CALL_PSEUDO);
|
|
}
|
|
|
|
static const char* const jq_builtins[] = {
|
|
"def map(f): [.[] | f];",
|
|
"def select(f): if f then . else empty end;",
|
|
"def sort_by(f): _sort_by_impl(map([f]));",
|
|
"def group_by(f): _group_by_impl(map([f]));",
|
|
"def unique: group_by(.) | map(.[0]);",
|
|
"def max_by(f): _max_by_impl(map([f]));",
|
|
"def min_by(f): _min_by_impl(map([f]));",
|
|
"def add: reduce .[] as $x (null; . + $x);",
|
|
"def del(f): delpaths([path(f)]);",
|
|
"def _assign(paths; value): value as $v | reduce path(paths) as $p (.; setpath($p; $v));",
|
|
"def _modify(paths; update): reduce path(paths) as $p (.; setpath($p; getpath($p) | update));",
|
|
"def recurse(f): ., (f | select(. != null) | recurse(f));",
|
|
"def to_entries: [keys[] as $k | {key: $k, value: .[$k]}];",
|
|
"def from_entries: map({(.key): .value}) | add;",
|
|
"def with_entries(f): to_entries | map(f) | from_entries;",
|
|
"def reverse: [.[length - 1 - range(0;length)]];",
|
|
};
|
|
|
|
|
|
int builtins_bind_one(block* bb, const char* code) {
|
|
struct locfile src;
|
|
locfile_init(&src, code, strlen(code));
|
|
block funcs;
|
|
int nerrors = jq_parse_library(&src, &funcs);
|
|
if (nerrors == 0) {
|
|
*bb = block_bind_referenced(funcs, *bb, OP_IS_CALL_PSEUDO);
|
|
}
|
|
locfile_free(&src);
|
|
return nerrors;
|
|
}
|
|
|
|
int slurp_lib(block* bb) {
|
|
int nerrors = 0;
|
|
char* home = getenv("HOME");
|
|
if (home) { // silently ignore no $HOME
|
|
jv filename = jv_string_append_str(jv_string(home), "/.jq");
|
|
jv data = slurp_file(jv_string_value(filename), 1);
|
|
if (jv_is_valid(data)) {
|
|
nerrors = builtins_bind_one(bb, jv_string_value(data) );
|
|
}
|
|
jv_free(filename);
|
|
jv_free(data);
|
|
}
|
|
return nerrors;
|
|
}
|
|
|
|
int builtins_bind(block* bb) {
|
|
int nerrors = slurp_lib(bb);
|
|
if (nerrors) {
|
|
block_free(*bb);
|
|
return nerrors;
|
|
}
|
|
for (int i=(int)(sizeof(jq_builtins)/sizeof(jq_builtins[0]))-1; i>=0; i--) {
|
|
nerrors = builtins_bind_one(bb, jq_builtins[i]);
|
|
assert(!nerrors);
|
|
}
|
|
*bb = bind_bytecoded_builtins(*bb);
|
|
*bb = gen_cbinding(function_list, sizeof(function_list)/sizeof(function_list[0]), *bb);
|
|
return nerrors;
|
|
}
|