static int
iter_rbk(strm_stream* strm, strm_value data)
{
struct rbk_data *d = strm->data;
strm_value k, v;
khiter_t i;
int r;
if (!strm_array_p(data) || strm_ary_len(data) != 2) {
strm_raise(strm, "reduce_by_key element must be a key-value pair");
return STRM_NG;
}
k = strm_ary_ptr(data)[0];
v = strm_ary_ptr(data)[1];
i = kh_put(rbk, d->tbl, k, &r);
if (r < 0) { /* r<0 operation failed */
return STRM_NG;
}
if (r != 0) { /* key does not exist */
kh_value(d->tbl, i) = v;
}
else {
strm_value args[3];
args[0] = k;
args[1] = kh_value(d->tbl, i);
args[2] = v;
if (strm_funcall(strm, d->func, 3, args, &v) == STRM_NG) {
return STRM_NG;
}
kh_value(d->tbl, i) = v;
}
return STRM_OK;
}
static int
exec_call(strm_stream* strm, strm_state* state, strm_string name, int argc, strm_value* argv, strm_value* ret)
{
int n = STRM_NG;
strm_value m;
if (argc > 0) {
strm_state* ns = strm_value_ns(argv[0]);
if (ns) {
n = strm_var_get(ns, name, &m);
}
else if (argc == 1 && strm_array_p(argv[0])) {
m = strm_str_value(name);
n = ary_get(strm, argv[0], 1, &m, ret);
if (n == STRM_OK) return STRM_OK;
}
}
if (n == STRM_NG) {
n = strm_var_get(state, name, &m);
}
if (n == STRM_OK) {
return strm_funcall(strm, m, argc, argv, ret);
}
strm_raise(strm, "function not found");
return STRM_NG;
}
static int
iter_minmax(strm_stream* strm, strm_value data)
{
struct minmax_data* d = strm->data;
strm_value e;
double num;
if (!strm_nil_p(d->func)) {
if (strm_funcall(strm, d->func, 1, &data, &e) == STRM_NG) {
return STRM_NG;
}
}
else {
e = data;
}
num = strm_value_float(e);
if (d->start) {
d->start = FALSE;
d->num = num;
d->data = data;
}
else if (d->min) { /* min */
if (d->num > num) {
d->num = num;
d->data = data;
}
}
else { /* max */
if (d->num < num) {
d->num = num;
d->data = data;
}
}
return STRM_OK;
}
static int
iter_each(strm_stream* strm, strm_value data)
{
struct map_data* d = strm->data;
strm_value val;
if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
return STRM_NG;
}
return STRM_OK;
}
static int
iter_map(strm_stream* strm, strm_value data)
{
struct map_data* d = strm->data;
strm_value val;
if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
return STRM_NG;
}
strm_emit(strm, val, NULL);
return STRM_OK;
}
static strm_value
convert_number(strm_stream* strm, strm_value data, strm_value func)
{
strm_value val;
if (strm_funcall(strm, func, 1, &data, &val) == STRM_NG) {
return STRM_NG;
}
if (!strm_number_p(val)) {
strm_raise(strm, "number required");
return STRM_NG;
}
return val;
}
static int
iter_filter(strm_stream* strm, strm_value data)
{
struct map_data* d = strm->data;
strm_value val;
if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
return STRM_NG;
}
if (strm_value_bool(val)) {
strm_emit(strm, data, NULL);
}
return STRM_OK;
}
static int
ary_each(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value* v;
strm_int len;
strm_value func;
strm_int i;
strm_value r;
strm_get_args(strm, argc, args, "av", &v, &len, &func);
for (i=0; i<len; i++) {
if (strm_funcall(strm, func, 1, &v[i], &r) == STRM_NG) {
return STRM_NG;
}
}
*ret = strm_ary_value(args[0]);
return STRM_OK;
}
static int
iter_reduce(strm_stream* strm, strm_value data)
{
struct reduce_data* d = strm->data;
strm_value args[2];
/* first acc */
if (!d->init) {
d->init = 1;
d->acc = data;
return STRM_OK;
}
args[0] = d->acc;
args[1] = data;
if (strm_funcall(strm, d->func, 2, args, &data) == STRM_NG) {
return STRM_NG;
}
d->acc = data;
return STRM_OK;
}
static int
flatmap_push(strm_stream* strm, strm_array ary, strm_value func, strm_value** p)
{
strm_value* v = strm_ary_ptr(ary);
strm_int i, len;
len = strm_ary_len(ary);
for (i=0; i<len; i++) {
if (strm_array_p(v[i])) {
if (flatmap_push(strm, v[i], func, p) == STRM_NG) {
return STRM_NG;
}
}
else {
if (strm_funcall(strm, func, 1, &v[i], *p) == STRM_NG) {
return STRM_NG;
}
*p += 1;
}
}
return STRM_OK;
}
static int
iter_flatmap(strm_stream* strm, strm_value data)
{
struct map_data* d = strm->data;
strm_value val;
strm_int i, len;
strm_value* e;
if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
return STRM_NG;
}
if (!strm_array_p(val)) {
strm_raise(strm, "no array given for flatmap");
return STRM_NG;
}
len = strm_ary_len(val);
e = strm_ary_ptr(val);
for (i=0; i<len; i++){
strm_emit(strm, e[i], NULL);
}
return STRM_OK;
}
static int
ary_map(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value* v;
strm_int len;
strm_value func;
strm_int i;
strm_array a2;
strm_value* v2;
strm_get_args(strm, argc, args, "av", &v, &len, &func);
a2 = strm_ary_new(NULL, len);
v2 = strm_ary_ptr(a2);
for (i=0; i<len; i++) {
if (strm_funcall(strm, func, 1, &v[i], &v2[i]) == STRM_NG) {
return STRM_NG;
}
}
*ret = strm_ary_value(a2);
return STRM_OK;
}
static int
iter_uniqf(strm_stream* strm, strm_value data)
{
struct uniq_data* d = strm->data;
strm_value val;
if (strm_funcall(strm, d->func, 1, &data, &val) == STRM_NG) {
return STRM_NG;
}
if (!d->init) {
d->init = TRUE;
d->last = data;
d->v = val;
strm_emit(strm, data, NULL);
return STRM_OK;
}
if (!strm_value_eq(val, d->v)) {
d->last = data;
d->v = val;
strm_emit(strm, data, NULL);
}
return STRM_OK;
}
strm_string
strm_to_str(strm_value v)
{
char buf[32];
int n;
strm_state* ns = strm_value_ns(v);
if (ns) {
strm_value m;
n = strm_var_get(ns, strm_str_intern_lit("string"), &m);
if (n == STRM_OK) {
n = strm_funcall(NULL, m, 1, &v, &m);
if (n == STRM_OK && strm_string_p(m)) return m;
}
}
switch (strm_value_tag(v)) {
case STRM_TAG_INT:
n = sprintf(buf, "%d", strm_to_int(v));
return strm_str_new(buf, n);
case STRM_TAG_BOOL:
n = sprintf(buf, strm_to_int(v) ? "true" : "false");
return strm_str_new(buf, n);
case STRM_TAG_CFUNC:
n = sprintf(buf, "<cfunc:%p>", (void*)strm_value_cfunc(v));
return strm_str_new(buf, n);
case STRM_TAG_STRING_I:
case STRM_TAG_STRING_6:
case STRM_TAG_STRING_O:
case STRM_TAG_STRING_F:
return strm_value_str(v);
case STRM_TAG_ARRAY:
case STRM_TAG_STRUCT:
return strm_inspect(v);
case STRM_TAG_PTR:
if (strm_value_val(v) == 0)
return strm_str_lit("nil");
else {
void *p = strm_ptr(v);
switch (strm_ptr_type(p)) {
case STRM_PTR_STREAM:
n = sprintf(buf, "<stream:%p>", p);
break;
case STRM_PTR_IO: {
strm_io io = (strm_io)p;
char *mode;
switch (io->mode & 3) {
case STRM_IO_READ:
mode = "r"; break;
case STRM_IO_WRITE:
mode = "w"; break;
case STRM_IO_READ|STRM_IO_WRITE:
mode = "rw"; break;
default:
mode = "?"; break;
}
n = sprintf(buf, "<io: fd=%d mode=%s>", io->fd, mode);
break;
}
case STRM_PTR_LAMBDA:
n = sprintf(buf, "<lambda:%p>", p);
break;
case STRM_PTR_AUX:
n = sprintf(buf, "<obj:%p>", p);
break;
}
return strm_str_new(buf, n);
}
default:
if (strm_flt_p(v)) {
n = sprintf(buf, "%.14g", strm_to_flt(v));
return strm_str_new(buf, n);
}
n = sprintf(buf, "<%p>", strm_value_vptr(v));
return strm_str_new(buf, n);
}
/* not reached */
return strm_str_null;
}
