mirrors/janet
1
0
Fork 0
mirror of https://github.com/janet-lang/janet synced 2025-04-28 21:53:19 +00:00
Code Issues 1 Releases Wiki Activity

Expose abstract type definitions in janet.h

Browse Source 
This makes certain operations easier, and allows
more access to built in APIs.
This commit is contained in:
Calvin Rose 2020-03-14 10:12:47 -05:00
parent 7996edfef9
commit 6a3a983f43
9 changed files with 176 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/core/inttypes.c
View File

@ -81,7 +81,7 @@ static void it_u64_tostring(void *p, JanetBuffer *buffer) {
janet_buffer_push_cstring(buffer, str); janet_buffer_push_cstring(buffer, str);
} }
static const JanetAbstractType it_s64_type = { const JanetAbstractType janet_s64_type = {
"core/s64", "core/s64",
NULL, NULL,
NULL, NULL,
@ -95,7 +95,7 @@ static const JanetAbstractType it_s64_type = {
JANET_ATEND_HASH JANET_ATEND_HASH
}; };
static const JanetAbstractType it_u64_type = { const JanetAbstractType janet_u64_type = {
"core/u64", "core/u64",
NULL, NULL,
NULL, NULL,
@ -128,8 +128,8 @@ int64_t janet_unwrap_s64(Janet x) {
} }
case JANET_ABSTRACT: { case JANET_ABSTRACT: {
void *abst = janet_unwrap_abstract(x); void *abst = janet_unwrap_abstract(x);
if (janet_abstract_type(abst) == &it_s64_type || if (janet_abstract_type(abst) == &janet_s64_type ||
(janet_abstract_type(abst) == &it_u64_type)) (janet_abstract_type(abst) == &janet_u64_type))
return *(int64_t *)abst; return *(int64_t *)abst;
break; break;
} }
@ -157,8 +157,8 @@ uint64_t janet_unwrap_u64(Janet x) {
} }
case JANET_ABSTRACT: { case JANET_ABSTRACT: {
void *abst = janet_unwrap_abstract(x); void *abst = janet_unwrap_abstract(x);
if (janet_abstract_type(abst) == &it_s64_type || if (janet_abstract_type(abst) == &janet_s64_type ||
(janet_abstract_type(abst) == &it_u64_type)) (janet_abstract_type(abst) == &janet_u64_type))
return *(uint64_t *)abst; return *(uint64_t *)abst;
break; break;
} }
@ -170,19 +170,19 @@ uint64_t janet_unwrap_u64(Janet x) {
JanetIntType janet_is_int(Janet x) { JanetIntType janet_is_int(Janet x) {
if (!janet_checktype(x, JANET_ABSTRACT)) return JANET_INT_NONE; if (!janet_checktype(x, JANET_ABSTRACT)) return JANET_INT_NONE;
const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x)); const JanetAbstractType *at = janet_abstract_type(janet_unwrap_abstract(x));
return (at == &it_s64_type) ? JANET_INT_S64 : return (at == &janet_s64_type) ? JANET_INT_S64 :
((at == &it_u64_type) ? JANET_INT_U64 : ((at == &janet_u64_type) ? JANET_INT_U64 :
JANET_INT_NONE); JANET_INT_NONE);
} }
Janet janet_wrap_s64(int64_t x) { Janet janet_wrap_s64(int64_t x) {
int64_t *box = janet_abstract(&it_s64_type, sizeof(int64_t)); int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
*box = (int64_t)x; *box = (int64_t)x;
return janet_wrap_abstract(box); return janet_wrap_abstract(box);
} }
Janet janet_wrap_u64(uint64_t x) { Janet janet_wrap_u64(uint64_t x) {
uint64_t *box = janet_abstract(&it_u64_type, sizeof(uint64_t)); uint64_t *box = janet_abstract(&janet_u64_type, sizeof(uint64_t));
*box = (uint64_t)x; *box = (uint64_t)x;
return janet_wrap_abstract(box); return janet_wrap_abstract(box);
} }
@ -200,7 +200,7 @@ static Janet cfun_it_u64_new(int32_t argc, Janet *argv) {
#define OPMETHOD(T, type, name, oper) \ #define OPMETHOD(T, type, name, oper) \
static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
janet_arity(argc, 2, -1); \ janet_arity(argc, 2, -1); \
T *box = janet_abstract(&it_##type##_type, sizeof(T)); \ T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
*box = janet_unwrap_##type(argv[0]); \ *box = janet_unwrap_##type(argv[0]); \
for (int32_t i = 1; i < argc; i++) \ for (int32_t i = 1; i < argc; i++) \
*box oper##= janet_unwrap_##type(argv[i]); \ *box oper##= janet_unwrap_##type(argv[i]); \
@ -210,7 +210,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
#define OPMETHODINVERT(T, type, name, oper) \ #define OPMETHODINVERT(T, type, name, oper) \
static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
janet_fixarity(argc, 2); \ janet_fixarity(argc, 2); \
T *box = janet_abstract(&it_##type##_type, sizeof(T)); \ T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
*box = janet_unwrap_##type(argv[1]); \ *box = janet_unwrap_##type(argv[1]); \
*box oper##= janet_unwrap_##type(argv[0]); \ *box oper##= janet_unwrap_##type(argv[0]); \
return janet_wrap_abstract(box); \ return janet_wrap_abstract(box); \
@ -219,7 +219,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
#define DIVMETHOD(T, type, name, oper) \ #define DIVMETHOD(T, type, name, oper) \
static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
janet_arity(argc, 2, -1); \ janet_arity(argc, 2, -1); \
T *box = janet_abstract(&it_##type##_type, sizeof(T)); \ T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
*box = janet_unwrap_##type(argv[0]); \ *box = janet_unwrap_##type(argv[0]); \
for (int32_t i = 1; i < argc; i++) { \ for (int32_t i = 1; i < argc; i++) { \
T value = janet_unwrap_##type(argv[i]); \ T value = janet_unwrap_##type(argv[i]); \
@ -232,7 +232,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
#define DIVMETHODINVERT(T, type, name, oper) \ #define DIVMETHODINVERT(T, type, name, oper) \
static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
janet_fixarity(argc, 2); \ janet_fixarity(argc, 2); \
T *box = janet_abstract(&it_##type##_type, sizeof(T)); \ T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
*box = janet_unwrap_##type(argv[1]); \ *box = janet_unwrap_##type(argv[1]); \
T value = janet_unwrap_##type(argv[0]); \ T value = janet_unwrap_##type(argv[0]); \
if (value == 0) janet_panic("division by zero"); \ if (value == 0) janet_panic("division by zero"); \
@ -243,7 +243,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
#define DIVMETHOD_SIGNED(T, type, name, oper) \ #define DIVMETHOD_SIGNED(T, type, name, oper) \
static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
janet_arity(argc, 2, -1); \ janet_arity(argc, 2, -1); \
T *box = janet_abstract(&it_##type##_type, sizeof(T)); \ T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
*box = janet_unwrap_##type(argv[0]); \ *box = janet_unwrap_##type(argv[0]); \
for (int32_t i = 1; i < argc; i++) { \ for (int32_t i = 1; i < argc; i++) { \
T value = janet_unwrap_##type(argv[i]); \ T value = janet_unwrap_##type(argv[i]); \
@ -257,7 +257,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
#define DIVMETHODINVERT_SIGNED(T, type, name, oper) \ #define DIVMETHODINVERT_SIGNED(T, type, name, oper) \
static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
janet_fixarity(argc, 2); \ janet_fixarity(argc, 2); \
T *box = janet_abstract(&it_##type##_type, sizeof(T)); \ T *box = janet_abstract(&janet_##type##_type, sizeof(T)); \
*box = janet_unwrap_##type(argv[1]); \ *box = janet_unwrap_##type(argv[1]); \
T value = janet_unwrap_##type(argv[0]); \ T value = janet_unwrap_##type(argv[0]); \
if (value == 0) janet_panic("division by zero"); \ if (value == 0) janet_panic("division by zero"); \
@ -276,7 +276,7 @@ static Janet cfun_it_##type##_##name(int32_t argc, Janet *argv) { \
static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) { static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
janet_arity(argc, 2, -1); janet_arity(argc, 2, -1);
int64_t *box = janet_abstract(&it_s64_type, sizeof(int64_t)); int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
*box = janet_unwrap_s64(argv[0]); *box = janet_unwrap_s64(argv[0]);
for (int32_t i = 1; i < argc; i++) { for (int32_t i = 1; i < argc; i++) {
int64_t value = janet_unwrap_s64(argv[i]); int64_t value = janet_unwrap_s64(argv[i]);
@ -292,7 +292,7 @@ static Janet cfun_it_s64_mod(int32_t argc, Janet *argv) {
static Janet cfun_it_s64_modi(int32_t argc, Janet *argv) { static Janet cfun_it_s64_modi(int32_t argc, Janet *argv) {
janet_fixarity(argc, 2); janet_fixarity(argc, 2);
int64_t *box = janet_abstract(&it_s64_type, sizeof(int64_t)); int64_t *box = janet_abstract(&janet_s64_type, sizeof(int64_t));
int64_t op1 = janet_unwrap_s64(argv[0]); int64_t op1 = janet_unwrap_s64(argv[0]);
int64_t op2 = janet_unwrap_s64(argv[1]); int64_t op2 = janet_unwrap_s64(argv[1]);
int64_t x = op1 % op2; int64_t x = op1 % op2;
@ -441,8 +441,8 @@ static const JanetReg it_cfuns[] = {
/* Module entry point */ /* Module entry point */
void janet_lib_inttypes(JanetTable *env) { void janet_lib_inttypes(JanetTable *env) {
janet_core_cfuns(env, NULL, it_cfuns); janet_core_cfuns(env, NULL, it_cfuns);
janet_register_abstract_type(&it_s64_type); janet_register_abstract_type(&janet_s64_type);
janet_register_abstract_type(&it_u64_type); janet_register_abstract_type(&janet_u64_type);
} }
#endif #endif

50
src/core/io.c
View File

@ -33,16 +33,10 @@
#include <sys/wait.h> #include <sys/wait.h>
#endif #endif
typedef struct IOFile IOFile;
struct IOFile {
FILE *file;
int flags;
};
static int cfun_io_gc(void *p, size_t len); static int cfun_io_gc(void *p, size_t len);
static int io_file_get(void *p, Janet key, Janet *out); static int io_file_get(void *p, Janet key, Janet *out);
JanetAbstractType cfun_io_filetype = { const JanetAbstractType janet_file_type = {
"core/file", "core/file",
cfun_io_gc, cfun_io_gc,
NULL, NULL,
@ -90,7 +84,7 @@ static int checkflags(const uint8_t *str) {
} }
static Janet makef(FILE *f, int flags) { static Janet makef(FILE *f, int flags) {
IOFile *iof = (IOFile *) janet_abstract(&cfun_io_filetype, sizeof(IOFile)); JanetFile *iof = (JanetFile *) janet_abstract(&janet_file_type, sizeof(JanetFile));
iof->file = f; iof->file = f;
iof->flags = flags; iof->flags = flags;
return janet_wrap_abstract(iof); return janet_wrap_abstract(iof);
@ -158,7 +152,7 @@ static Janet cfun_io_fopen(int32_t argc, Janet *argv) {
} }
/* Read up to n bytes into buffer. */ /* Read up to n bytes into buffer. */
static void read_chunk(IOFile *iof, JanetBuffer *buffer, int32_t nBytesMax) { static void read_chunk(JanetFile *iof, JanetBuffer *buffer, int32_t nBytesMax) {
if (!(iof->flags & (JANET_FILE_READ | JANET_FILE_UPDATE))) if (!(iof->flags & (JANET_FILE_READ | JANET_FILE_UPDATE)))
janet_panic("file is not readable"); janet_panic("file is not readable");
janet_buffer_extra(buffer, nBytesMax); janet_buffer_extra(buffer, nBytesMax);
@ -172,7 +166,7 @@ static void read_chunk(IOFile *iof, JanetBuffer *buffer, int32_t nBytesMax) {
/* Read a certain number of bytes into memory */ /* Read a certain number of bytes into memory */
static Janet cfun_io_fread(int32_t argc, Janet *argv) { static Janet cfun_io_fread(int32_t argc, Janet *argv) {
janet_arity(argc, 2, 3); janet_arity(argc, 2, 3);
IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
if (iof->flags & JANET_FILE_CLOSED) janet_panic("file is closed"); if (iof->flags & JANET_FILE_CLOSED) janet_panic("file is closed");
JanetBuffer *buffer; JanetBuffer *buffer;
if (argc == 2) { if (argc == 2) {
@ -212,7 +206,7 @@ static Janet cfun_io_fread(int32_t argc, Janet *argv) {
/* Write bytes to a file */ /* Write bytes to a file */
static Janet cfun_io_fwrite(int32_t argc, Janet *argv) { static Janet cfun_io_fwrite(int32_t argc, Janet *argv) {
janet_arity(argc, 1, -1); janet_arity(argc, 1, -1);
IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
if (iof->flags & JANET_FILE_CLOSED) if (iof->flags & JANET_FILE_CLOSED)
janet_panic("file is closed"); janet_panic("file is closed");
if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE))) if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE)))
@ -235,7 +229,7 @@ static Janet cfun_io_fwrite(int32_t argc, Janet *argv) {
/* Flush the bytes in the file */ /* Flush the bytes in the file */
static Janet cfun_io_fflush(int32_t argc, Janet *argv) { static Janet cfun_io_fflush(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
if (iof->flags & JANET_FILE_CLOSED) if (iof->flags & JANET_FILE_CLOSED)
janet_panic("file is closed"); janet_panic("file is closed");
if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE))) if (!(iof->flags & (JANET_FILE_WRITE | JANET_FILE_APPEND | JANET_FILE_UPDATE)))
@ -248,7 +242,7 @@ static Janet cfun_io_fflush(int32_t argc, Janet *argv) {
/* Cleanup a file */ /* Cleanup a file */
static int cfun_io_gc(void *p, size_t len) { static int cfun_io_gc(void *p, size_t len) {
(void) len; (void) len;
IOFile *iof = (IOFile *)p; JanetFile *iof = (JanetFile *)p;
if (!(iof->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) { if (!(iof->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) {
return fclose(iof->file); return fclose(iof->file);
} }
@ -258,7 +252,7 @@ static int cfun_io_gc(void *p, size_t len) {
/* Close a file */ /* Close a file */
static Janet cfun_io_fclose(int32_t argc, Janet *argv) { static Janet cfun_io_fclose(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
if (iof->flags & JANET_FILE_CLOSED) if (iof->flags & JANET_FILE_CLOSED)
return janet_wrap_nil(); return janet_wrap_nil();
if (iof->flags & (JANET_FILE_NOT_CLOSEABLE)) if (iof->flags & (JANET_FILE_NOT_CLOSEABLE))
@ -282,7 +276,7 @@ static Janet cfun_io_fclose(int32_t argc, Janet *argv) {
/* Seek a file */ /* Seek a file */
static Janet cfun_io_fseek(int32_t argc, Janet *argv) { static Janet cfun_io_fseek(int32_t argc, Janet *argv) {
janet_arity(argc, 2, 3); janet_arity(argc, 2, 3);
IOFile *iof = janet_getabstract(argv, 0, &cfun_io_filetype); JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
if (iof->flags & JANET_FILE_CLOSED) if (iof->flags & JANET_FILE_CLOSED)
janet_panic("file is closed"); janet_panic("file is closed");
long int offset = 0; long int offset = 0;
@ -326,8 +320,8 @@ FILE *janet_dynfile(const char *name, FILE *def) {
Janet x = janet_dyn(name); Janet x = janet_dyn(name);
if (!janet_checktype(x, JANET_ABSTRACT)) return def; if (!janet_checktype(x, JANET_ABSTRACT)) return def;
void *abstract = janet_unwrap_abstract(x); void *abstract = janet_unwrap_abstract(x);
if (janet_abstract_type(abstract) != &cfun_io_filetype) return def; if (janet_abstract_type(abstract) != &janet_file_type) return def;
IOFile *iofile = abstract; JanetFile *iofile = abstract;
return iofile->file; return iofile->file;
} }
@ -354,9 +348,9 @@ static Janet cfun_io_print_impl(int32_t argc, Janet *argv,
break; break;
case JANET_ABSTRACT: { case JANET_ABSTRACT: {
void *abstract = janet_unwrap_abstract(x); void *abstract = janet_unwrap_abstract(x);
if (janet_abstract_type(abstract) != &cfun_io_filetype) if (janet_abstract_type(abstract) != &janet_file_type)
return janet_wrap_nil(); return janet_wrap_nil();
IOFile *iofile = abstract; JanetFile *iofile = abstract;
f = iofile->file; f = iofile->file;
break; break;
} }
@ -421,9 +415,9 @@ static Janet cfun_io_printf_impl(int32_t argc, Janet *argv, int newline,
break; break;
case JANET_ABSTRACT: { case JANET_ABSTRACT: {
void *abstract = janet_unwrap_abstract(x); void *abstract = janet_unwrap_abstract(x);
if (janet_abstract_type(abstract) != &cfun_io_filetype) if (janet_abstract_type(abstract) != &janet_file_type)
return janet_wrap_nil(); return janet_wrap_nil();
IOFile *iofile = abstract; JanetFile *iofile = abstract;
f = iofile->file; f = iofile->file;
break; break;
} }
@ -470,8 +464,8 @@ static void janet_flusher(const char *name, FILE *dflt_file) {
break; break;
case JANET_ABSTRACT: { case JANET_ABSTRACT: {
void *abstract = janet_unwrap_abstract(x); void *abstract = janet_unwrap_abstract(x);
if (janet_abstract_type(abstract) != &cfun_io_filetype) break; if (janet_abstract_type(abstract) != &janet_file_type) break;
IOFile *iofile = abstract; JanetFile *iofile = abstract;
fflush(iofile->file); fflush(iofile->file);
break; break;
} }
@ -511,9 +505,9 @@ void janet_dynprintf(const char *name, FILE *dflt_file, const char *format, ...)
janet_formatb(&buffer, format, args); janet_formatb(&buffer, format, args);
if (xtype == JANET_ABSTRACT) { if (xtype == JANET_ABSTRACT) {
void *abstract = janet_unwrap_abstract(x); void *abstract = janet_unwrap_abstract(x);
if (janet_abstract_type(abstract) != &cfun_io_filetype) if (janet_abstract_type(abstract) != &janet_file_type)
break; break;
IOFile *iofile = abstract; JanetFile *iofile = abstract;
f = iofile->file; f = iofile->file;
} }
fwrite(buffer.data, buffer.count, 1, f); fwrite(buffer.data, buffer.count, 1, f);
@ -660,7 +654,7 @@ static const JanetReg io_cfuns[] = {
/* C API */ /* C API */
FILE *janet_getfile(const Janet *argv, int32_t n, int *flags) { FILE *janet_getfile(const Janet *argv, int32_t n, int *flags) {
IOFile *iof = janet_getabstract(argv, n, &cfun_io_filetype); JanetFile *iof = janet_getabstract(argv, n, &janet_file_type);
if (NULL != flags) *flags = iof->flags; if (NULL != flags) *flags = iof->flags;
return iof->file; return iof->file;
} }
@ -670,11 +664,11 @@ Janet janet_makefile(FILE *f, int flags) {
} }
JanetAbstract janet_checkfile(Janet j) { JanetAbstract janet_checkfile(Janet j) {
return janet_checkabstract(j, &cfun_io_filetype); return janet_checkabstract(j, &janet_file_type);
} }
FILE *janet_unwrapfile(Janet j, int *flags) { FILE *janet_unwrapfile(Janet j, int *flags) {
IOFile *iof = janet_unwrap_abstract(j); JanetFile *iof = janet_unwrap_abstract(j);
if (NULL != flags) *flags = iof->flags; if (NULL != flags) *flags = iof->flags;
return iof->file; return iof->file;
} }

12
src/core/math.c
View File

@ -52,7 +52,7 @@ static void *janet_rng_unmarshal(JanetMarshalContext *ctx) {
return rng; return rng;
} }
static JanetAbstractType JanetRNG_type = { const JanetAbstractType janet_rng_type = {
"core/rng", "core/rng",
NULL, NULL,
NULL, NULL,
@ -115,7 +115,7 @@ double janet_rng_double(JanetRNG *rng) {
static Janet cfun_rng_make(int32_t argc, Janet *argv) { static Janet cfun_rng_make(int32_t argc, Janet *argv) {
janet_arity(argc, 0, 1); janet_arity(argc, 0, 1);
JanetRNG *rng = janet_abstract(&JanetRNG_type, sizeof(JanetRNG)); JanetRNG *rng = janet_abstract(&janet_rng_type, sizeof(JanetRNG));
if (argc == 1) { if (argc == 1) {
if (janet_checkint(argv[0])) { if (janet_checkint(argv[0])) {
uint32_t seed = (uint32_t)(janet_getinteger(argv, 0)); uint32_t seed = (uint32_t)(janet_getinteger(argv, 0));
@ -132,13 +132,13 @@ static Janet cfun_rng_make(int32_t argc, Janet *argv) {
static Janet cfun_rng_uniform(int32_t argc, Janet *argv) { static Janet cfun_rng_uniform(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetRNG *rng = janet_getabstract(argv, 0, &JanetRNG_type); JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type);
return janet_wrap_number(janet_rng_double(rng)); return janet_wrap_number(janet_rng_double(rng));
} }
static Janet cfun_rng_int(int32_t argc, Janet *argv) { static Janet cfun_rng_int(int32_t argc, Janet *argv) {
janet_arity(argc, 1, 2); janet_arity(argc, 1, 2);
JanetRNG *rng = janet_getabstract(argv, 0, &JanetRNG_type); JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type);
if (argc == 1) { if (argc == 1) {
uint32_t word = janet_rng_u32(rng) >> 1; uint32_t word = janet_rng_u32(rng) >> 1;
return janet_wrap_integer(word); return janet_wrap_integer(word);
@ -166,7 +166,7 @@ static void rng_get_4bytes(JanetRNG *rng, uint8_t *buf) {
static Janet cfun_rng_buffer(int32_t argc, Janet *argv) { static Janet cfun_rng_buffer(int32_t argc, Janet *argv) {
janet_arity(argc, 2, 3); janet_arity(argc, 2, 3);
JanetRNG *rng = janet_getabstract(argv, 0, &JanetRNG_type); JanetRNG *rng = janet_getabstract(argv, 0, &janet_rng_type);
int32_t n = janet_getnat(argv, 1); int32_t n = janet_getnat(argv, 1);
JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, n); JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, n);
@ -459,7 +459,7 @@ static const JanetReg math_cfuns[] = {
/* Module entry point */ /* Module entry point */
void janet_lib_math(JanetTable *env) { void janet_lib_math(JanetTable *env) {
janet_core_cfuns(env, NULL, math_cfuns); janet_core_cfuns(env, NULL, math_cfuns);
janet_register_abstract_type(&JanetRNG_type); janet_register_abstract_type(&janet_rng_type);
#ifdef JANET_BOOTSTRAP #ifdef JANET_BOOTSTRAP
janet_def(env, "math/pi", janet_wrap_number(3.1415926535897931), janet_def(env, "math/pi", janet_wrap_number(3.1415926535897931),
JDOC("The value pi.")); JDOC("The value pi."));

32
src/core/parse.c
View File

@ -732,7 +732,7 @@ static int parsergc(void *p, size_t size) {
static int parserget(void *p, Janet key, Janet *out); static int parserget(void *p, Janet key, Janet *out);
static JanetAbstractType janet_parse_parsertype = { const JanetAbstractType janet_parser_type = {
"core/parser", "core/parser",
parsergc, parsergc,
parsermark, parsermark,
@ -744,14 +744,14 @@ static JanetAbstractType janet_parse_parsertype = {
static Janet cfun_parse_parser(int32_t argc, Janet *argv) { static Janet cfun_parse_parser(int32_t argc, Janet *argv) {
(void) argv; (void) argv;
janet_fixarity(argc, 0); janet_fixarity(argc, 0);
JanetParser *p = janet_abstract(&janet_parse_parsertype, sizeof(JanetParser)); JanetParser *p = janet_abstract(&janet_parser_type, sizeof(JanetParser));
janet_parser_init(p); janet_parser_init(p);
return janet_wrap_abstract(p); return janet_wrap_abstract(p);
} }
static Janet cfun_parse_consume(int32_t argc, Janet *argv) { static Janet cfun_parse_consume(int32_t argc, Janet *argv) {
janet_arity(argc, 2, 3); janet_arity(argc, 2, 3);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
JanetByteView view = janet_getbytes(argv, 1); JanetByteView view = janet_getbytes(argv, 1);
if (argc == 3) { if (argc == 3) {
int32_t offset = janet_getinteger(argv, 2); int32_t offset = janet_getinteger(argv, 2);
@ -776,14 +776,14 @@ static Janet cfun_parse_consume(int32_t argc, Janet *argv) {
static Janet cfun_parse_eof(int32_t argc, Janet *argv) { static Janet cfun_parse_eof(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
janet_parser_eof(p); janet_parser_eof(p);
return argv[0]; return argv[0];
} }
static Janet cfun_parse_insert(int32_t argc, Janet *argv) { static Janet cfun_parse_insert(int32_t argc, Janet *argv) {
janet_fixarity(argc, 2); janet_fixarity(argc, 2);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
JanetParseState *s = p->states + p->statecount - 1; JanetParseState *s = p->states + p->statecount - 1;
if (s->consumer == tokenchar) { if (s->consumer == tokenchar) {
janet_parser_consume(p, ' '); janet_parser_consume(p, ' ');
@ -817,13 +817,13 @@ static Janet cfun_parse_insert(int32_t argc, Janet *argv) {
static Janet cfun_parse_has_more(int32_t argc, Janet *argv) { static Janet cfun_parse_has_more(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
return janet_wrap_boolean(janet_parser_has_more(p)); return janet_wrap_boolean(janet_parser_has_more(p));
} }
static Janet cfun_parse_byte(int32_t argc, Janet *argv) { static Janet cfun_parse_byte(int32_t argc, Janet *argv) {
janet_fixarity(argc, 2); janet_fixarity(argc, 2);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
int32_t i = janet_getinteger(argv, 1); int32_t i = janet_getinteger(argv, 1);
janet_parser_consume(p, 0xFF & i); janet_parser_consume(p, 0xFF & i);
return argv[0]; return argv[0];
@ -831,7 +831,7 @@ static Janet cfun_parse_byte(int32_t argc, Janet *argv) {
static Janet cfun_parse_status(int32_t argc, Janet *argv) { static Janet cfun_parse_status(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
const char *stat = NULL; const char *stat = NULL;
switch (janet_parser_status(p)) { switch (janet_parser_status(p)) {
case JANET_PARSE_PENDING: case JANET_PARSE_PENDING:
@ -852,7 +852,7 @@ static Janet cfun_parse_status(int32_t argc, Janet *argv) {
static Janet cfun_parse_error(int32_t argc, Janet *argv) { static Janet cfun_parse_error(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
const char *err = janet_parser_error(p); const char *err = janet_parser_error(p);
if (err) return janet_cstringv(err); if (err) return janet_cstringv(err);
return janet_wrap_nil(); return janet_wrap_nil();
@ -860,20 +860,20 @@ static Janet cfun_parse_error(int32_t argc, Janet *argv) {
static Janet cfun_parse_produce(int32_t argc, Janet *argv) { static Janet cfun_parse_produce(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
return janet_parser_produce(p); return janet_parser_produce(p);
} }
static Janet cfun_parse_flush(int32_t argc, Janet *argv) { static Janet cfun_parse_flush(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
janet_parser_flush(p); janet_parser_flush(p);
return argv[0]; return argv[0];
} }
static Janet cfun_parse_where(int32_t argc, Janet *argv) { static Janet cfun_parse_where(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
Janet *tup = janet_tuple_begin(2); Janet *tup = janet_tuple_begin(2);
tup[0] = janet_wrap_integer(p->line); tup[0] = janet_wrap_integer(p->line);
tup[1] = janet_wrap_integer(p->column); tup[1] = janet_wrap_integer(p->column);
@ -953,7 +953,7 @@ struct ParserStateGetter {
}; };
static Janet parser_state_delimiters(const JanetParser *_p) { static Janet parser_state_delimiters(const JanetParser *_p) {
JanetParser *clone = janet_abstract(&janet_parse_parsertype, sizeof(JanetParser)); JanetParser *clone = janet_abstract(&janet_parser_type, sizeof(JanetParser));
janet_parser_clone(_p, clone); janet_parser_clone(_p, clone);
size_t i; size_t i;
const uint8_t *str; const uint8_t *str;
@ -1004,7 +1004,7 @@ static const struct ParserStateGetter parser_state_getters[] = {
static Janet cfun_parse_state(int32_t argc, Janet *argv) { static Janet cfun_parse_state(int32_t argc, Janet *argv) {
janet_arity(argc, 1, 2); janet_arity(argc, 1, 2);
const uint8_t *key = NULL; const uint8_t *key = NULL;
JanetParser *p = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
if (argc == 2) { if (argc == 2) {
key = janet_getkeyword(argv, 1); key = janet_getkeyword(argv, 1);
} }
@ -1031,8 +1031,8 @@ static Janet cfun_parse_state(int32_t argc, Janet *argv) {
static Janet cfun_parse_clone(int32_t argc, Janet *argv) { static Janet cfun_parse_clone(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
JanetParser *src = janet_getabstract(argv, 0, &janet_parse_parsertype); JanetParser *src = janet_getabstract(argv, 0, &janet_parser_type);
JanetParser *dest = janet_abstract(&janet_parse_parsertype, sizeof(JanetParser)); JanetParser *dest = janet_abstract(&janet_parser_type, sizeof(JanetParser));
janet_parser_clone(src, dest); janet_parser_clone(src, dest);
return janet_wrap_abstract(dest); return janet_wrap_abstract(dest);
} }

67
src/core/peg.c
View File

@ -35,34 +35,6 @@
* Runtime * Runtime
*/ */
/* opcodes for peg vm */
typedef enum {
RULE_LITERAL, /* [len, bytes...] */
RULE_NCHAR, /* [n] */
RULE_NOTNCHAR, /* [n] */
RULE_RANGE, /* [lo | hi << 16 (1 word)] */
RULE_SET, /* [bitmap (8 words)] */
RULE_LOOK, /* [offset, rule] */
RULE_CHOICE, /* [len, rules...] */
RULE_SEQUENCE, /* [len, rules...] */
RULE_IF, /* [rule_a, rule_b (b if a)] */
RULE_IFNOT, /* [rule_a, rule_b (b if not a)] */
RULE_NOT, /* [rule] */
RULE_BETWEEN, /* [lo, hi, rule] */
RULE_GETTAG, /* [searchtag, tag] */
RULE_CAPTURE, /* [rule, tag] */
RULE_POSITION, /* [tag] */
RULE_ARGUMENT, /* [argument-index, tag] */
RULE_CONSTANT, /* [constant, tag] */
RULE_ACCUMULATE, /* [rule, tag] */
RULE_GROUP, /* [rule, tag] */
RULE_REPLACE, /* [rule, constant, tag] */
RULE_MATCHTIME, /* [rule, constant, tag] */
RULE_ERROR, /* [rule] */
RULE_DROP, /* [rule] */
RULE_BACKMATCH, /* [tag] */
} Opcode;
/* Hold captured patterns and match state */ /* Hold captured patterns and match state */
typedef struct { typedef struct {
const uint8_t *text_start; const uint8_t *text_start;
@ -1016,16 +988,9 @@ static uint32_t peg_compile1(Builder *b, Janet peg) {
* Post-Compilation * Post-Compilation
*/ */
typedef struct {
uint32_t *bytecode;
Janet *constants;
size_t bytecode_len;
uint32_t num_constants;
} Peg;
static int peg_mark(void *p, size_t size) { static int peg_mark(void *p, size_t size) {
(void) size; (void) size;
Peg *peg = (Peg *)p; JanetPeg *peg = (JanetPeg *)p;
if (NULL != peg->constants) if (NULL != peg->constants)
for (uint32_t i = 0; i < peg->num_constants; i++) for (uint32_t i = 0; i < peg->num_constants; i++)
janet_mark(peg->constants[i]); janet_mark(peg->constants[i]);
@ -1033,7 +998,7 @@ static int peg_mark(void *p, size_t size) {
} }
static void peg_marshal(void *p, JanetMarshalContext *ctx) { static void peg_marshal(void *p, JanetMarshalContext *ctx) {
Peg *peg = (Peg *)p; JanetPeg *peg = (JanetPeg *)p;
janet_marshal_size(ctx, peg->bytecode_len); janet_marshal_size(ctx, peg->bytecode_len);
janet_marshal_int(ctx, (int32_t)peg->num_constants); janet_marshal_int(ctx, (int32_t)peg->num_constants);
janet_marshal_abstract(ctx, p); janet_marshal_abstract(ctx, p);
@ -1055,7 +1020,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
uint32_t num_constants = (uint32_t) janet_unmarshal_int(ctx); uint32_t num_constants = (uint32_t) janet_unmarshal_int(ctx);
/* Calculate offsets. Should match those in make_peg */ /* Calculate offsets. Should match those in make_peg */
size_t bytecode_start = size_padded(sizeof(Peg), sizeof(uint32_t)); size_t bytecode_start = size_padded(sizeof(JanetPeg), sizeof(uint32_t));
size_t bytecode_size = bytecode_len * sizeof(uint32_t); size_t bytecode_size = bytecode_len * sizeof(uint32_t);
size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet)); size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet));
size_t total_size = constants_start + sizeof(Janet) * (size_t) num_constants; size_t total_size = constants_start + sizeof(Janet) * (size_t) num_constants;
@ -1065,7 +1030,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
/* Allocate PEG */ /* Allocate PEG */
char *mem = janet_unmarshal_abstract(ctx, total_size); char *mem = janet_unmarshal_abstract(ctx, total_size);
Peg *peg = (Peg *)mem; JanetPeg *peg = (JanetPeg *)mem;
uint32_t *bytecode = (uint32_t *)(mem + bytecode_start); uint32_t *bytecode = (uint32_t *)(mem + bytecode_start);
Janet *constants = (Janet *)(mem + constants_start); Janet *constants = (Janet *)(mem + constants_start);
peg->bytecode = NULL; peg->bytecode = NULL;
@ -1208,7 +1173,7 @@ bad:
static int cfun_peg_getter(JanetAbstract a, Janet key, Janet *out); static int cfun_peg_getter(JanetAbstract a, Janet key, Janet *out);
static const JanetAbstractType peg_type = { const JanetAbstractType janet_peg_type = {
"core/peg", "core/peg",
NULL, NULL,
peg_mark, peg_mark,
@ -1219,15 +1184,15 @@ static const JanetAbstractType peg_type = {
JANET_ATEND_UNMARSHAL JANET_ATEND_UNMARSHAL
}; };
/* Convert Builder to Peg (Janet Abstract Value) */ /* Convert Builder to JanetPeg (Janet Abstract Value) */
static Peg *make_peg(Builder *b) { static JanetPeg *make_peg(Builder *b) {
size_t bytecode_start = size_padded(sizeof(Peg), sizeof(uint32_t)); size_t bytecode_start = size_padded(sizeof(JanetPeg), sizeof(uint32_t));
size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t); size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t);
size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet)); size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet));
size_t constants_size = janet_v_count(b->constants) * sizeof(Janet); size_t constants_size = janet_v_count(b->constants) * sizeof(Janet);
size_t total_size = constants_start + constants_size; size_t total_size = constants_start + constants_size;
char *mem = janet_abstract(&peg_type, total_size); char *mem = janet_abstract(&janet_peg_type, total_size);
Peg *peg = (Peg *)mem; JanetPeg *peg = (JanetPeg *)mem;
peg->bytecode = (uint32_t *)(mem + bytecode_start); peg->bytecode = (uint32_t *)(mem + bytecode_start);
peg->constants = (Janet *)(mem + constants_start); peg->constants = (Janet *)(mem + constants_start);
peg->num_constants = janet_v_count(b->constants); peg->num_constants = janet_v_count(b->constants);
@ -1238,7 +1203,7 @@ static Peg *make_peg(Builder *b) {
} }
/* Compiler entry point */ /* Compiler entry point */
static Peg *compile_peg(Janet x) { static JanetPeg *compile_peg(Janet x) {
Builder builder; Builder builder;
builder.grammar = janet_table(0); builder.grammar = janet_table(0);
builder.default_grammar = janet_get_core_table("default-peg-grammar"); builder.default_grammar = janet_get_core_table("default-peg-grammar");
@ -1249,7 +1214,7 @@ static Peg *compile_peg(Janet x) {
builder.form = x; builder.form = x;
builder.depth = JANET_RECURSION_GUARD; builder.depth = JANET_RECURSION_GUARD;
peg_compile1(&builder, x); peg_compile1(&builder, x);
Peg *peg = make_peg(&builder); JanetPeg *peg = make_peg(&builder);
builder_cleanup(&builder); builder_cleanup(&builder);
return peg; return peg;
} }
@ -1260,15 +1225,15 @@ static Peg *compile_peg(Janet x) {
static Janet cfun_peg_compile(int32_t argc, Janet *argv) { static Janet cfun_peg_compile(int32_t argc, Janet *argv) {
janet_fixarity(argc, 1); janet_fixarity(argc, 1);
Peg *peg = compile_peg(argv[0]); JanetPeg *peg = compile_peg(argv[0]);
return janet_wrap_abstract(peg); return janet_wrap_abstract(peg);
} }
static Janet cfun_peg_match(int32_t argc, Janet *argv) { static Janet cfun_peg_match(int32_t argc, Janet *argv) {
janet_arity(argc, 2, -1); janet_arity(argc, 2, -1);
Peg *peg; JanetPeg *peg;
if (janet_checktype(argv[0], JANET_ABSTRACT) && if (janet_checktype(argv[0], JANET_ABSTRACT) &&
janet_abstract_type(janet_unwrap_abstract(argv[0])) == &peg_type) { janet_abstract_type(janet_unwrap_abstract(argv[0])) == &janet_peg_type) {
peg = janet_unwrap_abstract(argv[0]); peg = janet_unwrap_abstract(argv[0]);
} else { } else {
peg = compile_peg(argv[0]); peg = compile_peg(argv[0]);
@ -1327,7 +1292,7 @@ static const JanetReg peg_cfuns[] = {
/* Load the peg module */ /* Load the peg module */
void janet_lib_peg(JanetTable *env) { void janet_lib_peg(JanetTable *env) {
janet_core_cfuns(env, NULL, peg_cfuns); janet_core_cfuns(env, NULL, peg_cfuns);
janet_register_abstract_type(&peg_type); janet_register_abstract_type(&janet_peg_type);
} }
#endif /* ifdef JANET_PEG */ #endif /* ifdef JANET_PEG */

8
src/core/thread.c
View File

@ -409,7 +409,7 @@ int janet_thread_receive(Janet *msg_out, double timeout) {
static int janet_thread_getter(void *p, Janet key, Janet *out); static int janet_thread_getter(void *p, Janet key, Janet *out);
static JanetAbstractType Thread_AT = { const JanetAbstractType janet_thread_type = {
"core/thread", "core/thread",
thread_gc, thread_gc,
thread_mark, thread_mark,
@ -418,7 +418,7 @@ static JanetAbstractType Thread_AT = {
}; };
static JanetThread *janet_make_thread(JanetMailbox *mailbox, JanetTable *encode) { static JanetThread *janet_make_thread(JanetMailbox *mailbox, JanetTable *encode) {
JanetThread *thread = janet_abstract(&Thread_AT, sizeof(JanetThread)); JanetThread *thread = janet_abstract(&janet_thread_type, sizeof(JanetThread));
janet_mailbox_ref(mailbox, 1); janet_mailbox_ref(mailbox, 1);
thread->mailbox = mailbox; thread->mailbox = mailbox;
thread->encode = encode; thread->encode = encode;
@ -426,7 +426,7 @@ static JanetThread *janet_make_thread(JanetMailbox *mailbox, JanetTable *encode)
} }
JanetThread *janet_getthread(const Janet *argv, int32_t n) { JanetThread *janet_getthread(const Janet *argv, int32_t n) {
return (JanetThread *) janet_getabstract(argv, n, &Thread_AT); return (JanetThread *) janet_getabstract(argv, n, &janet_thread_type);
} }
/* Runs in new thread */ /* Runs in new thread */
@ -664,7 +664,7 @@ static const JanetReg threadlib_cfuns[] = {
/* Module entry point */ /* Module entry point */
void janet_lib_thread(JanetTable *env) { void janet_lib_thread(JanetTable *env) {
janet_core_cfuns(env, NULL, threadlib_cfuns); janet_core_cfuns(env, NULL, threadlib_cfuns);
janet_register_abstract_type(&Thread_AT); janet_register_abstract_type(&janet_thread_type);
} }
#endif #endif

38
src/core/typedarray.c
View File

@ -111,7 +111,7 @@ static void *ta_buffer_unmarshal(JanetMarshalContext *ctx) {
return buf; return buf;
} }
static const JanetAbstractType ta_buffer_type = { const JanetAbstractType janet_ta_buffer_type = {
"ta/buffer", "ta/buffer",
ta_buffer_gc, ta_buffer_gc,
NULL, NULL,
@ -154,7 +154,7 @@ static void *ta_view_unmarshal(JanetMarshalContext *ctx) {
offset = janet_unmarshal_size(ctx); offset = janet_unmarshal_size(ctx);
buffer = janet_unmarshal_janet(ctx); buffer = janet_unmarshal_janet(ctx);
if (!janet_checktype(buffer, JANET_ABSTRACT) || if (!janet_checktype(buffer, JANET_ABSTRACT) ||
(janet_abstract_type(janet_unwrap_abstract(buffer)) != &ta_buffer_type)) { (janet_abstract_type(janet_unwrap_abstract(buffer)) != &janet_ta_buffer_type)) {
janet_panicf("expected typed array buffer"); janet_panicf("expected typed array buffer");
} }
view->buffer = (JanetTArrayBuffer *)janet_unwrap_abstract(buffer); view->buffer = (JanetTArrayBuffer *)janet_unwrap_abstract(buffer);
@ -275,7 +275,7 @@ static void ta_setter(void *p, Janet key, Janet value) {
} }
} }
static const JanetAbstractType ta_view_type = { const JanetAbstractType janet_ta_view_type = {
"ta/view", "ta/view",
NULL, NULL,
ta_mark, ta_mark,
@ -287,7 +287,7 @@ static const JanetAbstractType ta_view_type = {
}; };
JanetTArrayBuffer *janet_tarray_buffer(size_t size) { JanetTArrayBuffer *janet_tarray_buffer(size_t size) {
JanetTArrayBuffer *buf = janet_abstract(&ta_buffer_type, sizeof(JanetTArrayBuffer)); JanetTArrayBuffer *buf = janet_abstract(&janet_ta_buffer_type, sizeof(JanetTArrayBuffer));
ta_buffer_init(buf, size); ta_buffer_init(buf, size);
return buf; return buf;
} }
@ -299,13 +299,13 @@ JanetTArrayView *janet_tarray_view(
size_t offset, size_t offset,
JanetTArrayBuffer *buffer) { JanetTArrayBuffer *buffer) {
JanetTArrayView *view = janet_abstract(&ta_view_type, sizeof(JanetTArrayView)); JanetTArrayView *view = janet_abstract(&janet_ta_view_type, sizeof(JanetTArrayView));
if ((stride < 1) || (size < 1)) janet_panic("stride and size should be > 0"); if ((stride < 1) || (size < 1)) janet_panic("stride and size should be > 0");
size_t buf_size = offset + ta_type_sizes[type] * ((size - 1) * stride + 1); size_t buf_size = offset + ta_type_sizes[type] * ((size - 1) * stride + 1);
if (NULL == buffer) { if (NULL == buffer) {
buffer = janet_abstract(&ta_buffer_type, sizeof(JanetTArrayBuffer)); buffer = janet_abstract(&janet_ta_buffer_type, sizeof(JanetTArrayBuffer));
ta_buffer_init(buffer, buf_size); ta_buffer_init(buffer, buf_size);
} }
@ -325,15 +325,15 @@ JanetTArrayView *janet_tarray_view(
} }
JanetTArrayBuffer *janet_gettarray_buffer(const Janet *argv, int32_t n) { JanetTArrayBuffer *janet_gettarray_buffer(const Janet *argv, int32_t n) {
return janet_getabstract(argv, n, &ta_buffer_type); return janet_getabstract(argv, n, &janet_ta_buffer_type);
} }
JanetTArrayView *janet_gettarray_any(const Janet *argv, int32_t n) { JanetTArrayView *janet_gettarray_any(const Janet *argv, int32_t n) {
return janet_getabstract(argv, n, &ta_view_type); return janet_getabstract(argv, n, &janet_ta_view_type);
} }
JanetTArrayView *janet_gettarray_view(const Janet *argv, int32_t n, JanetTArrayType type) { JanetTArrayView *janet_gettarray_view(const Janet *argv, int32_t n, JanetTArrayType type) {
JanetTArrayView *view = janet_getabstract(argv, n, &ta_view_type); JanetTArrayView *view = janet_getabstract(argv, n, &janet_ta_view_type);
if (view->type != type) { if (view->type != type) {
janet_panicf("bad slot #%d, expected typed array of type %s, got %v", janet_panicf("bad slot #%d, expected typed array of type %s, got %v",
n, ta_type_names[type], argv[n]); n, ta_type_names[type], argv[n]);
@ -359,7 +359,7 @@ static Janet cfun_typed_array_new(int32_t argc, Janet *argv) {
4, argv[4]); 4, argv[4]);
} }
void *p = janet_unwrap_abstract(argv[4]); void *p = janet_unwrap_abstract(argv[4]);
if (janet_abstract_type(p) == &ta_view_type) { if (janet_abstract_type(p) == &janet_ta_view_type) {
JanetTArrayView *view = (JanetTArrayView *)p; JanetTArrayView *view = (JanetTArrayView *)p;
offset = (view->buffer->data - view->as.u8) + offset * ta_type_sizes[view->type]; offset = (view->buffer->data - view->as.u8) + offset * ta_type_sizes[view->type];
stride *= view->stride; stride *= view->stride;
@ -375,7 +375,7 @@ static Janet cfun_typed_array_new(int32_t argc, Janet *argv) {
static JanetTArrayView *ta_is_view(Janet x) { static JanetTArrayView *ta_is_view(Janet x) {
if (!janet_checktype(x, JANET_ABSTRACT)) return NULL; if (!janet_checktype(x, JANET_ABSTRACT)) return NULL;
void *abst = janet_unwrap_abstract(x); void *abst = janet_unwrap_abstract(x);
if (janet_abstract_type(abst) != &ta_view_type) return NULL; if (janet_abstract_type(abst) != &janet_ta_view_type) return NULL;
return (JanetTArrayView *)abst; return (JanetTArrayView *)abst;
} }
@ -396,7 +396,7 @@ static Janet cfun_typed_array_size(int32_t argc, Janet *argv) {
if ((view = ta_is_view(argv[0]))) { if ((view = ta_is_view(argv[0]))) {
return janet_wrap_number((double) view->size); return janet_wrap_number((double) view->size);
} }
JanetTArrayBuffer *buf = (JanetTArrayBuffer *)janet_getabstract(argv, 0, &ta_buffer_type); JanetTArrayBuffer *buf = (JanetTArrayBuffer *)janet_getabstract(argv, 0, &janet_ta_buffer_type);
return janet_wrap_number((double) buf->size); return janet_wrap_number((double) buf->size);
} }
@ -433,7 +433,7 @@ static Janet cfun_typed_array_properties(int32_t argc, Janet *argv) {
static Janet cfun_typed_array_slice(int32_t argc, Janet *argv) { static Janet cfun_typed_array_slice(int32_t argc, Janet *argv) {
janet_arity(argc, 1, 3); janet_arity(argc, 1, 3);
JanetTArrayView *src = janet_getabstract(argv, 0, &ta_view_type); JanetTArrayView *src = janet_getabstract(argv, 0, &janet_ta_view_type);
JanetRange range; JanetRange range;
int32_t length = (int32_t)src->size; int32_t length = (int32_t)src->size;
if (argc == 1) { if (argc == 1) {
@ -461,9 +461,9 @@ static Janet cfun_typed_array_slice(int32_t argc, Janet *argv) {
static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) { static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) {
janet_arity(argc, 4, 5); janet_arity(argc, 4, 5);
JanetTArrayView *src = janet_getabstract(argv, 0, &ta_view_type); JanetTArrayView *src = janet_getabstract(argv, 0, &janet_ta_view_type);
size_t index_src = janet_getsize(argv, 1); size_t index_src = janet_getsize(argv, 1);
JanetTArrayView *dst = janet_getabstract(argv, 2, &ta_view_type); JanetTArrayView *dst = janet_getabstract(argv, 2, &janet_ta_view_type);
size_t index_dst = janet_getsize(argv, 3); size_t index_dst = janet_getsize(argv, 3);
size_t count = (argc == 5) ? janet_getsize(argv, 4) : 1; size_t count = (argc == 5) ? janet_getsize(argv, 4) : 1;
size_t src_atom_size = ta_type_sizes[src->type]; size_t src_atom_size = ta_type_sizes[src->type];
@ -488,9 +488,9 @@ static Janet cfun_typed_array_copy_bytes(int32_t argc, Janet *argv) {
static Janet cfun_typed_array_swap_bytes(int32_t argc, Janet *argv) { static Janet cfun_typed_array_swap_bytes(int32_t argc, Janet *argv) {
janet_arity(argc, 4, 5); janet_arity(argc, 4, 5);
JanetTArrayView *src = janet_getabstract(argv, 0, &ta_view_type); JanetTArrayView *src = janet_getabstract(argv, 0, &janet_ta_view_type);
size_t index_src = janet_getsize(argv, 1); size_t index_src = janet_getsize(argv, 1);
JanetTArrayView *dst = janet_getabstract(argv, 2, &ta_view_type); JanetTArrayView *dst = janet_getabstract(argv, 2, &janet_ta_view_type);
size_t index_dst = janet_getsize(argv, 3); size_t index_dst = janet_getsize(argv, 3);
size_t count = (argc == 5) ? janet_getsize(argv, 4) : 1; size_t count = (argc == 5) ? janet_getsize(argv, 4) : 1;
size_t src_atom_size = ta_type_sizes[src->type]; size_t src_atom_size = ta_type_sizes[src->type];
@ -574,8 +574,8 @@ static JanetMethod tarray_view_methods[] = {
/* Module entry point */ /* Module entry point */
void janet_lib_typed_array(JanetTable *env) { void janet_lib_typed_array(JanetTable *env) {
janet_core_cfuns(env, NULL, ta_cfuns); janet_core_cfuns(env, NULL, ta_cfuns);
janet_register_abstract_type(&ta_buffer_type); janet_register_abstract_type(&janet_ta_buffer_type);
janet_register_abstract_type(&ta_view_type); janet_register_abstract_type(&janet_ta_view_type);
} }
#endif #endif

10
src/core/util.c
View File

@ -421,10 +421,10 @@ void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns)
free(longname_buffer); free(longname_buffer);
} }
/* Abstract type introspection */ /* Abstract type introspection - not meant to be used directly */
static const JanetAbstractType type_wrap = { static const JanetAbstractType janet_abstract_info_type = {
"core/type-info", "core/abstract-info",
JANET_ATEND_NAME JANET_ATEND_NAME
}; };
@ -434,7 +434,7 @@ typedef struct {
void janet_register_abstract_type(const JanetAbstractType *at) { void janet_register_abstract_type(const JanetAbstractType *at) {
JanetAbstractTypeWrap *abstract = (JanetAbstractTypeWrap *) JanetAbstractTypeWrap *abstract = (JanetAbstractTypeWrap *)
janet_abstract(&type_wrap, sizeof(JanetAbstractTypeWrap)); janet_abstract(&janet_abstract_info_type, sizeof(JanetAbstractTypeWrap));
abstract->at = at; abstract->at = at;
Janet sym = janet_csymbolv(at->name); Janet sym = janet_csymbolv(at->name);
if (!(janet_checktype(janet_table_get(janet_vm_registry, sym), JANET_NIL))) { if (!(janet_checktype(janet_table_get(janet_vm_registry, sym), JANET_NIL))) {
@ -450,7 +450,7 @@ const JanetAbstractType *janet_get_abstract_type(Janet key) {
return NULL; return NULL;
} }
if (!janet_checktype(twrap, JANET_ABSTRACT) || if (!janet_checktype(twrap, JANET_ABSTRACT) ||
(janet_abstract_type(janet_unwrap_abstract(twrap)) != &type_wrap)) { (janet_abstract_type(janet_unwrap_abstract(twrap)) != &janet_abstract_info_type)) {
janet_panic("expected abstract type"); janet_panic("expected abstract type");
} }
JanetAbstractTypeWrap *w = (JanetAbstractTypeWrap *)janet_unwrap_abstract(twrap); JanetAbstractTypeWrap *w = (JanetAbstractTypeWrap *)janet_unwrap_abstract(twrap);

69
src/include/janet.h
View File

@ -887,8 +887,9 @@ struct JanetParser {
int flag; int flag;
}; };
/* A context for marshaling and unmarshaling abstract types */
typedef struct { typedef struct {
void *m_state; /* void* to not expose MarshalState ?*/ void *m_state;
void *u_state; void *u_state;
int flags; int flags;
const uint8_t *data; const uint8_t *data;
@ -965,6 +966,12 @@ struct JanetRNG {
uint32_t counter; uint32_t counter;
}; };
typedef struct JanetFile JanetFile;
struct JanetFile {
FILE *file;
int flags;
};
/* Thread types */ /* Thread types */
#ifdef JANET_THREADS #ifdef JANET_THREADS
typedef struct JanetThread JanetThread; typedef struct JanetThread JanetThread;
@ -1095,6 +1102,7 @@ extern enum JanetInstructionType janet_instructions[JOP_INSTRUCTION_COUNT];
/***** START SECTION MAIN *****/ /***** START SECTION MAIN *****/
/* Parsing */ /* Parsing */
extern JANET_API const JanetAbstractType janet_parser_type;
JANET_API void janet_parser_init(JanetParser *parser); JANET_API void janet_parser_init(JanetParser *parser);
JANET_API void janet_parser_deinit(JanetParser *parser); JANET_API void janet_parser_deinit(JanetParser *parser);
JANET_API void janet_parser_consume(JanetParser *parser, uint8_t c); JANET_API void janet_parser_consume(JanetParser *parser, uint8_t c);
@ -1156,6 +1164,7 @@ JANET_API void janet_debug_find(
JanetString source, int32_t line, int32_t column); JanetString source, int32_t line, int32_t column);
/* RNG */ /* RNG */
extern JANET_API const JanetAbstractType janet_rng_type;
JANET_API JanetRNG *janet_default_rng(void); JANET_API JanetRNG *janet_default_rng(void);
JANET_API void janet_rng_seed(JanetRNG *rng, uint32_t seed); JANET_API void janet_rng_seed(JanetRNG *rng, uint32_t seed);
JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len); JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len);
@ -1468,6 +1477,8 @@ JANET_API JanetArray *janet_optarray(const Janet *argv, int32_t argc, int32_t n,
JANET_API Janet janet_dyn(const char *name); JANET_API Janet janet_dyn(const char *name);
JANET_API void janet_setdyn(const char *name, Janet value); JANET_API void janet_setdyn(const char *name, Janet value);
extern JANET_API const JanetAbstractType janet_file_type;
#define JANET_FILE_WRITE 1 #define JANET_FILE_WRITE 1
#define JANET_FILE_READ 2 #define JANET_FILE_READ 2
#define JANET_FILE_APPEND 4 #define JANET_FILE_APPEND 4
@ -1505,8 +1516,52 @@ JANET_API JanetAbstract janet_unmarshal_abstract(JanetMarshalContext *ctx, size_
JANET_API void janet_register_abstract_type(const JanetAbstractType *at); JANET_API void janet_register_abstract_type(const JanetAbstractType *at);
JANET_API const JanetAbstractType *janet_get_abstract_type(Janet key); JANET_API const JanetAbstractType *janet_get_abstract_type(Janet key);
#ifdef JANET_PEG
extern JANET_API const JanetAbstractType janet_peg_type;
/* opcodes for peg vm */
typedef enum {
RULE_LITERAL, /* [len, bytes...] */
RULE_NCHAR, /* [n] */
RULE_NOTNCHAR, /* [n] */
RULE_RANGE, /* [lo | hi << 16 (1 word)] */
RULE_SET, /* [bitmap (8 words)] */
RULE_LOOK, /* [offset, rule] */
RULE_CHOICE, /* [len, rules...] */
RULE_SEQUENCE, /* [len, rules...] */
RULE_IF, /* [rule_a, rule_b (b if a)] */
RULE_IFNOT, /* [rule_a, rule_b (b if not a)] */
RULE_NOT, /* [rule] */
RULE_BETWEEN, /* [lo, hi, rule] */
RULE_GETTAG, /* [searchtag, tag] */
RULE_CAPTURE, /* [rule, tag] */
RULE_POSITION, /* [tag] */
RULE_ARGUMENT, /* [argument-index, tag] */
RULE_CONSTANT, /* [constant, tag] */
RULE_ACCUMULATE, /* [rule, tag] */
RULE_GROUP, /* [rule, tag] */
RULE_REPLACE, /* [rule, constant, tag] */
RULE_MATCHTIME, /* [rule, constant, tag] */
RULE_ERROR, /* [rule] */
RULE_DROP, /* [rule] */
RULE_BACKMATCH, /* [tag] */
} JanetPegOpcode;
typedef struct {
uint32_t *bytecode;
Janet *constants;
size_t bytecode_len;
uint32_t num_constants;
} JanetPeg;
#endif
#ifdef JANET_TYPED_ARRAY #ifdef JANET_TYPED_ARRAY
extern JANET_API const JanetAbstractType janet_ta_view_type;
extern JANET_API const JanetAbstractType janet_ta_buffer_type;
typedef enum { typedef enum {
JANET_TARRAY_TYPE_U8, JANET_TARRAY_TYPE_U8,
JANET_TARRAY_TYPE_S8, JANET_TARRAY_TYPE_S8,
@ -1557,6 +1612,9 @@ JanetTArrayView *janet_gettarray_any(const Janet *argv, int32_t n);
#ifdef JANET_INT_TYPES #ifdef JANET_INT_TYPES
extern JANET_API const JanetAbstractType janet_s64_type;
extern JANET_API const JanetAbstractType janet_s64_type;
typedef enum { typedef enum {
JANET_INT_NONE, JANET_INT_NONE,
JANET_INT_S64, JANET_INT_S64,
@ -1573,6 +1631,15 @@ JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);
#endif #endif
#ifdef JANET_THREADS
extern JANET_API const JanetAbstractType janet_thread_type;
JANET_API int janet_thread_receive(Janet *msg_out, double timeout);
JANET_API int janet_thread_send(JanetThread *thread, Janet msg, double timeout);
#endif
/***** END SECTION MAIN *****/ /***** END SECTION MAIN *****/
#ifdef __cplusplus #ifdef __cplusplus