mirror of https://github.com/janet-lang/janet
Refactor stl to corelib and stl. Corelib is part of vm, stl
is part of dst language. Add bootstrapping code directly into stl. Stl is now logically grouped with compiler.
This commit is contained in:
bakpakin
parent
ce5708af98
commit
4f74d57359
|
|
@ -37,6 +37,7 @@ src/compiler/compile.c
|
|||
src/compiler/specials.c
|
||||
src/compiler/cfuns.c
|
||||
src/compiler/context.c
|
||||
src/compiler/stl.c
|
||||
|
||||
src/compiler/compile.h
|
||||
)
|
||||
|
|
@ -47,12 +48,12 @@ src/core/array.c
|
|||
src/core/ast.c
|
||||
src/core/buffer.c
|
||||
src/core/bytecode.c
|
||||
src/core/corelib.c
|
||||
src/core/fiber.c
|
||||
src/core/gc.c
|
||||
src/core/io.c
|
||||
src/core/math.c
|
||||
src/core/native.c
|
||||
src/core/stl.c
|
||||
src/core/string.c
|
||||
src/core/struct.c
|
||||
src/core/symcache.c
|
||||
|
|
@ -70,6 +71,9 @@ src/core/util.h
|
|||
|
||||
set(MAINCLIENT_SOURCES
|
||||
src/mainclient/main.c
|
||||
src/mainclient/linenoise.c
|
||||
|
||||
src/mainclient/linenoise.h
|
||||
)
|
||||
|
||||
set(PARSER_SOURCES
|
||||
|
|
|
|||
25
LICENSE
25
LICENSE
|
|
@ -17,3 +17,28 @@ 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.
|
||||
|
||||
Copyright (c) 2010-2014, Salvatore Sanfilippo <antirez at gmail dot com>
|
||||
Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
|
||||
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice,
|
||||
this list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
|
|
|
|||
|
|
@ -879,3 +879,16 @@ int dst_disasm_cfun(DstArgs args) {
|
|||
f = dst_unwrap_function(args.v[0]);
|
||||
return dst_return(args, dst_disasm(f->def));
|
||||
}
|
||||
|
||||
static const DstReg cfuns[] = {
|
||||
{"asm", dst_asm_cfun},
|
||||
{"disasm", dst_disasm_cfun},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
/* Load the library */
|
||||
int dst_lib_asm(DstArgs args) {
|
||||
DstTable *env = dst_env_arg(args);
|
||||
dst_env_cfuns(env, cfuns);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
*/
|
||||
|
||||
#include <dst/dst.h>
|
||||
#include <dst/dststl.h>
|
||||
#include <dst/dstcorelib.h>
|
||||
#include "compile.h"
|
||||
#include <headerlibs/vector.h>
|
||||
#undef DST_V_NODEF_GROW
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
*/
|
||||
|
||||
#include <dst/dst.h>
|
||||
#include <dst/dststl.h>
|
||||
#include <dst/dstcorelib.h>
|
||||
#include "compile.h"
|
||||
|
||||
#define DST_V_DEF_COPYMEM
|
||||
|
|
@ -737,7 +737,7 @@ static DstSlot dstc_array(DstFopts opts, DstAst *ast, Dst x) {
|
|||
DstArray *a = dst_unwrap_array(x);
|
||||
return dstc_call(opts, ast,
|
||||
dstc_toslots(c, a->data, a->count),
|
||||
dstc_cslot(dst_wrap_cfunction(dst_cfun_array)));
|
||||
dstc_cslot(dst_wrap_cfunction(dst_core_array)));
|
||||
}
|
||||
|
||||
static DstSlot dstc_tablector(DstFopts opts, DstAst *ast, Dst x, DstCFunction cfun) {
|
||||
|
|
@ -750,10 +750,11 @@ DstSlot dstc_value(DstFopts opts, Dst x) {
|
|||
DstSlot ret;
|
||||
DstAst *ast;
|
||||
DstCompiler *c = opts.compiler;
|
||||
int macrorecur = 0;
|
||||
opts.compiler->recursion_guard--;
|
||||
recur:
|
||||
ast = dst_ast_node(x);
|
||||
x = dst_ast_unwrap1(x);
|
||||
recur:
|
||||
if (dstc_iserr(&opts)) {
|
||||
return dstc_cslot(dst_wrap_nil());
|
||||
}
|
||||
|
|
@ -801,12 +802,17 @@ recur:
|
|||
if (dst_checktype(dst_get(entry, dst_csymbolv("macro")), DST_NIL)) break;
|
||||
fn = dst_get(entry, dst_csymbolv("value"));
|
||||
if (!dst_checktype(fn, DST_FUNCTION)) break;
|
||||
status = dst_call(fn, &x, dst_tuple_length(tup) - 1, tup + 1);
|
||||
if (status) {
|
||||
dstc_cerror(c, ast, "error in macro expansion");
|
||||
if (macrorecur++ > DST_RECURSION_GUARD) {
|
||||
dstc_cerror(c, ast, "macro expansion recursed too deeply");
|
||||
return dstc_cslot(dst_wrap_nil());
|
||||
} else {
|
||||
status = dst_call(fn, &x, dst_tuple_length(tup) - 1, tup + 1);
|
||||
if (status) {
|
||||
dstc_cerror(c, ast, "error in macro expansion");
|
||||
}
|
||||
/* Tail recur on the value */
|
||||
goto recur;
|
||||
}
|
||||
/* Tail recur on the value */
|
||||
goto recur;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -823,10 +829,10 @@ recur:
|
|||
ret = dstc_array(opts, ast, x);
|
||||
break;
|
||||
case DST_STRUCT:
|
||||
ret = dstc_tablector(opts, ast, x, dst_cfun_struct);
|
||||
ret = dstc_tablector(opts, ast, x, dst_core_struct);
|
||||
break;
|
||||
case DST_TABLE:
|
||||
ret = dstc_tablector(opts, ast, x, dst_cfun_table);
|
||||
ret = dstc_tablector(opts, ast, x, dst_core_table);
|
||||
break;
|
||||
}
|
||||
if (dstc_iserr(&opts)) {
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@
|
|||
|
||||
#define CHUNKSIZE 1024
|
||||
|
||||
/* Read input for a repl */
|
||||
/* read input for a repl */
|
||||
static int replread(DstContext *c, enum DstParserStatus status) {
|
||||
if (status == DST_PARSE_PENDING)
|
||||
printf(">> ");
|
||||
|
|
@ -45,6 +45,24 @@ static int replread(DstContext *c, enum DstParserStatus status) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int cstringread(DstContext *c, enum DstParserStatus status) {
|
||||
char *src = (char *)(c->user);
|
||||
(void) status;
|
||||
DstBuffer *b = &c->buffer;
|
||||
if (!b->capacity) {
|
||||
dst_buffer_ensure(b, CHUNKSIZE);
|
||||
}
|
||||
if (!*src) return 1;
|
||||
while (*src && b->count < b->capacity) {
|
||||
dst_buffer_push_u8(b, *src++);
|
||||
}
|
||||
if (!*src) {
|
||||
dst_buffer_push_u8(b, '\n');
|
||||
}
|
||||
c->user = src;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Output for a repl */
|
||||
static void replonvalue(DstContext *c, Dst value) {
|
||||
(void) c;
|
||||
|
|
@ -129,6 +147,13 @@ int dst_context_file(DstContext *c, DstTable *env, const char *path) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_context_cstring(DstContext *c, DstTable *env, const char *source) {
|
||||
dst_context_init(c, env);
|
||||
c->user = (void *) source;
|
||||
c->read_chunk = cstringread;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Do something on an error. Return flags to or with current flags. */
|
||||
static int doerror(
|
||||
DstContext *c,
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
*/
|
||||
|
||||
#include <dst/dst.h>
|
||||
#include <dst/dststl.h>
|
||||
#include <dst/dstcorelib.h>
|
||||
#include <dst/dstcompile.h>
|
||||
#include <dst/dstparse.h>
|
||||
#include "compile.h"
|
||||
|
|
|
|||
|
|
@ -0,0 +1,126 @@
|
|||
/*
|
||||
* 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 <dst/dst.h>
|
||||
#include <dst/dstopcodes.h>
|
||||
#include <dst/dstcorelib.h>
|
||||
#include <dst/dstasm.h>
|
||||
#include <dst/dstparse.h>
|
||||
#include <dst/dstcompile.h>
|
||||
|
||||
static const DstReg cfuns[] = {
|
||||
{"native", dst_core_native},
|
||||
{"print", dst_core_print},
|
||||
{"describe", dst_core_describe},
|
||||
{"string", dst_core_string},
|
||||
{"symbol", dst_core_symbol},
|
||||
{"buffer-string", dst_core_buffer_to_string},
|
||||
{"table", dst_core_table},
|
||||
{"array", dst_core_array},
|
||||
{"tuple", dst_core_tuple},
|
||||
{"struct", dst_core_struct},
|
||||
{"fiber", dst_core_fiber},
|
||||
{"status", dst_core_status},
|
||||
{"buffer", dst_core_buffer},
|
||||
{"gensym", dst_core_gensym},
|
||||
{"get", dst_core_get},
|
||||
{"put", dst_core_put},
|
||||
{"length", dst_core_length},
|
||||
{"gccollect", dst_core_gccollect},
|
||||
{"type", dst_core_type},
|
||||
{"next", dst_core_next},
|
||||
{"hash", dst_core_hash},
|
||||
{"exit", dst_core_exit},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
static const char *bootstrap =
|
||||
"(def defmacro macro (fn [name & more] (tuple 'def name 'macro (tuple-prepend (tuple-prepend more name) 'fn))))\n"
|
||||
"(defmacro defn [name & more] (tuple 'def name (tuple-prepend (tuple-prepend more name) 'fn)))\n"
|
||||
"(defmacro when [cond & body] (tuple 'if cond (tuple-prepend body 'do)))\n";
|
||||
|
||||
DstTable *dst_stl_env() {
|
||||
static uint32_t error_asm[] = {
|
||||
DOP_ERROR
|
||||
};
|
||||
|
||||
static uint32_t apply_asm[] = {
|
||||
DOP_PUSH_ARRAY | (1 << 8),
|
||||
DOP_TAILCALL
|
||||
};
|
||||
|
||||
static uint32_t yield_asm[] = {
|
||||
DOP_LOAD_NIL | (1 << 8),
|
||||
DOP_TRANSFER | (1 << 16),
|
||||
DOP_RETURN
|
||||
};
|
||||
|
||||
static uint32_t transfer_asm[] = {
|
||||
DOP_TRANSFER | (1 << 24),
|
||||
DOP_RETURN
|
||||
};
|
||||
|
||||
DstTable *env = dst_table(0);
|
||||
Dst ret = dst_wrap_table(env);
|
||||
|
||||
/* Load main functions */
|
||||
dst_env_cfuns(env, cfuns);
|
||||
|
||||
dst_env_def(env, "error", dst_wrap_function(dst_quick_asm(1, 0, 1, error_asm, sizeof(error_asm))));
|
||||
dst_env_def(env, "apply", dst_wrap_function(dst_quick_asm(2, 0, 2, apply_asm, sizeof(apply_asm))));
|
||||
dst_env_def(env, "yield", dst_wrap_function(dst_quick_asm(1, 0, 2, yield_asm, sizeof(yield_asm))));
|
||||
dst_env_def(env, "transfer", dst_wrap_function(dst_quick_asm(2, 0, 2, transfer_asm, sizeof(transfer_asm))));
|
||||
|
||||
/* Allow references to the environment */
|
||||
dst_env_def(env, "_env", ret);
|
||||
|
||||
/* Set as gc root */
|
||||
dst_gcroot(dst_wrap_table(env));
|
||||
|
||||
/* Load auxiliary envs */
|
||||
{
|
||||
DstArgs args;
|
||||
args.n = 1;
|
||||
args.v = &ret;
|
||||
args.ret = &ret;
|
||||
dst_lib_io(args);
|
||||
dst_lib_math(args);
|
||||
dst_lib_array(args);
|
||||
dst_lib_ast(args);
|
||||
dst_lib_tuple(args);
|
||||
dst_lib_buffer(args);
|
||||
dst_lib_parse(args);
|
||||
dst_lib_compile(args);
|
||||
dst_lib_asm(args);
|
||||
}
|
||||
|
||||
/* Run bootstrap source */
|
||||
{
|
||||
DstContext ctxt;
|
||||
dst_context_cstring(&ctxt, env, bootstrap);
|
||||
dst_context_run(&ctxt, 0);
|
||||
}
|
||||
|
||||
dst_gcunroot(dst_wrap_table(env));
|
||||
|
||||
return env;
|
||||
}
|
||||
|
|
@ -32,7 +32,7 @@ static int dst_ast_gcmark(void *p, size_t size) {
|
|||
|
||||
/* AST type */
|
||||
static DstAbstractType dst_ast_type = {
|
||||
"ast",
|
||||
"core.ast",
|
||||
NULL,
|
||||
dst_ast_gcmark
|
||||
};
|
||||
|
|
|
|||
|
|
@ -21,11 +21,9 @@
|
|||
*/
|
||||
|
||||
#include <dst/dst.h>
|
||||
#include <dst/dststl.h>
|
||||
#include <dst/dstasm.h>
|
||||
#include <dst/dstopcodes.h>
|
||||
#include <dst/dstcorelib.h>
|
||||
|
||||
int dst_stl_exit(DstArgs args) {
|
||||
int dst_core_exit(DstArgs args) {
|
||||
int32_t exitcode = 0;
|
||||
if (args.n > 0) {
|
||||
exitcode = dst_hash(args.v[0]);
|
||||
|
|
@ -34,7 +32,7 @@ int dst_stl_exit(DstArgs args) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_print(DstArgs args) {
|
||||
int dst_core_print(DstArgs args) {
|
||||
int32_t i;
|
||||
for (i = 0; i < args.n; ++i) {
|
||||
int32_t j, len;
|
||||
|
|
@ -48,7 +46,7 @@ int dst_stl_print(DstArgs args) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_describe(DstArgs args) {
|
||||
int dst_core_describe(DstArgs args) {
|
||||
int32_t i;
|
||||
for (i = 0; i < args.n; ++i) {
|
||||
int32_t j, len;
|
||||
|
|
@ -62,7 +60,7 @@ int dst_stl_describe(DstArgs args) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_string(DstArgs args) {
|
||||
int dst_core_string(DstArgs args) {
|
||||
int32_t i;
|
||||
DstBuffer b;
|
||||
dst_buffer_init(&b, 0);
|
||||
|
|
@ -77,7 +75,7 @@ int dst_stl_string(DstArgs args) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_symbol(DstArgs args) {
|
||||
int dst_core_symbol(DstArgs args) {
|
||||
int32_t i;
|
||||
DstBuffer b;
|
||||
dst_buffer_init(&b, 0);
|
||||
|
|
@ -92,7 +90,7 @@ int dst_stl_symbol(DstArgs args) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_buffer_to_string(DstArgs args) {
|
||||
int dst_core_buffer_to_string(DstArgs args) {
|
||||
DstBuffer *b;
|
||||
if (args.n != 1) return dst_throw(args, "expected 1 argument");
|
||||
if (!dst_checktype(args.v[0], DST_BUFFER)) return dst_throw(args, "expected buffer");
|
||||
|
|
@ -100,18 +98,18 @@ int dst_stl_buffer_to_string(DstArgs args) {
|
|||
return dst_return(args, dst_wrap_string(dst_string(b->data, b->count)));
|
||||
}
|
||||
|
||||
int dst_cfun_tuple(DstArgs args) {
|
||||
int dst_core_tuple(DstArgs args) {
|
||||
return dst_return(args, dst_wrap_tuple(dst_tuple_n(args.v, args.n)));
|
||||
}
|
||||
|
||||
int dst_cfun_array(DstArgs args) {
|
||||
int dst_core_array(DstArgs args) {
|
||||
DstArray *array = dst_array(args.n);
|
||||
array->count = args.n;
|
||||
memcpy(array->data, args.v, args.n * sizeof(Dst));
|
||||
return dst_return(args, dst_wrap_array(array));
|
||||
}
|
||||
|
||||
int dst_cfun_table(DstArgs args) {
|
||||
int dst_core_table(DstArgs args) {
|
||||
int32_t i;
|
||||
DstTable *table = dst_table(args.n >> 1);
|
||||
if (args.n & 1) return dst_throw(args, "expected even number of arguments");
|
||||
|
|
@ -121,7 +119,7 @@ int dst_cfun_table(DstArgs args) {
|
|||
return dst_return(args, dst_wrap_table(table));
|
||||
}
|
||||
|
||||
int dst_cfun_struct(DstArgs args) {
|
||||
int dst_core_struct(DstArgs args) {
|
||||
int32_t i;
|
||||
DstKV *st = dst_struct_begin(args.n >> 1);
|
||||
if (args.n & 1) return dst_throw(args, "expected even number of arguments");
|
||||
|
|
@ -131,7 +129,7 @@ int dst_cfun_struct(DstArgs args) {
|
|||
return dst_return(args, dst_wrap_struct(dst_struct_end(st)));
|
||||
}
|
||||
|
||||
int dst_stl_fiber(DstArgs args) {
|
||||
int dst_core_fiber(DstArgs args) {
|
||||
DstFiber *fiber;
|
||||
if (args.n < 1) return dst_throw(args, "expected at least one argument");
|
||||
if (!dst_checktype(args.v[0], DST_FUNCTION)) return dst_throw(args, "expected a function");
|
||||
|
|
@ -141,7 +139,7 @@ int dst_stl_fiber(DstArgs args) {
|
|||
return dst_return(args, dst_wrap_fiber(fiber));
|
||||
}
|
||||
|
||||
int dst_stl_buffer(DstArgs args) {
|
||||
int dst_core_buffer(DstArgs args) {
|
||||
DstBuffer *buffer = dst_buffer(10);
|
||||
int32_t i;
|
||||
for (i = 0; i < args.n; ++i) {
|
||||
|
|
@ -152,7 +150,7 @@ int dst_stl_buffer(DstArgs args) {
|
|||
return dst_return(args, dst_wrap_buffer(buffer));
|
||||
}
|
||||
|
||||
int dst_stl_gensym(DstArgs args) {
|
||||
int dst_core_gensym(DstArgs args) {
|
||||
if (args.n > 1) return dst_throw(args, "expected one argument");
|
||||
if (args.n == 0) {
|
||||
return dst_return(args, dst_wrap_symbol(dst_symbol_gen(NULL, 0)));
|
||||
|
|
@ -162,12 +160,12 @@ int dst_stl_gensym(DstArgs args) {
|
|||
}
|
||||
}
|
||||
|
||||
int dst_stl_length(DstArgs args) {
|
||||
int dst_core_length(DstArgs args) {
|
||||
if (args.n != 1) return dst_throw(args, "expected at least 1 argument");
|
||||
return dst_return(args, dst_wrap_integer(dst_length(args.v[0])));
|
||||
}
|
||||
|
||||
int dst_stl_get(DstArgs args) {
|
||||
int dst_core_get(DstArgs args) {
|
||||
int32_t i;
|
||||
Dst ds;
|
||||
if (args.n < 1) return dst_throw(args, "expected at least 1 argument");
|
||||
|
|
@ -180,7 +178,7 @@ int dst_stl_get(DstArgs args) {
|
|||
return dst_return(args, ds);
|
||||
}
|
||||
|
||||
int dst_stl_status(DstArgs args) {
|
||||
int dst_core_status(DstArgs args) {
|
||||
const char *status;
|
||||
if (args.n != 1) return dst_throw(args, "expected 1 argument");
|
||||
if (!dst_checktype(args.v[0], DST_FIBER)) return dst_throw(args, "expected fiber");
|
||||
|
|
@ -204,12 +202,12 @@ int dst_stl_status(DstArgs args) {
|
|||
return dst_return(args, dst_cstringv(status));
|
||||
}
|
||||
|
||||
int dst_stl_put(DstArgs args) {
|
||||
int dst_core_put(DstArgs args) {
|
||||
Dst ds, key, value;
|
||||
DstArgs subargs = args;
|
||||
if (args.n < 3) return dst_throw(args, "expected at least 3 arguments");
|
||||
subargs.n -= 2;
|
||||
if (dst_stl_get(subargs)) return 1;
|
||||
if (dst_core_get(subargs)) return 1;
|
||||
ds = *args.ret;
|
||||
key = args.v[args.n - 2];
|
||||
value = args.v[args.n - 1];
|
||||
|
|
@ -217,13 +215,13 @@ int dst_stl_put(DstArgs args) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_gccollect(DstArgs args) {
|
||||
int dst_core_gccollect(DstArgs args) {
|
||||
(void) args;
|
||||
dst_collect();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dst_stl_type(DstArgs args) {
|
||||
int dst_core_type(DstArgs args) {
|
||||
if (args.n != 1) return dst_throw(args, "expected 1 argument");
|
||||
if (dst_checktype(args.v[0], DST_ABSTRACT)) {
|
||||
return dst_return(args, dst_cstringv(dst_abstract_type(dst_unwrap_abstract(args.v[0]))->name));
|
||||
|
|
@ -232,7 +230,7 @@ int dst_stl_type(DstArgs args) {
|
|||
}
|
||||
}
|
||||
|
||||
int dst_stl_next(DstArgs args) {
|
||||
int dst_core_next(DstArgs args) {
|
||||
Dst ds;
|
||||
const DstKV *kv;
|
||||
if (args.n != 2) return dst_throw(args, "expected 2 arguments");
|
||||
|
|
@ -257,89 +255,7 @@ int dst_stl_next(DstArgs args) {
|
|||
return dst_return(args, dst_wrap_nil());
|
||||
}
|
||||
|
||||
int dst_stl_hash(DstArgs args) {
|
||||
int dst_core_hash(DstArgs args) {
|
||||
if (args.n != 1) return dst_throw(args, "expected 1 argument");
|
||||
return dst_return(args, dst_wrap_integer(dst_hash(args.v[0])));
|
||||
}
|
||||
|
||||
static const DstReg cfuns[] = {
|
||||
{"native", dst_load_native},
|
||||
{"print", dst_stl_print},
|
||||
{"describe", dst_stl_describe},
|
||||
{"string", dst_stl_string},
|
||||
{"symbol", dst_stl_symbol},
|
||||
{"buffer-string", dst_stl_buffer_to_string},
|
||||
{"table", dst_cfun_table},
|
||||
{"array", dst_cfun_array},
|
||||
{"tuple", dst_cfun_tuple},
|
||||
{"struct", dst_cfun_struct},
|
||||
{"fiber", dst_stl_fiber},
|
||||
{"status", dst_stl_status},
|
||||
{"buffer", dst_stl_buffer},
|
||||
{"gensym", dst_stl_gensym},
|
||||
{"get", dst_stl_get},
|
||||
{"put", dst_stl_put},
|
||||
{"length", dst_stl_length},
|
||||
{"gccollect", dst_stl_gccollect},
|
||||
{"type", dst_stl_type},
|
||||
{"next", dst_stl_next},
|
||||
{"hash", dst_stl_hash},
|
||||
{"exit", dst_stl_exit},
|
||||
{"asm", dst_asm_cfun},
|
||||
{"disasm", dst_disasm_cfun},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
DstTable *dst_stl_env() {
|
||||
static uint32_t error_asm[] = {
|
||||
DOP_ERROR
|
||||
};
|
||||
|
||||
static uint32_t apply_asm[] = {
|
||||
DOP_PUSH_ARRAY | (1 << 8),
|
||||
DOP_TAILCALL
|
||||
};
|
||||
|
||||
static uint32_t yield_asm[] = {
|
||||
DOP_LOAD_NIL | (1 << 8),
|
||||
DOP_TRANSFER | (1 << 16),
|
||||
DOP_RETURN
|
||||
};
|
||||
|
||||
static uint32_t transfer_asm[] = {
|
||||
DOP_TRANSFER | (1 << 24),
|
||||
DOP_RETURN
|
||||
};
|
||||
|
||||
DstTable *env = dst_table(0);
|
||||
Dst ret = dst_wrap_table(env);
|
||||
|
||||
/* Load main functions */
|
||||
dst_env_cfuns(env, cfuns);
|
||||
|
||||
dst_env_def(env, "error", dst_wrap_function(dst_quick_asm(1, 0, 1, error_asm, sizeof(error_asm))));
|
||||
dst_env_def(env, "apply", dst_wrap_function(dst_quick_asm(2, 0, 2, apply_asm, sizeof(apply_asm))));
|
||||
dst_env_def(env, "yield", dst_wrap_function(dst_quick_asm(1, 0, 2, yield_asm, sizeof(yield_asm))));
|
||||
dst_env_def(env, "transfer", dst_wrap_function(dst_quick_asm(2, 0, 2, transfer_asm, sizeof(transfer_asm))));
|
||||
|
||||
/* Allow references to the environment */
|
||||
dst_env_def(env, "_env", ret);
|
||||
|
||||
/* Load auxiliary envs */
|
||||
{
|
||||
DstArgs args;
|
||||
args.n = 1;
|
||||
args.v = &ret;
|
||||
args.ret = &ret;
|
||||
dst_lib_io(args);
|
||||
dst_lib_math(args);
|
||||
dst_lib_array(args);
|
||||
dst_lib_ast(args);
|
||||
dst_lib_tuple(args);
|
||||
dst_lib_buffer(args);
|
||||
dst_lib_parse(args);
|
||||
dst_lib_compile(args);
|
||||
}
|
||||
|
||||
return env;
|
||||
}
|
||||
|
|
@ -40,7 +40,7 @@ struct IOFile {
|
|||
static int dst_io_gc(void *p, size_t len);
|
||||
|
||||
DstAbstractType dst_io_filetype = {
|
||||
"io.file",
|
||||
"core.file",
|
||||
dst_io_gc,
|
||||
NULL
|
||||
};
|
||||
|
|
@ -84,16 +84,16 @@ static int checkflags(const uint8_t *str, int32_t len) {
|
|||
static IOFile *checkfile(DstArgs args, int32_t n) {
|
||||
IOFile *iof;
|
||||
if (n >= args.n) {
|
||||
dst_throw(args, "expected io.file");
|
||||
dst_throw(args, "expected core.file");
|
||||
return NULL;
|
||||
}
|
||||
if (!dst_checktype(args.v[n], DST_ABSTRACT)) {
|
||||
dst_throw(args, "expected io.file");
|
||||
dst_throw(args, "expected core.file");
|
||||
return NULL;
|
||||
}
|
||||
iof = (IOFile *) dst_unwrap_abstract(args.v[n]);
|
||||
if (dst_abstract_type(iof) != &dst_io_filetype) {
|
||||
dst_throw(args, "expected io.file");
|
||||
dst_throw(args, "expected core.file");
|
||||
return NULL;
|
||||
}
|
||||
return iof;
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
*/
|
||||
|
||||
#include <dst/dst.h>
|
||||
#include <dst/dststl.h>
|
||||
#include <dst/dstcorelib.h>
|
||||
|
||||
/* Use LoadLibrary on windows or dlopen on posix to load dynamic libaries
|
||||
* with native code. */
|
||||
|
|
@ -54,7 +54,7 @@ DstCFunction dst_native(const char *name, const uint8_t **error) {
|
|||
return init;
|
||||
}
|
||||
|
||||
int dst_load_native(DstArgs args) {
|
||||
int dst_core_native(DstArgs args) {
|
||||
DstCFunction init;
|
||||
const uint8_t *error = NULL;
|
||||
if (args.n < 1) {
|
||||
|
|
|
|||
|
|
@ -154,6 +154,9 @@ int dst_hashtable_view(Dst tab, const DstKV **data, int32_t *len, int32_t *cap);
|
|||
#define dst_abstract_size(u) (dst_abstract_header(u)->size)
|
||||
void *dst_abstract(const DstAbstractType *type, size_t size);
|
||||
|
||||
/* Native */
|
||||
DstCFunction dst_native(const char *name, const uint8_t **error);
|
||||
|
||||
/* GC */
|
||||
void dst_mark(Dst x);
|
||||
void dst_sweep();
|
||||
|
|
@ -186,9 +189,6 @@ Dst dst_getindex(Dst ds, int32_t index);
|
|||
void dst_setindex(Dst ds, Dst value, int32_t index);
|
||||
int dst_cstrcmp(const uint8_t *str, const char *other);
|
||||
|
||||
/* Native */
|
||||
DstCFunction dst_native(const char *name, const uint8_t **error);
|
||||
|
||||
/* VM functions */
|
||||
int dst_init();
|
||||
void dst_deinit();
|
||||
|
|
|
|||
|
|
@ -47,6 +47,8 @@ Dst dst_asm_decode_instruction(uint32_t instr);
|
|||
int dst_asm_cfun(DstArgs args);
|
||||
int dst_disasm_cfun(DstArgs args);
|
||||
|
||||
int dst_lib_asm(DstArgs args);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -49,10 +49,14 @@ int dst_compile_cfun(DstArgs args);
|
|||
/* Context - for executing dst in the interpretted form. */
|
||||
typedef struct DstContext DstContext;
|
||||
|
||||
/* Get the default environment for dst */
|
||||
DstTable *dst_stl_env();
|
||||
|
||||
void dst_context_init(DstContext *c, DstTable *env);
|
||||
void dst_context_deinit(DstContext *c);
|
||||
int dst_context_repl(DstContext *c, DstTable *env);
|
||||
int dst_context_file(DstContext *c, DstTable *env, const char *path);
|
||||
int dst_context_cstring(DstContext *c, DstTable *env, const char *source);
|
||||
int dst_context_run(DstContext *c, int flags);
|
||||
|
||||
/* Parse structs */
|
||||
|
|
@ -76,6 +80,8 @@ struct DstContext {
|
|||
void (*deinit)(DstContext *self);
|
||||
};
|
||||
|
||||
int dst_lib_compile(DstArgs args);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -35,7 +35,10 @@ extern "C" {
|
|||
* so that compiles can inject them into funcdefs. Later, a
|
||||
* different serialization mechanism might be used for cfunctions. */
|
||||
|
||||
int dst_load_native(DstArgs args);
|
||||
/* Native */
|
||||
int dst_core_native(DstArgs args);
|
||||
|
||||
/* Math functions */
|
||||
int dst_int(DstArgs args);
|
||||
int dst_real(DstArgs args);
|
||||
int dst_add(DstArgs args);
|
||||
|
|
@ -43,21 +46,56 @@ int dst_subtract(DstArgs args);
|
|||
int dst_multiply(DstArgs args);
|
||||
int dst_divide(DstArgs args);
|
||||
int dst_modulo(DstArgs args);
|
||||
int dst_band(DstArgs args);
|
||||
int dst_math_equal(DstArgs args);
|
||||
int dst_math_notequal(DstArgs args);
|
||||
int dst_math_ascending(DstArgs args);
|
||||
int dst_math_descending(DstArgs args);
|
||||
int dst_math_notdescending(DstArgs args);
|
||||
int dst_math_notascending(DstArgs args);
|
||||
int dst_bor(DstArgs args);
|
||||
int dst_band(DstArgs args);
|
||||
int dst_bxor(DstArgs args);
|
||||
int dst_lshift(DstArgs arsg);
|
||||
int dst_bnot(DstArgs args);
|
||||
int dst_lshift(DstArgs args);
|
||||
int dst_rshift(DstArgs args);
|
||||
int dst_lshiftu(DstArgs args);
|
||||
int dst_math_not(DstArgs args);
|
||||
int dst_cos(DstArgs args);
|
||||
int dst_sin(DstArgs args);
|
||||
int dst_tan(DstArgs args);
|
||||
int dst_acos(DstArgs args);
|
||||
int dst_asin(DstArgs args);
|
||||
int dst_atan(DstArgs args);
|
||||
int dst_exp(DstArgs args);
|
||||
int dst_log(DstArgs args);
|
||||
int dst_log10(DstArgs args);
|
||||
int dst_sqrt(DstArgs args);
|
||||
int dst_floor(DstArgs args);
|
||||
int dst_ceil(DstArgs args);
|
||||
int dst_pow(DstArgs args);
|
||||
|
||||
Dst dst_op_add(Dst lhs, Dst rhs);
|
||||
Dst dst_op_subtract(Dst lhs, Dst rhs);
|
||||
|
||||
/* Native type constructors */
|
||||
int dst_cfun_table(DstArgs args);
|
||||
int dst_cfun_array(DstArgs args);
|
||||
int dst_cfun_struct(DstArgs args);
|
||||
int dst_cfun_tuple(DstArgs args);
|
||||
/* Misc core functions */
|
||||
int dst_core_exit(DstArgs args);
|
||||
int dst_core_print(DstArgs args);
|
||||
int dst_core_describe(DstArgs args);
|
||||
int dst_core_string(DstArgs args);
|
||||
int dst_core_symbol(DstArgs args);
|
||||
int dst_core_buffer_to_string(DstArgs args);
|
||||
int dst_core_tuple(DstArgs args);
|
||||
int dst_core_array(DstArgs args);
|
||||
int dst_core_table(DstArgs args);
|
||||
int dst_core_struct(DstArgs args);
|
||||
int dst_core_fiber(DstArgs args);
|
||||
int dst_core_buffer(DstArgs args);
|
||||
int dst_core_gensym(DstArgs args);
|
||||
int dst_core_length(DstArgs args);
|
||||
int dst_core_get(DstArgs args);
|
||||
int dst_core_status(DstArgs args);
|
||||
int dst_core_put(DstArgs args);
|
||||
int dst_core_gccollect(DstArgs args);
|
||||
int dst_core_type(DstArgs args);
|
||||
int dst_core_next(DstArgs args);
|
||||
int dst_core_hash(DstArgs args);
|
||||
|
||||
/* Initialize builtin libraries */
|
||||
int dst_lib_io(DstArgs args);
|
||||
|
|
@ -66,8 +104,10 @@ int dst_lib_array(DstArgs args);
|
|||
int dst_lib_ast(DstArgs args);
|
||||
int dst_lib_tuple(DstArgs args);
|
||||
int dst_lib_buffer(DstArgs args);
|
||||
int dst_lib_parse(DstArgs args);
|
||||
int dst_lib_compile(DstArgs args);
|
||||
|
||||
/* Useful for compiler */
|
||||
Dst dst_op_add(Dst lhs, Dst rhs);
|
||||
Dst dst_op_subtract(Dst lhs, Dst rhs);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
@ -64,6 +64,8 @@ Dst dst_parser_produce(DstParser *parser);
|
|||
const char *dst_parser_error(DstParser *parser);
|
||||
int dst_parse_cfun(DstArgs args);
|
||||
|
||||
int dst_lib_parse(DstArgs args);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,73 @@
|
|||
/* linenoise.h -- VERSION 1.0
|
||||
*
|
||||
* Guerrilla line editing library against the idea that a line editing lib
|
||||
* needs to be 20,000 lines of C code.
|
||||
*
|
||||
* See linenoise.c for more information.
|
||||
*
|
||||
* ------------------------------------------------------------------------
|
||||
*
|
||||
* Copyright (c) 2010-2014, Salvatore Sanfilippo <antirez at gmail dot com>
|
||||
* Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
|
||||
*
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
*
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* * Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __LINENOISE_H
|
||||
#define __LINENOISE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef struct linenoiseCompletions {
|
||||
size_t len;
|
||||
char **cvec;
|
||||
} linenoiseCompletions;
|
||||
|
||||
typedef void(linenoiseCompletionCallback)(const char *, linenoiseCompletions *);
|
||||
typedef char*(linenoiseHintsCallback)(const char *, int *color, int *bold);
|
||||
typedef void(linenoiseFreeHintsCallback)(void *);
|
||||
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *);
|
||||
void linenoiseSetHintsCallback(linenoiseHintsCallback *);
|
||||
void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *);
|
||||
void linenoiseAddCompletion(linenoiseCompletions *, const char *);
|
||||
|
||||
char *linenoise(const char *prompt);
|
||||
void linenoiseFree(void *ptr);
|
||||
int linenoiseHistoryAdd(const char *line);
|
||||
int linenoiseHistorySetMaxLen(int len);
|
||||
int linenoiseHistorySave(const char *filename);
|
||||
int linenoiseHistoryLoad(const char *filename);
|
||||
void linenoiseClearScreen(void);
|
||||
void linenoiseSetMultiLine(int ml);
|
||||
void linenoisePrintKeyCodes(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __LINENOISE_H */
|
||||
|
|
@ -25,6 +25,9 @@
|
|||
#include <dst/dst.h>
|
||||
#include <dst/dstcompile.h>
|
||||
|
||||
#include "linenoise.h"
|
||||
#include <errno.h>
|
||||
|
||||
#define DST_CLIENT_HELP 1
|
||||
#define DST_CLIENT_VERBOSE 2
|
||||
#define DST_CLIENT_VERSION 4
|
||||
|
|
@ -44,6 +47,22 @@ static int client_strequal_witharg(const char *a, const char *b) {
|
|||
return *a == '=';
|
||||
}
|
||||
|
||||
static int linenoiseread(DstContext *c, enum DstParserStatus status) {
|
||||
const char *prompt = (status == DST_PARSE_PENDING)
|
||||
? ">> "
|
||||
: "> ";
|
||||
char *line = linenoise(prompt);
|
||||
if (line) {
|
||||
linenoiseHistoryAdd(line);
|
||||
dst_buffer_push_cstring(&c->buffer, line);
|
||||
free(line);
|
||||
} else if (errno) {
|
||||
return 1;
|
||||
}
|
||||
dst_buffer_push_u8(&c->buffer, '\n');
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int status = 0;
|
||||
int i;
|
||||
|
|
@ -150,6 +169,8 @@ int main(int argc, char **argv) {
|
|||
if (!fileRead || (flags & DST_CLIENT_REPL)) {
|
||||
DstContext ctxt;
|
||||
dst_context_repl(&ctxt, env);
|
||||
ctxt.read_chunk = linenoiseread;
|
||||
linenoiseSetMultiLine(1);
|
||||
puts(replsplash);
|
||||
status = dst_context_run(&ctxt, DST_PARSEFLAG_SOURCEMAP);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -303,7 +303,7 @@ static int tokenchar(DstParser *p, DstParseState *state, uint8_t c) {
|
|||
ret = dst_wrap_false();
|
||||
} else if (!check_str_const("true", p->buf, blen)) {
|
||||
ret = dst_wrap_true();
|
||||
} else {
|
||||
} else if (p->buf) {
|
||||
if (p->buf[0] >= '0' && p->buf[0] <= '9') {
|
||||
p->error = "symbol literal cannot start with a digit";
|
||||
return 0;
|
||||
|
|
@ -320,6 +320,9 @@ static int tokenchar(DstParser *p, DstParseState *state, uint8_t c) {
|
|||
ret = dst_symbolv(p->buf, blen);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
p->error = "empty symbol invalid";
|
||||
return 0;
|
||||
}
|
||||
dst_v_empty(p->buf);
|
||||
popstate(p, ret);
|
||||
|
|
@ -534,7 +537,7 @@ static int parsergc(void *p, size_t size) {
|
|||
}
|
||||
|
||||
DstAbstractType dst_parse_parsertype = {
|
||||
"stl.parser",
|
||||
"parse.parser",
|
||||
parsergc,
|
||||
parsermark
|
||||
};
|
||||
|
|
@ -558,16 +561,16 @@ static int cfun_parser(DstArgs args) {
|
|||
static DstParser *checkparser(DstArgs args) {
|
||||
DstParser *p;
|
||||
if (args.n == 0) {
|
||||
dst_throw(args, "expected stl.parser");
|
||||
dst_throw(args, "expected parse.parser");
|
||||
return NULL;
|
||||
}
|
||||
if (!dst_checktype(args.v[0], DST_ABSTRACT)) {
|
||||
dst_throw(args, "expected stl.parser");
|
||||
dst_throw(args, "expected parse.parser");
|
||||
return NULL;
|
||||
}
|
||||
p = (DstParser *) dst_unwrap_abstract(args.v[0]);
|
||||
if (dst_abstract_type(p) != &dst_parse_parsertype) {
|
||||
dst_throw(args, "expected stl.parser");
|
||||
dst_throw(args, "expected parse.parser");
|
||||
return NULL;
|
||||
}
|
||||
return p;
|
||||
|
|
|
|||
|
|
@ -1,7 +0,0 @@
|
|||
#include <dst/dst.h>
|
||||
|
||||
int dst_init_(DstArgs args) {
|
||||
DstTable *env = dst_env_arg(args);
|
||||
dst_env_def(env, "pi", dst_wrap_real(M_PI));
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue