mirrors/janet
1
0
Fork 0
mirror of https://github.com/janet-lang/janet synced 2024-06-26 07:03:16 +00:00
Code Issues 1 Releases Wiki Activity

Factor CFunction args into struct.

Browse Source
This commit is contained in:
bakpakin 2018-01-14 12:10:45 -05:00
parent 9291a4faf0
commit 3262316e60
8 changed files with 304 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

158
core/math.c
View File

@ -24,40 +24,40 @@
#include <math.h> #include <math.h>
/* Convert a number to an integer */ /* Convert a number to an integer */
int dst_int(int32_t argn, Dst *argv, Dst *ret) { int dst_int(DstArgs args) {
if (argn != 1) { if (args.n != 1) {
*ret = dst_cstringv("expected 1 argument"); *args.ret = dst_cstringv("expected 1 argument");
return 1; return 1;
} }
switch (dst_type(argv[0])) { switch (dst_type(args.v[0])) {
default: default:
*ret = dst_cstringv("could not convert to integer"); *args.ret = dst_cstringv("could not convert to integer");
return 1; return 1;
case DST_REAL: case DST_REAL:
*ret = dst_wrap_integer((int32_t) dst_unwrap_real(argv[0])); *args.ret = dst_wrap_integer((int32_t) dst_unwrap_real(args.v[0]));
break; break;
case DST_INTEGER: case DST_INTEGER:
*ret = argv[0]; *args.ret = args.v[0];
break; break;
} }
return 0; return 0;
} }
/* Convert a number to a real number */ /* Convert a number to a real number */
int dst_real(int32_t argn, Dst *argv, Dst *ret) { int dst_real(DstArgs args) {
if (argn != 1) { if (args.n != 1) {
*ret = dst_cstringv("expected 1 argument"); *args.ret = dst_cstringv("expected 1 argument");
return 1; return 1;
} }
switch (dst_type(argv[0])) { switch (dst_type(args.v[0])) {
default: default:
*ret = dst_cstringv("could not convert to real"); *args.ret = dst_cstringv("could not convert to real");
return 1; return 1;
case DST_REAL: case DST_REAL:
*ret = argv[0]; *args.ret = args.v[0];
break; break;
case DST_INTEGER: case DST_INTEGER:
*ret = dst_wrap_real((double) dst_unwrap_integer(argv[0])); *args.ret = dst_wrap_real((double) dst_unwrap_integer(args.v[0]));
break; break;
} }
return 0; return 0;
@ -105,17 +105,17 @@ DST_DEFINE_DIVIDER_OP(divide, DIV, DIV)
DST_DEFINE_DIVIDER_OP(modulo, MOD, fmod) DST_DEFINE_DIVIDER_OP(modulo, MOD, fmod)
#define DST_DEFINE_REDUCER(name, fop, start)\ #define DST_DEFINE_REDUCER(name, fop, start)\
int dst_##name(int32_t argn, Dst *argv, Dst *ret) {\ int dst_##name(DstArgs args) {\
int32_t i;\ int32_t i;\
Dst accum = dst_wrap_integer(start);\ Dst accum = dst_wrap_integer(start);\
for (i = 0; i < argn; i++) {\ for (i = 0; i < args.n; i++) {\
accum = fop(accum, argv[i]);\ accum = fop(accum, args.v[i]);\
}\ }\
if (dst_checktype(accum, DST_NIL)) {\ if (dst_checktype(accum, DST_NIL)) {\
*ret = dst_cstringv("expected number");\ *args.ret = dst_cstringv("expected number");\
return 1;\ return 1;\
}\ }\
*ret = accum;\ *args.ret = accum;\
return 0;\ return 0;\
} }
@ -123,27 +123,27 @@ DST_DEFINE_REDUCER(add, dst_op_add, 0)
DST_DEFINE_REDUCER(multiply, dst_op_multiply, 1) DST_DEFINE_REDUCER(multiply, dst_op_multiply, 1)
#define DST_DEFINE_DIVIDER(name, unarystart)\ #define DST_DEFINE_DIVIDER(name, unarystart)\
int dst_##name(int32_t argn, Dst *argv, Dst *ret) {\ int dst_##name(DstArgs args) {\
int32_t i;\ int32_t i;\
Dst accum;\ Dst accum;\
if (argn < 1) {\ if (args.n < 1) {\
*ret = dst_cstringv("expected at least one argument");\ *args.ret = dst_cstringv("expected at least one argument");\
return 1;\ return 1;\
} else if (argn == 1) {\ } else if (args.n == 1) {\
accum = unarystart;\ accum = unarystart;\
i = 0;\ i = 0;\
} else {\ } else {\
accum = argv[0];\ accum = args.v[0];\
i = 1;\ i = 1;\
}\ }\
for (; i < argn; i++) {\ for (; i < args.n; i++) {\
accum = dst_op_##name(accum, argv[i]);\ accum = dst_op_##name(accum, args.v[i]);\
}\ }\
if (dst_checktype(accum, DST_NIL)) {\ if (dst_checktype(accum, DST_NIL)) {\
*ret = dst_cstringv("expected number or division error");\ *args.ret = dst_cstringv("expected number or division error");\
return 1;\ return 1;\
}\ }\
*ret = accum;\ *args.ret = accum;\
return 0;\ return 0;\
} }
@ -157,32 +157,32 @@ DST_DEFINE_DIVIDER(subtract, dst_wrap_integer(0))
#undef MOD #undef MOD
#undef DST_DEFINE_BINOP #undef DST_DEFINE_BINOP
int dst_bnot(int32_t argn, Dst *argv, Dst *ret) { int dst_bnot(DstArgs args) {
if (argn != 1) { if (args.n != 1) {
*ret = dst_cstringv("expected 1 argument"); *args.ret = dst_cstringv("expected 1 argument");
return 1; return 1;
} }
if (!dst_checktype(argv[0], DST_INTEGER)) { if (!dst_checktype(args.v[0], DST_INTEGER)) {
*ret = dst_cstringv("expected integer"); *args.ret = dst_cstringv("expected integer");
return 1; return 1;
} }
*ret = dst_wrap_integer(~dst_unwrap_integer(argv[0])); *args.ret = dst_wrap_integer(~dst_unwrap_integer(args.v[0]));
return 0; return 0;
} }
#define DST_DEFINE_BITOP(name, op, start)\ #define DST_DEFINE_BITOP(name, op, start)\
int dst_##name(int32_t argn, Dst *argv, Dst *ret) {\ int dst_##name(DstArgs args) {\
int32_t i;\ int32_t i;\
int32_t accum = start;\ int32_t accum = start;\
for (i = 0; i < argn; i++) {\ for (i = 0; i < args.n; i++) {\
Dst arg = argv[i];\ Dst arg = args.v[i];\
if (!dst_checktype(arg, DST_INTEGER)) {\ if (!dst_checktype(arg, DST_INTEGER)) {\
*ret = dst_cstringv("expected integer");\ *args.ret = dst_cstringv("expected integer");\
return -1;\ return -1;\
}\ }\
accum op dst_unwrap_integer(arg);\ accum op dst_unwrap_integer(arg);\
}\ }\
*ret = dst_wrap_integer(accum);\ *args.ret = dst_wrap_integer(accum);\
return 0;\ return 0;\
} }
@ -190,47 +190,47 @@ DST_DEFINE_BITOP(band, &=, -1)
DST_DEFINE_BITOP(bor, |=, 0) DST_DEFINE_BITOP(bor, |=, 0)
DST_DEFINE_BITOP(bxor, ^=, 0) DST_DEFINE_BITOP(bxor, ^=, 0)
int dst_lshift(int argn, Dst *argv, Dst *ret) { int dst_lshift(DstArgs args) {
if (argn != 2 || !dst_checktype(argv[0], DST_INTEGER) || !dst_checktype(argv[1], DST_INTEGER)) { if (args.n != 2 || !dst_checktype(args.v[0], DST_INTEGER) || !dst_checktype(args.v[1], DST_INTEGER)) {
*ret = dst_cstringv("expected 2 integers"); *args.ret = dst_cstringv("expected 2 integers");
return 1; return 1;
} }
*ret = dst_wrap_integer(dst_unwrap_integer(argv[0]) >> dst_unwrap_integer(argv[1])); *args.ret = dst_wrap_integer(dst_unwrap_integer(args.v[0]) >> dst_unwrap_integer(args.v[1]));
return 0; return 0;
} }
int dst_rshift(int argn, Dst *argv, Dst *ret) { int dst_rshift(DstArgs args) {
if (argn != 2 || !dst_checktype(argv[0], DST_INTEGER) || !dst_checktype(argv[1], DST_INTEGER)) { if (args.n != 2 || !dst_checktype(args.v[0], DST_INTEGER) || !dst_checktype(args.v[1], DST_INTEGER)) {
*ret = dst_cstringv("expected 2 integers"); *args.ret = dst_cstringv("expected 2 integers");
return 1; return 1;
} }
*ret = dst_wrap_integer(dst_unwrap_integer(argv[0]) << dst_unwrap_integer(argv[1])); *args.ret = dst_wrap_integer(dst_unwrap_integer(args.v[0]) << dst_unwrap_integer(args.v[1]));
return 0; return 0;
} }
int dst_lshiftu(int argn, Dst *argv, Dst *ret) { int dst_lshiftu(DstArgs args) {
if (argn != 2 || !dst_checktype(argv[0], DST_INTEGER) || !dst_checktype(argv[1], DST_INTEGER)) { if (args.n != 2 || !dst_checktype(args.v[0], DST_INTEGER) || !dst_checktype(args.v[1], DST_INTEGER)) {
*ret = dst_cstringv("expected 2 integers"); *args.ret = dst_cstringv("expected 2 integers");
return 1; return 1;
} }
*ret = dst_wrap_integer((int32_t)((uint32_t)dst_unwrap_integer(argv[0]) >> dst_unwrap_integer(argv[1]))); *args.ret = dst_wrap_integer((int32_t)((uint32_t)dst_unwrap_integer(args.v[0]) >> dst_unwrap_integer(args.v[1])));
return 0; return 0;
} }
#define DST_DEFINE_MATHOP(name, fop)\ #define DST_DEFINE_MATHOP(name, fop)\
int dst_##name(int32_t argn, Dst *argv, Dst *ret) {\ int dst_##name(DstArgs args) {\
if (argn != 1) {\ if (args.n != 1) {\
*ret = dst_cstringv("expected 1 argument");\ *args.ret = dst_cstringv("expected 1 argument");\
return 1;\ return 1;\
}\ }\
if (dst_checktype(argv[0], DST_INTEGER)) {\ if (dst_checktype(args.v[0], DST_INTEGER)) {\
argv[0] = dst_wrap_real(dst_unwrap_integer(argv[0]));\ args.v[0] = dst_wrap_real(dst_unwrap_integer(args.v[0]));\
}\ }\
if (!dst_checktype(argv[0], DST_REAL)) {\ if (!dst_checktype(args.v[0], DST_REAL)) {\
*ret = dst_cstringv("expected number");\ *args.ret = dst_cstringv("expected number");\
return 1;\ return 1;\
}\ }\
*ret = dst_wrap_real(fop(dst_unwrap_real(argv[0])));\ *args.ret = dst_wrap_real(fop(dst_unwrap_real(args.v[0])));\
return 0;\ return 0;\
} }
@ -252,21 +252,21 @@ DST_DEFINE_MATHOP(fabs, fabs)
DST_DEFINE_MATHOP(floor, floor) DST_DEFINE_MATHOP(floor, floor)
#define DST_DEFINE_MATH2OP(name, fop)\ #define DST_DEFINE_MATH2OP(name, fop)\
int dst_##name(int32_t argn, Dst *argv, Dst *ret) {\ int dst_##name(DstArgs args) {\
if (argn != 2) {\ if (args.n != 2) {\
*ret = dst_cstringv("expected 2 arguments");\ *args.ret = dst_cstringv("expected 2 arguments");\
return 1;\ return 1;\
}\ }\
if (dst_checktype(argv[0], DST_INTEGER))\ if (dst_checktype(args.v[0], DST_INTEGER))\
argv[0] = dst_wrap_real(dst_unwrap_integer(argv[0]));\ args.v[0] = dst_wrap_real(dst_unwrap_integer(args.v[0]));\
if (dst_checktype(argv[1], DST_INTEGER))\ if (dst_checktype(args.v[1], DST_INTEGER))\
argv[1] = dst_wrap_real(dst_unwrap_integer(argv[1]));\ args.v[1] = dst_wrap_real(dst_unwrap_integer(args.v[1]));\
if (!dst_checktype(argv[0], DST_REAL) || !dst_checktype(argv[1], DST_REAL)) {\ if (!dst_checktype(args.v[0], DST_REAL) || !dst_checktype(args.v[1], DST_REAL)) {\
*ret = dst_cstringv("expected real");\ *args.ret = dst_cstringv("expected real");\
return 1;\ return 1;\
}\ }\
*ret =\ *args.ret =\
dst_wrap_real(fop(dst_unwrap_real(argv[0]), dst_unwrap_real(argv[1])));\ dst_wrap_real(fop(dst_unwrap_real(args.v[0]), dst_unwrap_real(args.v[1])));\
return 0;\ return 0;\
}\ }\
@ -274,22 +274,22 @@ DST_DEFINE_MATH2OP(atan2, atan2)
DST_DEFINE_MATH2OP(pow, pow) DST_DEFINE_MATH2OP(pow, pow)
DST_DEFINE_MATH2OP(fmod, fmod) DST_DEFINE_MATH2OP(fmod, fmod)
int dst_modf(int32_t argn, Dst *argv, Dst *ret) { int dst_modf(DstArgs args) {
double intpart; double intpart;
Dst *tup; Dst *tup;
if (argn != 1) { if (args.n != 1) {
*ret = dst_cstringv("expected 1 argument"); *args.ret = dst_cstringv("expected 1 argument");
return 1; return 1;
} }
if (dst_checktype(argv[0], DST_INTEGER)) if (dst_checktype(args.v[0], DST_INTEGER))
argv[0] = dst_wrap_real(dst_unwrap_integer(argv[0])); args.v[0] = dst_wrap_real(dst_unwrap_integer(args.v[0]));
if (!dst_checktype(argv[0], DST_REAL)) { if (!dst_checktype(args.v[0], DST_REAL)) {
*ret = dst_cstringv("expected real"); *args.ret = dst_cstringv("expected real");
return 1; return 1;
} }
tup = dst_tuple_begin(2); tup = dst_tuple_begin(2);
tup[0] = dst_wrap_real(modf(dst_unwrap_real(argv[0]), &intpart)); tup[0] = dst_wrap_real(modf(dst_unwrap_real(args.v[0]), &intpart));
tup[1] = dst_wrap_real(intpart); tup[1] = dst_wrap_real(intpart);
*ret = dst_wrap_tuple(dst_tuple_end(tup)); *args.ret = dst_wrap_tuple(dst_tuple_end(tup));
return 0; return 0;
} }

16
core/native.c
View File

@ -53,21 +53,21 @@ DstCFunction dst_native(const char *name, const uint8_t **error) {
return init; return init;
} }
int dst_load_native(int32_t argn, Dst *argv, Dst *ret) { int dst_load_native(DstArgs args) {
DstCFunction init; DstCFunction init;
const uint8_t *error = NULL; const uint8_t *error = NULL;
if (argn < 1) { if (args.n < 1) {
*ret = dst_cstringv("expected at least one argument"); *args.ret = dst_cstringv("expected at least one argument");
return 1; return 1;
} }
if (!dst_checktype(argv[0], DST_STRING)) { if (!dst_checktype(args.v[0], DST_STRING)) {
*ret = dst_cstringv("expected string"); *args.ret = dst_cstringv("expected string");
return 1; return 1;
} }
init = dst_native((const char *)dst_unwrap_string(argv[0]), &error); init = dst_native((const char *)dst_unwrap_string(args.v[0]), &error);
if (!init) { if (!init) {
*ret = dst_wrap_string(error); *args.ret = dst_wrap_string(error);
return 1; return 1;
} }
return init(argn, argv, ret); return init(args);
} }

263
core/stl.c
View File

@ -23,32 +23,32 @@
#include <dst/dst.h> #include <dst/dst.h>
#include <dst/dststl.h> #include <dst/dststl.h>
int dst_stl_push(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_push(DstArgs args) {
if (argn != 2) { if (args.n != 2) {
*ret = dst_cstringv("expected 2 arguments"); *args.ret = dst_cstringv("expected 2 arguments");
return 1; return 1;
} }
if (!dst_checktype(argv[0], DST_ARRAY)) { if (!dst_checktype(args.v[0], DST_ARRAY)) {
*ret = dst_cstringv("expected array"); *args.ret = dst_cstringv("expected array");
return 1; return 1;
} }
dst_array_push(dst_unwrap_array(argv[0]), argv[1]); dst_array_push(dst_unwrap_array(args.v[0]), args.v[1]);
*ret = argv[0]; *args.ret = args.v[0];
return 0; return 0;
} }
int dst_stl_parse(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_parse(DstArgs args) {
const uint8_t *src; const uint8_t *src;
int32_t len; int32_t len;
DstParseResult res; DstParseResult res;
const char *status_string = "ok"; const char *status_string = "ok";
DstTable *t; DstTable *t;
if (argn < 1) { if (args.n < 1) {
*ret = dst_cstringv("expected at least on argument"); *args.ret = dst_cstringv("expected at least on argument");
return 1; return 1;
} }
if (!dst_chararray_view(argv[0], &src, &len)) { if (!dst_chararray_view(args.v[0], &src, &len)) {
*ret = dst_cstringv("expected string/buffer"); *args.ret = dst_cstringv("expected string/buffer");
return 1; return 1;
} }
res = dst_parse(src, len); res = dst_parse(src, len);
@ -72,58 +72,55 @@ int dst_stl_parse(int32_t argn, Dst *argv, Dst *ret) {
if (res.status == DST_PARSE_OK) dst_table_put(t, dst_cstringv("value"), res.value); if (res.status == DST_PARSE_OK) dst_table_put(t, dst_cstringv("value"), res.value);
if (res.status == DST_PARSE_ERROR) dst_table_put(t, dst_cstringv("error"), dst_wrap_string(res.error)); if (res.status == DST_PARSE_ERROR) dst_table_put(t, dst_cstringv("error"), dst_wrap_string(res.error));
dst_table_put(t, dst_cstringv("bytes-read"), dst_wrap_integer(res.bytes_read)); dst_table_put(t, dst_cstringv("bytes-read"), dst_wrap_integer(res.bytes_read));
*ret = dst_wrap_table(t); *args.ret = dst_wrap_table(t);
return 0; return 0;
} }
int dst_stl_compile(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_compile(DstArgs args) {
DstCompileOptions opts; DstCompileOptions opts;
DstCompileResult res; DstCompileResult res;
DstTable *t; DstTable *t;
if (argn < 1) { if (args.n < 1) {
*ret = dst_cstringv("expected at least on argument"); *args.ret = dst_cstringv("expected at least on argument");
return 1; return 1;
} }
if (argn >= 3 && !dst_checktype(argv[2], DST_TUPLE)) { if (args.n >= 3 && !dst_checktype(args.v[2], DST_TUPLE)) {
*ret = dst_cstringv("expected source map to be tuple"); *args.ret = dst_cstringv("expected source map to be tuple");
return 1; return 1;
} }
opts.source = argv[0]; opts.source = args.v[0];
opts.env = argn >= 2 ? argv[1] : dst_loadstl(0); opts.env = args.n >= 2 ? args.v[1] : dst_loadstl(0);
opts.sourcemap = argn >= 3 ? dst_unwrap_tuple(argv[2]) : NULL; opts.sourcemap = args.n >= 3 ? dst_unwrap_tuple(args.v[2]) : NULL;
opts.flags = 0; opts.flags = 0;
res = dst_compile(opts); res = dst_compile(opts);
if (res.status == DST_COMPILE_OK) { if (res.status == DST_COMPILE_OK) {
DstFunction *fun = dst_compile_func(res); DstFunction *fun = dst_compile_func(res);
*ret = dst_wrap_function(fun); *args.ret = dst_wrap_function(fun);
} else { } else {
t = dst_table(2); t = dst_table(2);
dst_table_put(t, dst_cstringv("error"), dst_wrap_string(res.error)); dst_table_put(t, dst_cstringv("error"), dst_wrap_string(res.error));
dst_table_put(t, dst_cstringv("error-start"), dst_wrap_integer(res.error_start)); dst_table_put(t, dst_cstringv("error-start"), dst_wrap_integer(res.error_start));
dst_table_put(t, dst_cstringv("error-end"), dst_wrap_integer(res.error_end)); dst_table_put(t, dst_cstringv("error-end"), dst_wrap_integer(res.error_end));
*ret = dst_wrap_table(t); *args.ret = dst_wrap_table(t);
} }
return 0; return 0;
} }
int dst_stl_exit(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_exit(DstArgs args) {
(void)ret;
int32_t exitcode = 0; int32_t exitcode = 0;
if (argn > 0) { if (args.n > 0) {
exitcode = dst_hash(argv[0]); exitcode = dst_hash(args.v[0]);
} }
exit(exitcode); exit(exitcode);
return 0; return 0;
} }
int dst_stl_print(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_print(DstArgs args) {
(void)ret;
int32_t i; int32_t i;
for (i = 0; i < argn; ++i) { for (i = 0; i < args.n; ++i) {
int32_t j, len; int32_t j, len;
const uint8_t *vstr = dst_to_string(argv[i]); const uint8_t *vstr = dst_to_string(args.v[i]);
len = dst_string_length(vstr); len = dst_string_length(vstr);
for (j = 0; j < len; ++j) { for (j = 0; j < len; ++j) {
putc(vstr[j], stdout); putc(vstr[j], stdout);
@ -133,13 +130,11 @@ int dst_stl_print(int32_t argn, Dst *argv, Dst *ret) {
return 0; return 0;
} }
int dst_stl_describe(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_describe(DstArgs args) {
(void)ret;
int32_t i; int32_t i;
for (i = 0; i < argn; ++i) { for (i = 0; i < args.n; ++i) {
int32_t j, len; int32_t j, len;
const uint8_t *vstr = dst_description(argv[i]); const uint8_t *vstr = dst_description(args.v[i]);
len = dst_string_length(vstr); len = dst_string_length(vstr);
for (j = 0; j < len; ++j) { for (j = 0; j < len; ++j) {
putc(vstr[j], stdout); putc(vstr[j], stdout);
@ -149,172 +144,172 @@ int dst_stl_describe(int32_t argn, Dst *argv, Dst *ret) {
return 0; return 0;
} }
int dst_stl_string(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_string(DstArgs args) {
int32_t i; int32_t i;
DstBuffer b; DstBuffer b;
dst_buffer_init(&b, 0); dst_buffer_init(&b, 0);
for (i = 0; i < argn; ++i) { for (i = 0; i < args.n; ++i) {
int32_t len; int32_t len;
const uint8_t *str = dst_to_string(argv[i]); const uint8_t *str = dst_to_string(args.v[i]);
len = dst_string_length(str); len = dst_string_length(str);
dst_buffer_push_bytes(&b, str, len); dst_buffer_push_bytes(&b, str, len);
} }
*ret = dst_stringv(b.data, b.count); *args.ret = dst_stringv(b.data, b.count);
dst_buffer_deinit(&b); dst_buffer_deinit(&b);
return 0; return 0;
} }
int dst_stl_asm(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_asm(DstArgs args) {
DstAssembleOptions opts; DstAssembleOptions opts;
DstAssembleResult res; DstAssembleResult res;
if (argn < 1) { if (args.n < 1) {
*ret = dst_cstringv("expected assembly source"); *args.ret = dst_cstringv("expected assembly source");
return 1; return 1;
} }
opts.source = argv[0]; opts.source = args.v[0];
opts.flags = 0; opts.flags = 0;
res = dst_asm(opts); res = dst_asm(opts);
if (res.status == DST_ASSEMBLE_OK) { if (res.status == DST_ASSEMBLE_OK) {
*ret = dst_wrap_function(dst_asm_func(res)); *args.ret = dst_wrap_function(dst_asm_func(res));
return 0; return 0;
} else { } else {
*ret = dst_wrap_string(res.error); *args.ret = dst_wrap_string(res.error);
return 1; return 1;
} }
} }
int dst_stl_disasm(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_disasm(DstArgs args) {
DstFunction *f; DstFunction *f;
if (argn < 1 || !dst_checktype(argv[0], DST_FUNCTION)) { if (args.n < 1 || !dst_checktype(args.v[0], DST_FUNCTION)) {
*ret = dst_cstringv("expected function"); *args.ret = dst_cstringv("expected function");
return 1; return 1;
} }
f = dst_unwrap_function(argv[0]); f = dst_unwrap_function(args.v[0]);
*ret = dst_disasm(f->def); *args.ret = dst_disasm(f->def);
return 0; return 0;
} }
int dst_stl_tuple(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_tuple(DstArgs args) {
*ret = dst_wrap_tuple(dst_tuple_n(argv, argn)); *args.ret = dst_wrap_tuple(dst_tuple_n(args.v, args.n));
return 0; return 0;
} }
int dst_stl_array(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_array(DstArgs args) {
DstArray *array = dst_array(argn); DstArray *array = dst_array(args.n);
array->count = argn; array->count = args.n;
memcpy(array->data, argv, argn * sizeof(Dst)); memcpy(array->data, args.v, args.n * sizeof(Dst));
*ret = dst_wrap_array(array); *args.ret = dst_wrap_array(array);
return 0; return 0;
} }
int dst_stl_table(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_table(DstArgs args) {
int32_t i; int32_t i;
DstTable *table = dst_table(argn >> 1); DstTable *table = dst_table(args.n >> 1);
if (argn & 1) { if (args.n & 1) {
*ret = dst_cstringv("expected even number of arguments"); *args.ret = dst_cstringv("expected even number of arguments");
return 1; return 1;
} }
for (i = 0; i < argn; i += 2) { for (i = 0; i < args.n; i += 2) {
dst_table_put(table, argv[i], argv[i + 1]); dst_table_put(table, args.v[i], args.v[i + 1]);
} }
*ret = dst_wrap_table(table); *args.ret = dst_wrap_table(table);
return 0; return 0;
} }
int dst_stl_struct(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_struct(DstArgs args) {
int32_t i; int32_t i;
DstKV *st = dst_struct_begin(argn >> 1); DstKV *st = dst_struct_begin(args.n >> 1);
if (argn & 1) { if (args.n & 1) {
*ret = dst_cstringv("expected even number of arguments"); *args.ret = dst_cstringv("expected even number of arguments");
return 1; return 1;
} }
for (i = 0; i < argn; i += 2) { for (i = 0; i < args.n; i += 2) {
dst_struct_put(st, argv[i], argv[i + 1]); dst_struct_put(st, args.v[i], args.v[i + 1]);
} }
*ret = dst_wrap_struct(dst_struct_end(st)); *args.ret = dst_wrap_struct(dst_struct_end(st));
return 0; return 0;
} }
int dst_stl_fiber(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_fiber(DstArgs args) {
DstFiber *fiber; DstFiber *fiber;
if (argn < 1) { if (args.n < 1) {
*ret = dst_cstringv("expected at least one argument"); *args.ret = dst_cstringv("expected at least one argument");
return 1; return 1;
} }
if (!dst_checktype(argv[0], DST_FUNCTION)) { if (!dst_checktype(args.v[0], DST_FUNCTION)) {
*ret = dst_cstringv("expected a function"); *args.ret = dst_cstringv("expected a function");
return 1; return 1;
} }
fiber = dst_fiber(64); fiber = dst_fiber(64);
dst_fiber_funcframe(fiber, dst_unwrap_function(argv[0])); dst_fiber_funcframe(fiber, dst_unwrap_function(args.v[0]));
fiber->parent = dst_vm_fiber; fiber->parent = dst_vm_fiber;
*ret = dst_wrap_fiber(fiber); *args.ret = dst_wrap_fiber(fiber);
return 0; return 0;
} }
int dst_stl_buffer(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_buffer(DstArgs args) {
DstBuffer *buffer = dst_buffer(10); DstBuffer *buffer = dst_buffer(10);
int32_t i; int32_t i;
for (i = 0; i < argn; ++i) { for (i = 0; i < args.n; ++i) {
const uint8_t *bytes = dst_to_string(argv[i]); const uint8_t *bytes = dst_to_string(args.v[i]);
int32_t len = dst_string_length(bytes); int32_t len = dst_string_length(bytes);
dst_buffer_push_bytes(buffer, bytes, len); dst_buffer_push_bytes(buffer, bytes, len);
} }
*ret = dst_wrap_buffer(buffer); *args.ret = dst_wrap_buffer(buffer);
return 0; return 0;
} }
int dst_stl_gensym(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_gensym(DstArgs args) {
if (argn > 1) { if (args.n > 1) {
*ret = dst_cstringv("expected one argument"); *args.ret = dst_cstringv("expected one argument");
return 1; return 1;
} }
if (argn == 0) { if (args.n == 0) {
*ret = dst_wrap_symbol(dst_symbol_gen(NULL, 0)); *args.ret = dst_wrap_symbol(dst_symbol_gen(NULL, 0));
} else { } else {
const uint8_t *s = dst_to_string(argv[0]); const uint8_t *s = dst_to_string(args.v[0]);
*ret = dst_wrap_symbol(dst_symbol_gen(s, dst_string_length(s))); *args.ret = dst_wrap_symbol(dst_symbol_gen(s, dst_string_length(s)));
} }
return 0; return 0;
} }
int dst_stl_length(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_length(DstArgs args) {
if (argn != 1) { if (args.n != 1) {
*ret = dst_cstringv("expected at least 1 argument"); *args.ret = dst_cstringv("expected at least 1 argument");
return 1; return 1;
} }
*ret = dst_wrap_integer(dst_length(argv[0])); *args.ret = dst_wrap_integer(dst_length(args.v[0]));
return 0; return 0;
} }
int dst_stl_get(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_get(DstArgs args) {
int32_t i; int32_t i;
Dst ds; Dst ds;
if (argn < 1) { if (args.n < 1) {
*ret = dst_cstringv("expected at least 1 argument"); *args.ret = dst_cstringv("expected at least 1 argument");
return 1; return 1;
} }
ds = argv[0]; ds = args.v[0];
for (i = 1; i < argn; i++) { for (i = 1; i < args.n; i++) {
ds = dst_get(ds, argv[i]); ds = dst_get(ds, args.v[i]);
if (dst_checktype(ds, DST_NIL)) if (dst_checktype(ds, DST_NIL))
break; break;
} }
*ret = ds; *args.ret = ds;
return 0; return 0;
} }
int dst_stl_status(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_status(DstArgs args) {
const char *status; const char *status;
if (argn != 1) { if (args.n != 1) {
*ret = dst_cstringv("expected 1 argument"); *args.ret = dst_cstringv("expected 1 argument");
return 1; return 1;
} }
if (!dst_checktype(argv[0], DST_FIBER)) { if (!dst_checktype(args.v[0], DST_FIBER)) {
*ret = dst_cstringv("expected fiber"); *args.ret = dst_cstringv("expected fiber");
return 1; return 1;
} }
switch(dst_unwrap_fiber(argv[0])->status) { switch(dst_unwrap_fiber(args.v[0])->status) {
case DST_FIBER_PENDING: case DST_FIBER_PENDING:
status = "pending"; status = "pending";
break; break;
@ -331,65 +326,67 @@ int dst_stl_status(int32_t argn, Dst *argv, Dst *ret) {
status = "error"; status = "error";
break; break;
} }
*ret = dst_cstringv(status); *args.ret = dst_cstringv(status);
return 0; return 0;
} }
int dst_stl_put(int32_t argn, Dst *argv, Dst *ret) { int dst_stl_put(DstArgs args) {
Dst ds, key, value; Dst ds, key, value;
if (argn < 3) { DstArgs subargs = args;
*ret = dst_cstringv("expected at least 3 arguments"); if (args.n < 3) {
*args.ret = dst_cstringv("expected at least 3 arguments");
return 1; return 1;
} }
if (dst_stl_get(argn - 2, argv, ret)) { subargs.n -= 2;
if (dst_stl_get(subargs)) {
return 1; return 1;
} }
ds = *ret; ds = *args.ret;
key = argv[argn - 2]; key = args.v[args.n - 2];
value = argv[argn - 1]; value = args.v[args.n - 1];
dst_put(ds, key, value); dst_put(ds, key, value);
return 0; return 0;
} }
static int dst_stl_equal(int32_t argn, Dst *argv, Dst *ret) { static int dst_stl_equal(DstArgs args) {
int32_t i; int32_t i;
for (i = 0; i < argn - 1; i++) { for (i = 0; i < args.n - 1; i++) {
if (!dst_equals(argv[i], argv[i+1])) { if (!dst_equals(args.v[i], args.v[i+1])) {
*ret = dst_wrap_false(); *args.ret = dst_wrap_false();
return 0; return 0;
} }
} }
*ret = dst_wrap_true(); *args.ret = dst_wrap_true();
return 0; return 0;
} }
static int dst_stl_notequal(int32_t argn, Dst *argv, Dst *ret) { static int dst_stl_notequal(DstArgs args) {
int32_t i; int32_t i;
for (i = 0; i < argn - 1; i++) { for (i = 0; i < args.n - 1; i++) {
if (dst_equals(argv[i], argv[i+1])) { if (dst_equals(args.v[i], args.v[i+1])) {
*ret = dst_wrap_false(); *args.ret = dst_wrap_false();
return 0; return 0;
} }
} }
*ret = dst_wrap_true(); *args.ret = dst_wrap_true();
return 0; return 0;
} }
static int dst_stl_not(int32_t argn, Dst *argv, Dst *ret) { static int dst_stl_not(DstArgs args) {
*ret = dst_wrap_boolean(argn == 0 || !dst_truthy(argv[0])); *args.ret = dst_wrap_boolean(args.n == 0 || !dst_truthy(args.v[0]));
return 0; return 0;
} }
#define DST_DEFINE_COMPARATOR(name, pred)\ #define DST_DEFINE_COMPARATOR(name, pred)\
static int dst_stl_##name(int32_t argn, Dst *argv, Dst *ret) {\ static int dst_stl_##name(DstArgs args) {\
int32_t i;\ int32_t i;\
for (i = 0; i < argn - 1; i++) {\ for (i = 0; i < args.n - 1; i++) {\
if (dst_compare(argv[i], argv[i+1]) pred) {\ if (dst_compare(args.v[i], args.v[i+1]) pred) {\
*ret = dst_wrap_false();\ *args.ret = dst_wrap_false();\
return 0;\ return 0;\
}\ }\
}\ }\
*ret = dst_wrap_true();\ *args.ret = dst_wrap_true();\
return 0;\ return 0;\
} }

21
core/table.c
View File

@ -196,4 +196,25 @@ const DstKV *dst_table_to_struct(DstTable *t) {
return dst_struct_end(st); return dst_struct_end(st);
} }
/* Merge a table or struct into a table */
static void dst_table_mergekv(DstTable *table, const DstKV *kvs, int32_t cap) {
int32_t i;
for (i = 0; i < cap; i++) {
const DstKV *kv = kvs + i;
if (!dst_checktype(kv->key, DST_NIL)) {
dst_table_put(table, kv->key, kv->value);
}
}
}
/* Merge a table other into another table */
void dst_table_merge_table(DstTable *table, DstTable *other) {
dst_table_mergekv(table, other->data, other->capacity);
}
/* Merge a struct into a table */
void dst_table_merge_struct(DstTable *table, const DstKV *other) {
dst_table_mergekv(table, other, dst_struct_capacity(other));
}
#undef dst_table_maphash #undef dst_table_maphash

29
core/vm.c
View File

@ -492,13 +492,13 @@ static int dst_continue(Dst *returnreg) {
pc = func->def->bytecode; pc = func->def->bytecode;
vm_checkgc_next(); vm_checkgc_next();
} else if (dst_checktype(callee, DST_CFUNCTION)) { } else if (dst_checktype(callee, DST_CFUNCTION)) {
int32_t argn = dst_vm_fiber->stacktop - dst_vm_fiber->stackstart; DstArgs args;
args.n = dst_vm_fiber->stacktop - dst_vm_fiber->stackstart;
dst_fiber_cframe(dst_vm_fiber); dst_fiber_cframe(dst_vm_fiber);
retreg = dst_wrap_nil(); retreg = dst_wrap_nil();
if (dst_unwrap_cfunction(callee)( args.v = dst_vm_fiber->data + dst_vm_fiber->frame;
argn, args.ret = &retreg;
dst_vm_fiber->data + dst_vm_fiber->frame, if (dst_unwrap_cfunction(callee)(args)) {
&retreg)) {
goto vm_error; goto vm_error;
} }
goto vm_return_cfunc; goto vm_return_cfunc;
@ -516,13 +516,13 @@ static int dst_continue(Dst *returnreg) {
pc = func->def->bytecode; pc = func->def->bytecode;
vm_checkgc_next(); vm_checkgc_next();
} else if (dst_checktype(callee, DST_CFUNCTION)) { } else if (dst_checktype(callee, DST_CFUNCTION)) {
int32_t argn = dst_vm_fiber->stacktop - dst_vm_fiber->stackstart; DstArgs args;
args.n = dst_vm_fiber->stacktop - dst_vm_fiber->stackstart;
dst_fiber_cframe(dst_vm_fiber); dst_fiber_cframe(dst_vm_fiber);
retreg = dst_wrap_nil(); retreg = dst_wrap_nil();
if (dst_unwrap_cfunction(callee)( args.v = dst_vm_fiber->data + dst_vm_fiber->frame;
argn, args.ret = &retreg;
dst_vm_fiber->data + dst_vm_fiber->frame, if (dst_unwrap_cfunction(callee)(args)) {
&retreg)) {
goto vm_error; goto vm_error;
} }
goto vm_return_cfunc_tail; goto vm_return_cfunc_tail;
@ -684,12 +684,13 @@ int dst_run(Dst callee, Dst *returnreg) {
dst_fiber_reset(dst_vm_fiber); dst_fiber_reset(dst_vm_fiber);
} }
if (dst_checktype(callee, DST_CFUNCTION)) { if (dst_checktype(callee, DST_CFUNCTION)) {
DstArgs args;
*returnreg = dst_wrap_nil(); *returnreg = dst_wrap_nil();
dst_fiber_cframe(dst_vm_fiber); dst_fiber_cframe(dst_vm_fiber);
return dst_unwrap_cfunction(callee)( args.n = 0;
0, args.v = dst_vm_fiber->data + dst_vm_fiber->frame;
dst_vm_fiber->data + dst_vm_fiber->frame, args.ret = returnreg;
returnreg); return dst_unwrap_cfunction(callee)(args);
} else if (dst_checktype(callee, DST_FUNCTION)) { } else if (dst_checktype(callee, DST_FUNCTION)) {
dst_fiber_funcframe(dst_vm_fiber, dst_unwrap_function(callee)); dst_fiber_funcframe(dst_vm_fiber, dst_unwrap_function(callee));
return dst_continue(returnreg); return dst_continue(returnreg);

5
include/dst/dst.h
View File

@ -119,7 +119,8 @@ Dst dst_table_remove(DstTable *t, Dst key);
void dst_table_put(DstTable *t, Dst key, Dst value); void dst_table_put(DstTable *t, Dst key, Dst value);
const DstKV *dst_table_next(DstTable *t, const DstKV *kv); const DstKV *dst_table_next(DstTable *t, const DstKV *kv);
const DstKV *dst_table_to_struct(DstTable *t); const DstKV *dst_table_to_struct(DstTable *t);
void dst_table_merge(DstTable *t, Dst other); void dst_table_merge_table(DstTable *table, DstTable *other);
void dst_table_merge_struct(DstTable *table, const DstKV *other);
/* Fiber */ /* Fiber */
DstFiber *dst_fiber(int32_t capacity); DstFiber *dst_fiber(int32_t capacity);
@ -171,7 +172,7 @@ DstParseResult dst_parsec(const char *src);
/* Native */ /* Native */
DstCFunction dst_native(const char *name, const uint8_t **error); DstCFunction dst_native(const char *name, const uint8_t **error);
int dst_load_native(int32_t argn, Dst *argv, Dst *ret); int dst_load_native(DstArgs args);
/* VM functions */ /* VM functions */
int dst_init(); int dst_init();

78
include/dst/dststl.h
View File

@ -28,50 +28,50 @@
/* File type definition */ /* File type definition */
extern DstAbstractType dst_stl_filetype; extern DstAbstractType dst_stl_filetype;
int dst_int(int32_t argn, Dst *argv, Dst *ret); int dst_int(DstArgs args);
int dst_real(int32_t argn, Dst *argv, Dst *ret); int dst_real(DstArgs args);
int dst_add(int32_t argn, Dst *argv, Dst *ret); int dst_add(DstArgs args);
int dst_subtract(int32_t argn, Dst *argv, Dst *ret); int dst_subtract(DstArgs args);
int dst_multiply(int32_t argn, Dst *argv, Dst *ret); int dst_multiply(DstArgs args);
int dst_divide(int32_t argn, Dst *argv, Dst *ret); int dst_divide(DstArgs args);
int dst_modulo(int32_t argn, Dst *argv, Dst *ret); int dst_modulo(DstArgs args);
int dst_acos(int32_t argn, Dst *argv, Dst *ret); int dst_acos(DstArgs args);
int dst_asin(int32_t argn, Dst *argv, Dst *ret); int dst_asin(DstArgs args);
int dst_atan(int32_t argn, Dst *argv, Dst *ret); int dst_atan(DstArgs args);
int dst_cos(int32_t argn, Dst *argv, Dst *ret); int dst_cos(DstArgs args);
int dst_cosh(int32_t argn, Dst *argv, Dst *ret); int dst_cosh(DstArgs args);
int dst_sin(int32_t argn, Dst *argv, Dst *ret); int dst_sin(DstArgs args);
int dst_sinh(int32_t argn, Dst *argv, Dst *ret); int dst_sinh(DstArgs args);
int dst_tan(int32_t argn, Dst *argv, Dst *ret); int dst_tan(DstArgs args);
int dst_tanh(int32_t argn, Dst *argv, Dst *ret); int dst_tanh(DstArgs args);
int dst_exp(int32_t argn, Dst *argv, Dst *ret); int dst_exp(DstArgs args);
int dst_log(int32_t argn, Dst *argv, Dst *ret); int dst_log(DstArgs args);
int dst_log10(int32_t argn, Dst *argv, Dst *ret); int dst_log10(DstArgs args);
int dst_sqrt(int32_t argn, Dst *argv, Dst *ret); int dst_sqrt(DstArgs args);
int dst_ceil(int32_t argn, Dst *argv, Dst *ret); int dst_ceil(DstArgs args);
int dst_fabs(int32_t argn, Dst *argv, Dst *ret); int dst_fabs(DstArgs args);
int dst_floor(int32_t argn, Dst *argv, Dst *ret); int dst_floor(DstArgs args);
int dst_pow(int32_t argn, Dst *argv, Dst *ret); int dst_pow(DstArgs args);
int dst_stl_table(int32_t argn, Dst *argv, Dst *ret); int dst_stl_table(DstArgs args);
int dst_stl_array(int32_t argn, Dst *argv, Dst *ret); int dst_stl_array(DstArgs args);
int dst_stl_struct(int32_t argn, Dst *argv, Dst *ret); int dst_stl_struct(DstArgs args);
int dst_stl_tuple(int32_t argn, Dst *argv, Dst *ret); int dst_stl_tuple(DstArgs args);
int dst_band(int32_t argn, Dst *argv, Dst *ret); int dst_band(DstArgs args);
int dst_bor(int32_t argn, Dst *argv, Dst *ret); int dst_bor(DstArgs args);
int dst_bxor(int32_t argn, Dst *argv, Dst *ret); int dst_bxor(DstArgs args);
int dst_lshift(int argn, Dst *argv, Dst *ret); int dst_lshift(DstArgs arsg);
int dst_rshift(int argn, Dst *argv, Dst *ret); int dst_rshift(DstArgs args);
int dst_lshiftu(int argn, Dst *argv, Dst *ret); int dst_lshiftu(DstArgs args);
int dst_stl_fileopen(int32_t argn, Dst *argv, Dst *ret); int dst_stl_fileopen(DstArgs args);
int dst_stl_slurp(int32_t argn, Dst *argv, Dst *ret); int dst_stl_slurp(DstArgs args);
int dst_stl_fileread(int32_t argn, Dst *argv, Dst *ret); int dst_stl_fileread(DstArgs args);
int dst_stl_filewrite(int32_t argn, Dst *argv, Dst *ret); int dst_stl_filewrite(DstArgs args);
int dst_stl_fileclose(int32_t argn, Dst *argv, Dst *ret); int dst_stl_fileclose(DstArgs args);
#endif /* DST_MATH_H_defined */ #endif /* DST_MATH_H_defined */

10
include/dst/dsttypes.h
View File

@ -47,7 +47,8 @@ typedef struct DstFuncEnv DstFuncEnv;
typedef struct DstKV DstKV; typedef struct DstKV DstKV;
typedef struct DstStackFrame DstStackFrame; typedef struct DstStackFrame DstStackFrame;
typedef struct DstAbstractType DstAbstractType; typedef struct DstAbstractType DstAbstractType;
typedef int (*DstCFunction)(int32_t argn, Dst *argv, Dst *ret); typedef struct DstArgs DstArgs;
typedef int (*DstCFunction)(DstArgs args);
typedef enum DstAssembleStatus DstAssembleStatus; typedef enum DstAssembleStatus DstAssembleStatus;
typedef struct DstAssembleResult DstAssembleResult; typedef struct DstAssembleResult DstAssembleResult;
@ -309,6 +310,13 @@ struct DstReg {
DstCFunction function; DstCFunction function;
}; };
/* Hold components of arguments passed to DstCFunction. */
struct DstArgs {
int32_t n;
Dst *v;
Dst *ret;
};
/* A lightweight green thread in dst. Does not correspond to /* A lightweight green thread in dst. Does not correspond to
* operating system threads. */ * operating system threads. */
struct DstFiber { struct DstFiber {