✨ split io lib

CMakeLists.txt

@@ -23,6 +23,7 @@ set(NASAL_OBJECT_SOURCE_FILE
     ${CMAKE_SOURCE_DIR}/src/coroutine.cpp
     ${CMAKE_SOURCE_DIR}/src/fg_props.cpp
     ${CMAKE_SOURCE_DIR}/src/bits_lib.cpp
+    ${CMAKE_SOURCE_DIR}/src/io_lib.cpp
     ${CMAKE_SOURCE_DIR}/src/math_lib.cpp
     ${CMAKE_SOURCE_DIR}/src/nasal_codegen.cpp
     ${CMAKE_SOURCE_DIR}/src/nasal_dbg.cpp

makefile

@@ -19,6 +19,7 @@ NASAL_HEADER=\
 	src/symbol_finder.h\
 	src/fg_props.h\
 	src/bits_lib.h\
+	src/io_lib.h\
 	src/math_lib.h\
 	src/coroutine.h
 
@@ -39,6 +40,7 @@ NASAL_OBJECT=\
 	build/nasal_gc.o\
 	build/nasal_builtin.o\
 	build/fg_props.o\
+	build/io_lib.o\
 	build/math_lib.o\
 	build/coroutine.o\
 	build/nasal_vm.o\
@@ -111,6 +113,12 @@ build/math_lib.o: \
 	src/math_lib.h src/math_lib.cpp | build
 	$(CXX) -std=$(STD) -c -O3 src/math_lib.cpp -fno-exceptions -fPIC -o build/math_lib.o -I .
 
+build/io_lib.o: \
+	src/nasal.h\
+	src/nasal_gc.h\
+	src/io_lib.h src/io_lib.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/io_lib.cpp -fno-exceptions -fPIC -o build/io_lib.o -I .
+
 build/fg_props.o: \
 	src/nasal.h\
 	src/nasal_gc.h\

module/libfib.nas

@@ -1,31 +1,54 @@
 import.std.dylib;
 
-var libfib=func(){
-    var dl=dylib.dlopen("libfib."~(os.platform()=="windows"?"dll":"so"));
-    var fib=dl.fib;
-    var qfib=dl.quick_fib;
-    var create_ghost=dl.create_ghost;
-    var set_ghost=dl.set_ghost;
-    var print_ghost=dl.print_ghost;
-    var zero_call=dylib.limitcall(0);
-    var call=dylib.limitcall(1);
-    var test_call=dylib.limitcall(2);
-    var res={
-        fib: func(x) {return call(fib,x)},
-        qfib: func(x) {return call(qfib,x)},
-        create_ghost: func() {return zero_call(create_ghost)},
-        set_ghost: func(object, x) {return test_call(set_ghost, object, x)},
-        print_ghost: func(object) {return call(print_ghost, object)}
-    };
+var _dl = dylib.dlopen("libfib."~(os.platform()=="windows"?"dll":"so"));
 
-    res.test_ghost=func() {
-        var ghost=res.create_ghost();
-        res.print_ghost(nil); # err
-        res.print_ghost(ghost); # random
-        res.set_ghost(nil, 114); # err
-        res.set_ghost(ghost, 114); # success
-        res.print_ghost(ghost); # 114
+var _fib = _dl.fib;
+
+var _qfib = _dl.quick_fib;
+
+var _create_ghost = _dl.create_ghost;
+
+var _set_ghost = _dl.set_ghost;
+
+var _print_ghost = _dl.print_ghost;
+
+var _zero_call = dylib.limitcall(0);
+
+var _call = dylib.limitcall(1);
+
+var _test_call = dylib.limitcall(2);
+
+
+var fib = func(x) {
+    return _call(_fib, x)
 }
 
-    return res;
-}();
+
+var qfib = func(x) {
+    return _call(_qfib, x)
+}
+
+
+var create_ghost = func() {
+    return _zero_call(_create_ghost)
+}
+
+
+var set_ghost = func(object, x) {
+    return _test_call(_set_ghost, object, x)
+}
+
+
+var print_ghost = func(object) {
+    return _call(_print_ghost, object)
+}
+
+
+var test_ghost=func() {
+    var ghost = create_ghost();
+    print_ghost(nil); # err
+    print_ghost(ghost); # random
+    set_ghost(nil, 114); # err
+    set_ghost(ghost, 114); # success
+    print_ghost(ghost); # 114
+}

module/libmat.nas

@@ -1,62 +1,66 @@
 import.std.dylib;
 
-var dl=dylib.dlopen("libmat."~(os.platform()=="windows"?"dll":"so"));
-var vec2=dl.nas_vec2;
-var vec3=dl.nas_vec3;
-var (vec2add,vec2sub,vec2mul,vec2div,vec2neg,vec2norm,vec2len,vec2dot)=(
-    dl.nas_vec2_add,
-    dl.nas_vec2_sub,
-    dl.nas_vec2_mult,
-    dl.nas_vec2_div,
-    dl.nas_vec2_neg,
-    dl.nas_vec2_norm,
-    dl.nas_vec2_len,
-    dl.nas_vec2_dot
+var _dl = dylib.dlopen("libmat."~(os.platform()=="windows"?"dll":"so"));
+
+var _vec2 = _dl.nas_vec2;
+
+var _vec3 = _dl.nas_vec3;
+
+var (_vec2add, _vec2sub, _vec2mul, _vec2div, _vec2neg, _vec2norm, _vec2len, _vec2dot)=(
+    _dl.nas_vec2_add,
+    _dl.nas_vec2_sub,
+    _dl.nas_vec2_mult,
+    _dl.nas_vec2_div,
+    _dl.nas_vec2_neg,
+    _dl.nas_vec2_norm,
+    _dl.nas_vec2_len,
+    _dl.nas_vec2_dot
 );
-var (vec3add,vec3sub,vec3mul,vec3div,vec3neg,vec3norm,vec3len,vec3dot)=(
-    dl.nas_vec3_add,
-    dl.nas_vec3_sub,
-    dl.nas_vec3_mult,
-    dl.nas_vec3_div,
-    dl.nas_vec3_neg,
-    dl.nas_vec3_norm,
-    dl.nas_vec3_len,
-    dl.nas_vec3_dot
+var (_vec3add, _vec3sub, _vec3mul, _vec3div, _vec3neg, _vec3norm, _vec3len, _vec3dot)=(
+    _dl.nas_vec3_add,
+    _dl.nas_vec3_sub,
+    _dl.nas_vec3_mult,
+    _dl.nas_vec3_div,
+    _dl.nas_vec3_neg,
+    _dl.nas_vec3_norm,
+    _dl.nas_vec3_len,
+    _dl.nas_vec3_dot
 );
-var (rotate_x,rotate_y,rotate_z)=(
-    dl.nas_rotate_x,
-    dl.nas_rotate_y,
-    dl.nas_rotate_z
+var (_rotate_x, _rotate_y, _rotate_z)=(
+    _dl.nas_rotate_x,
+    _dl.nas_rotate_y,
+    _dl.nas_rotate_z
 );
-var (invoke_i,invoke_ii,invoke_iii)=(
+var (_invoke_i, _invoke_ii, _invoke_iii)=(
     dylib.limitcall(1),
     dylib.limitcall(2),
     dylib.limitcall(3)
 );
 
 var vec2 = {
-    new:  func(x,y){return invoke_ii(vec2,x,y);},
-    add:  func(v0,v1){return invoke_ii(vec2add,v0,v1);},
-    sub:  func(v0,v1){return invoke_ii(vec2sub,v0,v1);},
-    mul:  func(v0,v1){return invoke_ii(vec2mul,v0,v1);},
-    div:  func(v0,v1){return invoke_ii(vec2div,v0,v1);},
-    neg:  func(v0){return invoke_i(vec2neg,v0);},
-    norm: func(v0){return invoke_i(vec2norm,v0);},
-    len:  func(v0){return invoke_i(vec2len,v0);},
-    dot:  func(v0,v1){return invoke_ii(vec2dot,v0,v1);}
-};
-var vec3={
-    new:  func(x,y,z){return invoke_iii(vec3,x,y,z);},
-    add:  func(v0,v1){return invoke_ii(vec3add,v0,v1);},
-    sub:  func(v0,v1){return invoke_ii(vec3sub,v0,v1);},
-    mul:  func(v0,v1){return invoke_ii(vec3mul,v0,v1);},
-    div:  func(v0,v1){return invoke_ii(vec3div,v0,v1);},
-    neg:  func(v0){return invoke_i(vec3neg,v0);},
-    norm: func(v0){return invoke_i(vec3norm,v0);},
-    len:  func(v0){return invoke_i(vec3len,v0);},
-    rx:   func(v0,angle){return invoke_ii(rotate_x,v0,angle);},
-    ry:   func(v0,angle){return invoke_ii(rotate_y,v0,angle);},
-    rz:   func(v0,angle){return invoke_ii(rotate_z,v0,angle);},
-    dot:  func(v0,v1){return invoke_ii(vec3dot,v0,v1);}
+    new:  func(x, y) {return _invoke_ii(_vec2, x, y);},
+    add:  func(v0, v1) {return _invoke_ii(_vec2add, v0, v1);},
+    sub:  func(v0, v1) {return _invoke_ii(_vec2sub, v0, v1);},
+    mul:  func(v0, v1) {return _invoke_ii(_vec2mul, v0, v1);},
+    div:  func(v0, v1) {return _invoke_ii(_vec2div, v0, v1);},
+    neg:  func(v0) {return _invoke_i(_vec2neg, v0);},
+    norm: func(v0) {return _invoke_i(_vec2norm, v0);},
+    len:  func(v0) {return _invoke_i(_vec2len, v0);},
+    dot:  func(v0, v1) {return _invoke_ii(_vec2dot, v0, v1);}
+};
+
+var vec3 = {
+    new:  func(x, y, z) {return _invoke_iii(_vec3, x, y, z);},
+    add:  func(v0, v1) {return _invoke_ii(_vec3add, v0, v1);},
+    sub:  func(v0, v1) {return _invoke_ii(_vec3sub, v0, v1);},
+    mul:  func(v0, v1) {return _invoke_ii(_vec3mul, v0, v1);},
+    div:  func(v0, v1) {return _invoke_ii(_vec3div, v0, v1);},
+    neg:  func(v0) {return _invoke_i(_vec3neg, v0);},
+    norm: func(v0) {return _invoke_i(_vec3norm, v0);},
+    len:  func(v0) {return _invoke_i(_vec3len, v0);},
+    rx:   func(v0, angle) {return _invoke_ii(_rotate_x, v0, angle);},
+    ry:   func(v0, angle) {return _invoke_ii(_rotate_y, v0, angle);},
+    rz:   func(v0, angle) {return _invoke_ii(_rotate_z, v0, angle);},
+    dot:  func(v0, v1) {return _invoke_ii(_vec3dot, v0, v1);}
 };
 

src/io_lib.cpp

@@ -0,0 +1,191 @@
+#include "io_lib.h"
+
+var builtin_readfile(var* local, gc& ngc) {
+    var val = local[1];
+    if (val.type!=vm_str) {
+        return nas_err("io::readfile", "\"filename\" must be string");
+    }
+    std::ifstream in(val.str(), std::ios::binary);
+    std::stringstream rd;
+    if (!in.fail()) {
+        rd << in.rdbuf();
+    }
+    return ngc.newstr(rd.str());
+}
+
+var builtin_fout(var* local, gc& ngc) {
+    var val = local[1];
+    var str = local[2];
+    if (val.type!=vm_str) {
+        return nas_err("io::fout", "\"filename\" must be string");
+    }
+    std::ofstream out(val.str());
+    if (out.fail()) {
+        return nas_err("io::fout", "cannot open <"+val.str()+">");
+    }
+    out << str;
+    return nil;
+}
+
+var builtin_exists(var* local, gc& ngc) {
+    if (local[1].type!=vm_str) {
+        return zero;
+    }
+    return access(local[1].str().c_str(), F_OK)!=-1?one:zero;
+}
+
+var builtin_open(var* local, gc& ngc) {
+    var name = local[1];
+    var mode = local[2];
+    if (name.type!=vm_str) {
+        return nas_err("open", "\"filename\" must be string");
+    }
+    if (mode.type!=vm_str) {
+        return nas_err("open", "\"mode\" must be string");
+    }
+    FILE* res = fopen(name.str().c_str(), mode.str().c_str());
+    if (!res) {
+        return nas_err("open", "failed to open file <"+name.str()+">");
+    }
+    var ret = ngc.alloc(vm_obj);
+    ret.obj().set("file", filehandle_destructor, res);
+    return ret;
+}
+
+var builtin_close(var* local, gc& ngc) {
+    var fd = local[1];
+    if (!fd.objchk("file")) {
+        return nas_err("close", "not a valid filehandle");
+    }
+    fd.obj().clear();
+    return nil;
+}
+
+var builtin_read(var* local, gc& ngc) {
+    var fd = local[1];
+    var buf = local[2];
+    var len = local[3];
+    if (!fd.objchk("file")) {
+        return nas_err("read", "not a valid filehandle");
+    }
+    if (buf.type!=vm_str || buf.val.gcobj->unmut) {
+        return nas_err("read", "\"buf\" must be mutable string");
+    }
+    if (len.type!=vm_num) {
+        return nas_err("read", "\"len\" must be number");
+    }
+    if (len.num()<=0 || len.num()>=(1<<30)) {
+        return nas_err("read", "\"len\" less than 1 or too large");
+    }
+    char* buff = new char[(usize)len.num()+1];
+    if (!buff) {
+        return nas_err("read", "malloc failed");
+    }
+    f64 res = fread(buff,1,len.num(), (FILE*)fd.obj().ptr);
+    buf.str() = buff;
+    buf.val.gcobj->unmut = true;
+    delete []buff;
+    return var::num(res);
+}
+
+var builtin_write(var* local, gc& ngc) {
+    var fd = local[1];
+    var str = local[2];
+    if (!fd.objchk("file")) {
+        return nas_err("write", "not a valid filehandle");
+    }
+    if (str.type!=vm_str) {
+        return nas_err("write", "\"str\" must be string");
+    }
+    return var::num((f64)fwrite(str.str().c_str(), 1, str.str().length(), (FILE*)fd.obj().ptr));
+}
+
+var builtin_seek(var* local, gc& ngc) {
+    var fd = local[1];
+    var pos = local[2];
+    var whence = local[3];
+    if (!fd.objchk("file")) {
+        return nas_err("seek", "not a valid filehandle");
+    }
+    return var::num((f64)fseek((FILE*)fd.obj().ptr, pos.num(), whence.num()));
+}
+
+var builtin_tell(var* local, gc& ngc) {
+    var fd = local[1];
+    if (!fd.objchk("file")) {
+        return nas_err("tell", "not a valid filehandle");
+    }
+    return var::num((f64)ftell((FILE*)fd.obj().ptr));
+}
+
+var builtin_readln(var* local, gc& ngc) {
+    var fd = local[1];
+    if (!fd.objchk("file")) {
+        return nas_err("readln", "not a valid filehandle");
+    }
+    var str = ngc.alloc(vm_str);
+    char c;
+    while((c = fgetc((FILE*)fd.obj().ptr))!=EOF) {
+        if (c=='\r') {
+            continue;
+        }
+        if (c=='\n') {
+            return str;
+        }
+        str.str() += c;
+    }
+    if (str.str().length()) {
+        return str;
+    }
+    return nil;
+}
+
+var builtin_stat(var* local, gc& ngc) {
+    var name = local[1];
+    if (name.type!=vm_str) {
+        return nas_err("stat", "\"filename\" must be string");
+    }
+    struct stat buf;
+    if (stat(name.str().c_str(),&buf)<0) {
+        return nas_err("stat", "failed to open file <"+name.str()+">");
+    }
+    var ret = ngc.alloc(vm_vec);
+    ret.vec().elems = {
+        var::num((f64)buf.st_dev),
+        var::num((f64)buf.st_ino),
+        var::num((f64)buf.st_mode),
+        var::num((f64)buf.st_nlink),
+        var::num((f64)buf.st_uid),
+        var::num((f64)buf.st_gid),
+        var::num((f64)buf.st_rdev),
+        var::num((f64)buf.st_size),
+        var::num((f64)buf.st_atime),
+        var::num((f64)buf.st_mtime),
+        var::num((f64)buf.st_ctime)
+    };
+    return ret;
+}
+
+var builtin_eof(var* local, gc& ngc) {
+    var fd = local[1];
+    if (!fd.objchk("file")) {
+        return nas_err("readln", "not a valid filehandle");
+    }
+    return var::num((f64)feof((FILE*)fd.obj().ptr));
+}
+
+nasal_builtin_table io_lib_native[] = {
+    {"__readfile", builtin_readfile},
+    {"__fout", builtin_fout},
+    {"__exists", builtin_exists},
+    {"__open", builtin_open},
+    {"__close", builtin_close},
+    {"__read", builtin_read},
+    {"__write", builtin_write},
+    {"__seek", builtin_seek},
+    {"__tell", builtin_tell},
+    {"__readln", builtin_readln},
+    {"__stat", builtin_stat},
+    {"__eof", builtin_eof},
+    {nullptr, nullptr}
+};

src/io_lib.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "nasal.h"
+#include "nasal_gc.h"
+#include "nasal_builtin.h"
+
+#include <sys/stat.h>
+
+#ifdef _MSC_VER
+#define F_OK 0 // fuck msc
+#endif
+
+var builtin_readfile(var*, gc&);
+var builtin_fout(var*, gc&);
+var builtin_exists(var*, gc&);
+var builtin_open(var*, gc&);
+var builtin_close(var*, gc&);
+var builtin_read(var*, gc&);
+var builtin_write(var*, gc&);
+var builtin_seek(var*, gc&);
+var builtin_tell(var*, gc&);
+var builtin_readln(var*, gc&);
+var builtin_stat(var*, gc&);
+var builtin_eof(var*, gc&);
+
+extern nasal_builtin_table io_lib_native[];

src/nasal_builtin.cpp

@@ -72,33 +72,6 @@ var builtin_input(var* local, gc& ngc) {
     return ret;
 }
 
-var builtin_readfile(var* local, gc& ngc) {
-    var val = local[1];
-    if (val.type!=vm_str) {
-        return nas_err("io::readfile", "\"filename\" must be string");
-    }
-    std::ifstream in(val.str(), std::ios::binary);
-    std::stringstream rd;
-    if (!in.fail()) {
-        rd << in.rdbuf();
-    }
-    return ngc.newstr(rd.str());
-}
-
-var builtin_fout(var* local, gc& ngc) {
-    var val = local[1];
-    var str = local[2];
-    if (val.type!=vm_str) {
-        return nas_err("io::fout", "\"filename\" must be string");
-    }
-    std::ofstream out(val.str());
-    if (out.fail()) {
-        return nas_err("io::fout", "cannot open <"+val.str()+">");
-    }
-    out << str;
-    return nil;
-}
-
 var builtin_split(var* local, gc& ngc) {
     var delimeter = local[1];
     var str = local[2];
@@ -423,153 +396,6 @@ var builtin_values(var* local, gc& ngc) {
     return vec;
 }
 
-var builtin_exists(var* local, gc& ngc) {
-    if (local[1].type!=vm_str) {
-        return zero;
-    }
-    return access(local[1].str().c_str(), F_OK)!=-1?one:zero;
-}
-
-var builtin_open(var* local, gc& ngc) {
-    var name = local[1];
-    var mode = local[2];
-    if (name.type!=vm_str) {
-        return nas_err("open", "\"filename\" must be string");
-    }
-    if (mode.type!=vm_str) {
-        return nas_err("open", "\"mode\" must be string");
-    }
-    FILE* res = fopen(name.str().c_str(), mode.str().c_str());
-    if (!res) {
-        return nas_err("open", "failed to open file <"+name.str()+">");
-    }
-    var ret = ngc.alloc(vm_obj);
-    ret.obj().set("file", filehandle_destructor, res);
-    return ret;
-}
-
-var builtin_close(var* local, gc& ngc) {
-    var fd = local[1];
-    if (!fd.objchk("file")) {
-        return nas_err("close", "not a valid filehandle");
-    }
-    fd.obj().clear();
-    return nil;
-}
-
-var builtin_read(var* local, gc& ngc) {
-    var fd = local[1];
-    var buf = local[2];
-    var len = local[3];
-    if (!fd.objchk("file")) {
-        return nas_err("read", "not a valid filehandle");
-    }
-    if (buf.type!=vm_str || buf.val.gcobj->unmut) {
-        return nas_err("read", "\"buf\" must be mutable string");
-    }
-    if (len.type!=vm_num) {
-        return nas_err("read", "\"len\" must be number");
-    }
-    if (len.num()<=0 || len.num()>=(1<<30)) {
-        return nas_err("read", "\"len\" less than 1 or too large");
-    }
-    char* buff = new char[(usize)len.num()+1];
-    if (!buff) {
-        return nas_err("read", "malloc failed");
-    }
-    f64 res = fread(buff,1,len.num(), (FILE*)fd.obj().ptr);
-    buf.str() = buff;
-    buf.val.gcobj->unmut = true;
-    delete []buff;
-    return var::num(res);
-}
-
-var builtin_write(var* local, gc& ngc) {
-    var fd = local[1];
-    var str = local[2];
-    if (!fd.objchk("file")) {
-        return nas_err("write", "not a valid filehandle");
-    }
-    if (str.type!=vm_str) {
-        return nas_err("write", "\"str\" must be string");
-    }
-    return var::num((f64)fwrite(str.str().c_str(), 1, str.str().length(), (FILE*)fd.obj().ptr));
-}
-
-var builtin_seek(var* local, gc& ngc) {
-    var fd = local[1];
-    var pos = local[2];
-    var whence = local[3];
-    if (!fd.objchk("file")) {
-        return nas_err("seek", "not a valid filehandle");
-    }
-    return var::num((f64)fseek((FILE*)fd.obj().ptr, pos.num(), whence.num()));
-}
-
-var builtin_tell(var* local, gc& ngc) {
-    var fd = local[1];
-    if (!fd.objchk("file")) {
-        return nas_err("tell", "not a valid filehandle");
-    }
-    return var::num((f64)ftell((FILE*)fd.obj().ptr));
-}
-
-var builtin_readln(var* local, gc& ngc) {
-    var fd = local[1];
-    if (!fd.objchk("file")) {
-        return nas_err("readln", "not a valid filehandle");
-    }
-    var str = ngc.alloc(vm_str);
-    char c;
-    while((c = fgetc((FILE*)fd.obj().ptr))!=EOF) {
-        if (c=='\r') {
-            continue;
-        }
-        if (c=='\n') {
-            return str;
-        }
-        str.str() += c;
-    }
-    if (str.str().length()) {
-        return str;
-    }
-    return nil;
-}
-
-var builtin_stat(var* local, gc& ngc) {
-    var name = local[1];
-    if (name.type!=vm_str) {
-        return nas_err("stat", "\"filename\" must be string");
-    }
-    struct stat buf;
-    if (stat(name.str().c_str(),&buf)<0) {
-        return nas_err("stat", "failed to open file <"+name.str()+">");
-    }
-    var ret = ngc.alloc(vm_vec);
-    ret.vec().elems = {
-        var::num((f64)buf.st_dev),
-        var::num((f64)buf.st_ino),
-        var::num((f64)buf.st_mode),
-        var::num((f64)buf.st_nlink),
-        var::num((f64)buf.st_uid),
-        var::num((f64)buf.st_gid),
-        var::num((f64)buf.st_rdev),
-        var::num((f64)buf.st_size),
-        var::num((f64)buf.st_atime),
-        var::num((f64)buf.st_mtime),
-        var::num((f64)buf.st_ctime)
-    };
-    return ret;
-}
-
-var builtin_eof(var* local, gc& ngc) {
-    var fd = local[1];
-    if (!fd.objchk("file")) {
-        return nas_err("readln", "not a valid filehandle");
-    }
-    return var::num((f64)feof((FILE*)fd.obj().ptr));
-}
-
 var builtin_sleep(var* local, gc& ngc) {
     var val = local[1];
     if (val.type!=vm_num) {
@@ -1003,8 +829,6 @@ nasal_builtin_table builtin[] = {
     {"__setsize", builtin_setsize},
     {"__system", builtin_system},
     {"__input", builtin_input},
-    {"__readfile", builtin_readfile},
-    {"__fout", builtin_fout},
     {"__split", builtin_split},
     {"__rand", builtin_rand},
     {"__id", builtin_id},
@@ -1029,16 +853,6 @@ nasal_builtin_table builtin[] = {
     {"__chr", builtin_chr},
     {"__char", builtin_char},
     {"__values", builtin_values},
-    {"__exists", builtin_exists},
-    {"__open", builtin_open},
-    {"__close", builtin_close},
-    {"__read", builtin_read},
-    {"__write", builtin_write},
-    {"__seek", builtin_seek},
-    {"__tell", builtin_tell},
-    {"__readln", builtin_readln},
-    {"__stat", builtin_stat},
-    {"__eof", builtin_eof},
     {"__sleep", builtin_sleep},
     {"__pipe", builtin_pipe},
     {"__fork", builtin_fork},

src/nasal_builtin.h

@@ -21,7 +21,6 @@
 #include <sstream>
 #include <cmath>
 #include <thread>
-#include <sys/stat.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -43,8 +42,6 @@ var builtin_append(var*, gc&);
 var builtin_setsize(var*, gc&);
 var builtin_system(var*, gc&);
 var builtin_input(var*, gc&);
-var builtin_readfile(var*, gc&);
-var builtin_fout(var*, gc&);
 var builtin_split(var*, gc&);
 var builtin_rand(var*, gc&);
 var builtin_id(var*, gc&);
@@ -69,16 +66,6 @@ var builtin_cmp(var*, gc&);
 var builtin_chr(var*, gc&);
 var builtin_char(var*, gc&);
 var builtin_values(var*, gc&);
-var builtin_exists(var*, gc&);
-var builtin_open(var*, gc&);
-var builtin_close(var*, gc&);
-var builtin_read(var*, gc&);
-var builtin_write(var*, gc&);
-var builtin_seek(var*, gc&);
-var builtin_tell(var*, gc&);
-var builtin_readln(var*, gc&);
-var builtin_stat(var*, gc&);
-var builtin_eof(var*, gc&);
 var builtin_sleep(var*, gc&);
 var builtin_pipe(var*, gc&);
 var builtin_fork(var*, gc&);

src/nasal_codegen.cpp

@@ -21,6 +21,7 @@ void codegen::load_native_function_table(nasal_builtin_table* table) {
 
 void codegen::init_native_function() {
     load_native_function_table(builtin);
+    load_native_function_table(io_lib_native);
     load_native_function_table(math_lib_native);
     load_native_function_table(bits_native);
     load_native_function_table(coroutine_native);

src/nasal_codegen.h

@@ -13,6 +13,7 @@
 #include "bits_lib.h"
 #include "math_lib.h"
 #include "fg_props.h"
+#include "io_lib.h"
 
 #include <iomanip>
 #include <list>

std/bits.nas

@@ -59,12 +59,16 @@ var buf = func(len) {
     return __buf;
 }
 
-var bit = [var __ = 1];
-for(var i = 1; i<32; i += 1) {
-    func(vec, arg...){
+var bit = func() {
+    var res = [var __ = 1];
+    var append = func(vec, arg...) {
         return __append;
-    }(bit, __ += __);
     }
+    for(var i = 1; i<32; i += 1) {
+        append(res, __ += __);
+    }
+    return res;
+}();
 
 var test = func(n, b) {
     n /= bit[b];

test/module_test.nas

@@ -1,4 +1,8 @@
 import.std.dylib;
+import.module.libfib;
+
+println(keys(libfib));
+libfib.test_ghost();
 
 var libfib=func(){
     var (dd,fib,qfib)=(nil,nil,nil);