diff --git a/README.md b/README.md
index d8b7a06..740163d 100644
--- a/README.md
+++ b/README.md
@@ -71,7 +71,9 @@ __CAUTION__: If want to use the release zip/tar.gz file to build the interpreter
 
 Make sure your MinGW thread model is `posix thread model`, otherwise it may not have the thread library.
 
-> mingw32-make nasal.exe
+> mkdir build
+>
+> mingw32-make nasal.exe -j4
 
 ### __`Windows (Visual Studio)`__
 
@@ -79,16 +81,14 @@ This project gives a [__CMakelists.txt__](./CMakeLists.txt) for you to create pr
 
 ### __`Linux/macOS/Unix`__
 
-> make nasal
+> mkdir build
+>
+> make -j4
 
 You could choose which compiler you want to use:
 
 > make nasal CXX=...
 
-If you think `-O3` isn't that safe and stable, you could choose:
-
-> make stable-release
-
 ## __How to Use__
 
 ![usage](./doc/gif/help.gif)
diff --git a/doc/README_zh.md b/doc/README_zh.md
index 7c02eb2..a721005 100644
--- a/doc/README_zh.md
+++ b/doc/README_zh.md
@@ -62,7 +62,9 @@ __注意__: 如果你想直接下载发行版提供的zip/tar.gz压缩包来构
 
 一定要确保您的 MinGW thread model 是 `posix thread model`, 否则可能存在没有 thread 库的问题。
 
-> mingw32-make nasal.exe
+> mkdir build
+>
+> mingw32-make nasal.exe -j4
 
 ### __`Windows` 平台(`Vistual Studio`)__
 
@@ -70,16 +72,14 @@ __注意__: 如果你想直接下载发行版提供的zip/tar.gz压缩包来构
 
 ### __`Linux/macOS/Unix` 平台__
 
-> make nasal
+> mkdir build
+>
+> make -j4
 
 你也可以通过如下的其中一行命令来指定你想要使用的编译器：
 
 > make nasal CXX=...
 
-如果你觉得`-O3`编译的版本不是那么安全和稳定，你也可以选择生成稳定的版本：
-
-> make stable-release
-
 ## __使用方法__
 
 ![usage](../doc/gif/help.gif)
diff --git a/makefile b/makefile
index 6aeac4a..0fbaaad 100644
--- a/makefile
+++ b/makefile
@@ -1,81 +1,84 @@
 STD=c++17
 
 NASAL_OBJECT=\
-	nasal_err.o\
-	nasal_ast.o\
-	ast_visitor.o\
-	ast_dumper.o\
-	nasal_lexer.o\
-	nasal_parse.o\
-	nasal_import.o\
-	optimizer.o\
-	nasal_opcode.o\
-	symbol_finder.o\
-	nasal_codegen.o\
-	nasal_misc.o\
-	nasal_gc.o\
-	nasal_builtin.o\
-	nasal_vm.o\
-	nasal_dbg.o\
-	main.o
+	build/nasal_err.o\
+	build/nasal_ast.o\
+	build/ast_visitor.o\
+	build/ast_dumper.o\
+	build/nasal_lexer.o\
+	build/nasal_parse.o\
+	build/nasal_import.o\
+	build/optimizer.o\
+	build/nasal_opcode.o\
+	build/symbol_finder.o\
+	build/nasal_codegen.o\
+	build/nasal_misc.o\
+	build/nasal_gc.o\
+	build/nasal_builtin.o\
+	build/nasal_vm.o\
+	build/nasal_dbg.o\
+	build/main.o
 
 # for test
-nasal: $(NASAL_OBJECT)
+nasal: $(NASAL_OBJECT) | build
 	$(CXX) $(NASAL_OBJECT) -O3 -o nasal -ldl
 
-nasal.exe: $(NASAL_OBJECT)
+nasal.exe: $(NASAL_OBJECT) | build
 	$(CXX) $(NASAL_OBJECT) -O3 -o nasal.exe
 
-main.o: src/main.cpp
-	$(CXX) -std=$(STD) -c -O3 src/main.cpp -fno-exceptions -fPIC -o main.o -I .
+build:
+	@ if [ ! -d build ]; then mkdir build; fi
 
-nasal_misc.o: src/nasal.h src/nasal_misc.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_misc.cpp -fno-exceptions -fPIC -o nasal_misc.o -I .
+build/main.o: src/nasal.h src/nasal_err.h src/nasal_lexer.h src/main.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/main.cpp -fno-exceptions -fPIC -o build/main.o -I .
 
-nasal_err.o: src/nasal_err.h src/nasal_err.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_err.cpp -fno-exceptions -fPIC -o nasal_err.o -I .
+build/nasal_misc.o: src/nasal.h src/nasal_misc.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_misc.cpp -fno-exceptions -fPIC -o build/nasal_misc.o -I .
 
-nasal_gc.o: src/nasal_gc.h src/nasal_gc.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_gc.cpp -fno-exceptions -fPIC -o nasal_gc.o -I . 
+build/nasal_err.o: src/nasal_err.h src/nasal_err.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_err.cpp -fno-exceptions -fPIC -o build/nasal_err.o -I .
 
-nasal_import.o: src/nasal_import.h src/nasal_import.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_import.cpp -fno-exceptions -fPIC -o nasal_import.o -I .
+build/nasal_gc.o: src/nasal_gc.h src/nasal_gc.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_gc.cpp -fno-exceptions -fPIC -o build/nasal_gc.o -I . 
 
-nasal_lexer.o: src/nasal_lexer.h src/nasal_lexer.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_lexer.cpp -fno-exceptions -fPIC -o nasal_lexer.o -I .
+build/nasal_import.o: src/nasal_import.h src/nasal_import.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_import.cpp -fno-exceptions -fPIC -o build/nasal_import.o -I .
 
-nasal_ast.o: src/nasal_ast.h src/nasal_ast.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_ast.cpp -fno-exceptions -fPIC -o nasal_ast.o -I .
+build/nasal_lexer.o: src/nasal_lexer.h src/nasal_lexer.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_lexer.cpp -fno-exceptions -fPIC -o build/nasal_lexer.o -I .
 
-nasal_builtin.o: src/nasal_builtin.h src/nasal_builtin.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_builtin.cpp -fno-exceptions -fPIC -o nasal_builtin.o -I .
+build/nasal_ast.o: src/nasal_ast.h src/nasal_ast.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_ast.cpp -fno-exceptions -fPIC -o build/nasal_ast.o -I .
 
-nasal_codegen.o: src/nasal_codegen.h src/nasal_codegen.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_codegen.cpp -fno-exceptions -fPIC -o nasal_codegen.o -I .
+build/nasal_builtin.o: src/nasal_builtin.h src/nasal_builtin.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_builtin.cpp -fno-exceptions -fPIC -o build/nasal_builtin.o -I .
 
-nasal_opcode.o: src/nasal_opcode.h src/nasal_opcode.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_opcode.cpp -fno-exceptions -fPIC -o nasal_opcode.o -I .
+build/nasal_codegen.o: src/nasal_codegen.h src/nasal_codegen.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_codegen.cpp -fno-exceptions -fPIC -o build/nasal_codegen.o -I .
 
-nasal_parse.o: src/nasal_parse.h src/nasal_parse.cpp src/nasal_ast.h
-	$(CXX) -std=$(STD) -c -O3 src/nasal_parse.cpp -fno-exceptions -fPIC -o nasal_parse.o -I .
+build/nasal_opcode.o: src/nasal_opcode.h src/nasal_opcode.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_opcode.cpp -fno-exceptions -fPIC -o build/nasal_opcode.o -I .
 
-optimizer.o: src/optimizer.h src/optimizer.cpp src/nasal_ast.h
-	$(CXX) -std=$(STD) -c -O3 src/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
+build/nasal_parse.o: src/nasal_parse.h src/nasal_parse.cpp src/nasal_ast.h | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_parse.cpp -fno-exceptions -fPIC -o build/nasal_parse.o -I .
 
-symbol_finder.o: src/symbol_finder.h src/symbol_finder.cpp src/nasal_ast.h
-	$(CXX) -std=$(STD) -c -O3 src/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
+build/optimizer.o: src/optimizer.h src/optimizer.cpp src/nasal_ast.h | build
+	$(CXX) -std=$(STD) -c -O3 src/optimizer.cpp -fno-exceptions -fPIC -o build/optimizer.o -I .
 
-ast_visitor.o: src/nasal_ast.h src/ast_visitor.h src/ast_visitor.cpp
-	$(CXX) -std=$(STD) -c -O3 src/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
+build/symbol_finder.o: src/symbol_finder.h src/symbol_finder.cpp src/nasal_ast.h | build
+	$(CXX) -std=$(STD) -c -O3 src/symbol_finder.cpp -fno-exceptions -fPIC -o build/symbol_finder.o -I .
 
-ast_dumper.o: src/nasal_ast.h src/ast_visitor.h src/ast_dumper.h src/ast_dumper.cpp
-	$(CXX) -std=$(STD) -c -O3 src/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
+build/ast_visitor.o: src/nasal_ast.h src/ast_visitor.h src/ast_visitor.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/ast_visitor.cpp -fno-exceptions -fPIC -o build/ast_visitor.o -I .
 
-nasal_vm.o: src/nasal_vm.h src/nasal_vm.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_vm.cpp -fno-exceptions -fPIC -o nasal_vm.o -I .
+build/ast_dumper.o: src/nasal_ast.h src/ast_visitor.h src/ast_dumper.h src/ast_dumper.cpp
+	$(CXX) -std=$(STD) -c -O3 src/ast_dumper.cpp -fno-exceptions -fPIC -o build/ast_dumper.o -I .
 
-nasal_dbg.o: src/nasal_dbg.h src/nasal_dbg.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_dbg.cpp -fno-exceptions -fPIC -o nasal_dbg.o -I .
+build/nasal_vm.o: src/nasal_vm.h src/nasal_vm.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_vm.cpp -fno-exceptions -fPIC -o build/nasal_vm.o -I .
+
+build/nasal_dbg.o: src/nasal_dbg.h src/nasal_dbg.cpp | build
+	$(CXX) -std=$(STD) -c -O3 src/nasal_dbg.cpp -fno-exceptions -fPIC -o build/nasal_dbg.o -I .
 
 .PHONY: clean
 clean:
diff --git a/module/makefile b/module/makefile
index 4e635b0..1e28906 100644
--- a/module/makefile
+++ b/module/makefile
@@ -4,7 +4,7 @@ dynamic_libs_so = libfib.so libkey.so libnasock.so libmat.so
 dynamic_libs_dll = libfib.dll libkey.dll libnasock.dll libmat.dll
 
 used_header = ../src/nasal.h ../src/nasal_gc.h
-used_object = ../nasal_misc.o ../nasal_gc.o
+used_object = ../build/nasal_misc.o ../build/nasal_gc.o
 
 STD=c++17
 
diff --git a/src/main.cpp b/src/main.cpp
index 3fddb4e..7d9b8fa 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -135,7 +135,7 @@ void execute(
     }
 
     // run
-    auto start=clk::now();
+    auto start = clk::now();
     if (cmd&VM_DEBUG) {
         dbg(err).run(gen, ld, argv);
     } else if (cmd&VM_TIME || cmd&VM_EXEC) {
@@ -144,7 +144,7 @@ void execute(
 
     // get running time
     if (cmd&VM_TIME) {
-        f64 tm=(clk::now()-start).count()*1.0/den;
+        f64 tm = (clk::now()-start).count()*1.0/den;
         std::clog << "process exited after " << tm << "s.\n\n";
     }
 }
diff --git a/src/nasal_ast.h b/src/nasal_ast.h
index 35d03da..b7c0ca8 100644
--- a/src/nasal_ast.h
+++ b/src/nasal_ast.h
@@ -7,7 +7,7 @@
 #include <unordered_map>
 
 enum class expr_type:u32 {
-    ast_null=0,      // null node
+    ast_null = 0,    // null node
     ast_file_info,   // stores file info
     ast_block,       // code block 
     ast_nil,         // nil keyword
@@ -25,9 +25,9 @@ enum class expr_type:u32 {
     ast_callf,       // id()
     ast_subvec,      // id[index:index]
     ast_param,       // function parameter
-    ast_ternary,
-    ast_binary,
-    ast_unary,
+    ast_ternary,     // ternary operator
+    ast_binary,      // binary operator
+    ast_unary,       // unary operator
     ast_for,         // for keyword
     ast_forei,       // foreach or forindex loop
     ast_while,       // while
@@ -35,10 +35,10 @@ enum class expr_type:u32 {
     ast_cond,        // mark a sub-tree of conditional expression
     ast_if,          // if keyword
     ast_multi_id,    // multi identifiers sub-tree
-    ast_tuple,
+    ast_tuple,       // tuple, stores multiple scalars
     ast_def,         // definition
-    ast_assign,
-    ast_multi_assign,
+    ast_assign,      // assignment
+    ast_multi_assign,// multiple assignment
     ast_continue,    // continue keyword, only used in loop
     ast_break,       // break keyword, only used in loop
     ast_ret          // return keyword, only used in function block
diff --git a/src/nasal_builtin.cpp b/src/nasal_builtin.cpp
index 93eb303..3f0326f 100644
--- a/src/nasal_builtin.cpp
+++ b/src/nasal_builtin.cpp
@@ -1,18 +1,18 @@
 #include "nasal_builtin.h"
 
 var builtin_print(var* local, gc& ngc) {
-    for(auto& i:local[1].vec().elems) {
-        std::cout<<i;
+    for(auto& i : local[1].vec().elems) {
+        std::cout << i;
     }
-    std::cout<<std::flush;
+    std::cout << std::flush;
     return nil;
 }
 
 var builtin_println(var* local, gc& ngc) {
-    for(auto& i:local[1].vec().elems) {
-        std::cout<<i;
+    for(auto& i : local[1].vec().elems) {
+        std::cout << i;
     }
-    std::cout<<std::endl;
+    std::cout << std::endl;
     return nil;
 }
 
@@ -27,21 +27,21 @@ var builtin_abort(var* local, gc& ngc) {
 }
 
 var builtin_append(var* local, gc& ngc) {
-    var vec=local[1];
-    var elem=local[2];
+    var vec = local[1];
+    var elem = local[2];
     if (vec.type!=vm_vec) {
         return nas_err("append", "\"vec\" must be vector");
     }
-    auto& v=vec.vec().elems;
-    for(auto& i:elem.vec().elems) {
+    auto& v = vec.vec().elems;
+    for(auto& i : elem.vec().elems) {
         v.push_back(i);
     }
     return nil;
 }
 
 var builtin_setsize(var* local, gc& ngc) {
-    var vec=local[1];
-    var size=local[2];
+    var vec = local[1];
+    var size = local[2];
     if (vec.type!=vm_vec) {
         return nas_err("setsize", "\"vec\" must be vector");
     }
@@ -53,7 +53,7 @@ var builtin_setsize(var* local, gc& ngc) {
 }
 
 var builtin_system(var* local, gc& ngc) {
-    var str=local[1];
+    var str = local[1];
     if (str.type!=vm_str) {
         return var::num(-1);
     }
@@ -61,10 +61,10 @@ var builtin_system(var* local, gc& ngc) {
 }
 
 var builtin_input(var* local, gc& ngc) {
-    var end=local[1];
-    var ret=ngc.alloc(vm_str);
+    var end = local[1];
+    var ret = ngc.alloc(vm_str);
     if (end.type!=vm_str || end.str().length()>1 || !end.str().length()) {
-        std::cin>>ret.str();
+        std::cin >> ret.str();
     } else {
         std::getline(std::cin, ret.str(), end.str()[0]);
     }
@@ -72,21 +72,21 @@ var builtin_input(var* local, gc& ngc) {
 }
 
 var builtin_readfile(var* local, gc& ngc) {
-    var val=local[1];
+    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();
+        rd << in.rdbuf();
     }
     return ngc.newstr(rd.str());
 }
 
 var builtin_fout(var* local, gc& ngc) {
-    var val=local[1];
-    var str=local[2];
+    var val = local[1];
+    var str = local[2];
     if (val.type!=vm_str) {
         return nas_err("io::fout", "\"filename\" must be string");
     }
@@ -94,51 +94,51 @@ var builtin_fout(var* local, gc& ngc) {
     if (out.fail()) {
         return nas_err("io::fout", "cannot open <"+val.str()+">");
     }
-    out<<str;
+    out << str;
     return nil;
 }
 
 var builtin_split(var* local, gc& ngc) {
-    var delimeter=local[1];
-    var str=local[2];
+    var delimeter = local[1];
+    var str = local[2];
     if (delimeter.type!=vm_str) {
         return nas_err("split", "\"separator\" must be string");
     }
     if (str.type!=vm_str) {
         return nas_err("split", "\"str\" must be string");
     }
-    const std::string& deli=delimeter.str();
-    const std::string& s=str.str();
+    const auto& deli = delimeter.str();
+    const auto& s = str.str();
 
     // avoid being sweeped
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
+    var res = ngc.temp = ngc.alloc(vm_vec);
+    auto& vec = res.vec().elems;
 
     if (!deli.length()) {
-        for(auto i:s) {
+        for(auto i : s) {
             vec.push_back(ngc.newstr(i));
         }
-        ngc.temp=nil;
+        ngc.temp = nil;
         return res;
     }
-    usize last=0;
-    usize pos=s.find(deli, 0);
+    usize last = 0;
+    usize pos = s.find(deli, 0);
     while(pos!=std::string::npos) {
         if (pos>last) {
             vec.push_back(ngc.newstr(s.substr(last, pos-last)));
         }
-        last=pos+deli.length();
-        pos=s.find(deli, last);
+        last = pos+deli.length();
+        pos = s.find(deli, last);
     }
     if (last!=s.length()) {
         vec.push_back(ngc.newstr(s.substr(last)));
     }
-    ngc.temp=nil;
+    ngc.temp = nil;
     return res;
 }
 
 var builtin_rand(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     if (val.type!=vm_num && val.type!=vm_nil) {
         return nas_err("rand", "\"seed\" must be nil or number");
     }
@@ -146,25 +146,25 @@ var builtin_rand(var* local, gc& ngc) {
         srand((u32)val.num());
         return nil;
     }
-    f64 num=0;
-    for(u32 i=0;i<5;++i) {
-        num=(num+rand())*(1.0/(RAND_MAX+1.0));
+    f64 num = 0;
+    for(u32 i = 0; i<5; ++i) {
+        num = (num+rand())*(1.0/(RAND_MAX+1.0));
     }
     return var::num(num);
 }
 
 var builtin_id(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     std::stringstream ss;
-    ss<<"0";
+    ss << "0";
     if (val.type>vm_num) {
-        ss<<"x"<<std::hex<<(u64)val.val.gcobj<<std::dec;
+        ss << "x" << std::hex << (u64)val.val.gcobj << std::dec;
     }
     return ngc.newstr(ss.str());
 }
 
 var builtin_int(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     if (val.type!=vm_num && val.type!=vm_str) {
         return nil;
     }
@@ -172,19 +172,19 @@ var builtin_int(var* local, gc& ngc) {
 }
 
 var builtin_floor(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(std::floor(val.num()));
 }
 
 var builtin_num(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     if (val.type==vm_num) {
         return val;
     }
     if (val.type!=vm_str) {
         return nil;
     }
-    f64 res=val.tonum();
+    f64 res = val.tonum();
     if (std::isnan(res)) {
         return nil;
     }
@@ -192,13 +192,13 @@ var builtin_num(var* local, gc& ngc) {
 }
 
 var builtin_pop(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     if (val.type!=vm_vec) {
         return nas_err("pop", "\"vec\" must be vector");
     }
-    auto& vec=val.vec().elems;
+    auto& vec = val.vec().elems;
     if (vec.size()) {
-        var tmp=vec.back();
+        var tmp = vec.back();
         vec.pop_back();
         return tmp;
     }
@@ -210,13 +210,14 @@ var builtin_str(var* local, gc& ngc) {
 }
 
 var builtin_size(var* local, gc& ngc) {
-    var val=local[1];
-    f64 num=0;
+    var val = local[1];
+    f64 num = 0;
     switch(val.type) {
-        case vm_num:  num=val.num();         break;
-        case vm_str:  num=val.str().length();break;
-        case vm_vec:  num=val.vec().size();  break;
-        case vm_hash: num=val.hash().size(); break;
+        case vm_num:  num = val.num(); break;
+        case vm_str:  num = val.str().length(); break;
+        case vm_vec:  num = val.vec().size(); break;
+        case vm_hash: num = val.hash().size(); break;
+        case vm_map:  num = val.map().mapper.size(); break;
     }
     return var::num(num);
 }
@@ -242,8 +243,8 @@ var builtin_u32not(var* local, gc& ngc) {
 }
 
 var builtin_pow(var* local, gc& ngc) {
-    var x=local[1];
-    var y=local[2];
+    var x = local[1];
+    var y = local[2];
     if (x.type!=vm_num || y.type!=vm_num) {
         return var::num(std::nan(""));
     }
@@ -251,43 +252,43 @@ var builtin_pow(var* local, gc& ngc) {
 }
 
 var builtin_sin(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?sin(val.num()):std::nan(""));
 }
 
 var builtin_cos(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?cos(val.num()):std::nan(""));
 }
 
 var builtin_tan(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?tan(val.num()):std::nan(""));
 }
 
 var builtin_exp(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?exp(val.num()):std::nan(""));
 }
 
 var builtin_lg(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?log(val.num())/log(10.0):std::nan(""));
 }
 
 var builtin_ln(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?log(val.num()):std::nan(""));
 }
 
 var builtin_sqrt(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     return var::num(val.type==vm_num?sqrt(val.num()):std::nan(""));
 }
 
 var builtin_atan2(var* local, gc& ngc) {
-    var x=local[1];
-    var y=local[2];
+    var x = local[1];
+    var y = local[2];
     if (x.type!=vm_num || y.type!=vm_num) {
         return var::num(std::nan(""));
     }
@@ -295,31 +296,31 @@ var builtin_atan2(var* local, gc& ngc) {
 }
 
 var builtin_isnan(var* local, gc& ngc) {
-    var x=local[1];
+    var x = local[1];
     return (x.type==vm_num && std::isnan(x.num()))?one:zero;
 }
 
 var builtin_time(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     if (val.type!=vm_num) {
         return nas_err("time", "\"begin\" must be number");
     }
-    time_t begin=(time_t)val.num();
+    time_t begin = (time_t)val.num();
     return var::num((f64)time(&begin));
 }
 
 var builtin_contains(var* local, gc& ngc) {
-    var hash=local[1];
-    var key=local[2];
+    var hash = local[1];
+    var key = local[2];
     if (hash.type!=vm_hash || key.type!=vm_str) {
         return zero;
     }
-    return hash.hash().elems.count(key.str())?one:zero;
+    return hash.hash().elems.count(key.str())? one:zero;
 }
 
 var builtin_delete(var* local, gc& ngc) {
-    var hash=local[1];
-    var key=local[2];
+    var hash = local[1];
+    var key = local[2];
     if (hash.type!=vm_hash) {
         return nas_err("delete", "\"hash\" must be hash");
     }
@@ -333,13 +334,13 @@ var builtin_delete(var* local, gc& ngc) {
 }
 
 var builtin_keys(var* local, gc& ngc) {
-    var hash=local[1];
+    var hash = local[1];
     if (hash.type!=vm_hash && hash.type!=vm_map) {
         return nas_err("keys", "\"hash\" must be hash");
     }
     // avoid being sweeped
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
+    var res = ngc.temp = ngc.alloc(vm_vec);
+    auto& vec = res.vec().elems;
     if (hash.type==vm_hash) {
         for(const auto& iter : hash.hash().elems) {
             vec.push_back(ngc.newstr(iter.first));
@@ -358,9 +359,9 @@ var builtin_die(var* local, gc& ngc) {
 }
 
 var builtin_find(var* local, gc& ngc) {
-    var needle=local[1];
-    var haystack=local[2];
-    usize pos=haystack.tostr().find(needle.tostr());
+    var needle = local[1];
+    var haystack = local[2];
+    usize pos = haystack.tostr().find(needle.tostr());
     if (pos==std::string::npos) {
         return var::num((f64)-1);
     }
@@ -384,9 +385,9 @@ var builtin_type(var* local, gc& ngc) {
 }
 
 var builtin_substr(var* local, gc& ngc) {
-    var str=local[1];
-    var beg=local[2];
-    var len=local[3];
+    var str = local[1];
+    var beg = local[2];
+    var len = local[3];
     if (str.type!=vm_str) {
         return nas_err("substr", "\"str\" must be string");
     }
@@ -396,8 +397,8 @@ var builtin_substr(var* local, gc& ngc) {
     if (len.type!=vm_num || len.num()<0) {
         return nas_err("substr", "\"length\" should be number >= 0");
     }
-    usize begin=(usize)beg.num();
-    usize length=(usize)len.num();
+    usize begin = (usize)beg.num();
+    usize length = (usize)len.num();
     if (begin>=str.str().length()) {
         return nas_err("susbtr", "begin index out of range: "+std::to_string(begin));
     }
@@ -405,14 +406,14 @@ var builtin_substr(var* local, gc& ngc) {
 }
 
 var builtin_streq(var* local, gc& ngc) {
-    var a=local[1];
-    var b=local[2];
-    return var::num(f64((a.type!=vm_str || b.type!=vm_str)?0:(a.str()==b.str())));
+    var a = local[1];
+    var b = local[2];
+    return var::num(f64((a.type!=vm_str || b.type!=vm_str)? 0:(a.str()==b.str())));
 }
 
 var builtin_left(var* local, gc& ngc) {
-    var str=local[1];
-    var len=local[2];
+    var str = local[1];
+    var len = local[2];
     if (str.type!=vm_str) {
         return nas_err("left", "\"string\" must be string");
     }
@@ -422,32 +423,32 @@ var builtin_left(var* local, gc& ngc) {
     if (len.num()<0) {
         return ngc.newstr("");
     }
-    return ngc.newstr(str.str().substr(0,len.num()));
+    return ngc.newstr(str.str().substr(0, len.num()));
 }
 
 var builtin_right(var* local, gc& ngc) {
-    var str=local[1];
-    var len=local[2];
+    var str = local[1];
+    var len = local[2];
     if (str.type!=vm_str) {
         return nas_err("right", "\"string\" must be string");
     }
     if (len.type!=vm_num) {
         return nas_err("right", "\"length\" must be number");
     }
-    i32 length=(i32)len.num();
-    i32 srclen=str.str().length();
+    i32 length = (i32)len.num();
+    i32 srclen = str.str().length();
     if (length>srclen) {
-        length=srclen;
+        length = srclen;
     }
     if (length<0) {
-        length=0;
+        length = 0;
     }
     return ngc.newstr(str.str().substr(srclen-length, srclen));
 }
 
 var builtin_cmp(var* local, gc& ngc) {
-    var a=local[1];
-    var b=local[2];
+    var a = local[1];
+    var b = local[2];
     if (a.type!=vm_str || b.type!=vm_str) {
         return nas_err("cmp", "\"a\" and \"b\" must be string");
     }
@@ -455,7 +456,7 @@ var builtin_cmp(var* local, gc& ngc) {
 }
 
 var builtin_chr(var* local, gc& ngc) {
-    const char* extend[]={
+    const char* extend[] = {
         "€"," ","‚","ƒ","„","…","†","‡",
         "ˆ","‰","Š","‹","Œ"," ","Ž"," ",
         " ","‘","’","“","”","•","–","—",
@@ -473,7 +474,7 @@ var builtin_chr(var* local, gc& ngc) {
         "ð","ñ","ò","ó","ô","õ","ö","÷",
         "ø","ù","ú","û","ü","ý","þ","ÿ"
     };
-    i32 num=local[1].num();
+    i32 num = local[1].num();
     if (0<=num && num<128) {
         return ngc.newstr((char)num);
     } else if (128<=num && num<256) {
@@ -487,13 +488,13 @@ var builtin_char(var* local, gc& ngc) {
 }
 
 var builtin_values(var* local, gc& ngc) {
-    var hash=local[1];
+    var hash = local[1];
     if (hash.type!=vm_hash) {
         return nas_err("values", "\"hash\" must be hash");
     }
-    var vec=ngc.alloc(vm_vec);
-    auto& v=vec.vec().elems;
-    for(auto& i:hash.hash().elems) {
+    var vec = ngc.alloc(vm_vec);
+    auto& v = vec.vec().elems;
+    for(auto& i : hash.hash().elems) {
         v.push_back(i.second);
     }
     return vec;
@@ -507,25 +508,25 @@ var builtin_exists(var* local, gc& ngc) {
 }
 
 var builtin_open(var* local, gc& ngc) {
-    var name=local[1];
-    var mode=local[2];
+    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());
+    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);
+    var ret = ngc.alloc(vm_obj);
     ret.obj().set(ngc.global_ghost_type_table.ghost_file, res, &ngc.global_ghost_type_table);
     return ret;
 }
 
 var builtin_close(var* local, gc& ngc) {
-    var fd=local[1];
+    var fd = local[1];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("close", "not a valid filehandle");
     }
@@ -534,9 +535,9 @@ var builtin_close(var* local, gc& ngc) {
 }
 
 var builtin_read(var* local, gc& ngc) {
-    var fd=local[1];
-    var buf=local[2];
-    var len=local[3];
+    var fd = local[1];
+    var buf = local[2];
+    var len = local[3];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("read", "not a valid filehandle");
     }
@@ -549,20 +550,20 @@ var builtin_read(var* local, gc& ngc) {
     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];
+    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;
+    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];
+    var fd = local[1];
+    var str = local[2];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("write", "not a valid filehandle");
     }
@@ -573,9 +574,9 @@ var builtin_write(var* local, gc& ngc) {
 }
 
 var builtin_seek(var* local, gc& ngc) {
-    var fd=local[1];
-    var pos=local[2];
-    var whence=local[3];
+    var fd = local[1];
+    var pos = local[2];
+    var whence = local[3];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("seek", "not a valid filehandle");
     }
@@ -583,7 +584,7 @@ var builtin_seek(var* local, gc& ngc) {
 }
 
 var builtin_tell(var* local, gc& ngc) {
-    var fd=local[1];
+    var fd = local[1];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("tell", "not a valid filehandle");
     }
@@ -591,20 +592,20 @@ var builtin_tell(var* local, gc& ngc) {
 }
 
 var builtin_readln(var* local, gc& ngc) {
-    var fd=local[1];
+    var fd = local[1];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("readln", "not a valid filehandle");
     }
-    var str=ngc.alloc(vm_str);
+    var str = ngc.alloc(vm_str);
     char c;
-    while((c=fgetc((FILE*)fd.obj().ptr))!=EOF) {
+    while((c = fgetc((FILE*)fd.obj().ptr))!=EOF) {
         if (c=='\r') {
             continue;
         }
         if (c=='\n') {
             return str;
         }
-        str.str()+=c;
+        str.str() += c;
     }
     if (str.str().length()) {
         return str;
@@ -613,7 +614,7 @@ var builtin_readln(var* local, gc& ngc) {
 }
 
 var builtin_stat(var* local, gc& ngc) {
-    var name=local[1];
+    var name = local[1];
     if (name.type!=vm_str) {
         return nas_err("stat", "\"filename\" must be string");
     }
@@ -621,8 +622,8 @@ var builtin_stat(var* local, gc& ngc) {
     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 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),
@@ -639,7 +640,7 @@ var builtin_stat(var* local, gc& ngc) {
 }
 
 var builtin_eof(var* local, gc& ngc) {
-    var fd=local[1];
+    var fd = local[1];
     if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
         return nas_err("readln", "not a valid filehandle");
     }
@@ -650,25 +651,25 @@ var builtin_fld(var* local, gc& ngc) {
     // bits.fld(s,0,3);
     // if s stores 10100010(162)
     // will get 101(5)
-    var str=local[1];
-    var startbit=local[2];
-    var length=local[3];
+    var str = local[1];
+    var startbit = local[2];
+    var length = local[3];
     if (str.type!=vm_str || str.val.gcobj->unmut) {
         return nas_err("fld", "\"str\" must be mutable string");
     }
     if (startbit.type!=vm_num || length.type!=vm_num) {
         return nas_err("fld", "\"startbit\",\"len\" must be number");
     }
-    u32 bit=(u32)startbit.num();
-    u32 len=(u32)length.num();
+    u32 bit = (u32)startbit.num();
+    u32 len = (u32)length.num();
     if (bit+len>8*str.str().length()) {
         return nas_err("fld", "bitfield out of bounds");
     }
-    u32 res=0;
-    auto& s=str.str();
-    for(u32 i=bit;i<bit+len;++i) {
+    u32 res = 0;
+    auto& s = str.str();
+    for(u32 i = bit; i<bit+len; ++i) {
         if (s[i>>3]&(1<<(7-(i&7)))) {
-            res|=1<<(bit+len-i-1);
+            res |= 1<<(bit+len-i-1);
         }
     }
     return var::num((f64)res);
@@ -679,29 +680,29 @@ var builtin_sfld(var* local, gc& ngc) {
     // if s stores 10100010(162)
     // will get 101(5) then this will be signed extended to
     // 11111101(-3)
-    var str=local[1];
-    var startbit=local[2];
-    var length=local[3];
+    var str = local[1];
+    var startbit = local[2];
+    var length = local[3];
     if (str.type!=vm_str || str.val.gcobj->unmut) {
         return nas_err("sfld", "\"str\" must be mutable string");
     }
     if (startbit.type!=vm_num || length.type!=vm_num) {
         return nas_err("sfld", "\"startbit\",\"len\" must be number");
     }
-    u32 bit=(u32)startbit.num();
-    u32 len=(u32)length.num();
+    u32 bit = (u32)startbit.num();
+    u32 len = (u32)length.num();
     if (bit+len>8*str.str().length()) {
         return nas_err("sfld", "bitfield out of bounds");
     }
-    u32 res=0;
-    auto& s=str.str();
-    for(u32 i=bit;i<bit+len;++i) {
+    u32 res = 0;
+    auto& s = str.str();
+    for(u32 i = bit; i<bit+len; ++i) {
         if (s[i>>3]&(1<<(7-(i&7)))) {
-            res|=1<<(bit+len-i-1);
+            res |= 1<<(bit+len-i-1);
         }
     }
     if (res&(1<<(len-1))) {
-        res|=~((1<<len)-1);
+        res |= ~((1<<len)-1);
     }
     return var::num((f64)((i32)res));
 }
@@ -711,46 +712,46 @@ var builtin_setfld(var* local, gc& ngc) {
     // set 01000101(69) to string will get this:
     // 10100010(162)
     // so s[0]=162
-    var str=local[1];
-    var startbit=local[2];
-    var length=local[3];
-    var value=local[4];
+    var str = local[1];
+    var startbit = local[2];
+    var length = local[3];
+    var value = local[4];
     if (str.type!=vm_str || str.val.gcobj->unmut) {
         return nas_err("setfld", "\"str\" must be mutable string");
     }
     if (startbit.type!=vm_num || length.type!=vm_num || value.type!=vm_num) {
         return nas_err("setfld", "\"startbit\",\"len\",\"val\" must be number");
     }
-    u32 bit=(u32)startbit.num();
-    u32 len=(u32)length.num();
-    u64 val=(u64)value.num();
+    u32 bit = (u32)startbit.num();
+    u32 len = (u32)length.num();
+    u64 val = (u64)value.num();
     if (bit+len>8*str.str().length()) {
         return nas_err("setfld", "bitfield out of bounds");
     }
-    auto& s=str.str();
-    for(u32 i=bit;i<bit+len;++i) {
+    auto& s = str.str();
+    for(u32 i = bit; i<bit+len; ++i) {
         if (val&(1<<(i-bit))) {
-            s[i>>3]|=(1<<(7-(i&7)));
+            s[i>>3] |= (1<<(7-(i&7)));
         } else {
-            s[i>>3]&=~(1<<(7-(i&7)));
+            s[i>>3] &= ~(1<<(7-(i&7)));
         }
     }
     return nil;
 }
 
 var builtin_buf(var* local, gc& ngc) {
-    var length=local[1];
+    var length = local[1];
     if (length.type!=vm_num || length.num()<=0) {
         return nas_err("buf", "\"len\" must be number greater than 0");
     }
-    var str=ngc.alloc(vm_str);
-    auto& s=str.str();
+    var str = ngc.alloc(vm_str);
+    auto& s = str.str();
     s.resize(length.num(), '\0');
     return str;
 }
 
 var builtin_sleep(var* local, gc& ngc) {
-    var val=local[1];
+    var val = local[1];
     if (val.type!=vm_num) {
         return nil;
     }
@@ -767,7 +768,7 @@ var builtin_sleep(var* local, gc& ngc) {
 var builtin_pipe(var* local, gc& ngc) {
 #ifndef _WIN32
     i32 fd[2];
-    var res=ngc.alloc(vm_vec);
+    var res = ngc.alloc(vm_vec);
     if (pipe(fd)==-1) {
         return nas_err("pipe", "failed to create pipe");
     }
@@ -790,15 +791,15 @@ var builtin_fork(var* local, gc& ngc) {
 }
 
 var builtin_waitpid(var* local, gc& ngc) {
-    var pid=local[1];
-    var nohang=local[2];
+    var pid = local[1];
+    var nohang = local[2];
     if (pid.type!=vm_num || nohang.type!=vm_num) {
         return nas_err("waitpid", "pid and nohang must be number");
     }
 #ifndef _WIN32
     i32 ret_pid,status;
-    ret_pid=waitpid(pid.num(),&status,nohang.num()==0?0:WNOHANG);
-    var vec=ngc.alloc(vm_vec);
+    ret_pid = waitpid(pid.num(),&status,nohang.num()==0? 0:WNOHANG);
+    var vec = ngc.alloc(vm_vec);
     vec.vec().elems.push_back(var::num((f64)ret_pid));
     vec.vec().elems.push_back(var::num((f64)status));
     return vec;
@@ -807,30 +808,30 @@ var builtin_waitpid(var* local, gc& ngc) {
 }
 
 var builtin_opendir(var* local, gc& ngc) {
-    var path=local[1];
+    var path = local[1];
     if (path.type!=vm_str) {
         return nas_err("opendir", "\"path\" must be string");
     }
 #ifdef _MSC_VER
     WIN32_FIND_DATAA data;
     HANDLE p;
-    p=FindFirstFileA((path.str()+"\\*.*").c_str(),&data);
+    p = FindFirstFileA((path.str()+"\\*.*").c_str(),&data);
     if (p==INVALID_HANDLE_VALUE) {
         return nas_err("opendir", "cannot open dir <"+path.str()+">");
     }
 #else
-    DIR* p=opendir(path.str().c_str());
+    DIR* p = opendir(path.str().c_str());
     if (!p) {
         return nas_err("opendir", "cannot open dir <"+path.str()+">");
     }
 #endif
-    var ret=ngc.alloc(vm_obj);
+    var ret = ngc.alloc(vm_obj);
     ret.obj().set(ngc.global_ghost_type_table.ghost_dir, p, &ngc.global_ghost_type_table);
     return ret;
 }
 
 var builtin_readdir(var* local, gc& ngc) {
-    var handle=local[1];
+    var handle = local[1];
     if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
         return nas_err("readdir", "not a valid dir handle");
     }
@@ -841,13 +842,13 @@ var builtin_readdir(var* local, gc& ngc) {
     }
     return ngc.newstr(data.cFileName);
 #else
-    dirent* p=readdir((DIR*)handle.obj().ptr);
-    return p?ngc.newstr(p->d_name):nil;
+    dirent* p = readdir((DIR*)handle.obj().ptr);
+    return p? ngc.newstr(p->d_name):nil;
 #endif
 }
 
 var builtin_closedir(var* local, gc& ngc) {
-    var handle=local[1];
+    var handle = local[1];
     if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
         return nas_err("closedir", "not a valid dir handle");
     }
@@ -856,7 +857,7 @@ var builtin_closedir(var* local, gc& ngc) {
 }
 
 var builtin_chdir(var* local, gc& ngc) {
-    var path=local[1];
+    var path = local[1];
     if (path.type!=vm_str) {
         return var::num((f64)-1);
     }
@@ -864,83 +865,83 @@ var builtin_chdir(var* local, gc& ngc) {
 }
 
 var builtin_environ(var* local, gc& ngc) {
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
-    for(char** env=environ;*env;++env) {
+    var res = ngc.temp = ngc.alloc(vm_vec);
+    auto& vec = res.vec().elems;
+    for(char** env = environ; *env; ++env) {
         vec.push_back(ngc.newstr(*env));
     }
-    ngc.temp=nil;
+    ngc.temp = nil;
     return res;
 }
 
 var builtin_getcwd(var* local, gc& ngc) {
     char buf[1024];
-    if (!getcwd(buf,sizeof(buf))) {
+    if (!getcwd(buf, sizeof(buf))) {
         return nil;
     }
     return ngc.newstr(buf);
 }
 
 var builtin_getenv(var* local, gc& ngc) {
-    var envvar=local[1];
+    var envvar = local[1];
     if (envvar.type!=vm_str) {
         return nas_err("getenv", "\"envvar\" must be string");
     }
-    char* res=getenv(envvar.str().c_str());
-    return res?ngc.newstr(res):nil;
+    char* res = getenv(envvar.str().c_str());
+    return res? ngc.newstr(res):nil;
 }
 
 var builtin_dlopen(var* local, gc& ngc) {
-    var dlname=local[1];
+    var dlname = local[1];
     if (dlname.type!=vm_str) {
         return nas_err("dlopen", "\"libname\" must be string");
     }
 #ifdef _WIN32
-    wchar_t* str=new wchar_t[dlname.str().size()+1];
+    wchar_t* str = new wchar_t[dlname.str().size()+1];
     if (!str) {
         return nas_err("dlopen", "malloc failed");
     }
     memset(str, 0, sizeof(wchar_t)*dlname.str().size()+1);
     mbstowcs(str, dlname.str().c_str(),dlname.str().size()+1);
-    void* ptr=LoadLibraryA(dlname.str().c_str());
+    void* ptr = LoadLibraryA(dlname.str().c_str());
     delete []str;
 #else
-    void* ptr=dlopen(dlname.str().c_str(), RTLD_LOCAL|RTLD_LAZY);
+    void* ptr = dlopen(dlname.str().c_str(), RTLD_LOCAL|RTLD_LAZY);
 #endif
     if (!ptr) {
         return nas_err("dlopen", "cannot open dynamic lib <"+dlname.str()+">");
     }
-    var ret=ngc.temp=ngc.alloc(vm_hash);
-    var lib=ngc.alloc(vm_obj);
+    var ret = ngc.temp = ngc.alloc(vm_hash);
+    var lib = ngc.alloc(vm_obj);
     lib.obj().set(ngc.global_ghost_type_table.ghost_dylib, ptr, &ngc.global_ghost_type_table);
-    ret.hash().elems["lib"]=lib;
+    ret.hash().elems["lib"] = lib;
 
 #ifdef _WIN32
-    void* func=(void*)GetProcAddress((HMODULE)lib.obj().ptr, "get");
+    void* func = (void*)GetProcAddress((HMODULE)lib.obj().ptr, "get");
 #else
-    void* func=dlsym(lib.obj().ptr, "get");
+    void* func = dlsym(lib.obj().ptr, "get");
 #endif
     if (!func) {
         return nas_err("dlopen", "cannot find <get> function");
     }
     // get function pointer by name
-    module_func_info* tbl=((get_func_ptr)func)(&ngc.global_ghost_type_table);
+    module_func_info* tbl = ((get_func_ptr)func)(&ngc.global_ghost_type_table);
     if (!tbl) {
         return nas_err("dlopen", "failed to get module functions");
     }
-    for(u32 i=0;tbl[i].name;++i) {
-        void* p=(void*)tbl[i].fd;
-        var tmp=ngc.alloc(vm_obj);
+    for(u32 i = 0; tbl[i].name; ++i) {
+        void* p = (void*)tbl[i].fd;
+        var tmp = ngc.alloc(vm_obj);
         tmp.obj().set(ngc.global_ghost_type_table.ghost_faddr, p, &ngc.global_ghost_type_table);
-        ret.hash().elems[tbl[i].name]=tmp;
+        ret.hash().elems[tbl[i].name] = tmp;
     }
 
-    ngc.temp=nil;
+    ngc.temp = nil;
     return ret;
 }
 
 var builtin_dlclose(var* local, gc& ngc) {
-    var libptr=local[1];
+    var libptr = local[1];
     if (!libptr.objchk(ngc.global_ghost_type_table.ghost_dylib)) {
         return nas_err("dlclose", "\"lib\" is not a valid dynamic lib");
     }
@@ -949,33 +950,28 @@ var builtin_dlclose(var* local, gc& ngc) {
 }
 
 var builtin_dlcallv(var* local, gc& ngc) {
-    var fp=local[1];
-    var args=local[2];
+    var fp = local[1];
+    var args = local[2];
     if (!fp.objchk(ngc.global_ghost_type_table.ghost_faddr)) {
         return nas_err("dlcall", "\"ptr\" is not a valid function pointer");
     }
-    auto& vec=args.vec().elems;
-    return ((module_func)fp.obj().ptr)(
-        vec.data(),
-        vec.size(),
-        &ngc
-    );
+    auto& vec = args.vec().elems;
+    return ((module_func)fp.obj().ptr)(vec.data(), vec.size(), &ngc);
 }
 
 var builtin_dlcall(var* local, gc& ngc) {
-    var fp=local[1];
+    var fp = local[1];
     if (!fp.objchk(ngc.global_ghost_type_table.ghost_faddr)) {
         return nas_err("dlcall", "\"ptr\" is not a valid function pointer");
     }
 
-    var* local_frame_start=local+2;
-    usize local_frame_size=ngc.rctx->top-local_frame_start;
+    var* local_frame_start = local+2;
+    usize local_frame_size = ngc.rctx->top-local_frame_start;
     // arguments' stored place begins at local +2
     return ((module_func)fp.obj().ptr)(
         local_frame_start,
         local_frame_size,
-        &ngc
-    );
+        &ngc);
 }
 
 var builtin_platform(var* local, gc& ngc) {
@@ -1012,32 +1008,32 @@ var builtin_arch(var* local, gc& ngc) {
 
 // md5 related functions
 std::string tohex(u32 num) {
-    const char str16[]="0123456789abcdef";
-    std::string str="";
-    for(u32 i=0;i<4;i++, num>>=8) {
-        std::string tmp="";
-        for(u32 j=0,b=num&0xff;j<2;j++,b>>=4) {
-            tmp.insert(0,1,str16[b&0xf]);
+    const char str16[] = "0123456789abcdef";
+    std::string str = "";
+    for(u32 i = 0; i<4; i++, num >>= 8) {
+        std::string tmp = "";
+        for(u32 j = 0, b = num&0xff; j<2; j++, b >>= 4) {
+            tmp.insert(0, 1, str16[b&0xf]);
         }
-        str+=tmp;
+        str += tmp;
     }
     return str;
 }
 
 std::string md5(const std::string& src) {
     std::vector<u32> buff;
-    usize num=((src.length()+8)>>6)+1;
-    usize buffsize=num<<4;
+    usize num = ((src.length()+8)>>6)+1;
+    usize buffsize = num<<4;
     buff.resize(buffsize,0);
-    for(usize i=0;i<src.length();i++) {
-        buff[i>>2]|=((u8)src[i])<<((i&0x3)<<3);
+    for(usize i = 0; i<src.length(); i++) {
+        buff[i>>2] |= ((u8)src[i])<<((i&0x3)<<3);
     }
-    buff[src.length()>>2]|=0x80<<(((src.length()%4))<<3);
-    buff[buffsize-2]=(src.length()<<3)&0xffffffff;
-    buff[buffsize-1]=((src.length()<<3)>>32)&0xffffffff;
+    buff[src.length()>>2] |= 0x80<<(((src.length()%4))<<3);
+    buff[buffsize-2] = (src.length()<<3)&0xffffffff;
+    buff[buffsize-1] = ((src.length()<<3)>>32)&0xffffffff;
 
     // u32(abs(sin(i+1))*(2pow32))
-    const u32 k[]={
+    const u32 k[] = {
         0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,
         0x698098d8,0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,0xa679438e,0x49b40821,
         0xf61e2562,0xc040b340,0x265e5a51,0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
@@ -1049,7 +1045,7 @@ std::string md5(const std::string& src) {
     };
 
     // left shift bits
-    const u32 s[]={
+    const u32 s[] = {
         7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22,
         5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
         4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,
@@ -1057,7 +1053,7 @@ std::string md5(const std::string& src) {
     };
 
     // index
-    const u32 idx[]={
+    const u32 idx[] = {
         0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, // g=i
         1,6,11,0,5,10,15,4,9,14,3,8,13,2,7,12, // g=(5*i+1)%16;
         5,8,11,14,1,4,7,10,13,0,3,6,9,12,15,2, // g=(3*i+5)%16;
@@ -1070,31 +1066,31 @@ std::string md5(const std::string& src) {
 #define md5h(x,y,z) ((x)^(y)^(z))
 #define md5i(x,y,z) ((y)^((x)|(~z)))
     
-    u32 atmp=0x67452301,btmp=0xefcdab89;
-    u32 ctmp=0x98badcfe,dtmp=0x10325476;
-    for(u32 i=0;i<buffsize;i+=16) {
-        u32 f,a=atmp,b=btmp,c=ctmp,d=dtmp;
-        for(u32 j=0;j<64;j++) {
-            if (j<16)      f=md5f(b,c,d);
-            else if (j<32) f=md5g(b,c,d);
-            else if (j<48) f=md5h(b,c,d);
-            else           f=md5i(b,c,d);
-            u32 tmp=d;
-            d=c;
-            c=b;
-            b=b+shift((a+f+k[j]+buff[i+idx[j]]),s[j]);
-            a=tmp;
+    u32 atmp = 0x67452301, btmp = 0xefcdab89;
+    u32 ctmp = 0x98badcfe, dtmp = 0x10325476;
+    for(u32 i = 0; i<buffsize; i += 16) {
+        u32 f, a = atmp, b = btmp, c = ctmp, d = dtmp;
+        for(u32 j = 0; j<64; j++) {
+            if (j<16)      f = md5f(b, c, d);
+            else if (j<32) f = md5g(b, c, d);
+            else if (j<48) f = md5h(b, c, d);
+            else           f = md5i(b, c, d);
+            u32 tmp = d;
+            d = c;
+            c = b;
+            b = b+shift((a+f+k[j]+buff[i+idx[j]]),s[j]);
+            a = tmp;
         }
-        atmp+=a;
-        btmp+=b;
-        ctmp+=c;
-        dtmp+=d;
+        atmp += a;
+        btmp += b;
+        ctmp += c;
+        dtmp += d;
     }
     return tohex(atmp)+tohex(btmp)+tohex(ctmp)+tohex(dtmp);
 }
 
 var builtin_md5(var* local, gc& ngc) {
-    var str=local[1];
+    var str = local[1];
     if (str.type!=vm_str) {
         return nas_err("md5", "\"str\" must be string");
     }
@@ -1114,29 +1110,29 @@ var builtin_cocreate(var* local, gc& ngc) {
     // +-------------+ <- local pointer stored in localr
     // | old funcr   | <- old function stored in funcr
     // +-------------+
-    var func=local[1];
+    var func = local[1];
     if (func.type!=vm_func) {
         return nas_err("coroutine::create", "must use a function to create coroutine");
     }
     if (ngc.cort) {
         return nas_err("coroutine::create", "cannot create another coroutine in a coroutine");
     }
-    var co=ngc.alloc(vm_co);
-    nas_co& cort=co.co();
-    cort.ctx.pc=func.func().entry-1;
+    var co = ngc.alloc(vm_co);
+    nas_co& cort = co.co();
+    cort.ctx.pc = func.func().entry-1;
 
-    cort.ctx.top[0]=nil;
-    cort.ctx.localr=cort.ctx.top+1;
-    cort.ctx.top=cort.ctx.localr+func.func().lsize;
-    cort.ctx.localr[0]=func.func().local[0];
-    cort.ctx.top[0]=nil; // old upvalr
+    cort.ctx.top[0] = nil;
+    cort.ctx.localr = cort.ctx.top+1;
+    cort.ctx.top = cort.ctx.localr+func.func().lsize;
+    cort.ctx.localr[0] = func.func().local[0];
+    cort.ctx.top[0] = nil; // old upvalr
     cort.ctx.top++;
-    cort.ctx.top[0]=var::addr((var*)nullptr); // old localr
+    cort.ctx.top[0] = var::addr((var*)nullptr); // old localr
     cort.ctx.top++;
-    cort.ctx.top[0]=var::ret(0); // old pc, set to zero to make op_ret recognizing this as coroutine function
+    cort.ctx.top[0] = var::ret(0); // old pc, set to zero to make op_ret recognizing this as coroutine function
 
-    cort.ctx.funcr=func; // make sure the coroutine function can use correct upvalues
-    cort.status=coroutine_status::suspended;
+    cort.ctx.funcr = func; // make sure the coroutine function can use correct upvalues
+    cort.status = coroutine_status::suspended;
     
     return co;
 }
@@ -1145,7 +1141,7 @@ var builtin_coresume(var* local, gc& ngc) {
     if (ngc.cort) {
         return nas_err("coroutine::resume", "cannot start another coroutine when one is running");
     }
-    var co=local[1];
+    var co = local[1];
     // return nil if is not a coroutine object
     if (co.type!=vm_co) {
         return nil;
@@ -1191,41 +1187,41 @@ var builtin_coyield(var* local, gc& ngc) {
 }
 
 var builtin_costatus(var* local, gc& ngc) {
-    var co=local[1];
+    var co = local[1];
     if (co.type!=vm_co) {
         return ngc.newstr("error");
     }
     switch(co.co().status) {
-        case coroutine_status::suspended: return ngc.newstr("suspended");break;
-        case coroutine_status::running:   return ngc.newstr("running");  break;
-        case coroutine_status::dead:      return ngc.newstr("dead");     break;
+        case coroutine_status::suspended: return ngc.newstr("suspended");
+        case coroutine_status::running:   return ngc.newstr("running");
+        case coroutine_status::dead:      return ngc.newstr("dead");
     }
     return nil;
 }
 
 var builtin_corun(var* local, gc& ngc) {
-    return ngc.cort?one:zero;
+    return ngc.cort? one:zero;
 }
 
 var builtin_millisec(var* local, gc& ngc) {
-    f64 res=std::chrono::duration_cast<std::chrono::milliseconds>
+    f64 res = std::chrono::duration_cast<std::chrono::milliseconds>
             (std::chrono::high_resolution_clock::now().time_since_epoch())
             .count();
     return var::num(res);
 }
 
 var builtin_sysargv(var* local, gc& ngc) {
-    var res=ngc.alloc(vm_vec);
-    res.vec().elems=ngc.env_argv;
+    var res = ngc.alloc(vm_vec);
+    res.vec().elems = ngc.env_argv;
     return res;
 }
 
 var builtin_gcextend(var* local, gc& ngc) {
-    var type=local[1];
+    var type = local[1];
     if (type.type!=vm_str) {
         return nil;
     }
-    auto& s=type.str();
+    auto& s = type.str();
     if (s=="str") {
         ngc.extend(vm_str);
     } else if (s=="vec") {
@@ -1245,8 +1241,8 @@ var builtin_gcextend(var* local, gc& ngc) {
 }
 
 var builtin_logtime(var* local, gc& ngc) {
-    time_t t=time(nullptr);
-    tm* tm_t=localtime(&t);
+    time_t t = time(nullptr);
+    tm* tm_t = localtime(&t);
     char s[64];
     snprintf(
         s,64,"%d-%.2d-%.2d %.2d:%.2d:%.2d",
@@ -1273,96 +1269,96 @@ var builtin_ghosttype(var* local, gc& ngc) {
 }
 
 nasal_builtin_table builtin[] = {
-    {"__print",   builtin_print   },
-    {"__println", builtin_println },
-    {"__exit",    builtin_exit    },
-    {"__abort",   builtin_abort   },
-    {"__append",  builtin_append  },
-    {"__setsize", builtin_setsize },
-    {"__system",  builtin_system  },
-    {"__input",   builtin_input   },
-    {"__readfile",builtin_readfile},
-    {"__fout",    builtin_fout    },
-    {"__split",   builtin_split   },
-    {"__rand",    builtin_rand    },
-    {"__id",      builtin_id      },
-    {"__int",     builtin_int     },
-    {"__floor",   builtin_floor   },
-    {"__num",     builtin_num     },
-    {"__pop",     builtin_pop     },
-    {"__str",     builtin_str     },
-    {"__size",    builtin_size    },
-    {"__u32xor",  builtin_u32xor  },
-    {"__u32and",  builtin_u32and  },
-    {"__u32or",   builtin_u32or   },
-    {"__u32nand", builtin_u32nand },
-    {"__u32not",  builtin_u32not  },
-    {"__pow",     builtin_pow     },
-    {"__sin",     builtin_sin     },
-    {"__cos",     builtin_cos     },
-    {"__tan",     builtin_tan     },
-    {"__exp",     builtin_exp     },
-    {"__lg",      builtin_lg      },
-    {"__ln",      builtin_ln      },
-    {"__sqrt",    builtin_sqrt    },
-    {"__atan2",   builtin_atan2   },
-    {"__isnan",   builtin_isnan   },
-    {"__time",    builtin_time    },
-    {"__contains",builtin_contains},
-    {"__delete",  builtin_delete  },
-    {"__keys",    builtin_keys    },
-    {"__die",     builtin_die     },
-    {"__find",    builtin_find    },
-    {"__type",    builtin_type    },
-    {"__substr",  builtin_substr  },
-    {"__streq",   builtin_streq   },
-    {"__left",    builtin_left    },
-    {"__right",   builtin_right   },
-    {"__cmp",     builtin_cmp     },
-    {"__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     },
-    {"__fld",     builtin_fld     },
-    {"__sfld",    builtin_sfld    },
-    {"__setfld",  builtin_setfld  },
-    {"__buf",     builtin_buf     },
-    {"__sleep",   builtin_sleep   },
-    {"__pipe",    builtin_pipe    },
-    {"__fork",    builtin_fork    },
-    {"__waitpid", builtin_waitpid },
-    {"__opendir", builtin_opendir },
-    {"__readdir", builtin_readdir },
-    {"__closedir",builtin_closedir},
-    {"__chdir",   builtin_chdir   },
-    {"__environ", builtin_environ },
-    {"__getcwd",  builtin_getcwd  },
-    {"__getenv",  builtin_getenv  },
-    {"__dlopen",  builtin_dlopen  },
-    {"__dlclose", builtin_dlclose },
-    {"__dlcallv", builtin_dlcallv },
-    {"__dlcall",  builtin_dlcall  },
-    {"__platform",builtin_platform},
-    {"__arch",    builtin_arch    },
-    {"__md5",     builtin_md5     },
-    {"__cocreate",builtin_cocreate},
-    {"__coresume",builtin_coresume},
+    {"__print", builtin_print},
+    {"__println", builtin_println},
+    {"__exit", builtin_exit},
+    {"__abort", builtin_abort},
+    {"__append", builtin_append},
+    {"__setsize", builtin_setsize},
+    {"__system", builtin_system},
+    {"__input", builtin_input},
+    {"__readfile", builtin_readfile},
+    {"__fout", builtin_fout},
+    {"__split", builtin_split},
+    {"__rand", builtin_rand},
+    {"__id", builtin_id},
+    {"__int", builtin_int},
+    {"__floor", builtin_floor},
+    {"__num", builtin_num},
+    {"__pop", builtin_pop},
+    {"__str", builtin_str},
+    {"__size", builtin_size},
+    {"__u32xor", builtin_u32xor},
+    {"__u32and", builtin_u32and},
+    {"__u32or", builtin_u32or},
+    {"__u32nand", builtin_u32nand},
+    {"__u32not", builtin_u32not},
+    {"__pow", builtin_pow},
+    {"__sin", builtin_sin},
+    {"__cos", builtin_cos},
+    {"__tan", builtin_tan},
+    {"__exp", builtin_exp},
+    {"__lg", builtin_lg},
+    {"__ln", builtin_ln},
+    {"__sqrt", builtin_sqrt},
+    {"__atan2", builtin_atan2},
+    {"__isnan", builtin_isnan},
+    {"__time", builtin_time},
+    {"__contains", builtin_contains},
+    {"__delete", builtin_delete},
+    {"__keys", builtin_keys},
+    {"__die", builtin_die},
+    {"__find", builtin_find},
+    {"__type", builtin_type},
+    {"__substr", builtin_substr},
+    {"__streq", builtin_streq},
+    {"__left", builtin_left},
+    {"__right", builtin_right},
+    {"__cmp", builtin_cmp},
+    {"__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},
+    {"__fld", builtin_fld},
+    {"__sfld", builtin_sfld},
+    {"__setfld", builtin_setfld},
+    {"__buf", builtin_buf},
+    {"__sleep", builtin_sleep},
+    {"__pipe", builtin_pipe},
+    {"__fork", builtin_fork},
+    {"__waitpid", builtin_waitpid},
+    {"__opendir", builtin_opendir},
+    {"__readdir", builtin_readdir},
+    {"__closedir", builtin_closedir},
+    {"__chdir", builtin_chdir},
+    {"__environ", builtin_environ},
+    {"__getcwd", builtin_getcwd},
+    {"__getenv", builtin_getenv},
+    {"__dlopen", builtin_dlopen},
+    {"__dlclose", builtin_dlclose},
+    {"__dlcallv", builtin_dlcallv},
+    {"__dlcall", builtin_dlcall},
+    {"__platform", builtin_platform},
+    {"__arch", builtin_arch},
+    {"__md5", builtin_md5},
+    {"__cocreate", builtin_cocreate},
+    {"__coresume", builtin_coresume},
     {"__coyield", builtin_coyield },
-    {"__costatus",builtin_costatus},
-    {"__corun"   ,builtin_corun   },
-    {"__millisec",builtin_millisec},
-    {"__sysargv", builtin_sysargv },
-    {"__gcextd",  builtin_gcextend},
-    {"__logtime", builtin_logtime },
+    {"__costatus", builtin_costatus},
+    {"__corun", builtin_corun},
+    {"__millisec", builtin_millisec},
+    {"__sysargv", builtin_sysargv},
+    {"__gcextd", builtin_gcextend},
+    {"__logtime", builtin_logtime},
     {"__ghosttype", builtin_ghosttype},
-    {nullptr,     nullptr         }
+    {nullptr, nullptr}
 };
\ No newline at end of file
diff --git a/src/nasal_codegen.cpp b/src/nasal_codegen.cpp
index fee4dbb..f84c53e 100644
--- a/src/nasal_codegen.cpp
+++ b/src/nasal_codegen.cpp
@@ -1091,7 +1091,18 @@ const error& codegen::compile(parse& parse, linker& import) {
     fileindex = 0;
     file = import.filelist().data();
     in_iterloop.push(0);
+
+    // add special symbol globals, which is a hash stores all global variables
     add_symbol("globals");
+    // add special symbol arg here, which is used to store function arguments
+    // for example:
+    //     var f = func(a) {print(arg)}
+    //     f(1, 2, 3);
+    // then the arg is [2, 3], because 1 is accepted by "a"
+    // so in fact "f" is the same as:
+    //     var f = func(a, arg...) {return(arg)}
+    add_symbol("arg");
+
     find_symbol(parse.tree()); // search symbols first
     gen(op_intg, global.size(), 0);
     block_gen(parse.tree()); // generate main block
diff --git a/src/nasal_vm.h b/src/nasal_vm.h
index 673d893..e4103e7 100644
--- a/src/nasal_vm.h
+++ b/src/nasal_vm.h
@@ -643,6 +643,12 @@ inline void vm::o_callfv() {
         for(u32 i=psize;i<argc;++i) {
             dynamic.vec().elems.push_back(local[i]);
         }
+    } else if (psize<argc) {
+        // load arguments to "arg", located at stack+1
+        stack[1] = ngc.alloc(vm_vec);
+        for(u32 i=psize;i<argc;++i) {
+            stack[1].vec().elems.push_back(local[i]);
+        }
     }
     // should reset stack top after allocating vector
     // because this may cause gc
@@ -906,6 +912,9 @@ inline void vm::o_ret() {
     ctx.funcr = ctx.top[0];
     ctx.top[0] = ret; // rewrite func with returned value
 
+    // reset "arg"
+    stack[1] = nil;
+
     if (up.type==vm_upval) { // synchronize upvalue
         auto& upval = up.upval();
         auto size = func.func().lsize;
diff --git a/test/globals_test.nas b/test/globals_test.nas
index 68610fb..bb55d7f 100644
--- a/test/globals_test.nas
+++ b/test/globals_test.nas
@@ -12,4 +12,13 @@ globals.test_func = func() {
 }
 println();
 println(globals.test_func);
-globals.test_func();
\ No newline at end of file
+globals.test_func();
+
+var f = func() {
+    println(arg);
+}
+
+f(1, 2, 3);
+
+println(arg);
+println(globals.arg);
\ No newline at end of file
diff --git a/test/sample.nas b/test/sample.nas
new file mode 100644
index 0000000..8fb0c42
--- /dev/null
+++ b/test/sample.nas
@@ -0,0 +1,378 @@
+# This file is written by Andy Ross, and is protected by GPLv2.0
+
+# A no-op function used below to get this file to run.  Ignore and read on...
+dummyFunc = func { 1 }
+
+#
+# Literal numbers can be decimal, exponential, or hex constants.  All
+# numbers are stored internally as IEEE double-precision values.
+#
+n1 = 3;
+n2 = 3.14;
+n3 = 6.023e23;
+n3 = 0x123456;
+
+#
+# Two identical string literals with different quotes.  Double quotes
+# use typical escape sequences.  Single quotes treat everything as
+# literal except for embedded single quotes (including embedded
+# whitespace like newlines).  Double quotes handle the following
+# C-like escapes: \n \r \t \xnn \"
+#
+s1 = 'Andy\'s "computer" has a C:\righteous\newstuff directory.';
+s2 = "Andy's \"computer\" has a C:\\righteous\\newstuff directory.";
+
+#
+# Literal lists use square brackets with a comma-separated expression
+# list.
+#
+list1 = ["a", "b", 1, 2];
+
+#
+# Literal hashes (or objects -- same thing) use curlies and colons to
+# separate the key/value pairs.  Note that the key can be either a
+# symbol or a literal scalar.  Object definitions will typically want
+# to use symbols, lookup tables of other types will be more
+# comfortable with literals.
+#
+hash1 = { name : "Andy", job : "Hacker" };
+EnglishEspanol = { "one" : "uno", "two": "dos", "blue" : "azul" };
+
+#
+# Both vectors and hashes use square brackets for the lookup operation:
+#
+list1[0] == "a";
+hash1["name"] == "Andy";
+
+#
+# A simple function.  By default, arguments are passed in the "arg"
+# array, not unlike perl.  Note that this is just an assignment of an
+# (anonymous) function argument to the local "log_message" variable.
+# There is no function declaration syntax in Nasal.
+#
+log_message = func {
+    print(arg[0]);
+}
+
+#
+# You can also pass named arguments to a function, thus saving the
+# typing and performance costs of extracting them from the arg array.
+#
+sqrt = dummyFunc;
+dist = func(x1, y1, x2, y2) {
+    dx = x2-x1;
+    dy = y2-y1;
+    return sqrt(dx*dx + dy*dy);
+}
+dist(0,0,1,1); # == sqrt(2)
+
+#
+# These arguments can have default values, as in C++.  Note that the
+# default value must be a scalar (number, string, function, nil) and
+# not a mutable composite object (list, hash).
+#
+read = func(bytes, flags=0) { }
+
+#
+# Any extra arguments after the named list are placed in the "arg"
+# vector as above.  You can rename this to something other than "arg"
+# by specifying a final argument name with an ellipsis:
+#
+listify = func(elements...) { return elements; }
+listify(1, 2, 3, 4); # returns a list: [1, 2, 3, 4]
+
+#
+# You can use a "var" qualifier to make sure that an assigment is made
+# to a local variable, and not one from the enclosing scope.  This is
+# good practice in general, although it is not required.  Note that
+# this is not a "declaration", just a qualifier on the "=" operator.
+#
+innerFunc = func {
+    for(var dist=0; dist<100; dist += 1) {
+        # Does not interfere with the "dist" symbol defined above
+    }
+}
+
+#
+# Nasal has no "statements", which means that any expression can appear
+# in any context.  This means that you can use an if/else clause to do
+# what the ?: does in C.  The last semicolon in a code block is
+# optional, to make this prettier.
+#
+abs = func(n) { if(n<0) { -n } else { n } }
+
+#
+# But for those who don't like typing, the ternary operator works like
+# you expect:
+#
+abs = func(n) { n < 0 ? -n : n }
+
+#
+# Nasal supports a "nil" value for use as a null pointer equivalent.
+# It can be tested for equality, matching only other nils.
+#
+listNode = { data : ["what", "ever"], next : nil };
+
+#
+# Nasal's binary boolean operators are "and" and "or", unlike C.
+# unary not is still "!" however.  They short-circuit like you expect
+#
+toggle = 0;
+a = nil;
+if(a and a.field == 42) {
+    toggle = !toggle; # doesn't crash when a is nil
+}
+
+#
+# Looping constructs are mostly C-like.  The differences are that
+# there is no do{}while(); construct, and there is a foreach, which
+# takes a local variable name as its first argument and a vector as
+# its second.
+#
+doSomething = dummyFunc;
+
+stillGoing = 0;
+while(stillGoing) { doSomething(); }
+
+for(i=0; i < 3; i = i+1) {
+    elem = list1[i];
+    doSomething(elem);
+}
+
+foreach(elem; list1) { doSomething(elem) }  # Shorthand for above
+
+#
+# There is also a "forindex", which is like foreach except that it
+# assigns the index of each element, instead of the value, to the loop
+# variable.
+#
+forindex(i; list1) { doSomething(list1[i]); }
+
+#
+# Define a class object with one method, one field and one "new"
+# contstructor.  The "new" function is not special in any way; it
+# simply returns an initialized object with the "parents" field set
+# appropriately.  Member functions can get their local object (the
+# equivalent of the "this" pointer in C++) as the "me" variable.
+#
+Class1 = {};
+
+Class1.new = func {
+    obj = { parents : [Class1],
+            count : 0 };
+    return obj;
+}
+
+Class1.getcount = func {
+    me.count = me.count + 1;
+    return me.count;
+}
+
+c = Class1.new();
+print(c.getcount(), "\n"); # prints 1
+print(c.getcount(), "\n"); # prints 2
+print(c.getcount(), "\n"); # prints 3
+
+# Note that member *get* operations recurse into the parents array.
+# But *set* operations always go to the local object.  You can't
+# corrupt a parent class via OOP operations on its instances (but you
+# *can* get to it via hand-inspection of the parents arrays).
+c2 = Class1.new();
+c2.getcount() = func { 12345 }; # custom "derived" function!
+
+print(c2.getcount(), "\n"); # prints 12345
+print(c1.getcount(), "\n"); # prints 4, Class1.getcount is unchanged
+
+#
+# This creates an identical class using alternative syntax.
+#
+Class2 = {
+    new : func {
+        obj = {};
+	obj.parents = [Class2];
+	obj.count = 0;
+        return obj;
+    },
+    getcount : func {
+        me.count = me.count + 1;
+        return me.count;
+    }
+};
+
+#
+# Advanced strings: Nasal strings are always arrays of bytes (never
+# characters: see the utf8 library if you want character-based
+# equivalents of substr() et. al.).  They can be indexed just like in
+# C (although note that there is no nul termination -- get the length
+# with size()):
+#
+string = "abcdefghijklmnopqrstuvwxyz";
+var ascii_sum = 0;
+for(var i=0; i<size(string); i+=1) { ascii_sum += string[i]; }
+
+#
+# You can use backquotes to write UTF8 character constants
+#
+if(`A` != 65) { print("ASCII violation bug!\n"); }
+if(`©` != 169) { print("Unicode violation bug!\n"); }
+
+#
+# And you can mutate strings by assigning to their indices, as long as
+# they are not constants.  You
+# can make a mutable string either with the append operator or the
+# bits.buf() function.
+#
+ascii_lc = func(string) {
+    var mutable = string ~ "";
+    for(var i=0; i<size(mutable); i+=1) {
+        if(mutable[i] >= `A` and mutable[i] <= `Z`) {
+            mutable[i] += (`a` - `A`);
+        }
+    }
+    return mutable;
+}
+print(ascii_lc("ABCDEFG"), "\n"); # prints "abcdefg"
+
+#
+# Advanced vectors: The lookup index can be negative, where -1
+# indicates the last element in the vector (or string).
+#
+next_to_last = list1[-2];
+
+#
+# Remember that strings look syntactically like vectors of bytes; so
+# conversely, the "~" concatenation operator works equally well to
+# concatenate vectors:
+#
+joined_list = [1, 2, 3] ~ [4, 5, 6];
+
+###
+### Now some fun examples:
+###
+
+#
+# Make a "inverted index" hash out of a vector that returns the index
+# for each element.
+#
+invert = func(vec) {
+    hash = {};
+    for(i=0; i<size(vec); i = i+1) {
+        hash[vec[i]] = i;
+    }
+    return hash;
+}
+
+#
+# Use the return value of the above function to do an "index of"
+# lookup on a vector
+#
+vecfind = func(vec, elem) { return invert(vec)[elem]; }
+
+#
+# Joins its arguments with the empty string and returns a scalar.
+# Note use of "~" operator to do string concatenation (Nasal's only
+# funny syntax).
+#
+join = func { 
+    s = "";
+    foreach(elem; arg) { s = s ~ elem; }
+    return s;
+}
+
+#
+# Labeled break/continue syntax puts the label in as an extra first
+# argument to the for/while/foreach.
+#
+doneWithInnerLoopEarly = dummyFunc;
+completelyDone = dummyFunc;
+for(OUTER; i=0; i<100; i = i+1) {
+    for(j=0; j<100; j = j+1) {
+        if(doneWithInnerLoopEarly()) {
+            break;
+        } elsif(completelyDone()) {
+            break OUTER;
+        }
+    }
+}
+
+##
+## A rockin' metaprogramming hack.  Generates and returns a deep copy
+## of the object in valid Nasal syntax.  A warning to those who might
+## want to use this: it ignores function objects (which cannot be
+## inspected from Nasal) and replaces them with nil references.  It
+## also makes no attempt to escape special characters in strings, which
+## can break re-parsing in strange (and possibly insecure!) ways.
+##
+dump = func(o) {
+    result = "";
+    if(typeof(o) == "scalar") {
+        n = num(o);
+        if(n == nil) { result = result ~ '"' ~ o ~ '"'; }
+        else { result = result ~ o; }
+    } elsif(typeof(o) == "vector") {
+        result = result ~ "[ ";
+        if(size(o) > 0) { result = result ~ dump(o[0]); }
+        for(i=1; i<size(o); i=i+1) {
+            result = result ~ ", " ~ dump(o[i]);
+        }
+        result = result ~ " ]";
+    } elsif(typeof(o) == "hash") {
+        ks = keys(o);
+        result = result ~ "{ ";
+        if(size(o) > 0) {
+            k = ks[0];
+            result = result ~ k ~ ":" ~ dump(o[k]);
+        }
+        for(i=1; i<size(o); i=i+1) {
+            k = ks[i];
+            result = result ~ ", " ~ k ~ " : " ~ dump(o[k]);
+        }
+        result = result ~ " }";
+    } else {
+        result = result ~ "nil";
+    }
+    return result;
+}
+
+#
+# Functional programming A: All function expressions are inherently
+# anonymous lambdas and can be used and evaluated mid-expression:
+#
+# (Note the parens around the function expression.  This is necessary
+# because otherwise the parser would read a func following an
+# assignment as a "code block" instead of a subexpression.  This is
+# the rule that allows you to omit the semicolon at the end of a
+# normal function definition.  Oh well, every language has a syntactic
+# quirk or two...)
+#
+a = (func(n){ n + 1 })(232);  # "a" now equals 233
+
+#
+# Functional programming B.  All expressions have a value, the last
+# expression in a code block is the return value of that code block.
+# There are no "statements" in Nasal, although some expressions
+# (assignment, duh) have side effects.  e.g. The "if" expression works
+# both for code flow and as the ?: expression in C/C++.
+#
+factorial = func(n) { if(n == 0) { 1 }
+                      else       { n * factorial(n-1) } }
+print(factorial(10), "\n");
+
+#
+# Functional programming C: Lexical closures.  Functions "remember"
+# the context in which they were defined, and can continue to use the
+# local variables in the outer scope even after their creator has
+# returned.
+#
+getcounter = func { count = 0; return func { count = count + 1 } }
+mycounter = getcounter();
+print(mycounter(), "\n"); # prints 1
+print(mycounter(), "\n"); # prints 2
+print(mycounter(), "\n"); # prints 3
+print(mycounter(), "\n"); # prints 4...
+
+#
+# Functional programming D: see the documentation on the functions
+# bind(), call(), closure() and caller().  Basically, every piece of
+# the symbol lookup environment is inspectable and mutable at runtime.
+#