static int
exec_minus(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
if (argc == 1) {
if (strm_int_p(args[0])) {
*ret = strm_int_value(-strm_value_int(args[0]));
return STRM_OK;
}
if (strm_flt_p(args[0])) {
*ret = strm_flt_value(-strm_value_flt(args[0]));
return STRM_OK;
}
return STRM_NG;
}
assert(argc == 2);
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])-strm_value_int(args[1]));
return STRM_OK;
}
if (strm_num_p(args[0])) {
*ret = strm_flt_value(strm_value_flt(args[0])-strm_value_flt(args[1]));
return STRM_OK;
}
return STRM_NG;
}
static int
exec_minus(node_ctx* ctx, int argc, strm_value* args, strm_value* ret)
{
if (argc == 1) {
if (strm_int_p(args[0])) {
*ret = strm_int_value(-strm_value_int(args[0]));
return 0;
}
if (strm_flt_p(args[0])) {
*ret = strm_flt_value(-strm_value_flt(args[0]));
return 0;
}
return 1;
}
assert(argc == 2);
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])-strm_value_int(args[1]));
return 0;
}
else if (strm_num_p(args[0])) {
*ret = strm_flt_value(strm_value_flt(args[0])-strm_value_flt(args[1]));
return 0;
}
return 1;
}
static int
exec_plus(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
assert(argc == 2);
if (strm_string_p(*args)) {
strm_string str1 = strm_value_str(args[0]);
strm_string str2 = strm_value_str(args[1]);
strm_string str3 = strm_str_new(NULL, strm_str_len(str1) + strm_str_len(str2));
char *p;
p = (char*)strm_str_ptr(str3);
memcpy(p, strm_str_ptr(str1), strm_str_len(str1));
memcpy(p+strm_str_len(str1), strm_str_ptr(str2), strm_str_len(str2));
p[strm_str_len(str3)] = '\0';
*ret = strm_str_value(str3);
return STRM_OK;
}
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])+strm_value_int(args[1]));
return STRM_OK;
}
if (strm_num_p(args[0])) {
*ret = strm_flt_value(strm_value_flt(args[0])+strm_value_flt(args[1]));
return STRM_OK;
}
return STRM_NG;
}
static int
exec_plus(strm_state* state, int argc, strm_value* args, strm_value* ret)
{
assert(argc == 2);
if (strm_str_p(*args)) {
strm_string *str1 = strm_value_str(args[0]);
strm_string *str2 = strm_value_str(args[1]);
strm_string *str3 = strm_str_new(NULL, str1->len + str2->len);
char *p;
p = (char*)str3->ptr;
memcpy(p, str1->ptr, str1->len);
memcpy(p+str1->len, str2->ptr, str2->len);
p[str3->len] = '\0';
*ret = strm_ptr_value(str3);
return STRM_OK;
}
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])+strm_value_int(args[1]));
return STRM_OK;
}
if (strm_num_p(args[0])) {
*ret = strm_flt_value(strm_value_flt(args[0])+strm_value_flt(args[1]));
return STRM_OK;
}
return STRM_NG;
}
static int
exec_mod(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
assert(argc == 2);
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])%strm_value_int(args[1]));
return STRM_OK;
}
if (strm_num_p(args[0])) {
*ret = strm_flt_value((int)strm_value_flt(args[0])%(int)strm_value_flt(args[1]));
return STRM_OK;
}
return STRM_NG;
}
static int
exec_mult(strm_state* state, int argc, strm_value* args, strm_value* ret)
{
assert(argc == 2);
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])*strm_value_int(args[1]));
return STRM_OK;
}
if (strm_num_p(args[0])) {
*ret = strm_flt_value(strm_value_flt(args[0])*strm_value_flt(args[1]));
return STRM_OK;
}
return STRM_NG;
}
static int
exec_bar(node_ctx* ctx, int argc, strm_value* args, strm_value* ret)
{
assert(argc == 2);
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])|strm_value_int(args[1]));
return 0;
}
if (strm_task_p(args[0]) && strm_task_p(args[1])) {
strm_connect(strm_value_task(args[0]), strm_value_task(args[1]));
*ret = args[1];
return 0;
}
node_raise(ctx, "type error");
return 1;
}
static int
exec_seq(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_int start=1, end=-1, inc=1;
struct seq_data* d;
switch (argc) {
case 0:
break;
case 1:
end = strm_value_int(args[0]);
break;
case 2:
start = strm_value_int(args[0]);
end = strm_value_int(args[1]);
break;
case 3:
start = strm_value_int(args[0]);
inc = strm_value_int(args[1]);
end = strm_value_int(args[2]);
break;
default:
strm_raise(strm, "wrong number of arguments");
return STRM_NG;
}
d = malloc(sizeof(struct seq_data));
d->n = start;
d->inc = inc;
d->end = end;
*ret = strm_stream_value(strm_stream_new(strm_producer, gen_seq, NULL, (void*)d));
return STRM_OK;
}
static int
exec_seq(strm_state* state, int argc, strm_value* args, strm_value* ret)
{
long start, end, inc=1;
struct seq_seeder *s;
switch (argc) {
case 1:
start = 1;
end = strm_value_int(args[0]);
break;
case 2:
start = strm_value_int(args[0]);
end = strm_value_int(args[1]);
break;
case 3:
start = strm_value_int(args[0]);
inc = strm_value_int(args[1]);
end = strm_value_int(args[2]);
break;
default:
node_raise(state, "wrong number of arguments");
return STRM_NG;
}
s = malloc(sizeof(struct seq_seeder));
s->n = start;
s->inc = inc;
s->end = end;
*ret = strm_task_value(strm_task_new(strm_task_prod, seq_seed, NULL, (void*)s));
return STRM_OK;
}
static int
ary_get(strm_stream* strm, strm_value ary, int argc, strm_value* argv, strm_value* ret)
{
struct strm_array* a;
strm_value idx;
if (argc != 1) {
strm_raise(strm, "wrong number of arguments");
return STRM_NG;
}
a = strm_ary_struct(ary);
idx = argv[0];
if (strm_num_p(idx)) {
strm_int i = strm_value_int(idx);
if (i>=a->len)
return STRM_NG;
*ret = a->ptr[i];
return STRM_OK;
}
if (strm_string_p(idx)) {
if (a->headers) {
strm_int i, len = a->len;
for (i=0; i<len; i++) {
if (strm_str_eq(strm_value_str(idx),
strm_value_str(strm_ary_ptr(a->headers)[i]))) {
*ret = a->ptr[i];
return STRM_OK;
}
}
}
}
return STRM_NG;
}
static int
exec_bar(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value lhs, rhs;
assert(argc == 2);
/* int x int */
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])|strm_value_int(args[1]));
return STRM_OK;
}
lhs = args[0];
/* lhs: io */
if (strm_io_p(lhs)) {
lhs = strm_stream_value(strm_io_stream(lhs, STRM_IO_READ));
}
/* lhs: lambda */
else if (strm_lambda_p(lhs)) {
strm_lambda lmbd = strm_value_lambda(lhs);
lhs = strm_stream_value(strm_stream_new(strm_filter, blk_exec, NULL, (void*)lmbd));
}
/* lhs: array */
else if (strm_array_p(lhs)) {
struct array_data *arrd = malloc(sizeof(struct array_data));
arrd->arr = strm_value_ary(lhs);
arrd->n = 0;
lhs = strm_stream_value(strm_stream_new(strm_producer, arr_exec, NULL, (void*)arrd));
}
/* lhs: should be stream */
rhs = args[1];
/* rhs: io */
if (strm_io_p(rhs)) {
rhs = strm_stream_value(strm_io_stream(rhs, STRM_IO_WRITE));
}
/* rhs: lambda */
else if (strm_lambda_p(rhs)) {
strm_lambda lmbd = strm_value_lambda(rhs);
rhs = strm_stream_value(strm_stream_new(strm_filter, blk_exec, NULL, (void*)lmbd));
}
/* rhs: cfunc */
else if (strm_cfunc_p(rhs)) {
strm_cfunc func = strm_value_cfunc(rhs);
rhs = strm_stream_value(strm_stream_new(strm_filter, cfunc_exec, NULL, func));
}
/* stream x stream */
if (strm_stream_p(lhs) && strm_stream_p(rhs)) {
strm_stream* lstrm = strm_value_stream(lhs);
strm_stream* rstrm = strm_value_stream(rhs);
if (lstrm == NULL || rstrm == NULL ||
lstrm->mode == strm_consumer ||
rstrm->mode == strm_producer) {
strm_raise(strm, "stream error");
return STRM_NG;
}
strm_stream_connect(strm_value_stream(lhs), strm_value_stream(rhs));
*ret = rhs;
return STRM_OK;
}
strm_raise(strm, "type error");
return STRM_NG;
}
static int
exec_bar(strm_state* state, int argc, strm_value* args, strm_value* ret)
{
strm_value lhs, rhs;
assert(argc == 2);
/* int x int */
if (strm_int_p(args[0]) && strm_int_p(args[1])) {
*ret = strm_int_value(strm_value_int(args[0])|strm_value_int(args[1]));
return STRM_OK;
}
lhs = args[0];
/* lhs: io */
if (strm_io_p(lhs)) {
strm_io *io = strm_value_io(lhs);
lhs = strm_task_value(strm_io_open(io, STRM_IO_READ));
}
/* lhs: lambda */
else if (strm_lambda_p(lhs)) {
strm_lambda *lmbd = strm_value_lambda(lhs)
lhs = strm_task_value(strm_task_new(strm_task_filt, blk_exec, NULL, (void*)lmbd));
}
/* lhs: array */
else if (strm_array_p(lhs)) {
struct array_data *arrd = malloc(sizeof(struct array_data));
arrd->arr = strm_value_array(lhs);
arrd->n = 0;
lhs = strm_task_value(strm_task_new(strm_task_prod, arr_exec, arr_finish, (void*)arrd));
}
/* lhs: should be task */
rhs = args[1];
/* rhs: io */
if (strm_io_p(rhs)) {
strm_io *io = strm_value_io(rhs);
rhs = strm_task_value(strm_io_open(io, STRM_IO_WRITE));
}
/* rhs: lambda */
else if (strm_lambda_p(rhs)) {
strm_lambda *lmbd = strm_value_lambda(rhs);
rhs = strm_task_value(strm_task_new(strm_task_filt, blk_exec, NULL, (void*)lmbd));
}
/* rhs: cfunc */
else if (strm_cfunc_p(rhs)) {
void *func = rhs.val.p;
rhs = strm_task_value(strm_task_new(strm_task_filt, cfunc_exec, NULL, func));
}
/* task x task */
if (strm_task_p(lhs) && strm_task_p(rhs)) {
if (lhs.val.p == NULL || rhs.val.p == NULL) {
node_raise(state, "task error");
return STRM_NG;
}
strm_task_connect(strm_value_task(lhs), strm_value_task(rhs));
*ret = rhs;
return STRM_OK;
}
node_raise(state, "type error");
return STRM_NG;
}