mirror of
https://github.com/janet-lang/janet
synced 2024-12-26 00:10:27 +00:00
357 lines
12 KiB
C
357 lines
12 KiB
C
/*
|
|
* Copyright (c) 2017 Calvin Rose
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to
|
|
* deal in the Software without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <gst/gst.h>
|
|
|
|
/* Wrapper functions wrap a data type that is used from C into a
|
|
* gst value, which can then be used in gst. */
|
|
|
|
GstValue gst_wrap_nil() {
|
|
GstValue y;
|
|
y.type = GST_NIL;
|
|
return y;
|
|
}
|
|
|
|
int gst_check_nil(Gst *vm, uint32_t i) {
|
|
GstValue a = gst_arg(vm, i);
|
|
return a.type == GST_NIL;
|
|
}
|
|
|
|
#define GST_WRAP_DEFINE(NAME, TYPE, GTYPE, UM)\
|
|
GstValue gst_wrap_##NAME(TYPE x) {\
|
|
GstValue y;\
|
|
y.type = GTYPE;\
|
|
y.data.UM = x;\
|
|
return y;\
|
|
}\
|
|
\
|
|
int gst_check_##NAME(Gst *vm, uint32_t i, TYPE (*out)) {\
|
|
GstValue a = gst_arg(vm, i);\
|
|
if (a.type != GTYPE) return 0;\
|
|
*out = a.data.UM;\
|
|
return 1;\
|
|
}\
|
|
|
|
GST_WRAP_DEFINE(real, GstReal, GST_REAL, real)
|
|
GST_WRAP_DEFINE(integer, GstInteger, GST_INTEGER, integer)
|
|
GST_WRAP_DEFINE(boolean, int, GST_BOOLEAN, boolean)
|
|
GST_WRAP_DEFINE(string, const uint8_t *, GST_STRING, string)
|
|
GST_WRAP_DEFINE(array, GstArray *, GST_ARRAY, array)
|
|
GST_WRAP_DEFINE(tuple, const GstValue *, GST_TUPLE, tuple)
|
|
GST_WRAP_DEFINE(struct, const GstValue *, GST_STRUCT, st)
|
|
GST_WRAP_DEFINE(thread, GstThread *, GST_THREAD, thread)
|
|
GST_WRAP_DEFINE(buffer, GstBuffer *, GST_BYTEBUFFER, buffer)
|
|
GST_WRAP_DEFINE(function, GstFunction *, GST_FUNCTION, function)
|
|
GST_WRAP_DEFINE(cfunction, GstCFunction, GST_CFUNCTION, cfunction)
|
|
GST_WRAP_DEFINE(table, GstTable *, GST_TABLE, table)
|
|
GST_WRAP_DEFINE(funcenv, GstFuncEnv *, GST_FUNCENV, env)
|
|
GST_WRAP_DEFINE(funcdef, GstFuncDef *, GST_FUNCDEF, def)
|
|
|
|
#undef GST_WRAP_DEFINE
|
|
|
|
GstValue gst_wrap_userdata(void *x) {
|
|
GstValue ret;
|
|
ret.type = GST_USERDATA;
|
|
ret.data.pointer = x;
|
|
return ret;
|
|
}
|
|
|
|
void *gst_check_userdata(Gst *vm, uint32_t i, const GstUserType *type) {
|
|
GstValue x = gst_arg(vm, i);
|
|
GstUserdataHeader *h;
|
|
if (x.type != GST_USERDATA) return NULL;
|
|
h = gst_udata_header(x.data.pointer);
|
|
if (h->type != type) return NULL;
|
|
return x.data.pointer;
|
|
}
|
|
|
|
static void gst_cmodule_register(Gst *vm, const char *name, const GstModuleItem *mod) {
|
|
uint32_t startLength;
|
|
GstBuffer *buffer = gst_buffer(vm, 10);
|
|
gst_buffer_append_cstring(vm, buffer, name);
|
|
gst_buffer_push(vm, buffer, '.');
|
|
startLength = buffer->count;
|
|
while (mod->name != NULL) {
|
|
GstValue key;
|
|
buffer->count = startLength;
|
|
gst_buffer_append_cstring(vm, buffer, mod->name);
|
|
key = gst_wrap_string(gst_buffer_to_string(vm, buffer));
|
|
gst_table_put(vm, vm->registry, key, gst_wrap_cfunction(mod->data));
|
|
gst_table_put(vm, vm->registry, gst_wrap_cfunction(mod->data), key);
|
|
mod++;
|
|
}
|
|
}
|
|
|
|
static GstValue gst_cmodule_table(Gst *vm, const GstModuleItem *mod) {
|
|
GstTable *module = gst_table(vm, 10);
|
|
while (mod->name != NULL) {
|
|
GstValue key = gst_string_cv(vm, mod->name);
|
|
gst_table_put(vm, module, key, gst_wrap_cfunction(mod->data));
|
|
mod++;
|
|
}
|
|
return gst_wrap_table(module);
|
|
}
|
|
|
|
static GstValue gst_cmodule_struct(Gst *vm, const GstModuleItem *mod) {
|
|
uint32_t count = 0;
|
|
const GstModuleItem *m = mod;
|
|
GstValue *st;
|
|
while (m->name != NULL) {
|
|
++count;
|
|
++m;
|
|
}
|
|
st = gst_struct_begin(vm, count);
|
|
m = mod;
|
|
while (m->name != NULL) {
|
|
gst_struct_put(st,
|
|
gst_string_cv(vm, m->name),
|
|
gst_wrap_cfunction(m->data));
|
|
++m;
|
|
}
|
|
return gst_wrap_struct(gst_struct_end(vm, st));
|
|
}
|
|
|
|
void gst_module(Gst *vm, const char *packagename, const GstModuleItem *mod) {
|
|
gst_table_put(vm, vm->modules, gst_string_cv(vm, packagename), gst_cmodule_struct(vm, mod));
|
|
gst_cmodule_register(vm, packagename, mod);
|
|
}
|
|
|
|
void gst_module_mutable(Gst *vm, const char *packagename, const GstModuleItem *mod) {
|
|
gst_table_put(vm, vm->modules, gst_string_cv(vm, packagename), gst_cmodule_table(vm, mod));
|
|
gst_cmodule_register(vm, packagename, mod);
|
|
}
|
|
|
|
void gst_module_put(Gst *vm, const char *packagename, const char *name, GstValue v) {
|
|
GstValue modtable = gst_table_get(vm->modules, gst_string_cv(vm, packagename));
|
|
if (modtable.type == GST_TABLE) {
|
|
GstTable *table = modtable.data.table;
|
|
if (v.type == GST_CFUNCTION) {
|
|
GstValue key;
|
|
GstBuffer *buffer = gst_buffer(vm, 10);
|
|
gst_buffer_append_cstring(vm, buffer, packagename);
|
|
gst_buffer_push(vm, buffer, '.');
|
|
gst_buffer_append_cstring(vm, buffer, name);
|
|
key = gst_wrap_string(gst_buffer_to_string(vm, buffer));
|
|
gst_table_put(vm, vm->registry, key, v);
|
|
gst_table_put(vm, vm->registry, v, key);
|
|
}
|
|
gst_table_put(vm, table, gst_string_cv(vm, name), v);
|
|
}
|
|
}
|
|
|
|
GstValue gst_module_get(Gst *vm, const char *packagename) {
|
|
return gst_table_get(vm->modules, gst_string_cv(vm, packagename));
|
|
}
|
|
|
|
/****/
|
|
/* Misc */
|
|
/****/
|
|
|
|
/* Utilities for manipulating different types with the same semantics */
|
|
|
|
/* Read both tuples and arrays as c pointers + uint32_t length. Return 1 if the
|
|
* view can be constructed, 0 if an invalid type. */
|
|
int gst_seq_view(GstValue seq, const GstValue **data, uint32_t *len) {
|
|
if (seq.type == GST_ARRAY) {
|
|
*data = seq.data.array->data;
|
|
*len = seq.data.array->count;
|
|
return 1;
|
|
} else if (seq.type == GST_TUPLE) {
|
|
*data = seq.data.st;
|
|
*len = gst_tuple_length(seq.data.st);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Read both strings and buffer as unsigned character array + uint32_t len.
|
|
* Returns 1 if the view can be constructed and 0 if the type is invalid. */
|
|
int gst_chararray_view(GstValue str, const uint8_t **data, uint32_t *len) {
|
|
if (str.type == GST_STRING) {
|
|
*data = str.data.string;
|
|
*len = gst_string_length(str.data.string);
|
|
return 1;
|
|
} else if (str.type == GST_BYTEBUFFER) {
|
|
*data = str.data.buffer->data;
|
|
*len = str.data.buffer->count;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Read both structs and tables as the entries of a hashtable with
|
|
* identical structure. Returns 1 if the view can be constructed and
|
|
* 0 if the type is invalid. */
|
|
int gst_hashtable_view(GstValue tab, const GstValue **data, uint32_t *cap) {
|
|
if (tab.type == GST_TABLE) {
|
|
*data = tab.data.table->data;
|
|
*cap = tab.data.table->capacity;
|
|
return 1;
|
|
} else if (tab.type == GST_STRUCT) {
|
|
*data = tab.data.st;
|
|
*cap = gst_struct_capacity(tab.data.st);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
GstReal gst_integer_to_real(GstInteger x) {
|
|
return (GstReal) x;
|
|
}
|
|
|
|
GstInteger gst_real_to_integer(GstReal x) {
|
|
return (GstInteger) x;
|
|
}
|
|
|
|
GstInteger gst_startrange(GstInteger raw, uint32_t len) {
|
|
if (raw >= len)
|
|
return -1;
|
|
if (raw < 0)
|
|
return len + raw;
|
|
return raw;
|
|
}
|
|
|
|
GstInteger gst_endrange(GstInteger raw, uint32_t len) {
|
|
if (raw > len)
|
|
return -1;
|
|
if (raw < 0)
|
|
return len + raw + 1;
|
|
return raw;
|
|
}
|
|
|
|
int gst_callc(Gst *vm, GstCFunction fn, int numargs, ...) {
|
|
int result, i;
|
|
va_list args;
|
|
GstValue *stack;
|
|
va_start(args, numargs);
|
|
stack = gst_thread_beginframe(vm, vm->thread, gst_wrap_cfunction(fn), numargs);
|
|
for (i = 0; i < numargs; ++i) {
|
|
stack[i] = va_arg(args, GstValue);
|
|
}
|
|
va_end(args);
|
|
result = fn(vm);
|
|
gst_thread_popframe(vm, vm->thread);
|
|
return result;
|
|
}
|
|
|
|
static GstTable *gst_env_inttab(Gst *vm, GstTable *env, GstInteger i) {
|
|
GstTable *tab;
|
|
GstValue key = gst_wrap_integer(i);
|
|
GstValue maybeTab = gst_table_get(env, key);
|
|
if (maybeTab.type != GST_TABLE) {
|
|
tab = gst_table(vm, 10);
|
|
gst_table_put(vm, env, key, gst_wrap_table(tab));
|
|
} else {
|
|
tab = maybeTab.data.table;
|
|
}
|
|
return tab;
|
|
}
|
|
|
|
GstTable *gst_env_nils(Gst *vm, GstTable *env) {
|
|
return gst_env_inttab(vm, env, GST_ENV_NILS);
|
|
}
|
|
|
|
GstTable *gst_env_meta(Gst *vm, GstTable *env) {
|
|
return gst_env_inttab(vm, env, GST_ENV_METADATA);
|
|
}
|
|
|
|
/* Add many global variables and bind to nil */
|
|
static void mergenils(Gst *vm, GstTable *destEnv, GstTable *nils) {
|
|
const GstValue *data = nils->data;
|
|
uint32_t len = nils->capacity;
|
|
uint32_t i;
|
|
GstTable *destNils = gst_env_nils(vm, destEnv);
|
|
for (i = 0; i < len; i += 2) {
|
|
if (data[i].type == GST_STRING) {
|
|
gst_table_put(vm, destEnv, data[i], gst_wrap_nil());
|
|
gst_table_put(vm, destNils, data[i], gst_wrap_boolean(1));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Add many global variable metadata */
|
|
static void mergemeta(Gst *vm, GstTable *destEnv, GstTable *meta) {
|
|
const GstValue *data = meta->data;
|
|
uint32_t len = meta->capacity;
|
|
uint32_t i;
|
|
GstTable *destMeta = gst_env_meta(vm, destEnv);
|
|
for (i = 0; i < len; i += 2) {
|
|
if (data[i].type == GST_STRING) {
|
|
gst_table_put(vm, destMeta, data[i], data[i + 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Add many global variables */
|
|
void gst_env_merge(Gst *vm, GstTable *destEnv, GstTable *srcEnv) {
|
|
const GstValue *data = srcEnv->data;
|
|
uint32_t len = srcEnv->capacity;
|
|
uint32_t i;
|
|
for (i = 0; i < len; i += 2) {
|
|
if (data[i].type == GST_STRING) {
|
|
gst_table_put(vm, destEnv, data[i], data[i + 1]);
|
|
} else if (data[i].type == GST_INTEGER) {
|
|
switch (data[i].data.integer) {
|
|
case GST_ENV_NILS:
|
|
if (data[i + 1].type == GST_TABLE)
|
|
mergenils(vm, destEnv, data[i + 1].data.table);
|
|
break;
|
|
case GST_ENV_METADATA:
|
|
if (data[i + 1].type == GST_TABLE)
|
|
mergemeta(vm, destEnv, data[i + 1].data.table);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void gst_env_put(Gst *vm, GstTable *env, GstValue key, GstValue value) {
|
|
GstTable *meta = gst_env_meta(vm, env);
|
|
gst_table_put(vm, meta, key, gst_wrap_nil());
|
|
gst_table_put(vm, env, key, value);
|
|
if (value.type == GST_NIL) {
|
|
gst_table_put(vm, gst_env_nils(vm, env), key, gst_wrap_boolean(1));
|
|
}
|
|
}
|
|
|
|
void gst_env_putc(Gst *vm, GstTable *env, const char *key, GstValue value) {
|
|
GstValue keyv = gst_string_cv(vm, key);
|
|
gst_env_put(vm, env, keyv, value);
|
|
}
|
|
|
|
void gst_env_putvar(Gst *vm, GstTable *env, GstValue key, GstValue value) {
|
|
GstTable *meta = gst_env_meta(vm, env);
|
|
GstTable *newmeta = gst_table(vm, 4);
|
|
GstArray *ref = gst_array(vm, 1);
|
|
ref->count = 1;
|
|
ref->data[0] = value;
|
|
gst_table_put(vm, env, key, gst_wrap_array(ref));
|
|
gst_table_put(vm, newmeta, gst_string_cv(vm, "mutable"), gst_wrap_boolean(1));
|
|
gst_table_put(vm, meta, key, gst_wrap_table(newmeta));
|
|
}
|
|
|
|
void gst_env_putvarc(Gst *vm, GstTable *env, const char *key, GstValue value) {
|
|
GstValue keyv = gst_string_cv(vm, key);
|
|
gst_env_putvar(vm, env, keyv, value);
|
|
} |