mirror of
https://github.com/janet-lang/janet
synced 2025-04-06 07:17:16 +00:00
Add janet_fixarity. Update emscripten source.
This commit is contained in:
parent
b60e3e302a
commit
338b31f5a2
@ -119,20 +119,20 @@ Janet janet_array_peek(JanetArray *array) {
|
||||
/* C Functions */
|
||||
|
||||
static Janet cfun_new(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
int32_t cap = janet_getinteger(argv, 0);
|
||||
JanetArray *array = janet_array(cap);
|
||||
return janet_wrap_array(array);
|
||||
}
|
||||
|
||||
static Janet cfun_pop(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetArray *array = janet_getarray(argv, 0);
|
||||
return janet_array_pop(array);
|
||||
}
|
||||
|
||||
static Janet cfun_peek(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetArray *array = janet_getarray(argv, 0);
|
||||
return janet_array_peek(array);
|
||||
}
|
||||
@ -148,7 +148,7 @@ static Janet cfun_push(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_ensure(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 3, 3);
|
||||
janet_fixarity(argc, 3);
|
||||
JanetArray *array = janet_getarray(argv, 0);
|
||||
int32_t newcount = janet_getinteger(argv, 1);
|
||||
int32_t growth = janet_getinteger(argv, 2);
|
||||
|
@ -154,7 +154,7 @@ void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x) {
|
||||
/* C functions */
|
||||
|
||||
static Janet cfun_new(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
int32_t cap = janet_getinteger(argv, 0);
|
||||
JanetBuffer *buffer = janet_buffer(cap);
|
||||
return janet_wrap_buffer(buffer);
|
||||
@ -196,14 +196,14 @@ static Janet cfun_chars(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_clear(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetBuffer *buffer = janet_getbuffer(argv, 0);
|
||||
buffer->count = 0;
|
||||
return argv[0];
|
||||
}
|
||||
|
||||
static Janet cfun_popn(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetBuffer *buffer = janet_getbuffer(argv, 0);
|
||||
int32_t n = janet_getinteger(argv, 1);
|
||||
if (n < 0) janet_panic("n must be non-negative");
|
||||
|
@ -50,6 +50,11 @@ void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at) {
|
||||
janet_panicf("bad slot #%d, expected %s, got %v", n, at->name, x);
|
||||
}
|
||||
|
||||
void janet_fixarity(int32_t arity, int32_t fix) {
|
||||
if (arity != fix)
|
||||
janet_panicf("arity mismatch, expected %d, got %d", fix, arity);
|
||||
}
|
||||
|
||||
void janet_arity(int32_t arity, int32_t min, int32_t max) {
|
||||
if (min >= 0 && arity < min)
|
||||
janet_panicf("arity mismatch, expected at least %d, got %d", min, arity);
|
||||
|
@ -68,7 +68,7 @@ JanetModule janet_native(const char *name, const uint8_t **error) {
|
||||
static Janet janet_core_native(int32_t argc, Janet *argv) {
|
||||
JanetModule init;
|
||||
JanetTable *env = janet_table(0);
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
const uint8_t *path = janet_getstring(argv, 0);
|
||||
const uint8_t *error = NULL;
|
||||
init = janet_native((const char *)path, &error);
|
||||
@ -163,13 +163,13 @@ static Janet janet_core_buffer(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet janet_core_is_abstract(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
return janet_wrap_boolean(janet_checktype(argv[0], JANET_ABSTRACT));
|
||||
}
|
||||
|
||||
static Janet janet_core_scannumber(int32_t argc, Janet *argv) {
|
||||
double number;
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetByteView view = janet_getbytes(argv, 1);
|
||||
if (janet_scan_number(view.bytes, view.len, &number))
|
||||
return janet_wrap_nil();
|
||||
@ -211,7 +211,7 @@ static Janet janet_core_struct(int32_t argc, Janet *argv) {
|
||||
|
||||
static Janet janet_core_gensym(int32_t argc, Janet *argv) {
|
||||
(void) argv;
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
return janet_wrap_symbol(janet_symbol_gen());
|
||||
}
|
||||
|
||||
@ -223,7 +223,7 @@ static Janet janet_core_gccollect(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet janet_core_gcsetinterval(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
int32_t val = janet_getinteger(argv, 0);
|
||||
if (val < 0)
|
||||
janet_panic("expected non-negative integer");
|
||||
@ -233,12 +233,12 @@ static Janet janet_core_gcsetinterval(int32_t argc, Janet *argv) {
|
||||
|
||||
static Janet janet_core_gcinterval(int32_t argc, Janet *argv) {
|
||||
(void) argv;
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
return janet_wrap_number(janet_vm_gc_interval);
|
||||
}
|
||||
|
||||
static Janet janet_core_type(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetType t = janet_type(argv[0]);
|
||||
if (t == JANET_ABSTRACT) {
|
||||
return janet_ckeywordv(janet_abstract_type(janet_unwrap_abstract(argv[0]))->name);
|
||||
@ -248,7 +248,7 @@ static Janet janet_core_type(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet janet_core_next(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetDictView view = janet_getdictionary(argv, 0);
|
||||
const JanetKV *end = view.kvs + view.cap;
|
||||
const JanetKV *kv = janet_checktype(argv[1], JANET_NIL)
|
||||
@ -262,7 +262,7 @@ static Janet janet_core_next(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet janet_core_hash(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
return janet_wrap_number(janet_hash(argv[0]));
|
||||
}
|
||||
|
||||
|
@ -94,7 +94,7 @@ void janet_debug_find(
|
||||
/* Helper to find funcdef and bytecode offset to insert or remove breakpoints.
|
||||
* Takes a source file name and byte offset. */
|
||||
static void helper_find(int32_t argc, Janet *argv, JanetFuncDef **def, int32_t *bytecode_offset) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
const uint8_t *source = janet_getstring(argv, 0);
|
||||
int32_t source_offset = janet_getinteger(argv, 1);
|
||||
janet_debug_find(def, bytecode_offset, source, source_offset);
|
||||
@ -143,7 +143,7 @@ static Janet cfun_unfbreak(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_lineage(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetFiber *fiber = janet_getfiber(argv, 0);
|
||||
JanetArray *array = janet_array(0);
|
||||
while (fiber) {
|
||||
@ -200,7 +200,7 @@ static Janet doframe(JanetStackFrame *frame) {
|
||||
}
|
||||
|
||||
static Janet cfun_stack(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetFiber *fiber = janet_getfiber(argv, 0);
|
||||
JanetArray *array = janet_array(0);
|
||||
{
|
||||
@ -216,7 +216,7 @@ static Janet cfun_stack(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_argstack(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetFiber *fiber = janet_getfiber(argv, 0);
|
||||
JanetArray *array = janet_array(fiber->stacktop - fiber->stackstart);
|
||||
memcpy(array->data, fiber->data + fiber->stackstart, array->capacity * sizeof(Janet));
|
||||
|
@ -342,7 +342,7 @@ static Janet cfun_new(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_status(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetFiber *fiber = janet_getfiber(argv, 0);
|
||||
uint32_t s = (fiber->flags & JANET_FIBER_STATUS_MASK) >>
|
||||
JANET_FIBER_STATUS_OFFSET;
|
||||
@ -351,18 +351,18 @@ static Janet cfun_status(int32_t argc, Janet *argv) {
|
||||
|
||||
static Janet cfun_current(int32_t argc, Janet *argv) {
|
||||
(void) argv;
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
return janet_wrap_fiber(janet_vm_fiber);
|
||||
}
|
||||
|
||||
static Janet cfun_maxstack(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetFiber *fiber = janet_getfiber(argv, 0);
|
||||
return janet_wrap_integer(fiber->maxstack);
|
||||
}
|
||||
|
||||
static Janet cfun_setmaxstack(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetFiber *fiber = janet_getfiber(argv, 0);
|
||||
int32_t maxs = janet_getinteger(argv, 1);
|
||||
if (maxs < 0) {
|
||||
|
@ -226,7 +226,7 @@ static Janet janet_io_fwrite(int32_t argc, Janet *argv) {
|
||||
|
||||
/* Flush the bytes in the file */
|
||||
static Janet janet_io_fflush(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
|
||||
if (iof->flags & IO_CLOSED)
|
||||
janet_panic("file is closed");
|
||||
@ -249,7 +249,7 @@ static int janet_io_gc(void *p, size_t len) {
|
||||
|
||||
/* Close a file */
|
||||
static Janet janet_io_fclose(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
IOFile *iof = janet_getabstract(argv, 0, &janet_io_filetype);
|
||||
if (iof->flags & IO_CLOSED)
|
||||
janet_panic("file is closed");
|
||||
|
@ -406,30 +406,32 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
|
||||
goto done;
|
||||
case JANET_TABLE:
|
||||
{
|
||||
const JanetKV *kv = NULL;
|
||||
JanetTable *t = janet_unwrap_table(x);
|
||||
MARK_SEEN();
|
||||
pushbyte(st, t->proto ? LB_TABLE_PROTO : LB_TABLE);
|
||||
pushint(st, t->count);
|
||||
if (t->proto)
|
||||
marshal_one(st, janet_wrap_table(t->proto), flags + 1);
|
||||
while ((kv = janet_table_next(t, kv))) {
|
||||
marshal_one(st, kv->key, flags + 1);
|
||||
marshal_one(st, kv->value, flags + 1);
|
||||
for (int32_t i = 0; i < t->capacity; i++) {
|
||||
if (janet_checktype(t->data[i].key, JANET_NIL))
|
||||
continue;
|
||||
marshal_one(st, t->data[i].key, flags + 1);
|
||||
marshal_one(st, t->data[i].value, flags + 1);
|
||||
}
|
||||
}
|
||||
goto done;
|
||||
case JANET_STRUCT:
|
||||
{
|
||||
int32_t count;
|
||||
const JanetKV *kv = NULL;
|
||||
const JanetKV *struct_ = janet_unwrap_struct(x);
|
||||
count = janet_struct_length(struct_);
|
||||
pushbyte(st, LB_STRUCT);
|
||||
pushint(st, count);
|
||||
while ((kv = janet_struct_next(struct_, kv))) {
|
||||
marshal_one(st, kv->key, flags + 1);
|
||||
marshal_one(st, kv->value, flags + 1);
|
||||
for (int32_t i = 0; i < janet_struct_capacity(struct_); i++) {
|
||||
if (janet_checktype(struct_[i].key, JANET_NIL))
|
||||
continue;
|
||||
marshal_one(st, struct_[i].key, flags + 1);
|
||||
marshal_one(st, struct_[i].value, flags + 1);
|
||||
}
|
||||
/* Mark as seen AFTER marshaling */
|
||||
MARK_SEEN();
|
||||
@ -1102,7 +1104,7 @@ int janet_unmarshal(
|
||||
/* C functions */
|
||||
|
||||
static Janet cfun_env_lookup(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetTable *env = janet_gettable(argv, 0);
|
||||
return janet_wrap_table(janet_env_lookup(env));
|
||||
}
|
||||
|
@ -26,21 +26,21 @@
|
||||
/* Get a random number */
|
||||
Janet janet_rand(int32_t argc, Janet *argv) {
|
||||
(void) argv;
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
double r = (rand() % RAND_MAX) / ((double) RAND_MAX);
|
||||
return janet_wrap_number(r);
|
||||
}
|
||||
|
||||
/* Seed the random number generator */
|
||||
Janet janet_srand(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
int32_t x = janet_getinteger(argv, 0);
|
||||
srand((unsigned) x);
|
||||
return janet_wrap_nil();
|
||||
}
|
||||
|
||||
Janet janet_remainder(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
double x = janet_getnumber(argv, 0);
|
||||
double y = janet_getnumber(argv, 1);
|
||||
return janet_wrap_number(fmod(x, y));
|
||||
@ -48,7 +48,7 @@ Janet janet_remainder(int32_t argc, Janet *argv) {
|
||||
|
||||
#define JANET_DEFINE_MATHOP(name, fop)\
|
||||
Janet janet_##name(int32_t argc, Janet *argv) {\
|
||||
janet_arity(argc, 1, 1); \
|
||||
janet_fixarity(argc, 1); \
|
||||
double x = janet_getnumber(argv, 0); \
|
||||
return janet_wrap_number(fop(x)); \
|
||||
}
|
||||
@ -72,7 +72,7 @@ JANET_DEFINE_MATHOP(floor, floor)
|
||||
|
||||
#define JANET_DEFINE_MATH2OP(name, fop)\
|
||||
Janet janet_##name(int32_t argc, Janet *argv) {\
|
||||
janet_arity(argc, 2, 2); \
|
||||
janet_fixarity(argc, 2); \
|
||||
double lhs = janet_getnumber(argv, 0); \
|
||||
double rhs = janet_getnumber(argv, 1); \
|
||||
return janet_wrap_number(fop(lhs, rhs)); \
|
||||
@ -82,7 +82,7 @@ JANET_DEFINE_MATH2OP(atan2, atan2)
|
||||
JANET_DEFINE_MATH2OP(pow, pow)
|
||||
|
||||
static Janet janet_not(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
return janet_wrap_boolean(!janet_truthy(argv[0]));
|
||||
}
|
||||
|
||||
|
@ -41,7 +41,7 @@
|
||||
#endif
|
||||
|
||||
static Janet os_which(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
(void) argv;
|
||||
#ifdef JANET_WINDOWS
|
||||
return janet_ckeywordv("windows");
|
||||
@ -156,7 +156,7 @@ static Janet os_shell(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet os_getenv(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
const uint8_t *k = janet_getstring(argv, 0);
|
||||
const char *cstr = (const char *) k;
|
||||
const char *res = getenv(cstr);
|
||||
@ -198,7 +198,7 @@ static Janet os_exit(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet os_time(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
(void) argv;
|
||||
double dtime = (double)(time(NULL));
|
||||
return janet_wrap_number(dtime);
|
||||
@ -232,7 +232,7 @@ static int gettime(struct timespec *spec) {
|
||||
#endif
|
||||
|
||||
static Janet os_clock(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
(void) argv;
|
||||
struct timespec tv;
|
||||
if (gettime(&tv)) janet_panic("could not get time");
|
||||
@ -241,7 +241,7 @@ static Janet os_clock(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet os_sleep(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
double delay = janet_getnumber(argv, 0);
|
||||
if (delay < 0) janet_panic("invalid argument to sleep");
|
||||
#ifdef JANET_WINDOWS
|
||||
@ -258,7 +258,7 @@ static Janet os_sleep(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet os_cwd(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
(void) argv;
|
||||
char buf[FILENAME_MAX];
|
||||
char *ptr;
|
||||
|
@ -623,7 +623,7 @@ static JanetAbstractType janet_parse_parsertype = {
|
||||
/* C Function parser */
|
||||
static Janet cfun_parser(int32_t argc, Janet *argv) {
|
||||
(void) argv;
|
||||
janet_arity(argc, 0, 0);
|
||||
janet_fixarity(argc, 0);
|
||||
JanetParser *p = janet_abstract(&janet_parse_parsertype, sizeof(JanetParser));
|
||||
janet_parser_init(p);
|
||||
return janet_wrap_abstract(p);
|
||||
@ -655,13 +655,13 @@ static Janet cfun_consume(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_has_more(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
return janet_wrap_boolean(janet_parser_has_more(p));
|
||||
}
|
||||
|
||||
static Janet cfun_byte(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
int32_t i = janet_getinteger(argv, 1);
|
||||
janet_parser_consume(p, 0xFF & i);
|
||||
@ -669,7 +669,7 @@ static Janet cfun_byte(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_status(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
const char *stat = NULL;
|
||||
switch (janet_parser_status(p)) {
|
||||
@ -687,7 +687,7 @@ static Janet cfun_status(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_error(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
const char *err = janet_parser_error(p);
|
||||
if (err) return janet_cstringv(err);
|
||||
@ -695,20 +695,20 @@ static Janet cfun_error(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_produce(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
return janet_parser_produce(p);
|
||||
}
|
||||
|
||||
static Janet cfun_flush(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
janet_parser_flush(p);
|
||||
return argv[0];
|
||||
}
|
||||
|
||||
static Janet cfun_where(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
return janet_wrap_integer(p->offset);
|
||||
}
|
||||
@ -717,7 +717,7 @@ static Janet cfun_state(int32_t argc, Janet *argv) {
|
||||
size_t i;
|
||||
const uint8_t *str;
|
||||
size_t oldcount;
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype);
|
||||
oldcount = p->bufcount;
|
||||
for (i = 0; i < p->statecount; i++) {
|
||||
|
@ -832,7 +832,7 @@ static Janet cfun_slice(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_repeat(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetByteView view = janet_getbytes(argv, 0);
|
||||
int32_t rep = janet_getinteger(argv, 1);
|
||||
if (rep < 0) janet_panic("expected non-negative number of repetitions");
|
||||
@ -849,7 +849,7 @@ static Janet cfun_repeat(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_bytes(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetByteView view = janet_getbytes(argv, 0);
|
||||
Janet *tup = janet_tuple_begin(view.len);
|
||||
int32_t i;
|
||||
@ -870,7 +870,7 @@ static Janet cfun_frombytes(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_asciilower(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetByteView view = janet_getbytes(argv, 0);
|
||||
uint8_t *buf = janet_string_begin(view.len);
|
||||
for (int32_t i = 0; i < view.len; i++) {
|
||||
@ -885,7 +885,7 @@ static Janet cfun_asciilower(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_asciiupper(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetByteView view = janet_getbytes(argv, 0);
|
||||
uint8_t *buf = janet_string_begin(view.len);
|
||||
for (int32_t i = 0; i < view.len; i++) {
|
||||
@ -900,7 +900,7 @@ static Janet cfun_asciiupper(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_reverse(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetByteView view = janet_getbytes(argv, 0);
|
||||
uint8_t *buf = janet_string_begin(view.len);
|
||||
int32_t i, j;
|
||||
|
@ -158,17 +158,6 @@ Janet janet_struct_get(const JanetKV *st, Janet key) {
|
||||
return kv ? kv->value : janet_wrap_nil();
|
||||
}
|
||||
|
||||
/* Get the next key in a struct */
|
||||
const JanetKV *janet_struct_next(const JanetKV *st, const JanetKV *kv) {
|
||||
const JanetKV *end = st + janet_struct_capacity(st);
|
||||
kv = (kv == NULL) ? st : kv + 1;
|
||||
while (kv < end) {
|
||||
if (!janet_checktype(kv->key, JANET_NIL)) return kv;
|
||||
kv++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Convert struct to table */
|
||||
JanetTable *janet_struct_to_table(const JanetKV *st) {
|
||||
JanetTable *table = janet_table(janet_struct_capacity(st));
|
||||
|
@ -158,17 +158,6 @@ void janet_table_clear(JanetTable *t) {
|
||||
t->deleted = 0;
|
||||
}
|
||||
|
||||
/* Find next key in an object. Returns NULL if no next key. */
|
||||
const JanetKV *janet_table_next(JanetTable *t, const JanetKV *kv) {
|
||||
JanetKV *end = t->data + t->capacity;
|
||||
kv = (kv == NULL) ? t->data : kv + 1;
|
||||
while (kv < end) {
|
||||
if (!janet_checktype(kv->key, JANET_NIL)) return kv;
|
||||
kv++;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Convert table to struct */
|
||||
const JanetKV *janet_table_to_struct(JanetTable *t) {
|
||||
JanetKV *st = janet_struct_begin(t->count);
|
||||
@ -206,13 +195,13 @@ void janet_table_merge_struct(JanetTable *table, const JanetKV *other) {
|
||||
/* C Functions */
|
||||
|
||||
static Janet cfun_new(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
int32_t cap = janet_getinteger(argv, 0);
|
||||
return janet_wrap_table(janet_table(cap));
|
||||
}
|
||||
|
||||
static Janet cfun_getproto(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetTable *t = janet_gettable(argv, 0);
|
||||
return t->proto
|
||||
? janet_wrap_table(t->proto)
|
||||
@ -220,7 +209,7 @@ static Janet cfun_getproto(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_setproto(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetTable *table = janet_gettable(argv, 0);
|
||||
JanetTable *proto = NULL;
|
||||
if (!janet_checktype(argv[1], JANET_NIL)) {
|
||||
@ -231,13 +220,13 @@ static Janet cfun_setproto(int32_t argc, Janet *argv) {
|
||||
}
|
||||
|
||||
static Janet cfun_tostruct(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 1, 1);
|
||||
janet_fixarity(argc, 1);
|
||||
JanetTable *t = janet_gettable(argv, 0);
|
||||
return janet_wrap_struct(janet_table_to_struct(t));
|
||||
}
|
||||
|
||||
static Janet cfun_rawget(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
JanetTable *table = janet_gettable(argv, 0);
|
||||
return janet_table_rawget(table, argv[1]);
|
||||
}
|
||||
|
@ -1032,7 +1032,6 @@ JANET_API JanetKV *janet_struct_begin(int32_t count);
|
||||
JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value);
|
||||
JANET_API const JanetKV *janet_struct_end(JanetKV *st);
|
||||
JANET_API Janet janet_struct_get(const JanetKV *st, Janet key);
|
||||
JANET_API const JanetKV *janet_struct_next(const JanetKV *st, const JanetKV *kv);
|
||||
JANET_API JanetTable *janet_struct_to_table(const JanetKV *st);
|
||||
JANET_API int janet_struct_equal(const JanetKV *lhs, const JanetKV *rhs);
|
||||
JANET_API int janet_struct_compare(const JanetKV *lhs, const JanetKV *rhs);
|
||||
@ -1046,7 +1045,6 @@ JANET_API Janet janet_table_get(JanetTable *t, Janet key);
|
||||
JANET_API Janet janet_table_rawget(JanetTable *t, Janet key);
|
||||
JANET_API Janet janet_table_remove(JanetTable *t, Janet key);
|
||||
JANET_API void janet_table_put(JanetTable *t, Janet key, Janet value);
|
||||
JANET_API const JanetKV *janet_table_next(JanetTable *t, const JanetKV *kv);
|
||||
JANET_API const JanetKV *janet_table_to_struct(JanetTable *t);
|
||||
JANET_API void janet_table_merge_table(JanetTable *table, JanetTable *other);
|
||||
JANET_API void janet_table_merge_struct(JanetTable *table, const JanetKV *other);
|
||||
@ -1150,6 +1148,7 @@ JANET_API void janet_panics(const uint8_t *message);
|
||||
JANET_API void janet_panic_type(Janet x, int32_t n, int expected);
|
||||
JANET_API void janet_panic_abstract(Janet x, int32_t n, const JanetAbstractType *at);
|
||||
JANET_API void janet_arity(int32_t arity, int32_t min, int32_t max);
|
||||
JANET_API void janet_fixarity(int32_t arity, int32_t fix);
|
||||
|
||||
JANET_API double janet_getnumber(const Janet *argv, int32_t n);
|
||||
JANET_API JanetArray *janet_getarray(const Janet *argv, int32_t n);
|
||||
|
@ -24,7 +24,7 @@
|
||||
|
||||
/* Common */
|
||||
Janet janet_line_getter(int32_t argc, Janet *argv) {
|
||||
janet_arity(argc, 2, 2);
|
||||
janet_fixarity(argc, 2);
|
||||
const uint8_t *str = janet_getstring(argv, 0);
|
||||
JanetBuffer *buf = janet_getbuffer(argv, 1);
|
||||
janet_line_get(str, buf);
|
||||
|
@ -32,11 +32,11 @@ static const uint8_t *line_prompt = NULL;
|
||||
|
||||
/* Yield to JS event loop from janet. Takes a repl prompt
|
||||
* and a buffer to fill with input data. */
|
||||
static int repl_yield(JanetArgs args) {
|
||||
JANET_FIXARITY(args, 2);
|
||||
JANET_ARG_STRING(line_prompt, args, 0);
|
||||
JANET_ARG_BUFFER(line_buffer, args, 1);
|
||||
JANET_RETURN_NIL(args);
|
||||
static Janet repl_yield(int32_t argc, Janet *argv) {
|
||||
janet_fixarity(argc, 2);
|
||||
line_prompt = janet_getstring(argv, 0);
|
||||
line_buffer = janet_getbuffer(argv, 1);
|
||||
return janet_wrap_nil();
|
||||
}
|
||||
|
||||
/* Re-enter the loop */
|
||||
@ -53,14 +53,11 @@ static int enter_loop(void) {
|
||||
}
|
||||
|
||||
/* Allow JS interop from within janet */
|
||||
static int cfun_js(JanetArgs args) {
|
||||
const uint8_t *bytes;
|
||||
int32_t len;
|
||||
JANET_FIXARITY(args, 1);
|
||||
JANET_ARG_BYTES(bytes, len, args, 0);
|
||||
(void) len;
|
||||
emscripten_run_script((const char *)bytes);
|
||||
JANET_RETURN_NIL(args);
|
||||
static Janet cfun_js(int32_t argc, Janet *argv) {
|
||||
janet_fixarity(argc, 1);
|
||||
JanetByteView bytes = janet_getbytes(argv, 0);
|
||||
emscripten_run_script((const char *)bytes.bytes);
|
||||
return janet_wrap_nil();
|
||||
}
|
||||
|
||||
/* Intialize the repl */
|
||||
|
Loading…
x
Reference in New Issue
Block a user