🎨 add namespace

module/fib.cpp

@@ -3,7 +3,8 @@
 #include <iostream>
 #include "../src/nasal.h"
 
-namespace nasal_fib_module {
+namespace nasal {
+namespace fib_module {
 
 double fibonaci(double x) {
     if (x<=2) {
@@ -88,5 +89,7 @@ module_func_info func_tbl[] = {
 }
 
 extern "C" module_func_info* get() {
-    return nasal_fib_module::func_tbl;
+    return fib_module::func_tbl;
+}
+
 }

module/keyboard.cpp

@@ -12,46 +12,50 @@
 #include <termios.h>
 #endif
 
+namespace nasal {
+
 class noecho_input {
 private:
 #ifndef _WIN32
     struct termios init_termios;
     struct termios new_termios;
-    int peek_char=-1;
+    int peek_char = -1;
 #endif
 public:
     noecho_input() {
 #ifndef _WIN32
         tcflush(0, TCIOFLUSH);
         tcgetattr(0, &init_termios);
-        new_termios=init_termios;
+        new_termios = init_termios;
-        new_termios.c_lflag&=~(ICANON|ECHO|ECHONL|ECHOE);
+        new_termios.c_lflag &= ~(ICANON|ECHO|ECHONL|ECHOE);
         // vmin=0 is nonblock input, but in wsl there is a bug that will block input
         // so we use fcntl to write the nonblock input
-        new_termios.c_cc[VMIN]=1;
+        new_termios.c_cc[VMIN] = 1;
-        new_termios.c_cc[VTIME]=0;
+        new_termios.c_cc[VTIME] = 0;
         tcsetattr(0, TCSANOW, &new_termios);
 #endif
     }
+
     ~noecho_input() {
 #ifndef _WIN32
         tcflush(0, TCIOFLUSH);
         tcsetattr(0, TCSANOW, &init_termios);
 #endif
     }
+
     int noecho_kbhit() {
 #ifndef _WIN32
-        unsigned char ch=0;
+        unsigned char ch = 0;
-        int nread=0;
+        int nread = 0;
         if (peek_char!=-1) {
             return 1;
         }
-        int flag=fcntl(0, F_GETFL);
+        int flag = fcntl(0, F_GETFL);
         fcntl(0, F_SETFL,flag|O_NONBLOCK);
-        nread=read(0, &ch, 1);
+        nread = read(0, &ch, 1);
         fcntl(0, F_SETFL, flag);
         if (nread==1) {
-            peek_char=ch;
+            peek_char = ch;
             return 1;
         }
         return 0;
@@ -59,15 +63,16 @@ public:
         return kbhit();
 #endif
     }
+
     int noecho_getch() {
 #ifndef _WIN32
-        int ch=0;
+        int ch = 0;
         if (peek_char!=-1) {
-            ch=peek_char;
+            ch = peek_char;
-            peek_char=-1;
+            peek_char = -1;
             return ch;
         }
-        ssize_t tmp=read(0, &ch, 1);
+        ssize_t tmp = read(0, &ch, 1);
         return ch;
 #else
         return getch();
@@ -92,7 +97,7 @@ var nas_noblock(var* args, usize size, gc* ngc) {
     return nil;
 }
 
-module_func_info func_tbl[]={
+module_func_info func_tbl[] = {
     {"nas_getch",nas_getch},
     {"nas_kbhit",nas_kbhit},
     {"nas_noblock",nas_noblock},
@@ -101,4 +106,6 @@ module_func_info func_tbl[]={
 
 extern "C" module_func_info* get() {
     return func_tbl;
-}
+}
+
+}

module/matrix.cpp

@@ -1,15 +1,17 @@
 #include "../src/nasal.h"
 #include <cmath>
 
+namespace nasal {
+
 var nas_vec2(var* args, usize size, gc* ngc) {
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(args[0]);
     res.vec().elems.push_back(args[1]);
     return res;
 }
 
 var nas_vec3(var* args, usize size, gc* ngc) {
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(args[0]);
     res.vec().elems.push_back(args[1]);
     res.vec().elems.push_back(args[2]);
@@ -19,11 +21,11 @@ var nas_vec3(var* args, usize size, gc* ngc) {
 var nas_vec2_add(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=2 || v1.size()!=2)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num()));
     return res;
@@ -32,11 +34,11 @@ var nas_vec2_add(var* args, usize size, gc* ngc) {
 var nas_vec2_sub(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=2 || v1.size()!=2)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num()));
     return res;
@@ -45,11 +47,11 @@ var nas_vec2_sub(var* args, usize size, gc* ngc) {
 var nas_vec2_mult(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=2 || v1.size()!=2)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num()));
     return res;
@@ -58,11 +60,11 @@ var nas_vec2_mult(var* args, usize size, gc* ngc) {
 var nas_vec2_div(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=2 || v1.size()!=2)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num()));
     return res;
@@ -71,10 +73,10 @@ var nas_vec2_div(var* args, usize size, gc* ngc) {
 var nas_vec2_neg(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=2)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(-v0[0].num()));
     res.vec().elems.push_back(var::num(-v0[1].num()));
     return res;
@@ -83,13 +85,13 @@ var nas_vec2_neg(var* args, usize size, gc* ngc) {
 var nas_vec2_norm(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=2)
         return nil;
-    auto x=v0[0].num();
+    auto x = v0[0].num();
-    auto y=v0[1].num();
+    auto y = v0[1].num();
-    auto t=std::sqrt(x*x+y*y);
+    auto t = std::sqrt(x*x+y*y);
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(x/t));
     res.vec().elems.push_back(var::num(y/t));
     return res;
@@ -98,19 +100,19 @@ var nas_vec2_norm(var* args, usize size, gc* ngc) {
 var nas_vec2_len(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=2)
         return nil;
-    auto x=v0[0].num();
+    auto x = v0[0].num();
-    auto y=v0[1].num();
+    auto y = v0[1].num();
     return var::num(std::sqrt(x*x+y*y));
 }
 
 var nas_vec2_dot(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=2 || v1.size()!=2)
         return nil;
     return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num());
@@ -119,11 +121,11 @@ var nas_vec2_dot(var* args, usize size, gc* ngc) {
 var nas_vec3_add(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=3 || v1.size()!=3)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()+v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()+v1[1].num()));
     res.vec().elems.push_back(var::num(v0[2].num()+v1[2].num()));
@@ -133,11 +135,11 @@ var nas_vec3_add(var* args, usize size, gc* ngc) {
 var nas_vec3_sub(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=3 || v1.size()!=3)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()-v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()-v1[1].num()));
     res.vec().elems.push_back(var::num(v0[2].num()-v1[2].num()));
@@ -147,11 +149,11 @@ var nas_vec3_sub(var* args, usize size, gc* ngc) {
 var nas_vec3_mult(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=3 || v1.size()!=3)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()*v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()*v1[1].num()));
     res.vec().elems.push_back(var::num(v0[2].num()*v1[2].num()));
@@ -161,11 +163,11 @@ var nas_vec3_mult(var* args, usize size, gc* ngc) {
 var nas_vec3_div(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=3 || v1.size()!=3)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()/v1[0].num()));
     res.vec().elems.push_back(var::num(v0[1].num()/v1[1].num()));
     res.vec().elems.push_back(var::num(v0[2].num()/v1[2].num()));
@@ -175,10 +177,10 @@ var nas_vec3_div(var* args, usize size, gc* ngc) {
 var nas_vec3_neg(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=3)
         return nil;
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(-v0[0].num()));
     res.vec().elems.push_back(var::num(-v0[1].num()));
     res.vec().elems.push_back(var::num(-v0[2].num()));
@@ -188,14 +190,14 @@ var nas_vec3_neg(var* args, usize size, gc* ngc) {
 var nas_vec3_norm(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=3)
         return nil;
-    auto x=v0[0].num();
+    auto x = v0[0].num();
-    auto y=v0[1].num();
+    auto y = v0[1].num();
-    auto z=v0[2].num();
+    auto z = v0[2].num();
-    auto t=std::sqrt(x*x+y*y+z*z);
+    auto t = std::sqrt(x*x+y*y+z*z);
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(x/t));
     res.vec().elems.push_back(var::num(y/t));
     res.vec().elems.push_back(var::num(z/t));
@@ -205,23 +207,23 @@ var nas_vec3_norm(var* args, usize size, gc* ngc) {
 var nas_vec3_len(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=3)
         return nil;
-    auto x=v0[0].num();
+    auto x = v0[0].num();
-    auto y=v0[1].num();
+    auto y = v0[1].num();
-    auto z=v0[2].num();
+    auto z = v0[2].num();
     return var::num(std::sqrt(x*x+y*y+z*z));
 }
 
 var nas_rotate_x(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=3)
         return nil;
-    auto angle=args[1].num();
+    auto angle = args[1].num();
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()));
     res.vec().elems.push_back(var::num(v0[2].num()*std::sin(angle)+v0[1].num()*std::cos(angle)));
     res.vec().elems.push_back(var::num(v0[2].num()*std::cos(angle)-v0[1].num()*std::sin(angle)));
@@ -231,11 +233,11 @@ var nas_rotate_x(var* args, usize size, gc* ngc) {
 var nas_rotate_y(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=3)
         return nil;
-    auto angle=args[1].num();
+    auto angle = args[1].num();
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[2].num()*std::sin(angle)));
     res.vec().elems.push_back(var::num(v0[1].num()));
     res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[2].num()*std::cos(angle)));
@@ -245,11 +247,11 @@ var nas_rotate_y(var* args, usize size, gc* ngc) {
 var nas_rotate_z(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
     if (v0.size()!=3)
         return nil;
-    auto angle=args[1].num();
+    auto angle = args[1].num();
-    var res=ngc->alloc(vm_vec);
+    var res = ngc->alloc(vm_vec);
     res.vec().elems.push_back(var::num(v0[0].num()*std::cos(angle)-v0[1].num()*std::sin(angle)));
     res.vec().elems.push_back(var::num(v0[0].num()*std::sin(angle)+v0[1].num()*std::cos(angle)));
     res.vec().elems.push_back(var::num(v0[2].num()));
@@ -259,38 +261,40 @@ var nas_rotate_z(var* args, usize size, gc* ngc) {
 var nas_vec3_dot(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_vec || args[1].type!=vm_vec)
         return nil;
-    auto& v0=args[0].vec().elems;
+    auto& v0 = args[0].vec().elems;
-    auto& v1=args[1].vec().elems;
+    auto& v1 = args[1].vec().elems;
     if (v0.size()!=3 || v1.size()!=3)
         return nil;
     return var::num(v0[0].num()*v1[0].num()+v0[1].num()*v1[1].num()+v0[2].num()*v1[2].num());
 }
 
-module_func_info func_tbl[]={
+module_func_info func_tbl[] = {
-    {"nas_vec2",nas_vec2},
+    {"nas_vec2", nas_vec2},
-    {"nas_vec2_add",nas_vec2_add},
+    {"nas_vec2_add", nas_vec2_add},
-    {"nas_vec2_sub",nas_vec2_sub},
+    {"nas_vec2_sub", nas_vec2_sub},
-    {"nas_vec2_mult",nas_vec2_mult},
+    {"nas_vec2_mult", nas_vec2_mult},
-    {"nas_vec2_div",nas_vec2_div},
+    {"nas_vec2_div", nas_vec2_div},
-    {"nas_vec2_neg",nas_vec2_neg},
+    {"nas_vec2_neg", nas_vec2_neg},
-    {"nas_vec2_norm",nas_vec2_norm},
+    {"nas_vec2_norm", nas_vec2_norm},
-    {"nas_vec2_len",nas_vec2_len},
+    {"nas_vec2_len", nas_vec2_len},
-    {"nas_vec2_dot",nas_vec2_dot},
+    {"nas_vec2_dot", nas_vec2_dot},
-    {"nas_vec3",nas_vec3},
+    {"nas_vec3", nas_vec3},
-    {"nas_vec3_add",nas_vec3_add},
+    {"nas_vec3_add", nas_vec3_add},
-    {"nas_vec3_sub",nas_vec3_sub},
+    {"nas_vec3_sub", nas_vec3_sub},
-    {"nas_vec3_mult",nas_vec3_mult},
+    {"nas_vec3_mult", nas_vec3_mult},
-    {"nas_vec3_div",nas_vec3_div},
+    {"nas_vec3_div", nas_vec3_div},
-    {"nas_vec3_neg",nas_vec3_neg},
+    {"nas_vec3_neg", nas_vec3_neg},
-    {"nas_vec3_norm",nas_vec3_norm},
+    {"nas_vec3_norm", nas_vec3_norm},
-    {"nas_vec3_len",nas_vec3_len},
+    {"nas_vec3_len", nas_vec3_len},
-    {"nas_rotate_x",nas_rotate_x},
+    {"nas_rotate_x", nas_rotate_x},
-    {"nas_rotate_y",nas_rotate_y},
+    {"nas_rotate_y", nas_rotate_y},
-    {"nas_rotate_z",nas_rotate_z},
+    {"nas_rotate_z", nas_rotate_z},
-    {"nas_vec3_dot",nas_vec3_dot},
+    {"nas_vec3_dot", nas_vec3_dot},
-    {nullptr,nullptr}
+    {nullptr, nullptr}
 };
 
 extern "C" module_func_info* get() {
     return func_tbl;
+}
+
 }

module/nasocket.cpp

@@ -28,16 +28,18 @@ static WSAmanager win;
 #include <netinet/in.h>
 #endif
 
+namespace nasal {
+
 var nas_socket(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num || args[1].type!=vm_num || args[2].type!=vm_num)
-        return nas_err("socket","\"af\", \"type\", \"protocol\" should be number");
+        return nas_err("socket", "\"af\", \"type\", \"protocol\" should be number");
-    int sd=socket(args[0].num(),args[1].num(),args[2].num());
+    int sd = socket(args[0].num(), args[1].num(), args[2].num());
     return var::num((double)sd);
 }
 
 var nas_closesocket(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("closesocket","\"sd\" should be number");
+        return nas_err("closesocket", "\"sd\" should be number");
 #ifdef _WIN32
     return var::num((double)closesocket(args[0].num()));
 #else
@@ -47,145 +49,175 @@ var nas_closesocket(var* args, usize size, gc* ngc) {
 
 var nas_shutdown(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("shutdown","\"sd\" must be a number");
+        return nas_err("shutdown", "\"sd\" must be a number");
     if (args[1].type!=vm_num)
-        return nas_err("shutdown","\"how\" must be a number");
+        return nas_err("shutdown", "\"how\" must be a number");
-    return var::num((double)shutdown(args[0].num(),args[1].num()));
+    return var::num((double)shutdown(args[0].num(), args[1].num()));
 }
 
 var nas_bind(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("bind","\"sd\" muse be a number");
+        return nas_err("bind", "\"sd\" muse be a number");
     if (args[1].type!=vm_str)
-        return nas_err("bind","\"ip\" should be a string including an ip with correct format");
+        return nas_err("bind", "\"ip\" should be a string including an ip with correct format");
     if (args[2].type!=vm_num)
-        return nas_err("bind","\"port\" must be a number");
+        return nas_err("bind", "\"port\" must be a number");
     sockaddr_in server;
-    memset(&server,0,sizeof(sockaddr_in));
+    memset(&server, 0, sizeof(sockaddr_in));
-    server.sin_family=AF_INET;
+    server.sin_family = AF_INET;
-    server.sin_addr.s_addr=inet_addr(args[1].str().c_str());
+    server.sin_addr.s_addr = inet_addr(args[1].str().c_str());
-    server.sin_port=htons(args[2].num());
+    server.sin_port = htons(args[2].num());
-    return var::num((double)bind(args[0].num(),(sockaddr*)&server,sizeof(server)));
+    return var::num((double)bind(args[0].num(), (sockaddr*)&server, sizeof(server)));
 }
 
 var nas_listen(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("listen","\"sd\" must be a number");
+        return nas_err("listen", "\"sd\" must be a number");
     if (args[1].type!=vm_num)
-        return nas_err("listen","\"backlog\" must be a number");
+        return nas_err("listen", "\"backlog\" must be a number");
-    return var::num((double)listen(args[0].num(),args[1].num()));
+    return var::num((double)listen(args[0].num(), args[1].num()));
 }
 
 var nas_connect(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("connect","\"sd\" must be a number");
+        return nas_err("connect", "\"sd\" must be a number");
     if (args[1].type!=vm_str)
-        return nas_err("connect","\"hostname\" must be a string");
+        return nas_err("connect", "\"hostname\" must be a string");
     if (args[2].type!=vm_num)
-        return nas_err("connect","\"port\" must be a number");
+        return nas_err("connect", "\"port\" must be a number");
     sockaddr_in addr;
-    memset(&addr,0,sizeof(sockaddr_in));
+    memset(&addr, 0, sizeof(sockaddr_in));
-    addr.sin_family=AF_INET;
+    addr.sin_family = AF_INET;
-    addr.sin_port=htons(args[2].num());
+    addr.sin_port = htons(args[2].num());
-    hostent* entry=gethostbyname(args[1].str().c_str());
+    hostent* entry = gethostbyname(args[1].str().c_str());
-    memcpy(&addr.sin_addr,entry->h_addr,entry->h_length);
+    memcpy(&addr.sin_addr, entry->h_addr, entry->h_length);
-    return var::num((double)connect(args[0].num(),(sockaddr*)&addr,sizeof(sockaddr_in)));
+    return var::num((double)connect(
+        args[0].num(),
+        (sockaddr*)&addr,
+        sizeof(sockaddr_in)
+    ));
 }
 
 var nas_accept(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("accept","\"sd\" must be a number");
+        return nas_err("accept", "\"sd\" must be a number");
     sockaddr_in client;
-    int socklen=sizeof(sockaddr_in);
+    int socklen = sizeof(sockaddr_in);
 #ifdef _WIN32
-    int client_sd=accept(args[0].num(),(sockaddr*)&client,&socklen);
+    int client_sd = accept(args[0].num(), (sockaddr*)&client, &socklen);
 #else
-    int client_sd=accept(args[0].num(),(sockaddr*)&client,(socklen_t*)&socklen);
+    int client_sd = accept(args[0].num(), (sockaddr*)&client, (socklen_t*)&socklen);
 #endif
-    var res=ngc->temp=ngc->alloc(vm_hash);
+    var res=ngc->temp = ngc->alloc(vm_hash);
-    auto& hash=res.hash().elems;
+    auto& hash = res.hash().elems;
-    hash["sd"]=var::num((double)client_sd);
+    hash["sd"] = var::num((double)client_sd);
-    hash["ip"]=ngc->newstr(inet_ntoa(client.sin_addr));
+    hash["ip"] = ngc->newstr(inet_ntoa(client.sin_addr));
-    ngc->temp=nil;
+    ngc->temp = nil;
     return res;
 }
 
 var nas_send(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("send","\"sd\" must be a number");
+        return nas_err("send", "\"sd\" must be a number");
     if (args[1].type!=vm_str)
-        return nas_err("send","\"buff\" must be a string");
+        return nas_err("send", "\"buff\" must be a string");
     if (args[2].type!=vm_num)
-        return nas_err("send","\"flags\" muse be a number");
+        return nas_err("send", "\"flags\" muse be a number");
-    return var::num((double)send(args[0].num(),args[1].str().c_str(),args[1].str().length(),args[2].num()));
+    return var::num((double)send(
+        args[0].num(),
+        args[1].str().c_str(),
+        args[1].str().length(),
+        args[2].num()
+    ));
 }
 
 var nas_sendto(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("sendto","\"sd\" must be a number");
+        return nas_err("sendto", "\"sd\" must be a number");
     if (args[1].type!=vm_str)
-        return nas_err("sendto","\"hostname\" must be a string");
+        return nas_err("sendto", "\"hostname\" must be a string");
     if (args[2].type!=vm_num)
-        return nas_err("sendto","\"port\" must be a number");
+        return nas_err("sendto", "\"port\" must be a number");
     if (args[3].type!=vm_str)
-        return nas_err("sendto","\"buff\" must be a string");
+        return nas_err("sendto", "\"buff\" must be a string");
     if (args[4].type!=vm_num)
-        return nas_err("sendto","\"flags\" must be a number");
+        return nas_err("sendto", "\"flags\" must be a number");
     sockaddr_in addr;
-    memset(&addr,0,sizeof(sockaddr_in));
+    memset(&addr, 0, sizeof(sockaddr_in));
-    addr.sin_family=AF_INET;
+    addr.sin_family = AF_INET;
-    addr.sin_port=htons(args[2].num());
+    addr.sin_port = htons(args[2].num());
-    hostent* entry=gethostbyname(args[1].str().c_str());
+    hostent* entry = gethostbyname(args[1].str().c_str());
-    memcpy(&addr.sin_addr,entry->h_addr,entry->h_length);
+    memcpy(&addr.sin_addr, entry->h_addr, entry->h_length);
-    return var::num((double)sendto(args[0].num(),args[3].str().c_str(),args[3].str().length(),args[4].num(),(sockaddr*)&addr,sizeof(sockaddr_in)));
+    return var::num((double)sendto(
+        args[0].num(),
+        args[3].str().c_str(),
+        args[3].str().length(),
+        args[4].num(),
+        (sockaddr*)&addr,
+        sizeof(sockaddr_in)
+    ));
 }
 
 var nas_recv(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("recv","\"sd\" must be a number");
+        return nas_err("recv", "\"sd\" must be a number");
     if (args[1].type!=vm_num)
-        return nas_err("recv","\"len\" must be a number");
+        return nas_err("recv", "\"len\" must be a number");
     if (args[1].num()<=0 || args[1].num()>16*1024*1024)
-        return nas_err("recv","\"len\" out of range");
+        return nas_err("recv", "\"len\" out of range");
     if (args[2].type!=vm_num)
-        return nas_err("recv","\"flags\" muse be a number");
+        return nas_err("recv", "\"flags\" muse be a number");
-    var res=ngc->temp=ngc->alloc(vm_hash);
+    var res = ngc->temp = ngc->alloc(vm_hash);
-    auto& hash=res.hash().elems;
+    auto& hash = res.hash().elems;
-    char* buf=new char[(int)args[1].num()];
+    char* buf = new char[(int)args[1].num()];
-    auto recvsize=recv(args[0].num(),buf,args[1].num(),args[2].num());
+    auto recvsize = recv(args[0].num(), buf,args[1].num(), args[2].num());
-    hash["size"]=var::num((double)recvsize);
+    hash["size"] = var::num((double)recvsize);
-    buf[recvsize>=0?recvsize:0]=0;
+    buf[recvsize>=0? recvsize:0] = 0;
-    hash["str"]=ngc->newstr(buf);
+    hash["str"] = ngc->newstr(buf);
     delete[] buf;
-    ngc->temp=nil;
+    ngc->temp = nil;
     return res;
 }
 
 var nas_recvfrom(var* args, usize size, gc* ngc) {
     if (args[0].type!=vm_num)
-        return nas_err("recvfrom","\"sd\" must be a number");
+        return nas_err("recvfrom", "\"sd\" must be a number");
     if (args[1].type!=vm_num)
-        return nas_err("recvfrom","\"len\" must be a number");
+        return nas_err("recvfrom", "\"len\" must be a number");
     if (args[1].num()<=0 || args[1].num()>16*1024*1024)
-        return nas_err("recvfrom","\"len\" out of range");
+        return nas_err("recvfrom", "\"len\" out of range");
     if (args[2].type!=vm_num)
-        return nas_err("recvfrom","\"flags\" muse be a number");
+        return nas_err("recvfrom", "\"flags\" muse be a number");
     sockaddr_in addr;
-    int socklen=sizeof(sockaddr_in);
+    int socklen = sizeof(sockaddr_in);
-    var res=ngc->temp=ngc->alloc(vm_hash);
+    var res = ngc->temp = ngc->alloc(vm_hash);
-    auto& hash=res.hash().elems;
+    auto& hash = res.hash().elems;
-    char* buf=new char[(int)args[1].num()+1];
+    char* buf = new char[(int)args[1].num()+1];
 #ifdef _WIN32
-    auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,&socklen);
+    auto recvsize = recvfrom(
+        args[0].num(),
+        buf,
+        args[1].num(),
+        args[2].num(),
+        (sockaddr*)&addr,
+        &socklen
+    );
 #else
-    auto recvsize=recvfrom(args[0].num(),buf,args[1].num(),args[2].num(),(sockaddr*)&addr,(socklen_t*)&socklen);
+    auto recvsize = recvfrom(
+        args[0].num(),
+        buf,
+        args[1].num(),
+        args[2].num(),
+        (sockaddr*)&addr,
+        (socklen_t*)&socklen
+    );
 #endif
-    hash["size"]=var::num((double)recvsize);
+    hash["size"] = var::num((double)recvsize);
-    buf[recvsize>=0?recvsize:0]=0;
+    buf[recvsize>=0? recvsize:0] = 0;
-    hash["str"]=ngc->newstr(buf);
+    hash["str"] = ngc->newstr(buf);
     delete[] buf;
-    hash["fromip"]=ngc->newstr(inet_ntoa(addr.sin_addr));
+    hash["fromip"] = ngc->newstr(inet_ntoa(addr.sin_addr));
-    ngc->temp=nil;
+    ngc->temp = nil;
     return res;
 }
 
@@ -193,22 +225,24 @@ var nas_errno(var* args, usize size, gc* ngc) {
     return ngc->newstr(strerror(errno));
 }
 
-module_func_info func_tbl[]={
+module_func_info func_tbl[] = {
-    {"nas_socket",nas_socket},
+    {"nas_socket", nas_socket},
-    {"nas_closesocket",nas_closesocket},
+    {"nas_closesocket", nas_closesocket},
-    {"nas_shutdown",nas_shutdown},
+    {"nas_shutdown", nas_shutdown},
-    {"nas_bind",nas_bind},
+    {"nas_bind", nas_bind},
-    {"nas_listen",nas_listen},
+    {"nas_listen", nas_listen},
-    {"nas_connect",nas_connect},
+    {"nas_connect", nas_connect},
-    {"nas_accept",nas_accept},
+    {"nas_accept", nas_accept},
-    {"nas_send",nas_send},
+    {"nas_send", nas_send},
-    {"nas_sendto",nas_sendto},
+    {"nas_sendto", nas_sendto},
-    {"nas_recv",nas_recv},
+    {"nas_recv", nas_recv},
-    {"nas_recvfrom",nas_recvfrom},
+    {"nas_recvfrom", nas_recvfrom},
-    {"nas_errno",nas_errno},
+    {"nas_errno", nas_errno},
-    {nullptr,nullptr}
+    {nullptr, nullptr}
 };
 
 extern "C" module_func_info* get() {
     return func_tbl;
-}
+}
+
+}

src/bits_lib.cpp

@@ -1,5 +1,7 @@
 #include "bits_lib.h"
 
+namespace nasal {
+
 var builtin_u32xor(var* local, gc& ngc) {
     return var::num((f64)(u32(local[1].num())^u32(local[2].num())));
 }
@@ -134,4 +136,6 @@ nasal_builtin_table bits_native[] = {
     {"__setfld", builtin_setfld},
     {"__buf", builtin_buf},
     {nullptr, nullptr}
-};
+};
+
+}

src/bits_lib.h

@@ -4,6 +4,8 @@
 #include "nasal_gc.h"
 #include "nasal_builtin.h"
 
+namespace nasal {
+
 var builtin_u32xor(var*, gc&);
 var builtin_u32and(var*, gc&);
 var builtin_u32or(var*, gc&);
@@ -15,3 +17,5 @@ var builtin_setfld(var*, gc&);
 var builtin_buf(var*, gc&);
 
 extern nasal_builtin_table bits_native[];
+
+}

src/coroutine.cpp

@@ -1,5 +1,7 @@
 #include "coroutine.h"
 
+namespace nasal {
+
 var builtin_cocreate(var* local, gc& ngc) {
     // +-------------+
     // | old pc      | <- top[0]
@@ -113,4 +115,6 @@ nasal_builtin_table coroutine_native[] = {
     {"__costatus", builtin_costatus},
     {"__corun", builtin_corun},
     {nullptr, nullptr}
-};
+};
+
+}

src/coroutine.h

@@ -4,10 +4,14 @@
 #include "nasal_gc.h"
 #include "nasal_builtin.h"
 
+namespace nasal {
+
 var builtin_cocreate(var*, gc&);
 var builtin_coresume(var*, gc&);
 var builtin_coyield(var*, gc&);
 var builtin_costatus(var*, gc&);
 var builtin_corun(var*, gc&);
 
-extern nasal_builtin_table coroutine_native[];
+extern nasal_builtin_table coroutine_native[];
+
+}

src/dylib_lib.cpp

@@ -1,5 +1,7 @@
 #include "dylib_lib.h"
 
+namespace nasal {
+
 const auto dylib_type_name = "dylib";
 const auto func_addr_type_name = "faddr";
 
@@ -102,4 +104,6 @@ nasal_builtin_table dylib_lib_native[] = {
     {"__dlcallv", builtin_dlcallv},
     {"__dlcall", builtin_dlcall},
     {nullptr, nullptr}
-};
+};
+
+}

src/dylib_lib.h

@@ -11,6 +11,8 @@
 #include <sys/wait.h>
 #endif
 
+namespace nasal {
+
 void dylib_destructor(void*);
 void func_addr_destructor(void*);
 
@@ -19,4 +21,6 @@ var builtin_dlclose(var*, gc&);
 var builtin_dlcallv(var*, gc&);
 var builtin_dlcall(var*, gc&);
 
-extern nasal_builtin_table dylib_lib_native[];
+extern nasal_builtin_table dylib_lib_native[];
+
+}

src/fg_props.cpp

@@ -2,6 +2,8 @@
 
 #include <fstream>
 
+namespace nasal {
+
 var builtin_logprint(var* local, gc& ngc) {
     var level = local[1];
     var elems = local[2];
@@ -33,4 +35,6 @@ var builtin_logprint(var* local, gc& ngc) {
 nasal_builtin_table flight_gear_native[] = {
     {"_logprint", builtin_logprint},
     {nullptr, nullptr}
-};
+};
+
+}

src/fg_props.h

@@ -4,6 +4,8 @@
 #include "nasal_gc.h"
 #include "nasal_builtin.h"
 
+namespace nasal {
+
 #define SG_LOG_BULK 1
 #define SG_LOG_DEBUG 2
 #define SG_LOG_INFO 3
@@ -16,3 +18,5 @@
 var builtin_logprint(var*, gc&);
 
 extern nasal_builtin_table flight_gear_native[];
+
+}

src/io_lib.cpp

@@ -1,5 +1,7 @@
 #include "io_lib.h"
 
+namespace nasal {
+
 const auto file_type_name = "file";
 
 void filehandle_destructor(void* ptr) {
@@ -197,4 +199,6 @@ nasal_builtin_table io_lib_native[] = {
     {"__stat", builtin_stat},
     {"__eof", builtin_eof},
     {nullptr, nullptr}
-};
+};
+
+}

src/io_lib.h

@@ -10,6 +10,8 @@
 #define F_OK 0 // fuck msc
 #endif
 
+namespace nasal {
+
 void filehandle_destructor(void*);
 
 var builtin_readfile(var*, gc&);
@@ -25,4 +27,6 @@ var builtin_readln(var*, gc&);
 var builtin_stat(var*, gc&);
 var builtin_eof(var*, gc&);
 
-extern nasal_builtin_table io_lib_native[];
+extern nasal_builtin_table io_lib_native[];
+
+}

src/math_lib.cpp

@@ -1,5 +1,7 @@
 #include "math_lib.h"
 
+namespace nasal {
+
 var builtin_pow(var* local, gc& ngc) {
     var x = local[1];
     var y = local[2];
@@ -70,4 +72,6 @@ nasal_builtin_table math_lib_native[] = {
     {"__atan2", builtin_atan2},
     {"__isnan", builtin_isnan},
     {nullptr, nullptr}
-};
+};
+
+}

src/math_lib.h

@@ -4,6 +4,8 @@
 #include "nasal_gc.h"
 #include "nasal_builtin.h"
 
+namespace nasal {
+
 var builtin_pow(var*, gc&);
 var builtin_sin(var*, gc&);
 var builtin_cos(var*, gc&);
@@ -15,4 +17,6 @@ var builtin_sqrt(var*, gc&);
 var builtin_atan2(var*, gc&);
 var builtin_isnan(var*, gc&);
 
-extern nasal_builtin_table math_lib_native[];
+extern nasal_builtin_table math_lib_native[];
+
+}

src/nasal.h

@@ -11,6 +11,17 @@
 #include <cmath>
 #include <vector>
 
+using i32 = std::int32_t;
+using i64 = std::int64_t;
+using u8 = std::uint8_t;
+using u16 = std::uint16_t;
+using u32 = std::uint32_t;
+using u64 = std::uint64_t;
+using usize = std::size_t;
+using f64 = double;
+
+namespace nasal {
+
 bool is_windows();
 bool is_linux();
 bool is_macos();
@@ -23,14 +34,7 @@ bool is_ia64();
 bool is_powerpc();
 bool is_superh();
 
-using i32 = std::int32_t;
+
-using i64 = std::int64_t;
-using u8 = std::uint8_t;
-using u16 = std::uint16_t;
-using u32 = std::uint32_t;
-using u64 = std::uint64_t;
-using usize = std::size_t;
-using f64 = double;
 
 const u32 STACK_DEPTH = 4096;
 
@@ -50,4 +54,6 @@ i32 utf8_hdchk(const char);
 std::string chrhex(const char);
 std::string rawstr(const std::string&, const usize maxlen=0);
 
-#include "nasal_gc.h"
+}
+
+#include "nasal_gc.h"

src/nasal_builtin.cpp

@@ -1,6 +1,8 @@
 #include "nasal_builtin.h"
 #include <chrono>
 
+namespace nasal {
+
 var builtin_print(var* local, gc& ngc) {
     for(auto& i : local[1].vec().elems) {
         std::cout << i;
@@ -654,4 +656,6 @@ nasal_builtin_table builtin[] = {
     {"__logtime", builtin_logtime},
     {"__ghosttype", builtin_ghosttype},
     {nullptr, nullptr}
-};
+};
+
+}

src/nasal_builtin.h

@@ -22,6 +22,8 @@
 #define environ (*_NSGetEnviron())
 #endif
 
+namespace nasal {
+
 var builtin_print(var*, gc&);
 var builtin_println(var*, gc&);
 var builtin_exit(var*, gc&);
@@ -75,3 +77,5 @@ struct nasal_builtin_table {
 };
 
 extern nasal_builtin_table builtin[];
+
+}

src/nasal_err.cpp

@@ -75,10 +75,12 @@ std::ostream& reset(std::ostream& s) {
 void flstream::load(const std::string& f) {
     if (file==f) { // don't need to load a loaded file
         return;
-    } else {
-        file = f;
     }
+    
+    // update file name
+    file = f;
 
+    // REPL: load from memory
     if (repl::info::instance()->in_repl_mode &&
         repl::info::instance()->repl_file_name==file) {
         const auto& source = repl::info::instance()->repl_file_source;
@@ -134,7 +136,7 @@ void error::err(
     const usize maxlen = std::to_string(loc.end_line).length();
     const std::string iden = identation(maxlen);
 
-    for(u32 line=loc.begin_line; line<=loc.end_line; ++line) {
+    for(u32 line = loc.begin_line; line<=loc.end_line; ++line) {
         if (!line) {
             continue;
         }
@@ -160,7 +162,7 @@ void error::err(
             for(u32 i = 0; i<loc.begin_column; ++i) {
                 std::cerr << char(" \t"[code[i]=='\t']);
             }
-            for(u32 i = loc.begin_column ;i<loc.end_column; ++i) {
+            for(u32 i = loc.begin_column; i<loc.end_column; ++i) {
                 std::cerr << red << (code[i]=='\t'? "^^^^":"^") << reset;
             }
         } else if (line==loc.begin_line) {

src/nasal_gc.cpp

@@ -1,5 +1,7 @@
 #include "nasal_gc.h"
 
+namespace nasal {
+
 var nas_vec::get_val(const i32 n) {
     i32 size = elems.size();
     if (n<-size || n>=size) {
@@ -716,4 +718,6 @@ void gc::ctxreserve() {
 var nas_err(const std::string& error_function_name, const std::string& info) {
     std::cerr << "[vm] " << error_function_name << ": " << info << "\n";
     return var::none();
-}
+}
+
+}

src/nasal_gc.h

@@ -32,6 +32,8 @@
 
 #include "nasal.h"
 
+namespace nasal {
+
 enum vm_type:u8 {
     /* none-gc object */
     vm_none = 0,
@@ -388,3 +390,5 @@ struct module_func_info {
 
 // module function "get" type
 typedef module_func_info* (*get_func_ptr)();
+
+}

src/nasal_misc.cpp

@@ -1,5 +1,7 @@
 #include "nasal.h"
 
+namespace nasal {
+
 bool is_windows() {
 #if defined(_WIN32) || defined(_WIN64)
     return true;
@@ -227,4 +229,6 @@ std::string rawstr(const std::string& str, const usize maxlen) {
         ret = ret.substr(0,maxlen)+"...";
     }
     return ret;
-}
+}
+
+}

src/nasal_opcode.cpp

@@ -1,5 +1,7 @@
 #include "nasal_opcode.h"
 
+namespace nasal {
+
 const char* opname[] = {
     "exit  ", "intg  ", "intl  ", "loadg ",
     "loadl ", "loadu ", "pnum  ", "pnil  ",
@@ -115,4 +117,6 @@ void codestream::dump(std::ostream& out) const {
 std::ostream& operator<<(std::ostream& out, const codestream& ins) {
     ins.dump(out);
     return out;
+}
+
 }

src/nasal_opcode.h

@@ -5,6 +5,8 @@
 
 #include <iostream>
 
+namespace nasal {
+
 enum op_code_type:u8 {
     op_exit,   // stop the virtual machine
     op_intg,   // init global scope
@@ -126,4 +128,6 @@ public:
 
 std::ostream& operator<<(std::ostream&, const codestream&);
 
-extern const char* opname[];
+extern const char* opname[];
+
+}

src/unix_lib.cpp

@@ -1,5 +1,7 @@
 #include "unix_lib.h"
 
+namespace nasal {
+
 const auto dir_type_name = "dir";
 
 void dir_entry_destructor(void* ptr) {
@@ -148,4 +150,6 @@ nasal_builtin_table unix_lib_native[] = {
     {"__getcwd", builtin_getcwd},
     {"__getenv", builtin_getenv},
     {nullptr, nullptr}
-};
+};
+
+}

src/unix_lib.h

@@ -20,6 +20,8 @@
 #include <sys/wait.h>
 #endif
 
+namespace nasal {
+
 void dir_entry_destructor(void*);
 
 var builtin_pipe(var*, gc&);
@@ -33,4 +35,6 @@ var builtin_environ(var*, gc&);
 var builtin_getcwd(var*, gc&);
 var builtin_getenv(var*, gc&);
 
-extern nasal_builtin_table unix_lib_native[];
+extern nasal_builtin_table unix_lib_native[];
+
+}