diff --git a/CMakeLists.txt b/CMakeLists.txt index a9ae0dd4..255bda5f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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 diff --git a/LICENSE b/LICENSE index 4e5a480d..ef1cfd1e 100644 --- a/LICENSE +++ b/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 +Copyright (c) 2010-2013, Pieter Noordhuis + +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 diff --git a/src/assembler/asm.c b/src/assembler/asm.c index 08c7401d..d81e2a31 100644 --- a/src/assembler/asm.c +++ b/src/assembler/asm.c @@ -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; +} diff --git a/src/compiler/cfuns.c b/src/compiler/cfuns.c index 41f956c9..6c7d6c0d 100644 --- a/src/compiler/cfuns.c +++ b/src/compiler/cfuns.c @@ -21,7 +21,7 @@ */ #include -#include +#include #include "compile.h" #include #undef DST_V_NODEF_GROW diff --git a/src/compiler/compile.c b/src/compiler/compile.c index 1a0c26e6..fa5d48f5 100644 --- a/src/compiler/compile.c +++ b/src/compiler/compile.c @@ -21,7 +21,7 @@ */ #include -#include +#include #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)) { diff --git a/src/compiler/context.c b/src/compiler/context.c index 4e900957..bd7fda9c 100644 --- a/src/compiler/context.c +++ b/src/compiler/context.c @@ -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, diff --git a/src/compiler/specials.c b/src/compiler/specials.c index a5297ce6..0db7d1d9 100644 --- a/src/compiler/specials.c +++ b/src/compiler/specials.c @@ -21,7 +21,7 @@ */ #include -#include +#include #include #include #include "compile.h" diff --git a/src/compiler/stl.c b/src/compiler/stl.c new file mode 100644 index 00000000..c4cf5a9e --- /dev/null +++ b/src/compiler/stl.c @@ -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 +#include +#include +#include +#include +#include + +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; +} diff --git a/src/core/ast.c b/src/core/ast.c index 929340e2..7a9531c6 100644 --- a/src/core/ast.c +++ b/src/core/ast.c @@ -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 }; diff --git a/src/core/stl.c b/src/core/corelib.c similarity index 70% rename from src/core/stl.c rename to src/core/corelib.c index e8f69db2..05f86517 100644 --- a/src/core/stl.c +++ b/src/core/corelib.c @@ -21,11 +21,9 @@ */ #include -#include -#include -#include +#include -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; -} diff --git a/src/core/io.c b/src/core/io.c index e5093518..efb671d4 100644 --- a/src/core/io.c +++ b/src/core/io.c @@ -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; diff --git a/src/core/native.c b/src/core/native.c index c956cdee..4106a422 100644 --- a/src/core/native.c +++ b/src/core/native.c @@ -21,7 +21,7 @@ */ #include -#include +#include /* 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) { diff --git a/src/include/dst/dst.h b/src/include/dst/dst.h index 75cf5083..69bfeea0 100644 --- a/src/include/dst/dst.h +++ b/src/include/dst/dst.h @@ -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(); diff --git a/src/include/dst/dstasm.h b/src/include/dst/dstasm.h index 4372e660..63e15d58 100644 --- a/src/include/dst/dstasm.h +++ b/src/include/dst/dstasm.h @@ -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 diff --git a/src/include/dst/dstcompile.h b/src/include/dst/dstcompile.h index a90f0683..0bc0e2b9 100644 --- a/src/include/dst/dstcompile.h +++ b/src/include/dst/dstcompile.h @@ -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 diff --git a/src/include/dst/dststl.h b/src/include/dst/dstcorelib.h similarity index 58% rename from src/include/dst/dststl.h rename to src/include/dst/dstcorelib.h index baec097d..a86f16ac 100644 --- a/src/include/dst/dststl.h +++ b/src/include/dst/dstcorelib.h @@ -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 } diff --git a/src/include/dst/dstparse.h b/src/include/dst/dstparse.h index 5c9883d5..3f27dd27 100644 --- a/src/include/dst/dstparse.h +++ b/src/include/dst/dstparse.h @@ -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 diff --git a/src/mainclient/linenoise.c b/src/mainclient/linenoise.c new file mode 100644 index 00000000..fce14a7c --- /dev/null +++ b/src/mainclient/linenoise.c @@ -0,0 +1,1199 @@ +/* linenoise.c -- guerrilla line editing library against the idea that a + * line editing lib needs to be 20,000 lines of C code. + * + * You can find the latest source code at: + * + * http://github.com/antirez/linenoise + * + * Does a number of crazy assumptions that happen to be true in 99.9999% of + * the 2010 UNIX computers around. + * + * ------------------------------------------------------------------------ + * + * Copyright (c) 2010-2016, Salvatore Sanfilippo + * Copyright (c) 2010-2013, Pieter Noordhuis + * + * 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. + * + * ------------------------------------------------------------------------ + * + * References: + * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html + * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html + * + * Todo list: + * - Filter bogus Ctrl+ combinations. + * - Win32 support + * + * Bloat: + * - History search like Ctrl+r in readline? + * + * List of escape sequences used by this program, we do everything just + * with three sequences. In order to be so cheap we may have some + * flickering effect with some slow terminal, but the lesser sequences + * the more compatible. + * + * EL (Erase Line) + * Sequence: ESC [ n K + * Effect: if n is 0 or missing, clear from cursor to end of line + * Effect: if n is 1, clear from beginning of line to cursor + * Effect: if n is 2, clear entire line + * + * CUF (CUrsor Forward) + * Sequence: ESC [ n C + * Effect: moves cursor forward n chars + * + * CUB (CUrsor Backward) + * Sequence: ESC [ n D + * Effect: moves cursor backward n chars + * + * The following is used to get the terminal width if getting + * the width with the TIOCGWINSZ ioctl fails + * + * DSR (Device Status Report) + * Sequence: ESC [ 6 n + * Effect: reports the current cusor position as ESC [ n ; m R + * where n is the row and m is the column + * + * When multi line mode is enabled, we also use an additional escape + * sequence. However multi line editing is disabled by default. + * + * CUU (Cursor Up) + * Sequence: ESC [ n A + * Effect: moves cursor up of n chars. + * + * CUD (Cursor Down) + * Sequence: ESC [ n B + * Effect: moves cursor down of n chars. + * + * When linenoiseClearScreen() is called, two additional escape sequences + * are used in order to clear the screen and position the cursor at home + * position. + * + * CUP (Cursor position) + * Sequence: ESC [ H + * Effect: moves the cursor to upper left corner + * + * ED (Erase display) + * Sequence: ESC [ 2 J + * Effect: clear the whole screen + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "linenoise.h" + +#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100 +#define LINENOISE_MAX_LINE 4096 +static char *unsupported_term[] = {"dumb","cons25","emacs",NULL}; +static linenoiseCompletionCallback *completionCallback = NULL; +static linenoiseHintsCallback *hintsCallback = NULL; +static linenoiseFreeHintsCallback *freeHintsCallback = NULL; + +static struct termios orig_termios; /* In order to restore at exit.*/ +static int rawmode = 0; /* For atexit() function to check if restore is needed*/ +static int mlmode = 0; /* Multi line mode. Default is single line. */ +static int atexit_registered = 0; /* Register atexit just 1 time. */ +static int history_max_len = LINENOISE_DEFAULT_HISTORY_MAX_LEN; +static int history_len = 0; +static char **history = NULL; + +/* The linenoiseState structure represents the state during line editing. + * We pass this state to functions implementing specific editing + * functionalities. */ +struct linenoiseState { + int ifd; /* Terminal stdin file descriptor. */ + int ofd; /* Terminal stdout file descriptor. */ + char *buf; /* Edited line buffer. */ + size_t buflen; /* Edited line buffer size. */ + const char *prompt; /* Prompt to display. */ + size_t plen; /* Prompt length. */ + size_t pos; /* Current cursor position. */ + size_t oldpos; /* Previous refresh cursor position. */ + size_t len; /* Current edited line length. */ + size_t cols; /* Number of columns in terminal. */ + size_t maxrows; /* Maximum num of rows used so far (multiline mode) */ + int history_index; /* The history index we are currently editing. */ +}; + +enum KEY_ACTION{ + KEY_NULL = 0, /* NULL */ + CTRL_A = 1, /* Ctrl+a */ + CTRL_B = 2, /* Ctrl-b */ + CTRL_C = 3, /* Ctrl-c */ + CTRL_D = 4, /* Ctrl-d */ + CTRL_E = 5, /* Ctrl-e */ + CTRL_F = 6, /* Ctrl-f */ + CTRL_H = 8, /* Ctrl-h */ + TAB = 9, /* Tab */ + CTRL_K = 11, /* Ctrl+k */ + CTRL_L = 12, /* Ctrl+l */ + ENTER = 13, /* Enter */ + CTRL_N = 14, /* Ctrl-n */ + CTRL_P = 16, /* Ctrl-p */ + CTRL_T = 20, /* Ctrl-t */ + CTRL_U = 21, /* Ctrl+u */ + CTRL_W = 23, /* Ctrl+w */ + ESC = 27, /* Escape */ + BACKSPACE = 127 /* Backspace */ +}; + +static void linenoiseAtExit(void); +int linenoiseHistoryAdd(const char *line); +static void refreshLine(struct linenoiseState *l); + +/* Debugging macro. */ +#if 0 +FILE *lndebug_fp = NULL; +#define lndebug(...) \ + do { \ + if (lndebug_fp == NULL) { \ + lndebug_fp = fopen("/tmp/lndebug.txt","a"); \ + fprintf(lndebug_fp, \ + "[%d %d %d] p: %d, rows: %d, rpos: %d, max: %d, oldmax: %d\n", \ + (int)l->len,(int)l->pos,(int)l->oldpos,plen,rows,rpos, \ + (int)l->maxrows,old_rows); \ + } \ + fprintf(lndebug_fp, ", " __VA_ARGS__); \ + fflush(lndebug_fp); \ + } while (0) +#else +#define lndebug(fmt, ...) +#endif + +/* ======================= Low level terminal handling ====================== */ + +/* Set if to use or not the multi line mode. */ +void linenoiseSetMultiLine(int ml) { + mlmode = ml; +} + +/* Return true if the terminal name is in the list of terminals we know are + * not able to understand basic escape sequences. */ +static int isUnsupportedTerm(void) { + char *term = getenv("TERM"); + int j; + + if (term == NULL) return 0; + for (j = 0; unsupported_term[j]; j++) + if (!strcasecmp(term,unsupported_term[j])) return 1; + return 0; +} + +/* Raw mode: 1960 magic shit. */ +static int enableRawMode(int fd) { + struct termios raw; + + if (!isatty(STDIN_FILENO)) goto fatal; + if (!atexit_registered) { + atexit(linenoiseAtExit); + atexit_registered = 1; + } + if (tcgetattr(fd,&orig_termios) == -1) goto fatal; + + raw = orig_termios; /* modify the original mode */ + /* input modes: no break, no CR to NL, no parity check, no strip char, + * no start/stop output control. */ + raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON); + /* output modes - disable post processing */ + raw.c_oflag &= ~(OPOST); + /* control modes - set 8 bit chars */ + raw.c_cflag |= (CS8); + /* local modes - choing off, canonical off, no extended functions, + * no signal chars (^Z,^C) */ + raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG); + /* control chars - set return condition: min number of bytes and timer. + * We want read to return every single byte, without timeout. */ + raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; /* 1 byte, no timer */ + + /* put terminal in raw mode after flushing */ + if (tcsetattr(fd,TCSAFLUSH,&raw) < 0) goto fatal; + rawmode = 1; + return 0; + +fatal: + errno = ENOTTY; + return -1; +} + +static void disableRawMode(int fd) { + /* Don't even check the return value as it's too late. */ + if (rawmode && tcsetattr(fd,TCSAFLUSH,&orig_termios) != -1) + rawmode = 0; +} + +/* Use the ESC [6n escape sequence to query the horizontal cursor position + * and return it. On error -1 is returned, on success the position of the + * cursor. */ +static int getCursorPosition(int ifd, int ofd) { + char buf[32]; + int cols, rows; + unsigned int i = 0; + + /* Report cursor location */ + if (write(ofd, "\x1b[6n", 4) != 4) return -1; + + /* Read the response: ESC [ rows ; cols R */ + while (i < sizeof(buf)-1) { + if (read(ifd,buf+i,1) != 1) break; + if (buf[i] == 'R') break; + i++; + } + buf[i] = '\0'; + + /* Parse it. */ + if (buf[0] != ESC || buf[1] != '[') return -1; + if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1; + return cols; +} + +/* Try to get the number of columns in the current terminal, or assume 80 + * if it fails. */ +static int getColumns(int ifd, int ofd) { + struct winsize ws; + + if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) { + /* ioctl() failed. Try to query the terminal itself. */ + int start, cols; + + /* Get the initial position so we can restore it later. */ + start = getCursorPosition(ifd,ofd); + if (start == -1) goto failed; + + /* Go to right margin and get position. */ + if (write(ofd,"\x1b[999C",6) != 6) goto failed; + cols = getCursorPosition(ifd,ofd); + if (cols == -1) goto failed; + + /* Restore position. */ + if (cols > start) { + char seq[32]; + snprintf(seq,32,"\x1b[%dD",cols-start); + if (write(ofd,seq,strlen(seq)) == -1) { + /* Can't recover... */ + } + } + return cols; + } else { + return ws.ws_col; + } + +failed: + return 80; +} + +/* Clear the screen. Used to handle ctrl+l */ +void linenoiseClearScreen(void) { + if (write(STDOUT_FILENO,"\x1b[H\x1b[2J",7) <= 0) { + /* nothing to do, just to avoid warning. */ + } +} + +/* Beep, used for completion when there is nothing to complete or when all + * the choices were already shown. */ +static void linenoiseBeep(void) { + fprintf(stderr, "\x7"); + fflush(stderr); +} + +/* ============================== Completion ================================ */ + +/* Free a list of completion option populated by linenoiseAddCompletion(). */ +static void freeCompletions(linenoiseCompletions *lc) { + size_t i; + for (i = 0; i < lc->len; i++) + free(lc->cvec[i]); + if (lc->cvec != NULL) + free(lc->cvec); +} + +/* This is an helper function for linenoiseEdit() and is called when the + * user types the key in order to complete the string currently in the + * input. + * + * The state of the editing is encapsulated into the pointed linenoiseState + * structure as described in the structure definition. */ +static int completeLine(struct linenoiseState *ls) { + linenoiseCompletions lc = { 0, NULL }; + int nread, nwritten; + char c = 0; + + completionCallback(ls->buf,&lc); + if (lc.len == 0) { + linenoiseBeep(); + } else { + size_t stop = 0, i = 0; + + while(!stop) { + /* Show completion or original buffer */ + if (i < lc.len) { + struct linenoiseState saved = *ls; + + ls->len = ls->pos = strlen(lc.cvec[i]); + ls->buf = lc.cvec[i]; + refreshLine(ls); + ls->len = saved.len; + ls->pos = saved.pos; + ls->buf = saved.buf; + } else { + refreshLine(ls); + } + + nread = read(ls->ifd,&c,1); + if (nread <= 0) { + freeCompletions(&lc); + return -1; + } + + switch(c) { + case 9: /* tab */ + i = (i+1) % (lc.len+1); + if (i == lc.len) linenoiseBeep(); + break; + case 27: /* escape */ + /* Re-show original buffer */ + if (i < lc.len) refreshLine(ls); + stop = 1; + break; + default: + /* Update buffer and return */ + if (i < lc.len) { + nwritten = snprintf(ls->buf,ls->buflen,"%s",lc.cvec[i]); + ls->len = ls->pos = nwritten; + } + stop = 1; + break; + } + } + } + + freeCompletions(&lc); + return c; /* Return last read character */ +} + +/* Register a callback function to be called for tab-completion. */ +void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn) { + completionCallback = fn; +} + +/* Register a hits function to be called to show hits to the user at the + * right of the prompt. */ +void linenoiseSetHintsCallback(linenoiseHintsCallback *fn) { + hintsCallback = fn; +} + +/* Register a function to free the hints returned by the hints callback + * registered with linenoiseSetHintsCallback(). */ +void linenoiseSetFreeHintsCallback(linenoiseFreeHintsCallback *fn) { + freeHintsCallback = fn; +} + +/* This function is used by the callback function registered by the user + * in order to add completion options given the input string when the + * user typed . See the example.c source code for a very easy to + * understand example. */ +void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str) { + size_t len = strlen(str); + char *copy, **cvec; + + copy = malloc(len+1); + if (copy == NULL) return; + memcpy(copy,str,len+1); + cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1)); + if (cvec == NULL) { + free(copy); + return; + } + lc->cvec = cvec; + lc->cvec[lc->len++] = copy; +} + +/* =========================== Line editing ================================= */ + +/* We define a very simple "append buffer" structure, that is an heap + * allocated string where we can append to. This is useful in order to + * write all the escape sequences in a buffer and flush them to the standard + * output in a single call, to avoid flickering effects. */ +struct abuf { + char *b; + int len; +}; + +static void abInit(struct abuf *ab) { + ab->b = NULL; + ab->len = 0; +} + +static void abAppend(struct abuf *ab, const char *s, int len) { + char *new = realloc(ab->b,ab->len+len); + + if (new == NULL) return; + memcpy(new+ab->len,s,len); + ab->b = new; + ab->len += len; +} + +static void abFree(struct abuf *ab) { + free(ab->b); +} + +/* Helper of refreshSingleLine() and refreshMultiLine() to show hints + * to the right of the prompt. */ +void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) { + char seq[64]; + if (hintsCallback && plen+l->len < l->cols) { + int color = -1, bold = 0; + char *hint = hintsCallback(l->buf,&color,&bold); + if (hint) { + int hintlen = strlen(hint); + int hintmaxlen = l->cols-(plen+l->len); + if (hintlen > hintmaxlen) hintlen = hintmaxlen; + if (bold == 1 && color == -1) color = 37; + if (color != -1 || bold != 0) + snprintf(seq,64,"\033[%d;%d;49m",bold,color); + abAppend(ab,seq,strlen(seq)); + abAppend(ab,hint,hintlen); + if (color != -1 || bold != 0) + abAppend(ab,"\033[0m",4); + /* Call the function to free the hint returned. */ + if (freeHintsCallback) freeHintsCallback(hint); + } + } +} + +/* Single line low level line refresh. + * + * Rewrite the currently edited line accordingly to the buffer content, + * cursor position, and number of columns of the terminal. */ +static void refreshSingleLine(struct linenoiseState *l) { + char seq[64]; + size_t plen = strlen(l->prompt); + int fd = l->ofd; + char *buf = l->buf; + size_t len = l->len; + size_t pos = l->pos; + struct abuf ab; + + while((plen+pos) >= l->cols) { + buf++; + len--; + pos--; + } + while (plen+len > l->cols) { + len--; + } + + abInit(&ab); + /* Cursor to left edge */ + snprintf(seq,64,"\r"); + abAppend(&ab,seq,strlen(seq)); + /* Write the prompt and the current buffer content */ + abAppend(&ab,l->prompt,strlen(l->prompt)); + abAppend(&ab,buf,len); + /* Show hits if any. */ + refreshShowHints(&ab,l,plen); + /* Erase to right */ + snprintf(seq,64,"\x1b[0K"); + abAppend(&ab,seq,strlen(seq)); + /* Move cursor to original position. */ + snprintf(seq,64,"\r\x1b[%dC", (int)(pos+plen)); + abAppend(&ab,seq,strlen(seq)); + if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */ + abFree(&ab); +} + +/* Multi line low level line refresh. + * + * Rewrite the currently edited line accordingly to the buffer content, + * cursor position, and number of columns of the terminal. */ +static void refreshMultiLine(struct linenoiseState *l) { + char seq[64]; + int plen = strlen(l->prompt); + int rows = (plen+l->len+l->cols-1)/l->cols; /* rows used by current buf. */ + int rpos = (plen+l->oldpos+l->cols)/l->cols; /* cursor relative row. */ + int rpos2; /* rpos after refresh. */ + int col; /* colum position, zero-based. */ + int old_rows = l->maxrows; + int fd = l->ofd, j; + struct abuf ab; + + /* Update maxrows if needed. */ + if (rows > (int)l->maxrows) l->maxrows = rows; + + /* First step: clear all the lines used before. To do so start by + * going to the last row. */ + abInit(&ab); + if (old_rows-rpos > 0) { + lndebug("go down %d", old_rows-rpos); + snprintf(seq,64,"\x1b[%dB", old_rows-rpos); + abAppend(&ab,seq,strlen(seq)); + } + + /* Now for every row clear it, go up. */ + for (j = 0; j < old_rows-1; j++) { + lndebug("clear+up"); + snprintf(seq,64,"\r\x1b[0K\x1b[1A"); + abAppend(&ab,seq,strlen(seq)); + } + + /* Clean the top line. */ + lndebug("clear"); + snprintf(seq,64,"\r\x1b[0K"); + abAppend(&ab,seq,strlen(seq)); + + /* Write the prompt and the current buffer content */ + abAppend(&ab,l->prompt,strlen(l->prompt)); + abAppend(&ab,l->buf,l->len); + + /* Show hits if any. */ + refreshShowHints(&ab,l,plen); + + /* If we are at the very end of the screen with our prompt, we need to + * emit a newline and move the prompt to the first column. */ + if (l->pos && + l->pos == l->len && + (l->pos+plen) % l->cols == 0) + { + lndebug(""); + abAppend(&ab,"\n",1); + snprintf(seq,64,"\r"); + abAppend(&ab,seq,strlen(seq)); + rows++; + if (rows > (int)l->maxrows) l->maxrows = rows; + } + + /* Move cursor to right position. */ + rpos2 = (plen+l->pos+l->cols)/l->cols; /* current cursor relative row. */ + lndebug("rpos2 %d", rpos2); + + /* Go up till we reach the expected positon. */ + if (rows-rpos2 > 0) { + lndebug("go-up %d", rows-rpos2); + snprintf(seq,64,"\x1b[%dA", rows-rpos2); + abAppend(&ab,seq,strlen(seq)); + } + + /* Set column. */ + col = (plen+(int)l->pos) % (int)l->cols; + lndebug("set col %d", 1+col); + if (col) + snprintf(seq,64,"\r\x1b[%dC", col); + else + snprintf(seq,64,"\r"); + abAppend(&ab,seq,strlen(seq)); + + lndebug("\n"); + l->oldpos = l->pos; + + if (write(fd,ab.b,ab.len) == -1) {} /* Can't recover from write error. */ + abFree(&ab); +} + +/* Calls the two low level functions refreshSingleLine() or + * refreshMultiLine() according to the selected mode. */ +static void refreshLine(struct linenoiseState *l) { + if (mlmode) + refreshMultiLine(l); + else + refreshSingleLine(l); +} + +/* Insert the character 'c' at cursor current position. + * + * On error writing to the terminal -1 is returned, otherwise 0. */ +int linenoiseEditInsert(struct linenoiseState *l, char c) { + if (l->len < l->buflen) { + if (l->len == l->pos) { + l->buf[l->pos] = c; + l->pos++; + l->len++; + l->buf[l->len] = '\0'; + if ((!mlmode && l->plen+l->len < l->cols && !hintsCallback)) { + /* Avoid a full update of the line in the + * trivial case. */ + if (write(l->ofd,&c,1) == -1) return -1; + } else { + refreshLine(l); + } + } else { + memmove(l->buf+l->pos+1,l->buf+l->pos,l->len-l->pos); + l->buf[l->pos] = c; + l->len++; + l->pos++; + l->buf[l->len] = '\0'; + refreshLine(l); + } + } + return 0; +} + +/* Move cursor on the left. */ +void linenoiseEditMoveLeft(struct linenoiseState *l) { + if (l->pos > 0) { + l->pos--; + refreshLine(l); + } +} + +/* Move cursor on the right. */ +void linenoiseEditMoveRight(struct linenoiseState *l) { + if (l->pos != l->len) { + l->pos++; + refreshLine(l); + } +} + +/* Move cursor to the start of the line. */ +void linenoiseEditMoveHome(struct linenoiseState *l) { + if (l->pos != 0) { + l->pos = 0; + refreshLine(l); + } +} + +/* Move cursor to the end of the line. */ +void linenoiseEditMoveEnd(struct linenoiseState *l) { + if (l->pos != l->len) { + l->pos = l->len; + refreshLine(l); + } +} + +/* Substitute the currently edited line with the next or previous history + * entry as specified by 'dir'. */ +#define LINENOISE_HISTORY_NEXT 0 +#define LINENOISE_HISTORY_PREV 1 +void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) { + if (history_len > 1) { + /* Update the current history entry before to + * overwrite it with the next one. */ + free(history[history_len - 1 - l->history_index]); + history[history_len - 1 - l->history_index] = strdup(l->buf); + /* Show the new entry */ + l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1; + if (l->history_index < 0) { + l->history_index = 0; + return; + } else if (l->history_index >= history_len) { + l->history_index = history_len-1; + return; + } + strncpy(l->buf,history[history_len - 1 - l->history_index],l->buflen); + l->buf[l->buflen-1] = '\0'; + l->len = l->pos = strlen(l->buf); + refreshLine(l); + } +} + +/* Delete the character at the right of the cursor without altering the cursor + * position. Basically this is what happens with the "Delete" keyboard key. */ +void linenoiseEditDelete(struct linenoiseState *l) { + if (l->len > 0 && l->pos < l->len) { + memmove(l->buf+l->pos,l->buf+l->pos+1,l->len-l->pos-1); + l->len--; + l->buf[l->len] = '\0'; + refreshLine(l); + } +} + +/* Backspace implementation. */ +void linenoiseEditBackspace(struct linenoiseState *l) { + if (l->pos > 0 && l->len > 0) { + memmove(l->buf+l->pos-1,l->buf+l->pos,l->len-l->pos); + l->pos--; + l->len--; + l->buf[l->len] = '\0'; + refreshLine(l); + } +} + +/* Delete the previosu word, maintaining the cursor at the start of the + * current word. */ +void linenoiseEditDeletePrevWord(struct linenoiseState *l) { + size_t old_pos = l->pos; + size_t diff; + + while (l->pos > 0 && l->buf[l->pos-1] == ' ') + l->pos--; + while (l->pos > 0 && l->buf[l->pos-1] != ' ') + l->pos--; + diff = old_pos - l->pos; + memmove(l->buf+l->pos,l->buf+old_pos,l->len-old_pos+1); + l->len -= diff; + refreshLine(l); +} + +/* This function is the core of the line editing capability of linenoise. + * It expects 'fd' to be already in "raw mode" so that every key pressed + * will be returned ASAP to read(). + * + * The resulting string is put into 'buf' when the user type enter, or + * when ctrl+d is typed. + * + * The function returns the length of the current buffer. */ +static int linenoiseEdit(int stdin_fd, int stdout_fd, char *buf, size_t buflen, const char *prompt) +{ + struct linenoiseState l; + + /* Populate the linenoise state that we pass to functions implementing + * specific editing functionalities. */ + l.ifd = stdin_fd; + l.ofd = stdout_fd; + l.buf = buf; + l.buflen = buflen; + l.prompt = prompt; + l.plen = strlen(prompt); + l.oldpos = l.pos = 0; + l.len = 0; + l.cols = getColumns(stdin_fd, stdout_fd); + l.maxrows = 0; + l.history_index = 0; + + /* Buffer starts empty. */ + l.buf[0] = '\0'; + l.buflen--; /* Make sure there is always space for the nulterm */ + + /* The latest history entry is always our current buffer, that + * initially is just an empty string. */ + linenoiseHistoryAdd(""); + + if (write(l.ofd,prompt,l.plen) == -1) return -1; + while(1) { + char c; + int nread; + char seq[3]; + + nread = read(l.ifd,&c,1); + if (nread <= 0) return l.len; + + /* Only autocomplete when the callback is set. It returns < 0 when + * there was an error reading from fd. Otherwise it will return the + * character that should be handled next. */ + if (c == 9 && completionCallback != NULL) { + c = completeLine(&l); + /* Return on errors */ + if (c < 0) return l.len; + /* Read next character when 0 */ + if (c == 0) continue; + } + + switch(c) { + case ENTER: /* enter */ + history_len--; + free(history[history_len]); + if (mlmode) linenoiseEditMoveEnd(&l); + if (hintsCallback) { + /* Force a refresh without hints to leave the previous + * line as the user typed it after a newline. */ + linenoiseHintsCallback *hc = hintsCallback; + hintsCallback = NULL; + refreshLine(&l); + hintsCallback = hc; + } + return (int)l.len; + case CTRL_C: /* ctrl-c */ + errno = EAGAIN; + return -1; + case BACKSPACE: /* backspace */ + case 8: /* ctrl-h */ + linenoiseEditBackspace(&l); + break; + case CTRL_D: /* ctrl-d, remove char at right of cursor, or if the + line is empty, act as end-of-file. */ + if (l.len > 0) { + linenoiseEditDelete(&l); + } else { + history_len--; + free(history[history_len]); + return -1; + } + break; + case CTRL_T: /* ctrl-t, swaps current character with previous. */ + if (l.pos > 0 && l.pos < l.len) { + int aux = buf[l.pos-1]; + buf[l.pos-1] = buf[l.pos]; + buf[l.pos] = aux; + if (l.pos != l.len-1) l.pos++; + refreshLine(&l); + } + break; + case CTRL_B: /* ctrl-b */ + linenoiseEditMoveLeft(&l); + break; + case CTRL_F: /* ctrl-f */ + linenoiseEditMoveRight(&l); + break; + case CTRL_P: /* ctrl-p */ + linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV); + break; + case CTRL_N: /* ctrl-n */ + linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT); + break; + case ESC: /* escape sequence */ + /* Read the next two bytes representing the escape sequence. + * Use two calls to handle slow terminals returning the two + * chars at different times. */ + if (read(l.ifd,seq,1) == -1) break; + if (read(l.ifd,seq+1,1) == -1) break; + + /* ESC [ sequences. */ + if (seq[0] == '[') { + if (seq[1] >= '0' && seq[1] <= '9') { + /* Extended escape, read additional byte. */ + if (read(l.ifd,seq+2,1) == -1) break; + if (seq[2] == '~') { + switch(seq[1]) { + case '3': /* Delete key. */ + linenoiseEditDelete(&l); + break; + } + } + } else { + switch(seq[1]) { + case 'A': /* Up */ + linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_PREV); + break; + case 'B': /* Down */ + linenoiseEditHistoryNext(&l, LINENOISE_HISTORY_NEXT); + break; + case 'C': /* Right */ + linenoiseEditMoveRight(&l); + break; + case 'D': /* Left */ + linenoiseEditMoveLeft(&l); + break; + case 'H': /* Home */ + linenoiseEditMoveHome(&l); + break; + case 'F': /* End*/ + linenoiseEditMoveEnd(&l); + break; + } + } + } + + /* ESC O sequences. */ + else if (seq[0] == 'O') { + switch(seq[1]) { + case 'H': /* Home */ + linenoiseEditMoveHome(&l); + break; + case 'F': /* End*/ + linenoiseEditMoveEnd(&l); + break; + } + } + break; + default: + if (linenoiseEditInsert(&l,c)) return -1; + break; + case CTRL_U: /* Ctrl+u, delete the whole line. */ + buf[0] = '\0'; + l.pos = l.len = 0; + refreshLine(&l); + break; + case CTRL_K: /* Ctrl+k, delete from current to end of line. */ + buf[l.pos] = '\0'; + l.len = l.pos; + refreshLine(&l); + break; + case CTRL_A: /* Ctrl+a, go to the start of the line */ + linenoiseEditMoveHome(&l); + break; + case CTRL_E: /* ctrl+e, go to the end of the line */ + linenoiseEditMoveEnd(&l); + break; + case CTRL_L: /* ctrl+l, clear screen */ + linenoiseClearScreen(); + refreshLine(&l); + break; + case CTRL_W: /* ctrl+w, delete previous word */ + linenoiseEditDeletePrevWord(&l); + break; + } + } + return l.len; +} + +/* This special mode is used by linenoise in order to print scan codes + * on screen for debugging / development purposes. It is implemented + * by the linenoise_example program using the --keycodes option. */ +void linenoisePrintKeyCodes(void) { + char quit[4]; + + printf("Linenoise key codes debugging mode.\n" + "Press keys to see scan codes. Type 'quit' at any time to exit.\n"); + if (enableRawMode(STDIN_FILENO) == -1) return; + memset(quit,' ',4); + while(1) { + char c; + int nread; + + nread = read(STDIN_FILENO,&c,1); + if (nread <= 0) continue; + memmove(quit,quit+1,sizeof(quit)-1); /* shift string to left. */ + quit[sizeof(quit)-1] = c; /* Insert current char on the right. */ + if (memcmp(quit,"quit",sizeof(quit)) == 0) break; + + printf("'%c' %02x (%d) (type quit to exit)\n", + isprint(c) ? c : '?', (int)c, (int)c); + printf("\r"); /* Go left edge manually, we are in raw mode. */ + fflush(stdout); + } + disableRawMode(STDIN_FILENO); +} + +/* This function calls the line editing function linenoiseEdit() using + * the STDIN file descriptor set in raw mode. */ +static int linenoiseRaw(char *buf, size_t buflen, const char *prompt) { + int count; + + if (buflen == 0) { + errno = EINVAL; + return -1; + } + + if (enableRawMode(STDIN_FILENO) == -1) return -1; + count = linenoiseEdit(STDIN_FILENO, STDOUT_FILENO, buf, buflen, prompt); + disableRawMode(STDIN_FILENO); + printf("\n"); + return count; +} + +/* This function is called when linenoise() is called with the standard + * input file descriptor not attached to a TTY. So for example when the + * program using linenoise is called in pipe or with a file redirected + * to its standard input. In this case, we want to be able to return the + * line regardless of its length (by default we are limited to 4k). */ +static char *linenoiseNoTTY(void) { + char *line = NULL; + size_t len = 0, maxlen = 0; + + while(1) { + if (len == maxlen) { + if (maxlen == 0) maxlen = 16; + maxlen *= 2; + char *oldval = line; + line = realloc(line,maxlen); + if (line == NULL) { + if (oldval) free(oldval); + return NULL; + } + } + int c = fgetc(stdin); + if (c == EOF || c == '\n') { + if (c == EOF && len == 0) { + free(line); + return NULL; + } else { + line[len] = '\0'; + return line; + } + } else { + line[len] = c; + len++; + } + } +} + +/* The high level function that is the main API of the linenoise library. + * This function checks if the terminal has basic capabilities, just checking + * for a blacklist of stupid terminals, and later either calls the line + * editing function or uses dummy fgets() so that you will be able to type + * something even in the most desperate of the conditions. */ +char *linenoise(const char *prompt) { + char buf[LINENOISE_MAX_LINE]; + int count; + + if (!isatty(STDIN_FILENO)) { + /* Not a tty: read from file / pipe. In this mode we don't want any + * limit to the line size, so we call a function to handle that. */ + return linenoiseNoTTY(); + } else if (isUnsupportedTerm()) { + size_t len; + + printf("%s",prompt); + fflush(stdout); + if (fgets(buf,LINENOISE_MAX_LINE,stdin) == NULL) return NULL; + len = strlen(buf); + while(len && (buf[len-1] == '\n' || buf[len-1] == '\r')) { + len--; + buf[len] = '\0'; + } + return strdup(buf); + } else { + count = linenoiseRaw(buf,LINENOISE_MAX_LINE,prompt); + if (count == -1) return NULL; + return strdup(buf); + } +} + +/* This is just a wrapper the user may want to call in order to make sure + * the linenoise returned buffer is freed with the same allocator it was + * created with. Useful when the main program is using an alternative + * allocator. */ +void linenoiseFree(void *ptr) { + free(ptr); +} + +/* ================================ History ================================= */ + +/* Free the history, but does not reset it. Only used when we have to + * exit() to avoid memory leaks are reported by valgrind & co. */ +static void freeHistory(void) { + if (history) { + int j; + + for (j = 0; j < history_len; j++) + free(history[j]); + free(history); + } +} + +/* At exit we'll try to fix the terminal to the initial conditions. */ +static void linenoiseAtExit(void) { + disableRawMode(STDIN_FILENO); + freeHistory(); +} + +/* This is the API call to add a new entry in the linenoise history. + * It uses a fixed array of char pointers that are shifted (memmoved) + * when the history max length is reached in order to remove the older + * entry and make room for the new one, so it is not exactly suitable for huge + * histories, but will work well for a few hundred of entries. + * + * Using a circular buffer is smarter, but a bit more complex to handle. */ +int linenoiseHistoryAdd(const char *line) { + char *linecopy; + + if (history_max_len == 0) return 0; + + /* Initialization on first call. */ + if (history == NULL) { + history = malloc(sizeof(char*)*history_max_len); + if (history == NULL) return 0; + memset(history,0,(sizeof(char*)*history_max_len)); + } + + /* Don't add duplicated lines. */ + if (history_len && !strcmp(history[history_len-1], line)) return 0; + + /* Add an heap allocated copy of the line in the history. + * If we reached the max length, remove the older line. */ + linecopy = strdup(line); + if (!linecopy) return 0; + if (history_len == history_max_len) { + free(history[0]); + memmove(history,history+1,sizeof(char*)*(history_max_len-1)); + history_len--; + } + history[history_len] = linecopy; + history_len++; + return 1; +} + +/* Set the maximum length for the history. This function can be called even + * if there is already some history, the function will make sure to retain + * just the latest 'len' elements if the new history length value is smaller + * than the amount of items already inside the history. */ +int linenoiseHistorySetMaxLen(int len) { + char **new; + + if (len < 1) return 0; + if (history) { + int tocopy = history_len; + + new = malloc(sizeof(char*)*len); + if (new == NULL) return 0; + + /* If we can't copy everything, free the elements we'll not use. */ + if (len < tocopy) { + int j; + + for (j = 0; j < tocopy-len; j++) free(history[j]); + tocopy = len; + } + memset(new,0,sizeof(char*)*len); + memcpy(new,history+(history_len-tocopy), sizeof(char*)*tocopy); + free(history); + history = new; + } + history_max_len = len; + if (history_len > history_max_len) + history_len = history_max_len; + return 1; +} + +/* Save the history in the specified file. On success 0 is returned + * otherwise -1 is returned. */ +int linenoiseHistorySave(const char *filename) { + mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO); + FILE *fp; + int j; + + fp = fopen(filename,"w"); + umask(old_umask); + if (fp == NULL) return -1; + chmod(filename,S_IRUSR|S_IWUSR); + for (j = 0; j < history_len; j++) + fprintf(fp,"%s\n",history[j]); + fclose(fp); + return 0; +} + +/* Load the history from the specified file. If the file does not exist + * zero is returned and no operation is performed. + * + * If the file exists and the operation succeeded 0 is returned, otherwise + * on error -1 is returned. */ +int linenoiseHistoryLoad(const char *filename) { + FILE *fp = fopen(filename,"r"); + char buf[LINENOISE_MAX_LINE]; + + if (fp == NULL) return -1; + + while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) { + char *p; + + p = strchr(buf,'\r'); + if (!p) p = strchr(buf,'\n'); + if (p) *p = '\0'; + linenoiseHistoryAdd(buf); + } + fclose(fp); + return 0; +} diff --git a/src/mainclient/linenoise.h b/src/mainclient/linenoise.h new file mode 100644 index 00000000..ed20232c --- /dev/null +++ b/src/mainclient/linenoise.h @@ -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 + * Copyright (c) 2010-2013, Pieter Noordhuis + * + * 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 */ diff --git a/src/mainclient/main.c b/src/mainclient/main.c index d6cc6922..9bd28a6a 100644 --- a/src/mainclient/main.c +++ b/src/mainclient/main.c @@ -25,6 +25,9 @@ #include #include +#include "linenoise.h" +#include + #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); } diff --git a/src/parser/parse.c b/src/parser/parse.c index 8c2f8810..f63b3288 100644 --- a/src/parser/parse.c +++ b/src/parser/parse.c @@ -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; diff --git a/src/testlib/testlib.c b/src/testlib/testlib.c deleted file mode 100644 index 6d408501..00000000 --- a/src/testlib/testlib.c +++ /dev/null @@ -1,7 +0,0 @@ -#include - -int dst_init_(DstArgs args) { - DstTable *env = dst_env_arg(args); - dst_env_def(env, "pi", dst_wrap_real(M_PI)); - return 0; -}