static void
node_init(strm_state* state)
{
strm_var_def("STDIN", strm_ptr_value(strm_io_new(0, STRM_IO_READ)));
strm_var_def("STDOUT", strm_ptr_value(strm_io_new(1, STRM_IO_WRITE)));
strm_var_def("STDERR", strm_ptr_value(strm_io_new(2, STRM_IO_WRITE)));
strm_var_def("puts", strm_cfunc_value(exec_puts));
strm_var_def("+", strm_cfunc_value(exec_plus));
strm_var_def("-", strm_cfunc_value(exec_minus));
strm_var_def("*", strm_cfunc_value(exec_mult));
strm_var_def("/", strm_cfunc_value(exec_div));
strm_var_def("<", strm_cfunc_value(exec_lt));
strm_var_def("<=", strm_cfunc_value(exec_le));
strm_var_def(">", strm_cfunc_value(exec_gt));
strm_var_def(">=", strm_cfunc_value(exec_ge));
strm_var_def("==", strm_cfunc_value(exec_eq));
strm_var_def("!=", strm_cfunc_value(exec_neq));
strm_var_def("|", strm_cfunc_value(exec_bar));
strm_var_def("%", strm_cfunc_value(exec_mod));
strm_var_def("fread", strm_cfunc_value(exec_fread));
strm_var_def("fwrite", strm_cfunc_value(exec_fwrite));
strm_seq_init(state);
strm_socket_init(state);
strm_csv_init(state);
}
static void
node_init(strm_state* state)
{
strm_var_def(state, "stdin", strm_ptr_value(strm_io_new(0, STRM_IO_READ)));
strm_var_def(state, "stdout", strm_ptr_value(strm_io_new(1, STRM_IO_WRITE)));
strm_var_def(state, "stderr", strm_ptr_value(strm_io_new(2, STRM_IO_WRITE)));
strm_var_def(state, "puts", strm_cfunc_value(exec_puts));
strm_var_def(state, "+", strm_cfunc_value(exec_plus));
strm_var_def(state, "-", strm_cfunc_value(exec_minus));
strm_var_def(state, "*", strm_cfunc_value(exec_mult));
strm_var_def(state, "/", strm_cfunc_value(exec_div));
strm_var_def(state, "<", strm_cfunc_value(exec_lt));
strm_var_def(state, "<=", strm_cfunc_value(exec_le));
strm_var_def(state, ">", strm_cfunc_value(exec_gt));
strm_var_def(state, ">=", strm_cfunc_value(exec_ge));
strm_var_def(state, "==", strm_cfunc_value(exec_eq));
strm_var_def(state, "!=", strm_cfunc_value(exec_neq));
strm_var_def(state, "|", strm_cfunc_value(exec_bar));
strm_var_def(state, "%", strm_cfunc_value(exec_mod));
strm_var_def(state, "fread", strm_cfunc_value(exec_fread));
strm_var_def(state, "fwrite", strm_cfunc_value(exec_fwrite));
strm_iter_init(state);
strm_socket_init(state);
strm_csv_init(state);
}
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_fwrite(strm_state* state, int argc, strm_value* args, strm_value* ret)
{
int fd;
strm_string *path;
assert(argc == 1);
assert(strm_str_p(args[0]));
path = strm_value_str(args[0]);
fd = open(path->ptr, O_WRONLY|O_CREAT, 0644);
if (fd < 0) return STRM_NG;
*ret = strm_ptr_value(strm_io_new(fd, STRM_IO_WRITE));
return STRM_OK;
}
static int
exec_fread(strm_state* state, int argc, strm_value* args, strm_value* ret)
{
int fd;
strm_string *path;
assert(argc == 1);
assert(strm_str_p(args[0]));
path = strm_value_str(args[0]);
fd = open(path->ptr, O_RDONLY);
if (fd < 0) return STRM_NG;
*ret = strm_ptr_value(strm_io_new(fd, STRM_IO_READ));
return STRM_OK;
}
node*
node_array_headers(node* np)
{
int i;
node_values* v;
strm_array *headers = NULL;
strm_value *p = NULL;
node_map* map = malloc(sizeof(node_map));
map->type = NODE_MAP;
map->headers = NULL;
if (np == NULL)
np = node_array_new();
v = (node_values*)np;
map->len = v->len;
map->max = v->max;
map->data = v->data;
free(v);
for (i = 0; i < map->len; i++) {
node_pair* npair = (node_pair*)map->data[i];
if (npair->type == NODE_PAIR) {
if (!headers) {
headers = strm_ary_new(NULL, map->len);
p = (strm_value*)headers->ptr;
}
p[i] = strm_ptr_value(npair->key);
v->data[i] = npair->value;
}
}
map->headers = headers;
return (node*)map;
}
static int
exec_expr(strm_stream* strm, strm_state* state, node* np, strm_value* val)
{
int n;
if (np == NULL) {
return STRM_NG;
}
switch (np->type) {
/*
case NODE_ARGS:
break;
*/
case NODE_NS:
{
node_ns* ns = (node_ns*)np;
strm_state* s = strm_ns_find(state, node_to_sym(ns->name));
if (!s) {
strm_raise(strm, "failed to create namespace");
return STRM_NG;
}
return exec_expr(strm, s, ns->body, val);
}
case NODE_IMPORT:
{
node_import *ns = (node_import*)np;
strm_state* s = strm_ns_get(node_to_sym(ns->name));
if (!s) {
strm_raise(strm, "no such namespace");
return STRM_NG;
}
n = strm_env_copy(state, s);
if (n) {
strm_raise(strm, "failed to import");
return n;
}
return STRM_OK;
}
break;
case NODE_SKIP:
strm_set_exc(strm, NODE_ERROR_SKIP, strm_nil_value());
return STRM_OK;
case NODE_EMIT:
{
int i, n;
node_array* v0;
v0 = (node_array*)((node_emit*)np)->emit;
if (!v0) {
strm_emit(strm, strm_nil_value(), NULL);
}
else {
for (i = 0; i < v0->len; i++) {
n = exec_expr(strm, state, v0->data[i], val);
if (n) return n;
strm_emit(strm, *val, NULL);
}
}
return STRM_OK;
}
break;
case NODE_LET:
{
node_let *nlet = (node_let*)np;
n = exec_expr(strm, state, nlet->rhs, val);
if (n) {
strm_raise(strm, "failed to assign");
return n;
}
return strm_var_set(state, node_to_sym(nlet->lhs), *val);
}
case NODE_ARRAY:
{
node_array* v0 = (node_array*)np;
strm_array arr = strm_ary_new(NULL, v0->len);
strm_value *ptr = (strm_value*)strm_ary_ptr(arr);
int i=0;
for (i = 0; i < v0->len; i++, ptr++) {
n = exec_expr(strm, state, v0->data[i], ptr);
if (n) return n;
}
if (v0->headers) {
strm_ary_headers(arr) = ary_headers(v0->headers, v0->len);
}
if (v0->ns) {
strm_ary_ns(arr) = strm_ns_get(node_to_sym(v0->ns));
}
else {
strm_ary_ns(arr) = strm_str_null;
}
*val = strm_ary_value(arr);
return STRM_OK;
}
case NODE_IDENT:
{
node_ident* ni = (node_ident*)np;
n = strm_var_get(state, node_to_sym(ni->name), val);
if (n) {
strm_raise(strm, "failed to reference variable");
}
return n;
}
case NODE_IF:
{
strm_value v;
node_if* nif = (node_if*)np;
n = exec_expr(strm, state, nif->cond, &v);
if (n) return n;
if (strm_bool_p(v) && strm_value_bool(v)) {
return exec_expr(strm, state, nif->then, val);
}
else if (nif->opt_else != NULL) {
return exec_expr(strm, state, nif->opt_else, val);
}
else {
*val = strm_nil_value();
return STRM_OK;
}
}
break;
case NODE_OP:
{
node_op* nop = (node_op*)np;
strm_value args[2];
int i=0;
if (nop->lhs) {
n = exec_expr(strm, state, nop->lhs, &args[i++]);
if (n) return n;
}
if (nop->rhs) {
n = exec_expr(strm, state, nop->rhs, &args[i++]);
if (n) return n;
}
return exec_call(strm, state, node_to_sym(nop->op), i, args, val);
}
break;
case NODE_LAMBDA:
{
strm_lambda lambda = malloc(sizeof(struct strm_lambda));
if (!lambda) return STRM_NG;
lambda->type = STRM_PTR_LAMBDA;
lambda->body = (node_lambda*)np;
lambda->state = state;
*val = strm_ptr_value(lambda);
return STRM_OK;
}
break;
case NODE_CALL:
{
/* TODO: wip code of ident */
node_call* ncall = (node_call*)np;
int i;
node_nodes* v0 = (node_nodes*)ncall->args;
strm_value *args = malloc(sizeof(strm_value)*v0->len);
for (i = 0; i < v0->len; i++) {
n = exec_expr(strm, state, v0->data[i], &args[i]);
if (n) return n;
}
return exec_call(strm, state, node_to_sym(ncall->ident), i, args, val);
}
break;
case NODE_RETURN:
{
node_return* nreturn = (node_return*)np;
node_nodes* args = (node_nodes*)nreturn->rv;
strm_value arg;
if (!args) {
arg = strm_nil_value();
}
else {
switch (args->len) {
case 0:
arg = strm_nil_value();
break;
case 1:
n = exec_expr(strm, state, args->data[0], &arg);
if (n) return n;
break;
default:
{
strm_array ary = strm_ary_new(NULL, args->len);
strm_int i;
for (i=0; i<args->len; i++) {
n = exec_expr(strm, state, args->data[i], (strm_value*)&strm_ary_ptr(ary)[i]);
if (n) return n;
}
}
break;
}
}
strm_set_exc(strm, NODE_ERROR_RETURN, arg);
return STRM_OK;
}
break;
case NODE_NODES:
{
int i;
node_nodes* v = (node_nodes*)np;
for (i = 0; i < v->len; i++) {
n = exec_expr(strm, state, v->data[i], val);
if (n) {
if (strm) {
node_error* exc = strm->exc;
if (exc != NULL) {
node* n = v->data[i];
exc->fname = n->fname;
exc->lineno = n->lineno;
}
}
return n;
}
}
}
return STRM_OK;
case NODE_INT:
*val = strm_int_value(((node_int*)np)->value);
return STRM_OK;
case NODE_FLOAT:
*val = strm_int_value(((node_float*)np)->value);
return STRM_OK;
case NODE_BOOL:
*val = strm_bool_value(((node_bool*)np)->value);
return STRM_OK;
case NODE_NIL:
*val = strm_nil_value();
return STRM_OK;
case NODE_STR:
*val = strm_str_value(node_to_str(((node_str*)np)->value));
return STRM_OK;
default:
break;
}
return STRM_NG;
}
static int
exec_expr(strm_state* state, node* np, strm_value* val)
{
int n;
if (np == NULL) {
return STRM_NG;
}
switch (np->type) {
/*
case NODE_ARGS:
break;
*/
case NODE_SKIP:
{
state->exc = malloc(sizeof(node_error));
state->exc->type = NODE_ERROR_SKIP;
state->exc->arg = strm_nil_value();
return STRM_OK;
}
case NODE_EMIT:
{
int i, n;
node_values* v0;
if (!state->task) {
node_raise(state, "failed to emit");
}
v0 = (node_values*)np->value.v.p;
for (i = 0; i < v0->len; i++) {
n = exec_expr(state, v0->data[i], val);
if (n) return n;
strm_emit(state->task, *val, NULL);
}
return STRM_OK;
}
break;
case NODE_LET:
{
node_let *nlet = (node_let*)np;
n = exec_expr(state, nlet->rhs, val);
if (n) {
node_raise(state, "failed to assign");
return n;
}
return strm_var_set(state, nlet->lhs, *val);
}
case NODE_ARRAY:
{
node_values* v0 = (node_values*)np;
strm_array *arr = strm_ary_new(NULL, v0->len);
strm_value *ptr = (strm_value*)arr->ptr;
int i=0;
for (i = 0; i < v0->len; i++, ptr++) {
n = exec_expr(state, v0->data[i], ptr);
if (n) return n;
}
*val = strm_ptr_value(arr);
return STRM_OK;
}
case NODE_MAP:
{
node_map* v0 = (node_map*)np;
strm_value nmap;
strm_array* ary;
n = exec_expr(state, v0->values, &nmap);
if (n) return n;
ary = strm_value_ary(nmap);
ary->headers = v0->headers;
*val = nmap;
return STRM_OK;
}
case NODE_IDENT:
n = strm_var_get(state, np->value.v.s, val);
if (n) {
node_raise(state, "failed to reference variable");
}
return n;
case NODE_IF:
{
strm_value v;
node_if* nif = (node_if*)np;
n = exec_expr(state, nif->cond, &v);
if (n) return n;
if (strm_value_bool(v) && v.val.i) {
return exec_expr(state, nif->then, val);
}
else if (nif->opt_else != NULL) {
return exec_expr(state, nif->opt_else, val);
}
else {
*val = strm_nil_value();
return STRM_OK;
}
}
break;
case NODE_OP:
{
node_op* nop = (node_op*)np;
strm_value args[2];
int i=0;
if (nop->lhs) {
n = exec_expr(state, nop->lhs, &args[i++]);
if (n) return n;
}
if (nop->rhs) {
n = exec_expr(state, nop->rhs, &args[i++]);
if (n) return n;
}
return exec_call(state, nop->op, i, args, val);
}
break;
case NODE_LAMBDA:
{
struct strm_lambda* lambda = malloc(sizeof(strm_lambda));
if (!lambda) return STRM_NG;
lambda->type = STRM_OBJ_LAMBDA;
lambda->body = (node_lambda*)np;
lambda->state = state;
*val = strm_ptr_value(lambda);
return STRM_OK;
}
break;
case NODE_CALL:
{
/* TODO: wip code of ident */
node_call* ncall = (node_call*)np;
int i;
node_values* v0 = (node_values*)ncall->args;
strm_value *args = malloc(sizeof(strm_value)*v0->len);
for (i = 0; i < v0->len; i++) {
n = exec_expr(state, v0->data[i], &args[i]);
if (n) return n;
}
return exec_call(state, ncall->ident, i, args, val);
}
break;
case NODE_RETURN:
{
node_return* nreturn = (node_return*)np;
node_values* args = (node_values*)nreturn->rv;
state->exc = malloc(sizeof(node_error));
state->exc->type = NODE_ERROR_RETURN;
switch (args->len) {
case 0:
state->exc->arg = strm_nil_value();
break;
case 1:
n = exec_expr(state, args->data[0], &state->exc->arg);
if (n) return n;
break;
default:
{
strm_array* ary = strm_ary_new(NULL, args->len);
size_t i;
for (i=0; i<args->len; i++) {
n = exec_expr(state, args->data[i], (strm_value*)&ary->ptr[i]);
if (n) return n;
}
}
break;
}
return STRM_NG;
}
break;
case NODE_STMTS:
{
int i;
node_values* v = (node_values*)np;
for (i = 0; i < v->len; i++) {
n = exec_expr(state, v->data[i], val);
if (state->exc != NULL) return STRM_NG;
if (n) return n;
}
}
return STRM_OK;
case NODE_VALUE:
switch (np->value.t) {
case NODE_VALUE_BOOL:
*val = strm_bool_value(np->value.v.b);
return STRM_OK;
case NODE_VALUE_NIL:
*val = strm_nil_value();
return STRM_OK;
case NODE_VALUE_STRING:
case NODE_VALUE_IDENT:
*val = strm_ptr_value(np->value.v.s);
return STRM_OK;
case NODE_VALUE_DOUBLE:
*val = strm_flt_value(np->value.v.d);
return STRM_OK;
case NODE_VALUE_INT:
*val = strm_int_value(np->value.v.i);
return STRM_OK;
/* following type should not be evaluated */
case NODE_VALUE_ERROR:
case NODE_VALUE_USER:
default:
return STRM_NG;
}
default:
break;
}
return STRM_NG;
}
static void
csv_accept(strm_task* task, strm_value data)
{
strm_array *ary;
strm_string *line = strm_value_str(data);
strm_value *bp;
char *tmp, *tptr;
const char *ptr;
const char *pend;
int fieldcnt, len;
int in_quote = 0, quoted = 0, all_str = 1;;
struct csv_data *cd = task->data;
if (cd->prev) {
strm_string *str = strm_str_new(NULL, cd->prev->len+line->len+1);
tmp = (char*)str->ptr;
memcpy(tmp, cd->prev->ptr, cd->prev->len);
*(tmp+cd->prev->len) = '\n';
memcpy(tmp+cd->prev->len+1, line->ptr, line->len);
line = str;
cd->prev = NULL;
}
fieldcnt = count_fields(line);
if (fieldcnt == -1) {
cd->prev = line;
return;
}
if (cd->n > 0 && fieldcnt != cd->n)
return;
ptr = line->ptr;
pend = ptr + line->len;
ary = strm_ary_new(NULL, fieldcnt);
if (!ary) return;
bp = (strm_value*)ary->ptr;
len = line->len;
tmp = malloc(len+1);
if (!tmp) return;
*tmp='\0';
ptr=line->ptr;
tptr=tmp;
for (;ptr<pend; ptr++) {
if (in_quote) {
if (*ptr == '\"') {
if (ptr[1] == '\"') {
*tptr++ = '\"';
ptr++;
continue;
}
in_quote = 0;
}
else
*tptr++ = *ptr;
continue;
}
switch(*ptr) {
case '\"':
in_quote = 1;
quoted = 1;
continue;
case ',':
if (quoted) {
*bp = strm_str_value(tmp, tptr-tmp);
}
else {
*bp = csv_value(tmp, tptr-tmp);
}
if (!strm_str_p(*bp)) all_str = 0;
bp++;
tptr = tmp;
quoted = 0;
break;
default:
*tptr++ = *ptr;
continue;
}
}
/* trim newline at the end */
if (tptr > tmp && tptr[-1] == '\n') {
tptr--;
}
/* trim carriage return at the end */
if (tptr > tmp && tptr[-1] == '\r') {
tptr--;
}
*bp = csv_value(tmp, tptr-tmp);
if (!strm_str_p(*bp)) all_str = 0;
free(tmp);
/* check headers */
if (!cd->headers && !cd->types) {
if (all_str) {
cd->headers = ary;
ary = NULL;
}
cd->n = fieldcnt;
}
if (ary) {
int i;
/* set headers if any */
if (cd->headers)
ary->headers = cd->headers;
if (!cd->types) {
/* first data line (after optinal header line) */
if (cd->headers) {
if (all_str) { /* data line is all string; emit header line */
strm_emit(task, strm_ptr_value(cd->headers), NULL);
cd->headers = NULL;
}
else { /* intern header strings */
strm_array *h = cd->headers;
strm_value *p = (strm_value*)h->ptr;
int i;
for (i=0; i<h->len; i++) {
strm_string *str = strm_value_str(p[i]);
p[i] = strm_ptr_value(strm_str_intern_str(str));
}
}
}
/* initialize types (determined by first data line) */
cd->types = malloc(sizeof(enum csv_type)*fieldcnt);
if (!cd->types) return;
for (i=0; i<fieldcnt; i++) {
cd->types[i] = csv_type(ary->ptr[i]);
}
}
else {
/* type check */
for (i=0; i<fieldcnt; i++) {
if (cd->types[i] != csv_type(ary->ptr[i])) {
if (cd->types[i] == STRING_TYPE) {
/* convert value to string */
((strm_value*)ary->ptr)[i] = strm_ptr_value(strm_to_str(ary->ptr[i]));
}
else {
/* type mismatch (error); skip this line */
return;
}
}
}
}
strm_emit(task, strm_ptr_value(ary), NULL);
}
}
static int
exec_expr(node_ctx* ctx, node* np, strm_value* val)
{
int n;
if (np == NULL) {
return 1;
}
switch (np->type) {
/*
case NODE_ARGS:
break;
case NODE_EMIT:
break;
*/
case NODE_IDENT:
*val = strm_var_get(np->value.v.s);
return 0;
case NODE_IF:
{
strm_value v;
node_if* nif = (node_if*)np;
n = exec_expr(ctx, nif->cond, &v);
if (n) return n;
if (strm_value_bool(v)) {
return exec_expr(ctx, nif->then, val);
}
else if (nif->opt_else != NULL) {
return exec_expr(ctx, nif->opt_else, val);
}
else {
*val = strm_nil_value();
return 0;
}
}
break;
case NODE_OP:
{
node_op* nop = (node_op*)np;
strm_value args[2];
int i=0;
if (nop->lhs) {
n = exec_expr(ctx, nop->lhs, &args[i++]);
if (n) return n;
}
if (nop->rhs) {
n = exec_expr(ctx, nop->rhs, &args[i++]);
if (n) return n;
}
return exec_call(ctx, nop->op, i, args, val);
}
break;
case NODE_CALL:
{
/* TODO: wip code of ident */
node_call* ncall = (node_call*)np;
if (ncall->ident != NULL) {
int i;
node_values* v0 = (node_values*)ncall->args;
strm_value *args = malloc(sizeof(strm_value)*v0->len);
for (i = 0; i < v0->len; i++) {
n = exec_expr(ctx, v0->data[i], &args[i]);
if (n) return n;
}
return exec_call(ctx, ncall->ident->value.v.s, i, args, val);
}
else {
node_block* nblk = (node_block*)ncall;
strm_value v;
int n;
n = exec_expr(ctx, nblk->compstmt, &v);
if (n && ctx->exc->type == NODE_ERROR_RETURN) {
*val = ctx->exc->arg;
free(ctx->exc);
return 0;
}
}
}
break;
case NODE_RETURN:
{
node_return* nreturn = (node_return*)np;
ctx->exc = malloc(sizeof(node_error));
ctx->exc->type = NODE_ERROR_RETURN;
n = exec_expr(ctx, nreturn->rv, &ctx->exc->arg);
return n;
}
break;
case NODE_STMTS:
{
int i, n;
node_values* v = (node_values*)np;
for (i = 0; i < v->len; i++) {
n = exec_expr(ctx, v->data[i], val);
if (n) return n;
}
return 0;
}
break;
case NODE_VALUE:
switch (np->value.t) {
case NODE_VALUE_BOOL:
*val = strm_bool_value(np->value.v.b);
return 0;
case NODE_VALUE_NIL:
*val = strm_nil_value();
return 0;
case NODE_VALUE_STRING:
case NODE_VALUE_IDENT:
*val = strm_ptr_value(np->value.v.s);
return 0;
case NODE_VALUE_DOUBLE:
*val = strm_flt_value(np->value.v.d);
return 0;
case NODE_VALUE_INT:
*val = strm_int_value(np->value.v.i);
return 0;
/* following type should not be evaluated */
case NODE_VALUE_ERROR:
case NODE_VALUE_USER:
default:
return 1;
}
default:
break;
}
return 1;
}
